openMSX
imgui_draw.cc
Go to the documentation of this file.
1// dear imgui, v1.91.0
2// (drawing and font code)
3
4/*
5
6Index of this file:
7
8// [SECTION] STB libraries implementation
9// [SECTION] Style functions
10// [SECTION] ImDrawList
11// [SECTION] ImTriangulator, ImDrawList concave polygon fill
12// [SECTION] ImDrawListSplitter
13// [SECTION] ImDrawData
14// [SECTION] Helpers ShadeVertsXXX functions
15// [SECTION] ImFontConfig
16// [SECTION] ImFontAtlas
17// [SECTION] ImFontAtlas glyph ranges helpers
18// [SECTION] ImFontGlyphRangesBuilder
19// [SECTION] ImFont
20// [SECTION] ImGui Internal Render Helpers
21// [SECTION] Decompression code
22// [SECTION] Default font data (ProggyClean.ttf)
23
24*/
25
26#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
27#define _CRT_SECURE_NO_WARNINGS
28#endif
29
30#ifndef IMGUI_DEFINE_MATH_OPERATORS
31#define IMGUI_DEFINE_MATH_OPERATORS
32#endif
33
34#include "imgui.h"
35#ifndef IMGUI_DISABLE
36#include "imgui_internal.h"
37#ifdef IMGUI_ENABLE_FREETYPE
38#include "misc/freetype/imgui_freetype.h"
39#endif
40
41#include <stdio.h> // vsnprintf, sscanf, printf
42
43// Visual Studio warnings
44#ifdef _MSC_VER
45#pragma warning (disable: 4127) // condition expression is constant
46#pragma warning (disable: 4505) // unreferenced local function has been removed (stb stuff)
47#pragma warning (disable: 4996) // 'This function or variable may be unsafe': strcpy, strdup, sprintf, vsnprintf, sscanf, fopen
48#pragma warning (disable: 26451) // [Static Analyzer] Arithmetic overflow : Using operator 'xxx' on a 4 byte value and then casting the result to a 8 byte value. Cast the value to the wider type before calling operator 'xxx' to avoid overflow(io.2).
49#pragma warning (disable: 26812) // [Static Analyzer] The enum type 'xxx' is unscoped. Prefer 'enum class' over 'enum' (Enum.3). [MSVC Static Analyzer)
50#endif
51
52// Clang/GCC warnings with -Weverything
53#if defined(__clang__)
54#if __has_warning("-Wunknown-warning-option")
55#pragma clang diagnostic ignored "-Wunknown-warning-option" // warning: unknown warning group 'xxx' // not all warnings are known by all Clang versions and they tend to be rename-happy.. so ignoring warnings triggers new warnings on some configuration. Great!
56#endif
57#pragma clang diagnostic ignored "-Wunknown-pragmas" // warning: unknown warning group 'xxx'
58#pragma clang diagnostic ignored "-Wold-style-cast" // warning: use of old-style cast // yes, they are more terse.
59#pragma clang diagnostic ignored "-Wfloat-equal" // warning: comparing floating point with == or != is unsafe // storing and comparing against same constants ok.
60#pragma clang diagnostic ignored "-Wglobal-constructors" // warning: declaration requires a global destructor // similar to above, not sure what the exact difference is.
61#pragma clang diagnostic ignored "-Wsign-conversion" // warning: implicit conversion changes signedness
62#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant" // warning: zero as null pointer constant // some standard header variations use #define NULL 0
63#pragma clang diagnostic ignored "-Wcomma" // warning: possible misuse of comma operator here
64#pragma clang diagnostic ignored "-Wreserved-id-macro" // warning: macro name is a reserved identifier
65#pragma clang diagnostic ignored "-Wdouble-promotion" // warning: implicit conversion from 'float' to 'double' when passing argument to function // using printf() is a misery with this as C++ va_arg ellipsis changes float to double.
66#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion" // warning: implicit conversion from 'xxx' to 'float' may lose precision
67#pragma clang diagnostic ignored "-Wreserved-identifier" // warning: identifier '_Xxx' is reserved because it starts with '_' followed by a capital letter
68#pragma clang diagnostic ignored "-Wunsafe-buffer-usage" // warning: 'xxx' is an unsafe pointer used for buffer access
69#elif defined(__GNUC__)
70#pragma GCC diagnostic ignored "-Wpragmas" // warning: unknown option after '#pragma GCC diagnostic' kind
71#pragma GCC diagnostic ignored "-Wunused-function" // warning: 'xxxx' defined but not used
72#pragma GCC diagnostic ignored "-Wdouble-promotion" // warning: implicit conversion from 'float' to 'double' when passing argument to function
73#pragma GCC diagnostic ignored "-Wconversion" // warning: conversion to 'xxxx' from 'xxxx' may alter its value
74#pragma GCC diagnostic ignored "-Wstack-protector" // warning: stack protector not protecting local variables: variable length buffer
75#pragma GCC diagnostic ignored "-Wclass-memaccess" // [__GNUC__ >= 8] warning: 'memset/memcpy' clearing/writing an object of type 'xxxx' with no trivial copy-assignment; use assignment or value-initialization instead
76#endif
77
78//-------------------------------------------------------------------------
79// [SECTION] STB libraries implementation (for stb_truetype and stb_rect_pack)
80//-------------------------------------------------------------------------
81
82// Compile time options:
83//#define IMGUI_STB_NAMESPACE ImStb
84//#define IMGUI_STB_TRUETYPE_FILENAME "my_folder/stb_truetype.h"
85//#define IMGUI_STB_RECT_PACK_FILENAME "my_folder/stb_rect_pack.h"
86//#define IMGUI_DISABLE_STB_TRUETYPE_IMPLEMENTATION
87//#define IMGUI_DISABLE_STB_RECT_PACK_IMPLEMENTATION
88
89#ifdef IMGUI_STB_NAMESPACE
90namespace IMGUI_STB_NAMESPACE
91{
92#endif
93
94#ifdef _MSC_VER
95#pragma warning (push)
96#pragma warning (disable: 4456) // declaration of 'xx' hides previous local declaration
97#pragma warning (disable: 6011) // (stb_rectpack) Dereferencing NULL pointer 'cur->next'.
98#pragma warning (disable: 6385) // (stb_truetype) Reading invalid data from 'buffer': the readable size is '_Old_3`kernel_width' bytes, but '3' bytes may be read.
99#pragma warning (disable: 28182) // (stb_rectpack) Dereferencing NULL pointer. 'cur' contains the same NULL value as 'cur->next' did.
100#endif
101
102#if defined(__clang__)
103#pragma clang diagnostic push
104#pragma clang diagnostic ignored "-Wunused-function"
105#pragma clang diagnostic ignored "-Wmissing-prototypes"
106#pragma clang diagnostic ignored "-Wimplicit-fallthrough"
107#pragma clang diagnostic ignored "-Wcast-qual" // warning: cast from 'const xxxx *' to 'xxx *' drops const qualifier
108#endif
109
110#if defined(__GNUC__)
111#pragma GCC diagnostic push
112#pragma GCC diagnostic ignored "-Wtype-limits" // warning: comparison is always true due to limited range of data type [-Wtype-limits]
113#pragma GCC diagnostic ignored "-Wcast-qual" // warning: cast from type 'const xxxx *' to type 'xxxx *' casts away qualifiers
114#endif
115
116#ifndef STB_RECT_PACK_IMPLEMENTATION // in case the user already have an implementation in the _same_ compilation unit (e.g. unity builds)
117#ifndef IMGUI_DISABLE_STB_RECT_PACK_IMPLEMENTATION // in case the user already have an implementation in another compilation unit
118#define STBRP_STATIC
119#define STBRP_ASSERT(x) do { IM_ASSERT(x); } while (0)
120#define STBRP_SORT ImQsort
121#define STB_RECT_PACK_IMPLEMENTATION
122#endif
123#ifdef IMGUI_STB_RECT_PACK_FILENAME
124#include IMGUI_STB_RECT_PACK_FILENAME
125#else
126#include "imstb_rectpack.h"
127#endif
128#endif
129
130#ifdef IMGUI_ENABLE_STB_TRUETYPE
131#ifndef STB_TRUETYPE_IMPLEMENTATION // in case the user already have an implementation in the _same_ compilation unit (e.g. unity builds)
132#ifndef IMGUI_DISABLE_STB_TRUETYPE_IMPLEMENTATION // in case the user already have an implementation in another compilation unit
133#define STBTT_malloc(x,u) ((void)(u), IM_ALLOC(x))
134#define STBTT_free(x,u) ((void)(u), IM_FREE(x))
135#define STBTT_assert(x) do { IM_ASSERT(x); } while(0)
136#define STBTT_fmod(x,y) ImFmod(x,y)
137#define STBTT_sqrt(x) ImSqrt(x)
138#define STBTT_pow(x,y) ImPow(x,y)
139#define STBTT_fabs(x) ImFabs(x)
140#define STBTT_ifloor(x) ((int)ImFloor(x))
141#define STBTT_iceil(x) ((int)ImCeil(x))
142#define STBTT_STATIC
143#define STB_TRUETYPE_IMPLEMENTATION
144#else
145#define STBTT_DEF extern
146#endif
147#ifdef IMGUI_STB_TRUETYPE_FILENAME
148#include IMGUI_STB_TRUETYPE_FILENAME
149#else
150#include "imstb_truetype.h"
151#endif
152#endif
153#endif // IMGUI_ENABLE_STB_TRUETYPE
154
155#if defined(__GNUC__)
156#pragma GCC diagnostic pop
157#endif
158
159#if defined(__clang__)
160#pragma clang diagnostic pop
161#endif
162
163#if defined(_MSC_VER)
164#pragma warning (pop)
165#endif
166
167#ifdef IMGUI_STB_NAMESPACE
168} // namespace ImStb
169using namespace IMGUI_STB_NAMESPACE;
170#endif
171
172//-----------------------------------------------------------------------------
173// [SECTION] Style functions
174//-----------------------------------------------------------------------------
175
176void ImGui::StyleColorsDark(ImGuiStyle* dst)
177{
178 ImGuiStyle* style = dst ? dst : &ImGui::GetStyle();
179 ImVec4* colors = style->Colors;
180
181 colors[ImGuiCol_Text] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
182 colors[ImGuiCol_TextDisabled] = ImVec4(0.50f, 0.50f, 0.50f, 1.00f);
183 colors[ImGuiCol_WindowBg] = ImVec4(0.06f, 0.06f, 0.06f, 0.94f);
184 colors[ImGuiCol_ChildBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
185 colors[ImGuiCol_PopupBg] = ImVec4(0.08f, 0.08f, 0.08f, 0.94f);
186 colors[ImGuiCol_Border] = ImVec4(0.43f, 0.43f, 0.50f, 0.50f);
187 colors[ImGuiCol_BorderShadow] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
188 colors[ImGuiCol_FrameBg] = ImVec4(0.16f, 0.29f, 0.48f, 0.54f);
189 colors[ImGuiCol_FrameBgHovered] = ImVec4(0.26f, 0.59f, 0.98f, 0.40f);
190 colors[ImGuiCol_FrameBgActive] = ImVec4(0.26f, 0.59f, 0.98f, 0.67f);
191 colors[ImGuiCol_TitleBg] = ImVec4(0.04f, 0.04f, 0.04f, 1.00f);
192 colors[ImGuiCol_TitleBgActive] = ImVec4(0.16f, 0.29f, 0.48f, 1.00f);
193 colors[ImGuiCol_TitleBgCollapsed] = ImVec4(0.00f, 0.00f, 0.00f, 0.51f);
194 colors[ImGuiCol_MenuBarBg] = ImVec4(0.14f, 0.14f, 0.14f, 1.00f);
195 colors[ImGuiCol_ScrollbarBg] = ImVec4(0.02f, 0.02f, 0.02f, 0.53f);
196 colors[ImGuiCol_ScrollbarGrab] = ImVec4(0.31f, 0.31f, 0.31f, 1.00f);
197 colors[ImGuiCol_ScrollbarGrabHovered] = ImVec4(0.41f, 0.41f, 0.41f, 1.00f);
198 colors[ImGuiCol_ScrollbarGrabActive] = ImVec4(0.51f, 0.51f, 0.51f, 1.00f);
199 colors[ImGuiCol_CheckMark] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
200 colors[ImGuiCol_SliderGrab] = ImVec4(0.24f, 0.52f, 0.88f, 1.00f);
201 colors[ImGuiCol_SliderGrabActive] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
202 colors[ImGuiCol_Button] = ImVec4(0.26f, 0.59f, 0.98f, 0.40f);
203 colors[ImGuiCol_ButtonHovered] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
204 colors[ImGuiCol_ButtonActive] = ImVec4(0.06f, 0.53f, 0.98f, 1.00f);
205 colors[ImGuiCol_Header] = ImVec4(0.26f, 0.59f, 0.98f, 0.31f);
206 colors[ImGuiCol_HeaderHovered] = ImVec4(0.26f, 0.59f, 0.98f, 0.80f);
207 colors[ImGuiCol_HeaderActive] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
208 colors[ImGuiCol_Separator] = colors[ImGuiCol_Border];
209 colors[ImGuiCol_SeparatorHovered] = ImVec4(0.10f, 0.40f, 0.75f, 0.78f);
210 colors[ImGuiCol_SeparatorActive] = ImVec4(0.10f, 0.40f, 0.75f, 1.00f);
211 colors[ImGuiCol_ResizeGrip] = ImVec4(0.26f, 0.59f, 0.98f, 0.20f);
212 colors[ImGuiCol_ResizeGripHovered] = ImVec4(0.26f, 0.59f, 0.98f, 0.67f);
213 colors[ImGuiCol_ResizeGripActive] = ImVec4(0.26f, 0.59f, 0.98f, 0.95f);
214 colors[ImGuiCol_TabHovered] = colors[ImGuiCol_HeaderHovered];
215 colors[ImGuiCol_Tab] = ImLerp(colors[ImGuiCol_Header], colors[ImGuiCol_TitleBgActive], 0.80f);
216 colors[ImGuiCol_TabSelected] = ImLerp(colors[ImGuiCol_HeaderActive], colors[ImGuiCol_TitleBgActive], 0.60f);
217 colors[ImGuiCol_TabSelectedOverline] = colors[ImGuiCol_HeaderActive];
218 colors[ImGuiCol_TabDimmed] = ImLerp(colors[ImGuiCol_Tab], colors[ImGuiCol_TitleBg], 0.80f);
219 colors[ImGuiCol_TabDimmedSelected] = ImLerp(colors[ImGuiCol_TabSelected], colors[ImGuiCol_TitleBg], 0.40f);
220 colors[ImGuiCol_TabDimmedSelectedOverline] = ImVec4(0.50f, 0.50f, 0.50f, 1.00f);
221 colors[ImGuiCol_DockingPreview] = colors[ImGuiCol_HeaderActive] * ImVec4(1.0f, 1.0f, 1.0f, 0.7f);
222 colors[ImGuiCol_DockingEmptyBg] = ImVec4(0.20f, 0.20f, 0.20f, 1.00f);
223 colors[ImGuiCol_PlotLines] = ImVec4(0.61f, 0.61f, 0.61f, 1.00f);
224 colors[ImGuiCol_PlotLinesHovered] = ImVec4(1.00f, 0.43f, 0.35f, 1.00f);
225 colors[ImGuiCol_PlotHistogram] = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);
226 colors[ImGuiCol_PlotHistogramHovered] = ImVec4(1.00f, 0.60f, 0.00f, 1.00f);
227 colors[ImGuiCol_TableHeaderBg] = ImVec4(0.19f, 0.19f, 0.20f, 1.00f);
228 colors[ImGuiCol_TableBorderStrong] = ImVec4(0.31f, 0.31f, 0.35f, 1.00f); // Prefer using Alpha=1.0 here
229 colors[ImGuiCol_TableBorderLight] = ImVec4(0.23f, 0.23f, 0.25f, 1.00f); // Prefer using Alpha=1.0 here
230 colors[ImGuiCol_TableRowBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
231 colors[ImGuiCol_TableRowBgAlt] = ImVec4(1.00f, 1.00f, 1.00f, 0.06f);
232 colors[ImGuiCol_TextLink] = colors[ImGuiCol_HeaderActive];
233 colors[ImGuiCol_TextSelectedBg] = ImVec4(0.26f, 0.59f, 0.98f, 0.35f);
234 colors[ImGuiCol_DragDropTarget] = ImVec4(1.00f, 1.00f, 0.00f, 0.90f);
235 colors[ImGuiCol_NavHighlight] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
236 colors[ImGuiCol_NavWindowingHighlight] = ImVec4(1.00f, 1.00f, 1.00f, 0.70f);
237 colors[ImGuiCol_NavWindowingDimBg] = ImVec4(0.80f, 0.80f, 0.80f, 0.20f);
238 colors[ImGuiCol_ModalWindowDimBg] = ImVec4(0.80f, 0.80f, 0.80f, 0.35f);
239}
240
241void ImGui::StyleColorsClassic(ImGuiStyle* dst)
242{
243 ImGuiStyle* style = dst ? dst : &ImGui::GetStyle();
244 ImVec4* colors = style->Colors;
245
246 colors[ImGuiCol_Text] = ImVec4(0.90f, 0.90f, 0.90f, 1.00f);
247 colors[ImGuiCol_TextDisabled] = ImVec4(0.60f, 0.60f, 0.60f, 1.00f);
248 colors[ImGuiCol_WindowBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.85f);
249 colors[ImGuiCol_ChildBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
250 colors[ImGuiCol_PopupBg] = ImVec4(0.11f, 0.11f, 0.14f, 0.92f);
251 colors[ImGuiCol_Border] = ImVec4(0.50f, 0.50f, 0.50f, 0.50f);
252 colors[ImGuiCol_BorderShadow] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
253 colors[ImGuiCol_FrameBg] = ImVec4(0.43f, 0.43f, 0.43f, 0.39f);
254 colors[ImGuiCol_FrameBgHovered] = ImVec4(0.47f, 0.47f, 0.69f, 0.40f);
255 colors[ImGuiCol_FrameBgActive] = ImVec4(0.42f, 0.41f, 0.64f, 0.69f);
256 colors[ImGuiCol_TitleBg] = ImVec4(0.27f, 0.27f, 0.54f, 0.83f);
257 colors[ImGuiCol_TitleBgActive] = ImVec4(0.32f, 0.32f, 0.63f, 0.87f);
258 colors[ImGuiCol_TitleBgCollapsed] = ImVec4(0.40f, 0.40f, 0.80f, 0.20f);
259 colors[ImGuiCol_MenuBarBg] = ImVec4(0.40f, 0.40f, 0.55f, 0.80f);
260 colors[ImGuiCol_ScrollbarBg] = ImVec4(0.20f, 0.25f, 0.30f, 0.60f);
261 colors[ImGuiCol_ScrollbarGrab] = ImVec4(0.40f, 0.40f, 0.80f, 0.30f);
262 colors[ImGuiCol_ScrollbarGrabHovered] = ImVec4(0.40f, 0.40f, 0.80f, 0.40f);
263 colors[ImGuiCol_ScrollbarGrabActive] = ImVec4(0.41f, 0.39f, 0.80f, 0.60f);
264 colors[ImGuiCol_CheckMark] = ImVec4(0.90f, 0.90f, 0.90f, 0.50f);
265 colors[ImGuiCol_SliderGrab] = ImVec4(1.00f, 1.00f, 1.00f, 0.30f);
266 colors[ImGuiCol_SliderGrabActive] = ImVec4(0.41f, 0.39f, 0.80f, 0.60f);
267 colors[ImGuiCol_Button] = ImVec4(0.35f, 0.40f, 0.61f, 0.62f);
268 colors[ImGuiCol_ButtonHovered] = ImVec4(0.40f, 0.48f, 0.71f, 0.79f);
269 colors[ImGuiCol_ButtonActive] = ImVec4(0.46f, 0.54f, 0.80f, 1.00f);
270 colors[ImGuiCol_Header] = ImVec4(0.40f, 0.40f, 0.90f, 0.45f);
271 colors[ImGuiCol_HeaderHovered] = ImVec4(0.45f, 0.45f, 0.90f, 0.80f);
272 colors[ImGuiCol_HeaderActive] = ImVec4(0.53f, 0.53f, 0.87f, 0.80f);
273 colors[ImGuiCol_Separator] = ImVec4(0.50f, 0.50f, 0.50f, 0.60f);
274 colors[ImGuiCol_SeparatorHovered] = ImVec4(0.60f, 0.60f, 0.70f, 1.00f);
275 colors[ImGuiCol_SeparatorActive] = ImVec4(0.70f, 0.70f, 0.90f, 1.00f);
276 colors[ImGuiCol_ResizeGrip] = ImVec4(1.00f, 1.00f, 1.00f, 0.10f);
277 colors[ImGuiCol_ResizeGripHovered] = ImVec4(0.78f, 0.82f, 1.00f, 0.60f);
278 colors[ImGuiCol_ResizeGripActive] = ImVec4(0.78f, 0.82f, 1.00f, 0.90f);
279 colors[ImGuiCol_TabHovered] = colors[ImGuiCol_HeaderHovered];
280 colors[ImGuiCol_Tab] = ImLerp(colors[ImGuiCol_Header], colors[ImGuiCol_TitleBgActive], 0.80f);
281 colors[ImGuiCol_TabSelected] = ImLerp(colors[ImGuiCol_HeaderActive], colors[ImGuiCol_TitleBgActive], 0.60f);
282 colors[ImGuiCol_TabSelectedOverline] = colors[ImGuiCol_HeaderActive];
283 colors[ImGuiCol_TabDimmed] = ImLerp(colors[ImGuiCol_Tab], colors[ImGuiCol_TitleBg], 0.80f);
284 colors[ImGuiCol_TabDimmedSelected] = ImLerp(colors[ImGuiCol_TabSelected], colors[ImGuiCol_TitleBg], 0.40f);
285 colors[ImGuiCol_TabDimmedSelectedOverline] = colors[ImGuiCol_HeaderActive];
286 colors[ImGuiCol_DockingPreview] = colors[ImGuiCol_Header] * ImVec4(1.0f, 1.0f, 1.0f, 0.7f);
287 colors[ImGuiCol_DockingEmptyBg] = ImVec4(0.20f, 0.20f, 0.20f, 1.00f);
288 colors[ImGuiCol_PlotLines] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
289 colors[ImGuiCol_PlotLinesHovered] = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);
290 colors[ImGuiCol_PlotHistogram] = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);
291 colors[ImGuiCol_PlotHistogramHovered] = ImVec4(1.00f, 0.60f, 0.00f, 1.00f);
292 colors[ImGuiCol_TableHeaderBg] = ImVec4(0.27f, 0.27f, 0.38f, 1.00f);
293 colors[ImGuiCol_TableBorderStrong] = ImVec4(0.31f, 0.31f, 0.45f, 1.00f); // Prefer using Alpha=1.0 here
294 colors[ImGuiCol_TableBorderLight] = ImVec4(0.26f, 0.26f, 0.28f, 1.00f); // Prefer using Alpha=1.0 here
295 colors[ImGuiCol_TableRowBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
296 colors[ImGuiCol_TableRowBgAlt] = ImVec4(1.00f, 1.00f, 1.00f, 0.07f);
297 colors[ImGuiCol_TextLink] = colors[ImGuiCol_HeaderActive];
298 colors[ImGuiCol_TextSelectedBg] = ImVec4(0.00f, 0.00f, 1.00f, 0.35f);
299 colors[ImGuiCol_DragDropTarget] = ImVec4(1.00f, 1.00f, 0.00f, 0.90f);
300 colors[ImGuiCol_NavHighlight] = colors[ImGuiCol_HeaderHovered];
301 colors[ImGuiCol_NavWindowingHighlight] = ImVec4(1.00f, 1.00f, 1.00f, 0.70f);
302 colors[ImGuiCol_NavWindowingDimBg] = ImVec4(0.80f, 0.80f, 0.80f, 0.20f);
303 colors[ImGuiCol_ModalWindowDimBg] = ImVec4(0.20f, 0.20f, 0.20f, 0.35f);
304}
305
306// Those light colors are better suited with a thicker font than the default one + FrameBorder
307void ImGui::StyleColorsLight(ImGuiStyle* dst)
308{
309 ImGuiStyle* style = dst ? dst : &ImGui::GetStyle();
310 ImVec4* colors = style->Colors;
311
312 colors[ImGuiCol_Text] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
313 colors[ImGuiCol_TextDisabled] = ImVec4(0.60f, 0.60f, 0.60f, 1.00f);
314 colors[ImGuiCol_WindowBg] = ImVec4(0.94f, 0.94f, 0.94f, 1.00f);
315 colors[ImGuiCol_ChildBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
316 colors[ImGuiCol_PopupBg] = ImVec4(1.00f, 1.00f, 1.00f, 0.98f);
317 colors[ImGuiCol_Border] = ImVec4(0.00f, 0.00f, 0.00f, 0.30f);
318 colors[ImGuiCol_BorderShadow] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
319 colors[ImGuiCol_FrameBg] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
320 colors[ImGuiCol_FrameBgHovered] = ImVec4(0.26f, 0.59f, 0.98f, 0.40f);
321 colors[ImGuiCol_FrameBgActive] = ImVec4(0.26f, 0.59f, 0.98f, 0.67f);
322 colors[ImGuiCol_TitleBg] = ImVec4(0.96f, 0.96f, 0.96f, 1.00f);
323 colors[ImGuiCol_TitleBgActive] = ImVec4(0.82f, 0.82f, 0.82f, 1.00f);
324 colors[ImGuiCol_TitleBgCollapsed] = ImVec4(1.00f, 1.00f, 1.00f, 0.51f);
325 colors[ImGuiCol_MenuBarBg] = ImVec4(0.86f, 0.86f, 0.86f, 1.00f);
326 colors[ImGuiCol_ScrollbarBg] = ImVec4(0.98f, 0.98f, 0.98f, 0.53f);
327 colors[ImGuiCol_ScrollbarGrab] = ImVec4(0.69f, 0.69f, 0.69f, 0.80f);
328 colors[ImGuiCol_ScrollbarGrabHovered] = ImVec4(0.49f, 0.49f, 0.49f, 0.80f);
329 colors[ImGuiCol_ScrollbarGrabActive] = ImVec4(0.49f, 0.49f, 0.49f, 1.00f);
330 colors[ImGuiCol_CheckMark] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
331 colors[ImGuiCol_SliderGrab] = ImVec4(0.26f, 0.59f, 0.98f, 0.78f);
332 colors[ImGuiCol_SliderGrabActive] = ImVec4(0.46f, 0.54f, 0.80f, 0.60f);
333 colors[ImGuiCol_Button] = ImVec4(0.26f, 0.59f, 0.98f, 0.40f);
334 colors[ImGuiCol_ButtonHovered] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
335 colors[ImGuiCol_ButtonActive] = ImVec4(0.06f, 0.53f, 0.98f, 1.00f);
336 colors[ImGuiCol_Header] = ImVec4(0.26f, 0.59f, 0.98f, 0.31f);
337 colors[ImGuiCol_HeaderHovered] = ImVec4(0.26f, 0.59f, 0.98f, 0.80f);
338 colors[ImGuiCol_HeaderActive] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
339 colors[ImGuiCol_Separator] = ImVec4(0.39f, 0.39f, 0.39f, 0.62f);
340 colors[ImGuiCol_SeparatorHovered] = ImVec4(0.14f, 0.44f, 0.80f, 0.78f);
341 colors[ImGuiCol_SeparatorActive] = ImVec4(0.14f, 0.44f, 0.80f, 1.00f);
342 colors[ImGuiCol_ResizeGrip] = ImVec4(0.35f, 0.35f, 0.35f, 0.17f);
343 colors[ImGuiCol_ResizeGripHovered] = ImVec4(0.26f, 0.59f, 0.98f, 0.67f);
344 colors[ImGuiCol_ResizeGripActive] = ImVec4(0.26f, 0.59f, 0.98f, 0.95f);
345 colors[ImGuiCol_TabHovered] = colors[ImGuiCol_HeaderHovered];
346 colors[ImGuiCol_Tab] = ImLerp(colors[ImGuiCol_Header], colors[ImGuiCol_TitleBgActive], 0.90f);
347 colors[ImGuiCol_TabSelected] = ImLerp(colors[ImGuiCol_HeaderActive], colors[ImGuiCol_TitleBgActive], 0.60f);
348 colors[ImGuiCol_TabSelectedOverline] = colors[ImGuiCol_HeaderActive];
349 colors[ImGuiCol_TabDimmed] = ImLerp(colors[ImGuiCol_Tab], colors[ImGuiCol_TitleBg], 0.80f);
350 colors[ImGuiCol_TabDimmedSelected] = ImLerp(colors[ImGuiCol_TabSelected], colors[ImGuiCol_TitleBg], 0.40f);
351 colors[ImGuiCol_TabDimmedSelectedOverline] = ImVec4(0.26f, 0.59f, 1.00f, 1.00f);
352 colors[ImGuiCol_DockingPreview] = colors[ImGuiCol_Header] * ImVec4(1.0f, 1.0f, 1.0f, 0.7f);
353 colors[ImGuiCol_DockingEmptyBg] = ImVec4(0.20f, 0.20f, 0.20f, 1.00f);
354 colors[ImGuiCol_PlotLines] = ImVec4(0.39f, 0.39f, 0.39f, 1.00f);
355 colors[ImGuiCol_PlotLinesHovered] = ImVec4(1.00f, 0.43f, 0.35f, 1.00f);
356 colors[ImGuiCol_PlotHistogram] = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);
357 colors[ImGuiCol_PlotHistogramHovered] = ImVec4(1.00f, 0.45f, 0.00f, 1.00f);
358 colors[ImGuiCol_TableHeaderBg] = ImVec4(0.78f, 0.87f, 0.98f, 1.00f);
359 colors[ImGuiCol_TableBorderStrong] = ImVec4(0.57f, 0.57f, 0.64f, 1.00f); // Prefer using Alpha=1.0 here
360 colors[ImGuiCol_TableBorderLight] = ImVec4(0.68f, 0.68f, 0.74f, 1.00f); // Prefer using Alpha=1.0 here
361 colors[ImGuiCol_TableRowBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
362 colors[ImGuiCol_TableRowBgAlt] = ImVec4(0.30f, 0.30f, 0.30f, 0.09f);
363 colors[ImGuiCol_TextLink] = colors[ImGuiCol_HeaderActive];
364 colors[ImGuiCol_TextSelectedBg] = ImVec4(0.26f, 0.59f, 0.98f, 0.35f);
365 colors[ImGuiCol_DragDropTarget] = ImVec4(0.26f, 0.59f, 0.98f, 0.95f);
366 colors[ImGuiCol_NavHighlight] = colors[ImGuiCol_HeaderHovered];
367 colors[ImGuiCol_NavWindowingHighlight] = ImVec4(0.70f, 0.70f, 0.70f, 0.70f);
368 colors[ImGuiCol_NavWindowingDimBg] = ImVec4(0.20f, 0.20f, 0.20f, 0.20f);
369 colors[ImGuiCol_ModalWindowDimBg] = ImVec4(0.20f, 0.20f, 0.20f, 0.35f);
370}
371
372//-----------------------------------------------------------------------------
373// [SECTION] ImDrawList
374//-----------------------------------------------------------------------------
375
376ImDrawListSharedData::ImDrawListSharedData()
377{
378 memset(this, 0, sizeof(*this));
379 for (int i = 0; i < IM_ARRAYSIZE(ArcFastVtx); i++)
380 {
381 const float a = ((float)i * 2 * IM_PI) / (float)IM_ARRAYSIZE(ArcFastVtx);
382 ArcFastVtx[i] = ImVec2(ImCos(a), ImSin(a));
383 }
384 ArcFastRadiusCutoff = IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC_R(IM_DRAWLIST_ARCFAST_SAMPLE_MAX, CircleSegmentMaxError);
385}
386
387void ImDrawListSharedData::SetCircleTessellationMaxError(float max_error)
388{
389 if (CircleSegmentMaxError == max_error)
390 return;
391
392 IM_ASSERT(max_error > 0.0f);
393 CircleSegmentMaxError = max_error;
394 for (int i = 0; i < IM_ARRAYSIZE(CircleSegmentCounts); i++)
395 {
396 const float radius = (float)i;
397 CircleSegmentCounts[i] = (ImU8)((i > 0) ? IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC(radius, CircleSegmentMaxError) : IM_DRAWLIST_ARCFAST_SAMPLE_MAX);
398 }
399 ArcFastRadiusCutoff = IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC_R(IM_DRAWLIST_ARCFAST_SAMPLE_MAX, CircleSegmentMaxError);
400}
401
402// Initialize before use in a new frame. We always have a command ready in the buffer.
403// In the majority of cases, you would want to call PushClipRect() and PushTextureID() after this.
404void ImDrawList::_ResetForNewFrame()
405{
406 // Verify that the ImDrawCmd fields we want to memcmp() are contiguous in memory.
407 IM_STATIC_ASSERT(offsetof(ImDrawCmd, ClipRect) == 0);
408 IM_STATIC_ASSERT(offsetof(ImDrawCmd, TextureId) == sizeof(ImVec4));
409 IM_STATIC_ASSERT(offsetof(ImDrawCmd, VtxOffset) == sizeof(ImVec4) + sizeof(ImTextureID));
410 if (_Splitter._Count > 1)
411 _Splitter.Merge(this);
412
413 CmdBuffer.resize(0);
414 IdxBuffer.resize(0);
415 VtxBuffer.resize(0);
416 Flags = _Data->InitialFlags;
417 memset(&_CmdHeader, 0, sizeof(_CmdHeader));
418 _VtxCurrentIdx = 0;
419 _VtxWritePtr = NULL;
420 _IdxWritePtr = NULL;
421 _ClipRectStack.resize(0);
422 _TextureIdStack.resize(0);
423 _Path.resize(0);
424 _Splitter.Clear();
425 CmdBuffer.push_back(ImDrawCmd());
426 _FringeScale = 1.0f;
427}
428
429void ImDrawList::_ClearFreeMemory()
430{
431 CmdBuffer.clear();
432 IdxBuffer.clear();
433 VtxBuffer.clear();
434 Flags = ImDrawListFlags_None;
435 _VtxCurrentIdx = 0;
436 _VtxWritePtr = NULL;
437 _IdxWritePtr = NULL;
438 _ClipRectStack.clear();
439 _TextureIdStack.clear();
440 _Path.clear();
441 _Splitter.ClearFreeMemory();
442}
443
444ImDrawList* ImDrawList::CloneOutput() const
445{
446 ImDrawList* dst = IM_NEW(ImDrawList(_Data));
447 dst->CmdBuffer = CmdBuffer;
448 dst->IdxBuffer = IdxBuffer;
449 dst->VtxBuffer = VtxBuffer;
450 dst->Flags = Flags;
451 return dst;
452}
453
454void ImDrawList::AddDrawCmd()
455{
456 ImDrawCmd draw_cmd;
457 draw_cmd.ClipRect = _CmdHeader.ClipRect; // Same as calling ImDrawCmd_HeaderCopy()
458 draw_cmd.TextureId = _CmdHeader.TextureId;
459 draw_cmd.VtxOffset = _CmdHeader.VtxOffset;
460 draw_cmd.IdxOffset = IdxBuffer.Size;
461
462 IM_ASSERT(draw_cmd.ClipRect.x <= draw_cmd.ClipRect.z && draw_cmd.ClipRect.y <= draw_cmd.ClipRect.w);
463 CmdBuffer.push_back(draw_cmd);
464}
465
466// Pop trailing draw command (used before merging or presenting to user)
467// Note that this leaves the ImDrawList in a state unfit for further commands, as most code assume that CmdBuffer.Size > 0 && CmdBuffer.back().UserCallback == NULL
468void ImDrawList::_PopUnusedDrawCmd()
469{
470 while (CmdBuffer.Size > 0)
471 {
472 ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
473 if (curr_cmd->ElemCount != 0 || curr_cmd->UserCallback != NULL)
474 return;// break;
475 CmdBuffer.pop_back();
476 }
477}
478
479void ImDrawList::AddCallback(ImDrawCallback callback, void* callback_data)
480{
481 IM_ASSERT_PARANOID(CmdBuffer.Size > 0);
482 ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
483 IM_ASSERT(curr_cmd->UserCallback == NULL);
484 if (curr_cmd->ElemCount != 0)
485 {
486 AddDrawCmd();
487 curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
488 }
489 curr_cmd->UserCallback = callback;
490 curr_cmd->UserCallbackData = callback_data;
491
492 AddDrawCmd(); // Force a new command after us (see comment below)
493}
494
495// Compare ClipRect, TextureId and VtxOffset with a single memcmp()
496#define ImDrawCmd_HeaderSize (offsetof(ImDrawCmd, VtxOffset) + sizeof(unsigned int))
497#define ImDrawCmd_HeaderCompare(CMD_LHS, CMD_RHS) (memcmp(CMD_LHS, CMD_RHS, ImDrawCmd_HeaderSize)) // Compare ClipRect, TextureId, VtxOffset
498#define ImDrawCmd_HeaderCopy(CMD_DST, CMD_SRC) (memcpy(CMD_DST, CMD_SRC, ImDrawCmd_HeaderSize)) // Copy ClipRect, TextureId, VtxOffset
499#define ImDrawCmd_AreSequentialIdxOffset(CMD_0, CMD_1) (CMD_0->IdxOffset + CMD_0->ElemCount == CMD_1->IdxOffset)
500
501// Try to merge two last draw commands
502void ImDrawList::_TryMergeDrawCmds()
503{
504 IM_ASSERT_PARANOID(CmdBuffer.Size > 0);
505 ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
506 ImDrawCmd* prev_cmd = curr_cmd - 1;
507 if (ImDrawCmd_HeaderCompare(curr_cmd, prev_cmd) == 0 && ImDrawCmd_AreSequentialIdxOffset(prev_cmd, curr_cmd) && curr_cmd->UserCallback == NULL && prev_cmd->UserCallback == NULL)
508 {
509 prev_cmd->ElemCount += curr_cmd->ElemCount;
510 CmdBuffer.pop_back();
511 }
512}
513
514// Our scheme may appears a bit unusual, basically we want the most-common calls AddLine AddRect etc. to not have to perform any check so we always have a command ready in the stack.
515// The cost of figuring out if a new command has to be added or if we can merge is paid in those Update** functions only.
516void ImDrawList::_OnChangedClipRect()
517{
518 // If current command is used with different settings we need to add a new command
519 IM_ASSERT_PARANOID(CmdBuffer.Size > 0);
520 ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
521 if (curr_cmd->ElemCount != 0 && memcmp(&curr_cmd->ClipRect, &_CmdHeader.ClipRect, sizeof(ImVec4)) != 0)
522 {
523 AddDrawCmd();
524 return;
525 }
526 IM_ASSERT(curr_cmd->UserCallback == NULL);
527
528 // Try to merge with previous command if it matches, else use current command
529 ImDrawCmd* prev_cmd = curr_cmd - 1;
530 if (curr_cmd->ElemCount == 0 && CmdBuffer.Size > 1 && ImDrawCmd_HeaderCompare(&_CmdHeader, prev_cmd) == 0 && ImDrawCmd_AreSequentialIdxOffset(prev_cmd, curr_cmd) && prev_cmd->UserCallback == NULL)
531 {
532 CmdBuffer.pop_back();
533 return;
534 }
535
536 curr_cmd->ClipRect = _CmdHeader.ClipRect;
537}
538
539void ImDrawList::_OnChangedTextureID()
540{
541 // If current command is used with different settings we need to add a new command
542 IM_ASSERT_PARANOID(CmdBuffer.Size > 0);
543 ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
544 if (curr_cmd->ElemCount != 0 && curr_cmd->TextureId != _CmdHeader.TextureId)
545 {
546 AddDrawCmd();
547 return;
548 }
549 IM_ASSERT(curr_cmd->UserCallback == NULL);
550
551 // Try to merge with previous command if it matches, else use current command
552 ImDrawCmd* prev_cmd = curr_cmd - 1;
553 if (curr_cmd->ElemCount == 0 && CmdBuffer.Size > 1 && ImDrawCmd_HeaderCompare(&_CmdHeader, prev_cmd) == 0 && ImDrawCmd_AreSequentialIdxOffset(prev_cmd, curr_cmd) && prev_cmd->UserCallback == NULL)
554 {
555 CmdBuffer.pop_back();
556 return;
557 }
558
559 curr_cmd->TextureId = _CmdHeader.TextureId;
560}
561
562void ImDrawList::_OnChangedVtxOffset()
563{
564 // We don't need to compare curr_cmd->VtxOffset != _CmdHeader.VtxOffset because we know it'll be different at the time we call this.
565 _VtxCurrentIdx = 0;
566 IM_ASSERT_PARANOID(CmdBuffer.Size > 0);
567 ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
568 //IM_ASSERT(curr_cmd->VtxOffset != _CmdHeader.VtxOffset); // See #3349
569 if (curr_cmd->ElemCount != 0)
570 {
571 AddDrawCmd();
572 return;
573 }
574 IM_ASSERT(curr_cmd->UserCallback == NULL);
575 curr_cmd->VtxOffset = _CmdHeader.VtxOffset;
576}
577
578int ImDrawList::_CalcCircleAutoSegmentCount(float radius) const
579{
580 // Automatic segment count
581 const int radius_idx = (int)(radius + 0.999999f); // ceil to never reduce accuracy
582 if (radius_idx >= 0 && radius_idx < IM_ARRAYSIZE(_Data->CircleSegmentCounts))
583 return _Data->CircleSegmentCounts[radius_idx]; // Use cached value
584 else
585 return IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC(radius, _Data->CircleSegmentMaxError);
586}
587
588// Render-level scissoring. This is passed down to your render function but not used for CPU-side coarse clipping. Prefer using higher-level ImGui::PushClipRect() to affect logic (hit-testing and widget culling)
589void ImDrawList::PushClipRect(const ImVec2& cr_min, const ImVec2& cr_max, bool intersect_with_current_clip_rect)
590{
591 ImVec4 cr(cr_min.x, cr_min.y, cr_max.x, cr_max.y);
592 if (intersect_with_current_clip_rect)
593 {
594 ImVec4 current = _CmdHeader.ClipRect;
595 if (cr.x < current.x) cr.x = current.x;
596 if (cr.y < current.y) cr.y = current.y;
597 if (cr.z > current.z) cr.z = current.z;
598 if (cr.w > current.w) cr.w = current.w;
599 }
600 cr.z = ImMax(cr.x, cr.z);
601 cr.w = ImMax(cr.y, cr.w);
602
603 _ClipRectStack.push_back(cr);
604 _CmdHeader.ClipRect = cr;
605 _OnChangedClipRect();
606}
607
608void ImDrawList::PushClipRectFullScreen()
609{
610 PushClipRect(ImVec2(_Data->ClipRectFullscreen.x, _Data->ClipRectFullscreen.y), ImVec2(_Data->ClipRectFullscreen.z, _Data->ClipRectFullscreen.w));
611}
612
613void ImDrawList::PopClipRect()
614{
615 _ClipRectStack.pop_back();
616 _CmdHeader.ClipRect = (_ClipRectStack.Size == 0) ? _Data->ClipRectFullscreen : _ClipRectStack.Data[_ClipRectStack.Size - 1];
617 _OnChangedClipRect();
618}
619
620void ImDrawList::PushTextureID(ImTextureID texture_id)
621{
622 _TextureIdStack.push_back(texture_id);
623 _CmdHeader.TextureId = texture_id;
624 _OnChangedTextureID();
625}
626
627void ImDrawList::PopTextureID()
628{
629 _TextureIdStack.pop_back();
630 _CmdHeader.TextureId = (_TextureIdStack.Size == 0) ? (ImTextureID)NULL : _TextureIdStack.Data[_TextureIdStack.Size - 1];
631 _OnChangedTextureID();
632}
633
634// Reserve space for a number of vertices and indices.
635// You must finish filling your reserved data before calling PrimReserve() again, as it may reallocate or
636// submit the intermediate results. PrimUnreserve() can be used to release unused allocations.
637void ImDrawList::PrimReserve(int idx_count, int vtx_count)
638{
639 // Large mesh support (when enabled)
640 IM_ASSERT_PARANOID(idx_count >= 0 && vtx_count >= 0);
641 if (sizeof(ImDrawIdx) == 2 && (_VtxCurrentIdx + vtx_count >= (1 << 16)) && (Flags & ImDrawListFlags_AllowVtxOffset))
642 {
643 // FIXME: In theory we should be testing that vtx_count <64k here.
644 // In practice, RenderText() relies on reserving ahead for a worst case scenario so it is currently useful for us
645 // to not make that check until we rework the text functions to handle clipping and large horizontal lines better.
646 _CmdHeader.VtxOffset = VtxBuffer.Size;
647 _OnChangedVtxOffset();
648 }
649
650 ImDrawCmd* draw_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
651 draw_cmd->ElemCount += idx_count;
652
653 int vtx_buffer_old_size = VtxBuffer.Size;
654 VtxBuffer.resize(vtx_buffer_old_size + vtx_count);
655 _VtxWritePtr = VtxBuffer.Data + vtx_buffer_old_size;
656
657 int idx_buffer_old_size = IdxBuffer.Size;
658 IdxBuffer.resize(idx_buffer_old_size + idx_count);
659 _IdxWritePtr = IdxBuffer.Data + idx_buffer_old_size;
660}
661
662// Release the number of reserved vertices/indices from the end of the last reservation made with PrimReserve().
663void ImDrawList::PrimUnreserve(int idx_count, int vtx_count)
664{
665 IM_ASSERT_PARANOID(idx_count >= 0 && vtx_count >= 0);
666
667 ImDrawCmd* draw_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
668 draw_cmd->ElemCount -= idx_count;
669 VtxBuffer.shrink(VtxBuffer.Size - vtx_count);
670 IdxBuffer.shrink(IdxBuffer.Size - idx_count);
671}
672
673// Fully unrolled with inline call to keep our debug builds decently fast.
674void ImDrawList::PrimRect(const ImVec2& a, const ImVec2& c, ImU32 col)
675{
676 ImVec2 b(c.x, a.y), d(a.x, c.y), uv(_Data->TexUvWhitePixel);
677 ImDrawIdx idx = (ImDrawIdx)_VtxCurrentIdx;
678 _IdxWritePtr[0] = idx; _IdxWritePtr[1] = (ImDrawIdx)(idx+1); _IdxWritePtr[2] = (ImDrawIdx)(idx+2);
679 _IdxWritePtr[3] = idx; _IdxWritePtr[4] = (ImDrawIdx)(idx+2); _IdxWritePtr[5] = (ImDrawIdx)(idx+3);
680 _VtxWritePtr[0].pos = a; _VtxWritePtr[0].uv = uv; _VtxWritePtr[0].col = col;
681 _VtxWritePtr[1].pos = b; _VtxWritePtr[1].uv = uv; _VtxWritePtr[1].col = col;
682 _VtxWritePtr[2].pos = c; _VtxWritePtr[2].uv = uv; _VtxWritePtr[2].col = col;
683 _VtxWritePtr[3].pos = d; _VtxWritePtr[3].uv = uv; _VtxWritePtr[3].col = col;
684 _VtxWritePtr += 4;
685 _VtxCurrentIdx += 4;
686 _IdxWritePtr += 6;
687}
688
689void ImDrawList::PrimRectUV(const ImVec2& a, const ImVec2& c, const ImVec2& uv_a, const ImVec2& uv_c, ImU32 col)
690{
691 ImVec2 b(c.x, a.y), d(a.x, c.y), uv_b(uv_c.x, uv_a.y), uv_d(uv_a.x, uv_c.y);
692 ImDrawIdx idx = (ImDrawIdx)_VtxCurrentIdx;
693 _IdxWritePtr[0] = idx; _IdxWritePtr[1] = (ImDrawIdx)(idx+1); _IdxWritePtr[2] = (ImDrawIdx)(idx+2);
694 _IdxWritePtr[3] = idx; _IdxWritePtr[4] = (ImDrawIdx)(idx+2); _IdxWritePtr[5] = (ImDrawIdx)(idx+3);
695 _VtxWritePtr[0].pos = a; _VtxWritePtr[0].uv = uv_a; _VtxWritePtr[0].col = col;
696 _VtxWritePtr[1].pos = b; _VtxWritePtr[1].uv = uv_b; _VtxWritePtr[1].col = col;
697 _VtxWritePtr[2].pos = c; _VtxWritePtr[2].uv = uv_c; _VtxWritePtr[2].col = col;
698 _VtxWritePtr[3].pos = d; _VtxWritePtr[3].uv = uv_d; _VtxWritePtr[3].col = col;
699 _VtxWritePtr += 4;
700 _VtxCurrentIdx += 4;
701 _IdxWritePtr += 6;
702}
703
704void ImDrawList::PrimQuadUV(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& d, const ImVec2& uv_a, const ImVec2& uv_b, const ImVec2& uv_c, const ImVec2& uv_d, ImU32 col)
705{
706 ImDrawIdx idx = (ImDrawIdx)_VtxCurrentIdx;
707 _IdxWritePtr[0] = idx; _IdxWritePtr[1] = (ImDrawIdx)(idx+1); _IdxWritePtr[2] = (ImDrawIdx)(idx+2);
708 _IdxWritePtr[3] = idx; _IdxWritePtr[4] = (ImDrawIdx)(idx+2); _IdxWritePtr[5] = (ImDrawIdx)(idx+3);
709 _VtxWritePtr[0].pos = a; _VtxWritePtr[0].uv = uv_a; _VtxWritePtr[0].col = col;
710 _VtxWritePtr[1].pos = b; _VtxWritePtr[1].uv = uv_b; _VtxWritePtr[1].col = col;
711 _VtxWritePtr[2].pos = c; _VtxWritePtr[2].uv = uv_c; _VtxWritePtr[2].col = col;
712 _VtxWritePtr[3].pos = d; _VtxWritePtr[3].uv = uv_d; _VtxWritePtr[3].col = col;
713 _VtxWritePtr += 4;
714 _VtxCurrentIdx += 4;
715 _IdxWritePtr += 6;
716}
717
718// On AddPolyline() and AddConvexPolyFilled() we intentionally avoid using ImVec2 and superfluous function calls to optimize debug/non-inlined builds.
719// - Those macros expects l-values and need to be used as their own statement.
720// - Those macros are intentionally not surrounded by the 'do {} while (0)' idiom because even that translates to runtime with debug compilers.
721#define IM_NORMALIZE2F_OVER_ZERO(VX,VY) { float d2 = VX*VX + VY*VY; if (d2 > 0.0f) { float inv_len = ImRsqrt(d2); VX *= inv_len; VY *= inv_len; } } (void)0
722#define IM_FIXNORMAL2F_MAX_INVLEN2 100.0f // 500.0f (see #4053, #3366)
723#define IM_FIXNORMAL2F(VX,VY) { float d2 = VX*VX + VY*VY; if (d2 > 0.000001f) { float inv_len2 = 1.0f / d2; if (inv_len2 > IM_FIXNORMAL2F_MAX_INVLEN2) inv_len2 = IM_FIXNORMAL2F_MAX_INVLEN2; VX *= inv_len2; VY *= inv_len2; } } (void)0
724
725// TODO: Thickness anti-aliased lines cap are missing their AA fringe.
726// We avoid using the ImVec2 math operators here to reduce cost to a minimum for debug/non-inlined builds.
727void ImDrawList::AddPolyline(const ImVec2* points, const int points_count, ImU32 col, ImDrawFlags flags, float thickness)
728{
729 if (points_count < 2 || (col & IM_COL32_A_MASK) == 0)
730 return;
731
732 const bool closed = (flags & ImDrawFlags_Closed) != 0;
733 const ImVec2 opaque_uv = _Data->TexUvWhitePixel;
734 const int count = closed ? points_count : points_count - 1; // The number of line segments we need to draw
735 const bool thick_line = (thickness > _FringeScale);
736
737 if (Flags & ImDrawListFlags_AntiAliasedLines)
738 {
739 // Anti-aliased stroke
740 const float AA_SIZE = _FringeScale;
741 const ImU32 col_trans = col & ~IM_COL32_A_MASK;
742
743 // Thicknesses <1.0 should behave like thickness 1.0
744 thickness = ImMax(thickness, 1.0f);
745 const int integer_thickness = (int)thickness;
746 const float fractional_thickness = thickness - integer_thickness;
747
748 // Do we want to draw this line using a texture?
749 // - For now, only draw integer-width lines using textures to avoid issues with the way scaling occurs, could be improved.
750 // - If AA_SIZE is not 1.0f we cannot use the texture path.
751 const bool use_texture = (Flags & ImDrawListFlags_AntiAliasedLinesUseTex) && (integer_thickness < IM_DRAWLIST_TEX_LINES_WIDTH_MAX) && (fractional_thickness <= 0.00001f) && (AA_SIZE == 1.0f);
752
753 // We should never hit this, because NewFrame() doesn't set ImDrawListFlags_AntiAliasedLinesUseTex unless ImFontAtlasFlags_NoBakedLines is off
754 IM_ASSERT_PARANOID(!use_texture || !(_Data->Font->ContainerAtlas->Flags & ImFontAtlasFlags_NoBakedLines));
755
756 const int idx_count = use_texture ? (count * 6) : (thick_line ? count * 18 : count * 12);
757 const int vtx_count = use_texture ? (points_count * 2) : (thick_line ? points_count * 4 : points_count * 3);
758 PrimReserve(idx_count, vtx_count);
759
760 // Temporary buffer
761 // The first <points_count> items are normals at each line point, then after that there are either 2 or 4 temp points for each line point
762 _Data->TempBuffer.reserve_discard(points_count * ((use_texture || !thick_line) ? 3 : 5));
763 ImVec2* temp_normals = _Data->TempBuffer.Data;
764 ImVec2* temp_points = temp_normals + points_count;
765
766 // Calculate normals (tangents) for each line segment
767 for (int i1 = 0; i1 < count; i1++)
768 {
769 const int i2 = (i1 + 1) == points_count ? 0 : i1 + 1;
770 float dx = points[i2].x - points[i1].x;
771 float dy = points[i2].y - points[i1].y;
772 IM_NORMALIZE2F_OVER_ZERO(dx, dy);
773 temp_normals[i1].x = dy;
774 temp_normals[i1].y = -dx;
775 }
776 if (!closed)
777 temp_normals[points_count - 1] = temp_normals[points_count - 2];
778
779 // If we are drawing a one-pixel-wide line without a texture, or a textured line of any width, we only need 2 or 3 vertices per point
780 if (use_texture || !thick_line)
781 {
782 // [PATH 1] Texture-based lines (thick or non-thick)
783 // [PATH 2] Non texture-based lines (non-thick)
784
785 // The width of the geometry we need to draw - this is essentially <thickness> pixels for the line itself, plus "one pixel" for AA.
786 // - In the texture-based path, we don't use AA_SIZE here because the +1 is tied to the generated texture
787 // (see ImFontAtlasBuildRenderLinesTexData() function), and so alternate values won't work without changes to that code.
788 // - In the non texture-based paths, we would allow AA_SIZE to potentially be != 1.0f with a patch (e.g. fringe_scale patch to
789 // allow scaling geometry while preserving one-screen-pixel AA fringe).
790 const float half_draw_size = use_texture ? ((thickness * 0.5f) + 1) : AA_SIZE;
791
792 // If line is not closed, the first and last points need to be generated differently as there are no normals to blend
793 if (!closed)
794 {
795 temp_points[0] = points[0] + temp_normals[0] * half_draw_size;
796 temp_points[1] = points[0] - temp_normals[0] * half_draw_size;
797 temp_points[(points_count-1)*2+0] = points[points_count-1] + temp_normals[points_count-1] * half_draw_size;
798 temp_points[(points_count-1)*2+1] = points[points_count-1] - temp_normals[points_count-1] * half_draw_size;
799 }
800
801 // Generate the indices to form a number of triangles for each line segment, and the vertices for the line edges
802 // This takes points n and n+1 and writes into n+1, with the first point in a closed line being generated from the final one (as n+1 wraps)
803 // FIXME-OPT: Merge the different loops, possibly remove the temporary buffer.
804 unsigned int idx1 = _VtxCurrentIdx; // Vertex index for start of line segment
805 for (int i1 = 0; i1 < count; i1++) // i1 is the first point of the line segment
806 {
807 const int i2 = (i1 + 1) == points_count ? 0 : i1 + 1; // i2 is the second point of the line segment
808 const unsigned int idx2 = ((i1 + 1) == points_count) ? _VtxCurrentIdx : (idx1 + (use_texture ? 2 : 3)); // Vertex index for end of segment
809
810 // Average normals
811 float dm_x = (temp_normals[i1].x + temp_normals[i2].x) * 0.5f;
812 float dm_y = (temp_normals[i1].y + temp_normals[i2].y) * 0.5f;
813 IM_FIXNORMAL2F(dm_x, dm_y);
814 dm_x *= half_draw_size; // dm_x, dm_y are offset to the outer edge of the AA area
815 dm_y *= half_draw_size;
816
817 // Add temporary vertexes for the outer edges
818 ImVec2* out_vtx = &temp_points[i2 * 2];
819 out_vtx[0].x = points[i2].x + dm_x;
820 out_vtx[0].y = points[i2].y + dm_y;
821 out_vtx[1].x = points[i2].x - dm_x;
822 out_vtx[1].y = points[i2].y - dm_y;
823
824 if (use_texture)
825 {
826 // Add indices for two triangles
827 _IdxWritePtr[0] = (ImDrawIdx)(idx2 + 0); _IdxWritePtr[1] = (ImDrawIdx)(idx1 + 0); _IdxWritePtr[2] = (ImDrawIdx)(idx1 + 1); // Right tri
828 _IdxWritePtr[3] = (ImDrawIdx)(idx2 + 1); _IdxWritePtr[4] = (ImDrawIdx)(idx1 + 1); _IdxWritePtr[5] = (ImDrawIdx)(idx2 + 0); // Left tri
829 _IdxWritePtr += 6;
830 }
831 else
832 {
833 // Add indexes for four triangles
834 _IdxWritePtr[0] = (ImDrawIdx)(idx2 + 0); _IdxWritePtr[1] = (ImDrawIdx)(idx1 + 0); _IdxWritePtr[2] = (ImDrawIdx)(idx1 + 2); // Right tri 1
835 _IdxWritePtr[3] = (ImDrawIdx)(idx1 + 2); _IdxWritePtr[4] = (ImDrawIdx)(idx2 + 2); _IdxWritePtr[5] = (ImDrawIdx)(idx2 + 0); // Right tri 2
836 _IdxWritePtr[6] = (ImDrawIdx)(idx2 + 1); _IdxWritePtr[7] = (ImDrawIdx)(idx1 + 1); _IdxWritePtr[8] = (ImDrawIdx)(idx1 + 0); // Left tri 1
837 _IdxWritePtr[9] = (ImDrawIdx)(idx1 + 0); _IdxWritePtr[10] = (ImDrawIdx)(idx2 + 0); _IdxWritePtr[11] = (ImDrawIdx)(idx2 + 1); // Left tri 2
838 _IdxWritePtr += 12;
839 }
840
841 idx1 = idx2;
842 }
843
844 // Add vertexes for each point on the line
845 if (use_texture)
846 {
847 // If we're using textures we only need to emit the left/right edge vertices
848 ImVec4 tex_uvs = _Data->TexUvLines[integer_thickness];
849 /*if (fractional_thickness != 0.0f) // Currently always zero when use_texture==false!
850 {
851 const ImVec4 tex_uvs_1 = _Data->TexUvLines[integer_thickness + 1];
852 tex_uvs.x = tex_uvs.x + (tex_uvs_1.x - tex_uvs.x) * fractional_thickness; // inlined ImLerp()
853 tex_uvs.y = tex_uvs.y + (tex_uvs_1.y - tex_uvs.y) * fractional_thickness;
854 tex_uvs.z = tex_uvs.z + (tex_uvs_1.z - tex_uvs.z) * fractional_thickness;
855 tex_uvs.w = tex_uvs.w + (tex_uvs_1.w - tex_uvs.w) * fractional_thickness;
856 }*/
857 ImVec2 tex_uv0(tex_uvs.x, tex_uvs.y);
858 ImVec2 tex_uv1(tex_uvs.z, tex_uvs.w);
859 for (int i = 0; i < points_count; i++)
860 {
861 _VtxWritePtr[0].pos = temp_points[i * 2 + 0]; _VtxWritePtr[0].uv = tex_uv0; _VtxWritePtr[0].col = col; // Left-side outer edge
862 _VtxWritePtr[1].pos = temp_points[i * 2 + 1]; _VtxWritePtr[1].uv = tex_uv1; _VtxWritePtr[1].col = col; // Right-side outer edge
863 _VtxWritePtr += 2;
864 }
865 }
866 else
867 {
868 // If we're not using a texture, we need the center vertex as well
869 for (int i = 0; i < points_count; i++)
870 {
871 _VtxWritePtr[0].pos = points[i]; _VtxWritePtr[0].uv = opaque_uv; _VtxWritePtr[0].col = col; // Center of line
872 _VtxWritePtr[1].pos = temp_points[i * 2 + 0]; _VtxWritePtr[1].uv = opaque_uv; _VtxWritePtr[1].col = col_trans; // Left-side outer edge
873 _VtxWritePtr[2].pos = temp_points[i * 2 + 1]; _VtxWritePtr[2].uv = opaque_uv; _VtxWritePtr[2].col = col_trans; // Right-side outer edge
874 _VtxWritePtr += 3;
875 }
876 }
877 }
878 else
879 {
880 // [PATH 2] Non texture-based lines (thick): we need to draw the solid line core and thus require four vertices per point
881 const float half_inner_thickness = (thickness - AA_SIZE) * 0.5f;
882
883 // If line is not closed, the first and last points need to be generated differently as there are no normals to blend
884 if (!closed)
885 {
886 const int points_last = points_count - 1;
887 temp_points[0] = points[0] + temp_normals[0] * (half_inner_thickness + AA_SIZE);
888 temp_points[1] = points[0] + temp_normals[0] * (half_inner_thickness);
889 temp_points[2] = points[0] - temp_normals[0] * (half_inner_thickness);
890 temp_points[3] = points[0] - temp_normals[0] * (half_inner_thickness + AA_SIZE);
891 temp_points[points_last * 4 + 0] = points[points_last] + temp_normals[points_last] * (half_inner_thickness + AA_SIZE);
892 temp_points[points_last * 4 + 1] = points[points_last] + temp_normals[points_last] * (half_inner_thickness);
893 temp_points[points_last * 4 + 2] = points[points_last] - temp_normals[points_last] * (half_inner_thickness);
894 temp_points[points_last * 4 + 3] = points[points_last] - temp_normals[points_last] * (half_inner_thickness + AA_SIZE);
895 }
896
897 // Generate the indices to form a number of triangles for each line segment, and the vertices for the line edges
898 // This takes points n and n+1 and writes into n+1, with the first point in a closed line being generated from the final one (as n+1 wraps)
899 // FIXME-OPT: Merge the different loops, possibly remove the temporary buffer.
900 unsigned int idx1 = _VtxCurrentIdx; // Vertex index for start of line segment
901 for (int i1 = 0; i1 < count; i1++) // i1 is the first point of the line segment
902 {
903 const int i2 = (i1 + 1) == points_count ? 0 : (i1 + 1); // i2 is the second point of the line segment
904 const unsigned int idx2 = (i1 + 1) == points_count ? _VtxCurrentIdx : (idx1 + 4); // Vertex index for end of segment
905
906 // Average normals
907 float dm_x = (temp_normals[i1].x + temp_normals[i2].x) * 0.5f;
908 float dm_y = (temp_normals[i1].y + temp_normals[i2].y) * 0.5f;
909 IM_FIXNORMAL2F(dm_x, dm_y);
910 float dm_out_x = dm_x * (half_inner_thickness + AA_SIZE);
911 float dm_out_y = dm_y * (half_inner_thickness + AA_SIZE);
912 float dm_in_x = dm_x * half_inner_thickness;
913 float dm_in_y = dm_y * half_inner_thickness;
914
915 // Add temporary vertices
916 ImVec2* out_vtx = &temp_points[i2 * 4];
917 out_vtx[0].x = points[i2].x + dm_out_x;
918 out_vtx[0].y = points[i2].y + dm_out_y;
919 out_vtx[1].x = points[i2].x + dm_in_x;
920 out_vtx[1].y = points[i2].y + dm_in_y;
921 out_vtx[2].x = points[i2].x - dm_in_x;
922 out_vtx[2].y = points[i2].y - dm_in_y;
923 out_vtx[3].x = points[i2].x - dm_out_x;
924 out_vtx[3].y = points[i2].y - dm_out_y;
925
926 // Add indexes
927 _IdxWritePtr[0] = (ImDrawIdx)(idx2 + 1); _IdxWritePtr[1] = (ImDrawIdx)(idx1 + 1); _IdxWritePtr[2] = (ImDrawIdx)(idx1 + 2);
928 _IdxWritePtr[3] = (ImDrawIdx)(idx1 + 2); _IdxWritePtr[4] = (ImDrawIdx)(idx2 + 2); _IdxWritePtr[5] = (ImDrawIdx)(idx2 + 1);
929 _IdxWritePtr[6] = (ImDrawIdx)(idx2 + 1); _IdxWritePtr[7] = (ImDrawIdx)(idx1 + 1); _IdxWritePtr[8] = (ImDrawIdx)(idx1 + 0);
930 _IdxWritePtr[9] = (ImDrawIdx)(idx1 + 0); _IdxWritePtr[10] = (ImDrawIdx)(idx2 + 0); _IdxWritePtr[11] = (ImDrawIdx)(idx2 + 1);
931 _IdxWritePtr[12] = (ImDrawIdx)(idx2 + 2); _IdxWritePtr[13] = (ImDrawIdx)(idx1 + 2); _IdxWritePtr[14] = (ImDrawIdx)(idx1 + 3);
932 _IdxWritePtr[15] = (ImDrawIdx)(idx1 + 3); _IdxWritePtr[16] = (ImDrawIdx)(idx2 + 3); _IdxWritePtr[17] = (ImDrawIdx)(idx2 + 2);
933 _IdxWritePtr += 18;
934
935 idx1 = idx2;
936 }
937
938 // Add vertices
939 for (int i = 0; i < points_count; i++)
940 {
941 _VtxWritePtr[0].pos = temp_points[i * 4 + 0]; _VtxWritePtr[0].uv = opaque_uv; _VtxWritePtr[0].col = col_trans;
942 _VtxWritePtr[1].pos = temp_points[i * 4 + 1]; _VtxWritePtr[1].uv = opaque_uv; _VtxWritePtr[1].col = col;
943 _VtxWritePtr[2].pos = temp_points[i * 4 + 2]; _VtxWritePtr[2].uv = opaque_uv; _VtxWritePtr[2].col = col;
944 _VtxWritePtr[3].pos = temp_points[i * 4 + 3]; _VtxWritePtr[3].uv = opaque_uv; _VtxWritePtr[3].col = col_trans;
945 _VtxWritePtr += 4;
946 }
947 }
948 _VtxCurrentIdx += (ImDrawIdx)vtx_count;
949 }
950 else
951 {
952 // [PATH 4] Non texture-based, Non anti-aliased lines
953 const int idx_count = count * 6;
954 const int vtx_count = count * 4; // FIXME-OPT: Not sharing edges
955 PrimReserve(idx_count, vtx_count);
956
957 for (int i1 = 0; i1 < count; i1++)
958 {
959 const int i2 = (i1 + 1) == points_count ? 0 : i1 + 1;
960 const ImVec2& p1 = points[i1];
961 const ImVec2& p2 = points[i2];
962
963 float dx = p2.x - p1.x;
964 float dy = p2.y - p1.y;
965 IM_NORMALIZE2F_OVER_ZERO(dx, dy);
966 dx *= (thickness * 0.5f);
967 dy *= (thickness * 0.5f);
968
969 _VtxWritePtr[0].pos.x = p1.x + dy; _VtxWritePtr[0].pos.y = p1.y - dx; _VtxWritePtr[0].uv = opaque_uv; _VtxWritePtr[0].col = col;
970 _VtxWritePtr[1].pos.x = p2.x + dy; _VtxWritePtr[1].pos.y = p2.y - dx; _VtxWritePtr[1].uv = opaque_uv; _VtxWritePtr[1].col = col;
971 _VtxWritePtr[2].pos.x = p2.x - dy; _VtxWritePtr[2].pos.y = p2.y + dx; _VtxWritePtr[2].uv = opaque_uv; _VtxWritePtr[2].col = col;
972 _VtxWritePtr[3].pos.x = p1.x - dy; _VtxWritePtr[3].pos.y = p1.y + dx; _VtxWritePtr[3].uv = opaque_uv; _VtxWritePtr[3].col = col;
973 _VtxWritePtr += 4;
974
975 _IdxWritePtr[0] = (ImDrawIdx)(_VtxCurrentIdx); _IdxWritePtr[1] = (ImDrawIdx)(_VtxCurrentIdx + 1); _IdxWritePtr[2] = (ImDrawIdx)(_VtxCurrentIdx + 2);
976 _IdxWritePtr[3] = (ImDrawIdx)(_VtxCurrentIdx); _IdxWritePtr[4] = (ImDrawIdx)(_VtxCurrentIdx + 2); _IdxWritePtr[5] = (ImDrawIdx)(_VtxCurrentIdx + 3);
977 _IdxWritePtr += 6;
978 _VtxCurrentIdx += 4;
979 }
980 }
981}
982
983// - We intentionally avoid using ImVec2 and its math operators here to reduce cost to a minimum for debug/non-inlined builds.
984// - Filled shapes must always use clockwise winding order. The anti-aliasing fringe depends on it. Counter-clockwise shapes will have "inward" anti-aliasing.
985void ImDrawList::AddConvexPolyFilled(const ImVec2* points, const int points_count, ImU32 col)
986{
987 if (points_count < 3 || (col & IM_COL32_A_MASK) == 0)
988 return;
989
990 const ImVec2 uv = _Data->TexUvWhitePixel;
991
992 if (Flags & ImDrawListFlags_AntiAliasedFill)
993 {
994 // Anti-aliased Fill
995 const float AA_SIZE = _FringeScale;
996 const ImU32 col_trans = col & ~IM_COL32_A_MASK;
997 const int idx_count = (points_count - 2)*3 + points_count * 6;
998 const int vtx_count = (points_count * 2);
999 PrimReserve(idx_count, vtx_count);
1000
1001 // Add indexes for fill
1002 unsigned int vtx_inner_idx = _VtxCurrentIdx;
1003 unsigned int vtx_outer_idx = _VtxCurrentIdx + 1;
1004 for (int i = 2; i < points_count; i++)
1005 {
1006 _IdxWritePtr[0] = (ImDrawIdx)(vtx_inner_idx); _IdxWritePtr[1] = (ImDrawIdx)(vtx_inner_idx + ((i - 1) << 1)); _IdxWritePtr[2] = (ImDrawIdx)(vtx_inner_idx + (i << 1));
1007 _IdxWritePtr += 3;
1008 }
1009
1010 // Compute normals
1011 _Data->TempBuffer.reserve_discard(points_count);
1012 ImVec2* temp_normals = _Data->TempBuffer.Data;
1013 for (int i0 = points_count - 1, i1 = 0; i1 < points_count; i0 = i1++)
1014 {
1015 const ImVec2& p0 = points[i0];
1016 const ImVec2& p1 = points[i1];
1017 float dx = p1.x - p0.x;
1018 float dy = p1.y - p0.y;
1019 IM_NORMALIZE2F_OVER_ZERO(dx, dy);
1020 temp_normals[i0].x = dy;
1021 temp_normals[i0].y = -dx;
1022 }
1023
1024 for (int i0 = points_count - 1, i1 = 0; i1 < points_count; i0 = i1++)
1025 {
1026 // Average normals
1027 const ImVec2& n0 = temp_normals[i0];
1028 const ImVec2& n1 = temp_normals[i1];
1029 float dm_x = (n0.x + n1.x) * 0.5f;
1030 float dm_y = (n0.y + n1.y) * 0.5f;
1031 IM_FIXNORMAL2F(dm_x, dm_y);
1032 dm_x *= AA_SIZE * 0.5f;
1033 dm_y *= AA_SIZE * 0.5f;
1034
1035 // Add vertices
1036 _VtxWritePtr[0].pos.x = (points[i1].x - dm_x); _VtxWritePtr[0].pos.y = (points[i1].y - dm_y); _VtxWritePtr[0].uv = uv; _VtxWritePtr[0].col = col; // Inner
1037 _VtxWritePtr[1].pos.x = (points[i1].x + dm_x); _VtxWritePtr[1].pos.y = (points[i1].y + dm_y); _VtxWritePtr[1].uv = uv; _VtxWritePtr[1].col = col_trans; // Outer
1038 _VtxWritePtr += 2;
1039
1040 // Add indexes for fringes
1041 _IdxWritePtr[0] = (ImDrawIdx)(vtx_inner_idx + (i1 << 1)); _IdxWritePtr[1] = (ImDrawIdx)(vtx_inner_idx + (i0 << 1)); _IdxWritePtr[2] = (ImDrawIdx)(vtx_outer_idx + (i0 << 1));
1042 _IdxWritePtr[3] = (ImDrawIdx)(vtx_outer_idx + (i0 << 1)); _IdxWritePtr[4] = (ImDrawIdx)(vtx_outer_idx + (i1 << 1)); _IdxWritePtr[5] = (ImDrawIdx)(vtx_inner_idx + (i1 << 1));
1043 _IdxWritePtr += 6;
1044 }
1045 _VtxCurrentIdx += (ImDrawIdx)vtx_count;
1046 }
1047 else
1048 {
1049 // Non Anti-aliased Fill
1050 const int idx_count = (points_count - 2)*3;
1051 const int vtx_count = points_count;
1052 PrimReserve(idx_count, vtx_count);
1053 for (int i = 0; i < vtx_count; i++)
1054 {
1055 _VtxWritePtr[0].pos = points[i]; _VtxWritePtr[0].uv = uv; _VtxWritePtr[0].col = col;
1056 _VtxWritePtr++;
1057 }
1058 for (int i = 2; i < points_count; i++)
1059 {
1060 _IdxWritePtr[0] = (ImDrawIdx)(_VtxCurrentIdx); _IdxWritePtr[1] = (ImDrawIdx)(_VtxCurrentIdx + i - 1); _IdxWritePtr[2] = (ImDrawIdx)(_VtxCurrentIdx + i);
1061 _IdxWritePtr += 3;
1062 }
1063 _VtxCurrentIdx += (ImDrawIdx)vtx_count;
1064 }
1065}
1066
1067void ImDrawList::_PathArcToFastEx(const ImVec2& center, float radius, int a_min_sample, int a_max_sample, int a_step)
1068{
1069 if (radius < 0.5f)
1070 {
1071 _Path.push_back(center);
1072 return;
1073 }
1074
1075 // Calculate arc auto segment step size
1076 if (a_step <= 0)
1077 a_step = IM_DRAWLIST_ARCFAST_SAMPLE_MAX / _CalcCircleAutoSegmentCount(radius);
1078
1079 // Make sure we never do steps larger than one quarter of the circle
1080 a_step = ImClamp(a_step, 1, IM_DRAWLIST_ARCFAST_TABLE_SIZE / 4);
1081
1082 const int sample_range = ImAbs(a_max_sample - a_min_sample);
1083 const int a_next_step = a_step;
1084
1085 int samples = sample_range + 1;
1086 bool extra_max_sample = false;
1087 if (a_step > 1)
1088 {
1089 samples = sample_range / a_step + 1;
1090 const int overstep = sample_range % a_step;
1091
1092 if (overstep > 0)
1093 {
1094 extra_max_sample = true;
1095 samples++;
1096
1097 // When we have overstep to avoid awkwardly looking one long line and one tiny one at the end,
1098 // distribute first step range evenly between them by reducing first step size.
1099 if (sample_range > 0)
1100 a_step -= (a_step - overstep) / 2;
1101 }
1102 }
1103
1104 _Path.resize(_Path.Size + samples);
1105 ImVec2* out_ptr = _Path.Data + (_Path.Size - samples);
1106
1107 int sample_index = a_min_sample;
1108 if (sample_index < 0 || sample_index >= IM_DRAWLIST_ARCFAST_SAMPLE_MAX)
1109 {
1110 sample_index = sample_index % IM_DRAWLIST_ARCFAST_SAMPLE_MAX;
1111 if (sample_index < 0)
1112 sample_index += IM_DRAWLIST_ARCFAST_SAMPLE_MAX;
1113 }
1114
1115 if (a_max_sample >= a_min_sample)
1116 {
1117 for (int a = a_min_sample; a <= a_max_sample; a += a_step, sample_index += a_step, a_step = a_next_step)
1118 {
1119 // a_step is clamped to IM_DRAWLIST_ARCFAST_SAMPLE_MAX, so we have guaranteed that it will not wrap over range twice or more
1120 if (sample_index >= IM_DRAWLIST_ARCFAST_SAMPLE_MAX)
1121 sample_index -= IM_DRAWLIST_ARCFAST_SAMPLE_MAX;
1122
1123 const ImVec2 s = _Data->ArcFastVtx[sample_index];
1124 out_ptr->x = center.x + s.x * radius;
1125 out_ptr->y = center.y + s.y * radius;
1126 out_ptr++;
1127 }
1128 }
1129 else
1130 {
1131 for (int a = a_min_sample; a >= a_max_sample; a -= a_step, sample_index -= a_step, a_step = a_next_step)
1132 {
1133 // a_step is clamped to IM_DRAWLIST_ARCFAST_SAMPLE_MAX, so we have guaranteed that it will not wrap over range twice or more
1134 if (sample_index < 0)
1135 sample_index += IM_DRAWLIST_ARCFAST_SAMPLE_MAX;
1136
1137 const ImVec2 s = _Data->ArcFastVtx[sample_index];
1138 out_ptr->x = center.x + s.x * radius;
1139 out_ptr->y = center.y + s.y * radius;
1140 out_ptr++;
1141 }
1142 }
1143
1144 if (extra_max_sample)
1145 {
1146 int normalized_max_sample = a_max_sample % IM_DRAWLIST_ARCFAST_SAMPLE_MAX;
1147 if (normalized_max_sample < 0)
1148 normalized_max_sample += IM_DRAWLIST_ARCFAST_SAMPLE_MAX;
1149
1150 const ImVec2 s = _Data->ArcFastVtx[normalized_max_sample];
1151 out_ptr->x = center.x + s.x * radius;
1152 out_ptr->y = center.y + s.y * radius;
1153 out_ptr++;
1154 }
1155
1156 IM_ASSERT_PARANOID(_Path.Data + _Path.Size == out_ptr);
1157}
1158
1159void ImDrawList::_PathArcToN(const ImVec2& center, float radius, float a_min, float a_max, int num_segments)
1160{
1161 if (radius < 0.5f)
1162 {
1163 _Path.push_back(center);
1164 return;
1165 }
1166
1167 // Note that we are adding a point at both a_min and a_max.
1168 // If you are trying to draw a full closed circle you don't want the overlapping points!
1169 _Path.reserve(_Path.Size + (num_segments + 1));
1170 for (int i = 0; i <= num_segments; i++)
1171 {
1172 const float a = a_min + ((float)i / (float)num_segments) * (a_max - a_min);
1173 _Path.push_back(ImVec2(center.x + ImCos(a) * radius, center.y + ImSin(a) * radius));
1174 }
1175}
1176
1177// 0: East, 3: South, 6: West, 9: North, 12: East
1178void ImDrawList::PathArcToFast(const ImVec2& center, float radius, int a_min_of_12, int a_max_of_12)
1179{
1180 if (radius < 0.5f)
1181 {
1182 _Path.push_back(center);
1183 return;
1184 }
1185 _PathArcToFastEx(center, radius, a_min_of_12 * IM_DRAWLIST_ARCFAST_SAMPLE_MAX / 12, a_max_of_12 * IM_DRAWLIST_ARCFAST_SAMPLE_MAX / 12, 0);
1186}
1187
1188void ImDrawList::PathArcTo(const ImVec2& center, float radius, float a_min, float a_max, int num_segments)
1189{
1190 if (radius < 0.5f)
1191 {
1192 _Path.push_back(center);
1193 return;
1194 }
1195
1196 if (num_segments > 0)
1197 {
1198 _PathArcToN(center, radius, a_min, a_max, num_segments);
1199 return;
1200 }
1201
1202 // Automatic segment count
1203 if (radius <= _Data->ArcFastRadiusCutoff)
1204 {
1205 const bool a_is_reverse = a_max < a_min;
1206
1207 // We are going to use precomputed values for mid samples.
1208 // Determine first and last sample in lookup table that belong to the arc.
1209 const float a_min_sample_f = IM_DRAWLIST_ARCFAST_SAMPLE_MAX * a_min / (IM_PI * 2.0f);
1210 const float a_max_sample_f = IM_DRAWLIST_ARCFAST_SAMPLE_MAX * a_max / (IM_PI * 2.0f);
1211
1212 const int a_min_sample = a_is_reverse ? (int)ImFloor(a_min_sample_f) : (int)ImCeil(a_min_sample_f);
1213 const int a_max_sample = a_is_reverse ? (int)ImCeil(a_max_sample_f) : (int)ImFloor(a_max_sample_f);
1214 const int a_mid_samples = a_is_reverse ? ImMax(a_min_sample - a_max_sample, 0) : ImMax(a_max_sample - a_min_sample, 0);
1215
1216 const float a_min_segment_angle = a_min_sample * IM_PI * 2.0f / IM_DRAWLIST_ARCFAST_SAMPLE_MAX;
1217 const float a_max_segment_angle = a_max_sample * IM_PI * 2.0f / IM_DRAWLIST_ARCFAST_SAMPLE_MAX;
1218 const bool a_emit_start = ImAbs(a_min_segment_angle - a_min) >= 1e-5f;
1219 const bool a_emit_end = ImAbs(a_max - a_max_segment_angle) >= 1e-5f;
1220
1221 _Path.reserve(_Path.Size + (a_mid_samples + 1 + (a_emit_start ? 1 : 0) + (a_emit_end ? 1 : 0)));
1222 if (a_emit_start)
1223 _Path.push_back(ImVec2(center.x + ImCos(a_min) * radius, center.y + ImSin(a_min) * radius));
1224 if (a_mid_samples > 0)
1225 _PathArcToFastEx(center, radius, a_min_sample, a_max_sample, 0);
1226 if (a_emit_end)
1227 _Path.push_back(ImVec2(center.x + ImCos(a_max) * radius, center.y + ImSin(a_max) * radius));
1228 }
1229 else
1230 {
1231 const float arc_length = ImAbs(a_max - a_min);
1232 const int circle_segment_count = _CalcCircleAutoSegmentCount(radius);
1233 const int arc_segment_count = ImMax((int)ImCeil(circle_segment_count * arc_length / (IM_PI * 2.0f)), (int)(2.0f * IM_PI / arc_length));
1234 _PathArcToN(center, radius, a_min, a_max, arc_segment_count);
1235 }
1236}
1237
1238void ImDrawList::PathEllipticalArcTo(const ImVec2& center, const ImVec2& radius, float rot, float a_min, float a_max, int num_segments)
1239{
1240 if (num_segments <= 0)
1241 num_segments = _CalcCircleAutoSegmentCount(ImMax(radius.x, radius.y)); // A bit pessimistic, maybe there's a better computation to do here.
1242
1243 _Path.reserve(_Path.Size + (num_segments + 1));
1244
1245 const float cos_rot = ImCos(rot);
1246 const float sin_rot = ImSin(rot);
1247 for (int i = 0; i <= num_segments; i++)
1248 {
1249 const float a = a_min + ((float)i / (float)num_segments) * (a_max - a_min);
1250 ImVec2 point(ImCos(a) * radius.x, ImSin(a) * radius.y);
1251 const ImVec2 rel((point.x * cos_rot) - (point.y * sin_rot), (point.x * sin_rot) + (point.y * cos_rot));
1252 point.x = rel.x + center.x;
1253 point.y = rel.y + center.y;
1254 _Path.push_back(point);
1255 }
1256}
1257
1258ImVec2 ImBezierCubicCalc(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, float t)
1259{
1260 float u = 1.0f - t;
1261 float w1 = u * u * u;
1262 float w2 = 3 * u * u * t;
1263 float w3 = 3 * u * t * t;
1264 float w4 = t * t * t;
1265 return ImVec2(w1 * p1.x + w2 * p2.x + w3 * p3.x + w4 * p4.x, w1 * p1.y + w2 * p2.y + w3 * p3.y + w4 * p4.y);
1266}
1267
1268ImVec2 ImBezierQuadraticCalc(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, float t)
1269{
1270 float u = 1.0f - t;
1271 float w1 = u * u;
1272 float w2 = 2 * u * t;
1273 float w3 = t * t;
1274 return ImVec2(w1 * p1.x + w2 * p2.x + w3 * p3.x, w1 * p1.y + w2 * p2.y + w3 * p3.y);
1275}
1276
1277// Closely mimics ImBezierCubicClosestPointCasteljau() in imgui.cpp
1278static void PathBezierCubicCurveToCasteljau(ImVector<ImVec2>* path, float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4, float tess_tol, int level)
1279{
1280 float dx = x4 - x1;
1281 float dy = y4 - y1;
1282 float d2 = (x2 - x4) * dy - (y2 - y4) * dx;
1283 float d3 = (x3 - x4) * dy - (y3 - y4) * dx;
1284 d2 = (d2 >= 0) ? d2 : -d2;
1285 d3 = (d3 >= 0) ? d3 : -d3;
1286 if ((d2 + d3) * (d2 + d3) < tess_tol * (dx * dx + dy * dy))
1287 {
1288 path->push_back(ImVec2(x4, y4));
1289 }
1290 else if (level < 10)
1291 {
1292 float x12 = (x1 + x2) * 0.5f, y12 = (y1 + y2) * 0.5f;
1293 float x23 = (x2 + x3) * 0.5f, y23 = (y2 + y3) * 0.5f;
1294 float x34 = (x3 + x4) * 0.5f, y34 = (y3 + y4) * 0.5f;
1295 float x123 = (x12 + x23) * 0.5f, y123 = (y12 + y23) * 0.5f;
1296 float x234 = (x23 + x34) * 0.5f, y234 = (y23 + y34) * 0.5f;
1297 float x1234 = (x123 + x234) * 0.5f, y1234 = (y123 + y234) * 0.5f;
1298 PathBezierCubicCurveToCasteljau(path, x1, y1, x12, y12, x123, y123, x1234, y1234, tess_tol, level + 1);
1299 PathBezierCubicCurveToCasteljau(path, x1234, y1234, x234, y234, x34, y34, x4, y4, tess_tol, level + 1);
1300 }
1301}
1302
1303static void PathBezierQuadraticCurveToCasteljau(ImVector<ImVec2>* path, float x1, float y1, float x2, float y2, float x3, float y3, float tess_tol, int level)
1304{
1305 float dx = x3 - x1, dy = y3 - y1;
1306 float det = (x2 - x3) * dy - (y2 - y3) * dx;
1307 if (det * det * 4.0f < tess_tol * (dx * dx + dy * dy))
1308 {
1309 path->push_back(ImVec2(x3, y3));
1310 }
1311 else if (level < 10)
1312 {
1313 float x12 = (x1 + x2) * 0.5f, y12 = (y1 + y2) * 0.5f;
1314 float x23 = (x2 + x3) * 0.5f, y23 = (y2 + y3) * 0.5f;
1315 float x123 = (x12 + x23) * 0.5f, y123 = (y12 + y23) * 0.5f;
1316 PathBezierQuadraticCurveToCasteljau(path, x1, y1, x12, y12, x123, y123, tess_tol, level + 1);
1317 PathBezierQuadraticCurveToCasteljau(path, x123, y123, x23, y23, x3, y3, tess_tol, level + 1);
1318 }
1319}
1320
1321void ImDrawList::PathBezierCubicCurveTo(const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, int num_segments)
1322{
1323 ImVec2 p1 = _Path.back();
1324 if (num_segments == 0)
1325 {
1326 IM_ASSERT(_Data->CurveTessellationTol > 0.0f);
1327 PathBezierCubicCurveToCasteljau(&_Path, p1.x, p1.y, p2.x, p2.y, p3.x, p3.y, p4.x, p4.y, _Data->CurveTessellationTol, 0); // Auto-tessellated
1328 }
1329 else
1330 {
1331 float t_step = 1.0f / (float)num_segments;
1332 for (int i_step = 1; i_step <= num_segments; i_step++)
1333 _Path.push_back(ImBezierCubicCalc(p1, p2, p3, p4, t_step * i_step));
1334 }
1335}
1336
1337void ImDrawList::PathBezierQuadraticCurveTo(const ImVec2& p2, const ImVec2& p3, int num_segments)
1338{
1339 ImVec2 p1 = _Path.back();
1340 if (num_segments == 0)
1341 {
1342 IM_ASSERT(_Data->CurveTessellationTol > 0.0f);
1343 PathBezierQuadraticCurveToCasteljau(&_Path, p1.x, p1.y, p2.x, p2.y, p3.x, p3.y, _Data->CurveTessellationTol, 0);// Auto-tessellated
1344 }
1345 else
1346 {
1347 float t_step = 1.0f / (float)num_segments;
1348 for (int i_step = 1; i_step <= num_segments; i_step++)
1349 _Path.push_back(ImBezierQuadraticCalc(p1, p2, p3, t_step * i_step));
1350 }
1351}
1352
1353static inline ImDrawFlags FixRectCornerFlags(ImDrawFlags flags)
1354{
1355 /*
1356 IM_STATIC_ASSERT(ImDrawFlags_RoundCornersTopLeft == (1 << 4));
1357#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
1358 // Obsoleted in 1.82 (from February 2021). This code was stripped/simplified and mostly commented in 1.90 (from September 2023)
1359 // - Legacy Support for hard coded ~0 (used to be a suggested equivalent to ImDrawCornerFlags_All)
1360 if (flags == ~0) { return ImDrawFlags_RoundCornersAll; }
1361 // - Legacy Support for hard coded 0x01 to 0x0F (matching 15 out of 16 old flags combinations). Read details in older version of this code.
1362 if (flags >= 0x01 && flags <= 0x0F) { return (flags << 4); }
1363 // We cannot support hard coded 0x00 with 'float rounding > 0.0f' --> replace with ImDrawFlags_RoundCornersNone or use 'float rounding = 0.0f'
1364#endif
1365 */
1366 // If this assert triggers, please update your code replacing hardcoded values with new ImDrawFlags_RoundCorners* values.
1367 // Note that ImDrawFlags_Closed (== 0x01) is an invalid flag for AddRect(), AddRectFilled(), PathRect() etc. anyway.
1368 // See details in 1.82 Changelog as well as 2021/03/12 and 2023/09/08 entries in "API BREAKING CHANGES" section.
1369 IM_ASSERT((flags & 0x0F) == 0 && "Misuse of legacy hardcoded ImDrawCornerFlags values!");
1370
1371 if ((flags & ImDrawFlags_RoundCornersMask_) == 0)
1372 flags |= ImDrawFlags_RoundCornersAll;
1373
1374 return flags;
1375}
1376
1377void ImDrawList::PathRect(const ImVec2& a, const ImVec2& b, float rounding, ImDrawFlags flags)
1378{
1379 if (rounding >= 0.5f)
1380 {
1381 flags = FixRectCornerFlags(flags);
1382 rounding = ImMin(rounding, ImFabs(b.x - a.x) * (((flags & ImDrawFlags_RoundCornersTop) == ImDrawFlags_RoundCornersTop) || ((flags & ImDrawFlags_RoundCornersBottom) == ImDrawFlags_RoundCornersBottom) ? 0.5f : 1.0f) - 1.0f);
1383 rounding = ImMin(rounding, ImFabs(b.y - a.y) * (((flags & ImDrawFlags_RoundCornersLeft) == ImDrawFlags_RoundCornersLeft) || ((flags & ImDrawFlags_RoundCornersRight) == ImDrawFlags_RoundCornersRight) ? 0.5f : 1.0f) - 1.0f);
1384 }
1385 if (rounding < 0.5f || (flags & ImDrawFlags_RoundCornersMask_) == ImDrawFlags_RoundCornersNone)
1386 {
1387 PathLineTo(a);
1388 PathLineTo(ImVec2(b.x, a.y));
1389 PathLineTo(b);
1390 PathLineTo(ImVec2(a.x, b.y));
1391 }
1392 else
1393 {
1394 const float rounding_tl = (flags & ImDrawFlags_RoundCornersTopLeft) ? rounding : 0.0f;
1395 const float rounding_tr = (flags & ImDrawFlags_RoundCornersTopRight) ? rounding : 0.0f;
1396 const float rounding_br = (flags & ImDrawFlags_RoundCornersBottomRight) ? rounding : 0.0f;
1397 const float rounding_bl = (flags & ImDrawFlags_RoundCornersBottomLeft) ? rounding : 0.0f;
1398 PathArcToFast(ImVec2(a.x + rounding_tl, a.y + rounding_tl), rounding_tl, 6, 9);
1399 PathArcToFast(ImVec2(b.x - rounding_tr, a.y + rounding_tr), rounding_tr, 9, 12);
1400 PathArcToFast(ImVec2(b.x - rounding_br, b.y - rounding_br), rounding_br, 0, 3);
1401 PathArcToFast(ImVec2(a.x + rounding_bl, b.y - rounding_bl), rounding_bl, 3, 6);
1402 }
1403}
1404
1405void ImDrawList::AddLine(const ImVec2& p1, const ImVec2& p2, ImU32 col, float thickness)
1406{
1407 if ((col & IM_COL32_A_MASK) == 0)
1408 return;
1409 PathLineTo(p1 + ImVec2(0.5f, 0.5f));
1410 PathLineTo(p2 + ImVec2(0.5f, 0.5f));
1411 PathStroke(col, 0, thickness);
1412}
1413
1414// p_min = upper-left, p_max = lower-right
1415// Note we don't render 1 pixels sized rectangles properly.
1416void ImDrawList::AddRect(const ImVec2& p_min, const ImVec2& p_max, ImU32 col, float rounding, ImDrawFlags flags, float thickness)
1417{
1418 if ((col & IM_COL32_A_MASK) == 0)
1419 return;
1420 if (Flags & ImDrawListFlags_AntiAliasedLines)
1421 PathRect(p_min + ImVec2(0.50f, 0.50f), p_max - ImVec2(0.50f, 0.50f), rounding, flags);
1422 else
1423 PathRect(p_min + ImVec2(0.50f, 0.50f), p_max - ImVec2(0.49f, 0.49f), rounding, flags); // Better looking lower-right corner and rounded non-AA shapes.
1424 PathStroke(col, ImDrawFlags_Closed, thickness);
1425}
1426
1427void ImDrawList::AddRectFilled(const ImVec2& p_min, const ImVec2& p_max, ImU32 col, float rounding, ImDrawFlags flags)
1428{
1429 if ((col & IM_COL32_A_MASK) == 0)
1430 return;
1431 if (rounding < 0.5f || (flags & ImDrawFlags_RoundCornersMask_) == ImDrawFlags_RoundCornersNone)
1432 {
1433 PrimReserve(6, 4);
1434 PrimRect(p_min, p_max, col);
1435 }
1436 else
1437 {
1438 PathRect(p_min, p_max, rounding, flags);
1439 PathFillConvex(col);
1440 }
1441}
1442
1443// p_min = upper-left, p_max = lower-right
1444void ImDrawList::AddRectFilledMultiColor(const ImVec2& p_min, const ImVec2& p_max, ImU32 col_upr_left, ImU32 col_upr_right, ImU32 col_bot_right, ImU32 col_bot_left)
1445{
1446 if (((col_upr_left | col_upr_right | col_bot_right | col_bot_left) & IM_COL32_A_MASK) == 0)
1447 return;
1448
1449 const ImVec2 uv = _Data->TexUvWhitePixel;
1450 PrimReserve(6, 4);
1451 PrimWriteIdx((ImDrawIdx)(_VtxCurrentIdx)); PrimWriteIdx((ImDrawIdx)(_VtxCurrentIdx + 1)); PrimWriteIdx((ImDrawIdx)(_VtxCurrentIdx + 2));
1452 PrimWriteIdx((ImDrawIdx)(_VtxCurrentIdx)); PrimWriteIdx((ImDrawIdx)(_VtxCurrentIdx + 2)); PrimWriteIdx((ImDrawIdx)(_VtxCurrentIdx + 3));
1453 PrimWriteVtx(p_min, uv, col_upr_left);
1454 PrimWriteVtx(ImVec2(p_max.x, p_min.y), uv, col_upr_right);
1455 PrimWriteVtx(p_max, uv, col_bot_right);
1456 PrimWriteVtx(ImVec2(p_min.x, p_max.y), uv, col_bot_left);
1457}
1458
1459void ImDrawList::AddQuad(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, ImU32 col, float thickness)
1460{
1461 if ((col & IM_COL32_A_MASK) == 0)
1462 return;
1463
1464 PathLineTo(p1);
1465 PathLineTo(p2);
1466 PathLineTo(p3);
1467 PathLineTo(p4);
1468 PathStroke(col, ImDrawFlags_Closed, thickness);
1469}
1470
1471void ImDrawList::AddQuadFilled(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, ImU32 col)
1472{
1473 if ((col & IM_COL32_A_MASK) == 0)
1474 return;
1475
1476 PathLineTo(p1);
1477 PathLineTo(p2);
1478 PathLineTo(p3);
1479 PathLineTo(p4);
1480 PathFillConvex(col);
1481}
1482
1483void ImDrawList::AddTriangle(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, ImU32 col, float thickness)
1484{
1485 if ((col & IM_COL32_A_MASK) == 0)
1486 return;
1487
1488 PathLineTo(p1);
1489 PathLineTo(p2);
1490 PathLineTo(p3);
1491 PathStroke(col, ImDrawFlags_Closed, thickness);
1492}
1493
1494void ImDrawList::AddTriangleFilled(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, ImU32 col)
1495{
1496 if ((col & IM_COL32_A_MASK) == 0)
1497 return;
1498
1499 PathLineTo(p1);
1500 PathLineTo(p2);
1501 PathLineTo(p3);
1502 PathFillConvex(col);
1503}
1504
1505void ImDrawList::AddCircle(const ImVec2& center, float radius, ImU32 col, int num_segments, float thickness)
1506{
1507 if ((col & IM_COL32_A_MASK) == 0 || radius < 0.5f)
1508 return;
1509
1510 if (num_segments <= 0)
1511 {
1512 // Use arc with automatic segment count
1513 _PathArcToFastEx(center, radius - 0.5f, 0, IM_DRAWLIST_ARCFAST_SAMPLE_MAX, 0);
1514 _Path.Size--;
1515 }
1516 else
1517 {
1518 // Explicit segment count (still clamp to avoid drawing insanely tessellated shapes)
1519 num_segments = ImClamp(num_segments, 3, IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MAX);
1520
1521 // Because we are filling a closed shape we remove 1 from the count of segments/points
1522 const float a_max = (IM_PI * 2.0f) * ((float)num_segments - 1.0f) / (float)num_segments;
1523 PathArcTo(center, radius - 0.5f, 0.0f, a_max, num_segments - 1);
1524 }
1525
1526 PathStroke(col, ImDrawFlags_Closed, thickness);
1527}
1528
1529void ImDrawList::AddCircleFilled(const ImVec2& center, float radius, ImU32 col, int num_segments)
1530{
1531 if ((col & IM_COL32_A_MASK) == 0 || radius < 0.5f)
1532 return;
1533
1534 if (num_segments <= 0)
1535 {
1536 // Use arc with automatic segment count
1537 _PathArcToFastEx(center, radius, 0, IM_DRAWLIST_ARCFAST_SAMPLE_MAX, 0);
1538 _Path.Size--;
1539 }
1540 else
1541 {
1542 // Explicit segment count (still clamp to avoid drawing insanely tessellated shapes)
1543 num_segments = ImClamp(num_segments, 3, IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MAX);
1544
1545 // Because we are filling a closed shape we remove 1 from the count of segments/points
1546 const float a_max = (IM_PI * 2.0f) * ((float)num_segments - 1.0f) / (float)num_segments;
1547 PathArcTo(center, radius, 0.0f, a_max, num_segments - 1);
1548 }
1549
1550 PathFillConvex(col);
1551}
1552
1553// Guaranteed to honor 'num_segments'
1554void ImDrawList::AddNgon(const ImVec2& center, float radius, ImU32 col, int num_segments, float thickness)
1555{
1556 if ((col & IM_COL32_A_MASK) == 0 || num_segments <= 2)
1557 return;
1558
1559 // Because we are filling a closed shape we remove 1 from the count of segments/points
1560 const float a_max = (IM_PI * 2.0f) * ((float)num_segments - 1.0f) / (float)num_segments;
1561 PathArcTo(center, radius - 0.5f, 0.0f, a_max, num_segments - 1);
1562 PathStroke(col, ImDrawFlags_Closed, thickness);
1563}
1564
1565// Guaranteed to honor 'num_segments'
1566void ImDrawList::AddNgonFilled(const ImVec2& center, float radius, ImU32 col, int num_segments)
1567{
1568 if ((col & IM_COL32_A_MASK) == 0 || num_segments <= 2)
1569 return;
1570
1571 // Because we are filling a closed shape we remove 1 from the count of segments/points
1572 const float a_max = (IM_PI * 2.0f) * ((float)num_segments - 1.0f) / (float)num_segments;
1573 PathArcTo(center, radius, 0.0f, a_max, num_segments - 1);
1574 PathFillConvex(col);
1575}
1576
1577// Ellipse
1578void ImDrawList::AddEllipse(const ImVec2& center, const ImVec2& radius, ImU32 col, float rot, int num_segments, float thickness)
1579{
1580 if ((col & IM_COL32_A_MASK) == 0)
1581 return;
1582
1583 if (num_segments <= 0)
1584 num_segments = _CalcCircleAutoSegmentCount(ImMax(radius.x, radius.y)); // A bit pessimistic, maybe there's a better computation to do here.
1585
1586 // Because we are filling a closed shape we remove 1 from the count of segments/points
1587 const float a_max = IM_PI * 2.0f * ((float)num_segments - 1.0f) / (float)num_segments;
1588 PathEllipticalArcTo(center, radius, rot, 0.0f, a_max, num_segments - 1);
1589 PathStroke(col, true, thickness);
1590}
1591
1592void ImDrawList::AddEllipseFilled(const ImVec2& center, const ImVec2& radius, ImU32 col, float rot, int num_segments)
1593{
1594 if ((col & IM_COL32_A_MASK) == 0)
1595 return;
1596
1597 if (num_segments <= 0)
1598 num_segments = _CalcCircleAutoSegmentCount(ImMax(radius.x, radius.y)); // A bit pessimistic, maybe there's a better computation to do here.
1599
1600 // Because we are filling a closed shape we remove 1 from the count of segments/points
1601 const float a_max = IM_PI * 2.0f * ((float)num_segments - 1.0f) / (float)num_segments;
1602 PathEllipticalArcTo(center, radius, rot, 0.0f, a_max, num_segments - 1);
1603 PathFillConvex(col);
1604}
1605
1606// Cubic Bezier takes 4 controls points
1607void ImDrawList::AddBezierCubic(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, ImU32 col, float thickness, int num_segments)
1608{
1609 if ((col & IM_COL32_A_MASK) == 0)
1610 return;
1611
1612 PathLineTo(p1);
1613 PathBezierCubicCurveTo(p2, p3, p4, num_segments);
1614 PathStroke(col, 0, thickness);
1615}
1616
1617// Quadratic Bezier takes 3 controls points
1618void ImDrawList::AddBezierQuadratic(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, ImU32 col, float thickness, int num_segments)
1619{
1620 if ((col & IM_COL32_A_MASK) == 0)
1621 return;
1622
1623 PathLineTo(p1);
1624 PathBezierQuadraticCurveTo(p2, p3, num_segments);
1625 PathStroke(col, 0, thickness);
1626}
1627
1628void ImDrawList::AddText(const ImFont* font, float font_size, const ImVec2& pos, ImU32 col, const char* text_begin, const char* text_end, float wrap_width, const ImVec4* cpu_fine_clip_rect)
1629{
1630 if ((col & IM_COL32_A_MASK) == 0)
1631 return;
1632
1633 // Accept null ranges
1634 if (text_begin == text_end || text_begin[0] == 0)
1635 return;
1636 if (text_end == NULL)
1637 text_end = text_begin + strlen(text_begin);
1638
1639 // Pull default font/size from the shared ImDrawListSharedData instance
1640 if (font == NULL)
1641 font = _Data->Font;
1642 if (font_size == 0.0f)
1643 font_size = _Data->FontSize;
1644
1645 IM_ASSERT(font->ContainerAtlas->TexID == _CmdHeader.TextureId); // Use high-level ImGui::PushFont() or low-level ImDrawList::PushTextureId() to change font.
1646
1647 ImVec4 clip_rect = _CmdHeader.ClipRect;
1648 if (cpu_fine_clip_rect)
1649 {
1650 clip_rect.x = ImMax(clip_rect.x, cpu_fine_clip_rect->x);
1651 clip_rect.y = ImMax(clip_rect.y, cpu_fine_clip_rect->y);
1652 clip_rect.z = ImMin(clip_rect.z, cpu_fine_clip_rect->z);
1653 clip_rect.w = ImMin(clip_rect.w, cpu_fine_clip_rect->w);
1654 }
1655 font->RenderText(this, font_size, pos, col, clip_rect, text_begin, text_end, wrap_width, cpu_fine_clip_rect != NULL);
1656}
1657
1658void ImDrawList::AddText(const ImVec2& pos, ImU32 col, const char* text_begin, const char* text_end)
1659{
1660 AddText(NULL, 0.0f, pos, col, text_begin, text_end);
1661}
1662
1663void ImDrawList::AddImage(ImTextureID user_texture_id, const ImVec2& p_min, const ImVec2& p_max, const ImVec2& uv_min, const ImVec2& uv_max, ImU32 col)
1664{
1665 if ((col & IM_COL32_A_MASK) == 0)
1666 return;
1667
1668 const bool push_texture_id = user_texture_id != _CmdHeader.TextureId;
1669 if (push_texture_id)
1670 PushTextureID(user_texture_id);
1671
1672 PrimReserve(6, 4);
1673 PrimRectUV(p_min, p_max, uv_min, uv_max, col);
1674
1675 if (push_texture_id)
1676 PopTextureID();
1677}
1678
1679void ImDrawList::AddImageQuad(ImTextureID user_texture_id, const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, const ImVec2& uv1, const ImVec2& uv2, const ImVec2& uv3, const ImVec2& uv4, ImU32 col)
1680{
1681 if ((col & IM_COL32_A_MASK) == 0)
1682 return;
1683
1684 const bool push_texture_id = user_texture_id != _CmdHeader.TextureId;
1685 if (push_texture_id)
1686 PushTextureID(user_texture_id);
1687
1688 PrimReserve(6, 4);
1689 PrimQuadUV(p1, p2, p3, p4, uv1, uv2, uv3, uv4, col);
1690
1691 if (push_texture_id)
1692 PopTextureID();
1693}
1694
1695void ImDrawList::AddImageRounded(ImTextureID user_texture_id, const ImVec2& p_min, const ImVec2& p_max, const ImVec2& uv_min, const ImVec2& uv_max, ImU32 col, float rounding, ImDrawFlags flags)
1696{
1697 if ((col & IM_COL32_A_MASK) == 0)
1698 return;
1699
1700 flags = FixRectCornerFlags(flags);
1701 if (rounding < 0.5f || (flags & ImDrawFlags_RoundCornersMask_) == ImDrawFlags_RoundCornersNone)
1702 {
1703 AddImage(user_texture_id, p_min, p_max, uv_min, uv_max, col);
1704 return;
1705 }
1706
1707 const bool push_texture_id = user_texture_id != _CmdHeader.TextureId;
1708 if (push_texture_id)
1709 PushTextureID(user_texture_id);
1710
1711 int vert_start_idx = VtxBuffer.Size;
1712 PathRect(p_min, p_max, rounding, flags);
1713 PathFillConvex(col);
1714 int vert_end_idx = VtxBuffer.Size;
1715 ImGui::ShadeVertsLinearUV(this, vert_start_idx, vert_end_idx, p_min, p_max, uv_min, uv_max, true);
1716
1717 if (push_texture_id)
1718 PopTextureID();
1719}
1720
1721//-----------------------------------------------------------------------------
1722// [SECTION] ImTriangulator, ImDrawList concave polygon fill
1723//-----------------------------------------------------------------------------
1724// Triangulate concave polygons. Based on "Triangulation by Ear Clipping" paper, O(N^2) complexity.
1725// Reference: https://www.geometrictools.com/Documentation/TriangulationByEarClipping.pdf
1726// Provided as a convenience for user but not used by main library.
1727//-----------------------------------------------------------------------------
1728// - ImTriangulator [Internal]
1729// - AddConcavePolyFilled()
1730//-----------------------------------------------------------------------------
1731
1738
1749
1750struct ImTriangulatorNodeSpan
1751{
1752 ImTriangulatorNode** Data = NULL;
1753 int Size = 0;
1754
1755 void push_back(ImTriangulatorNode* node) { Data[Size++] = node; }
1756 void find_erase_unsorted(int idx) { for (int i = Size - 1; i >= 0; i--) if (Data[i]->Index == idx) { Data[i] = Data[Size - 1]; Size--; return; } }
1757};
1758
1759struct ImTriangulator
1760{
1761 static int EstimateTriangleCount(int points_count) { return (points_count < 3) ? 0 : points_count - 2; }
1762 static int EstimateScratchBufferSize(int points_count) { return sizeof(ImTriangulatorNode) * points_count + sizeof(ImTriangulatorNode*) * points_count * 2; }
1763
1764 void Init(const ImVec2* points, int points_count, void* scratch_buffer);
1765 void GetNextTriangle(unsigned int out_triangle[3]); // Return relative indexes for next triangle
1766
1767 // Internal functions
1768 void BuildNodes(const ImVec2* points, int points_count);
1769 void BuildReflexes();
1770 void BuildEars();
1771 void FlipNodeList();
1772 bool IsEar(int i0, int i1, int i2, const ImVec2& v0, const ImVec2& v1, const ImVec2& v2) const;
1773 void ReclassifyNode(ImTriangulatorNode* node);
1774
1775 // Internal members
1776 int _TrianglesLeft = 0;
1777 ImTriangulatorNode* _Nodes = NULL;
1778 ImTriangulatorNodeSpan _Ears;
1779 ImTriangulatorNodeSpan _Reflexes;
1780};
1781
1782// Distribute storage for nodes, ears and reflexes.
1783// FIXME-OPT: if everything is convex, we could report it to caller and let it switch to an convex renderer
1784// (this would require first building reflexes to bail to convex if empty, without even building nodes)
1785void ImTriangulator::Init(const ImVec2* points, int points_count, void* scratch_buffer)
1786{
1787 IM_ASSERT(scratch_buffer != NULL && points_count >= 3);
1788 _TrianglesLeft = EstimateTriangleCount(points_count);
1789 _Nodes = (ImTriangulatorNode*)scratch_buffer; // points_count x Node
1790 _Ears.Data = (ImTriangulatorNode**)(_Nodes + points_count); // points_count x Node*
1791 _Reflexes.Data = (ImTriangulatorNode**)(_Nodes + points_count) + points_count; // points_count x Node*
1792 BuildNodes(points, points_count);
1793 BuildReflexes();
1794 BuildEars();
1795}
1796
1797void ImTriangulator::BuildNodes(const ImVec2* points, int points_count)
1798{
1799 for (int i = 0; i < points_count; i++)
1800 {
1801 _Nodes[i].Type = ImTriangulatorNodeType_Convex;
1802 _Nodes[i].Index = i;
1803 _Nodes[i].Pos = points[i];
1804 _Nodes[i].Next = _Nodes + i + 1;
1805 _Nodes[i].Prev = _Nodes + i - 1;
1806 }
1807 _Nodes[0].Prev = _Nodes + points_count - 1;
1808 _Nodes[points_count - 1].Next = _Nodes;
1809}
1810
1811void ImTriangulator::BuildReflexes()
1812{
1813 ImTriangulatorNode* n1 = _Nodes;
1814 for (int i = _TrianglesLeft; i >= 0; i--, n1 = n1->Next)
1815 {
1816 if (ImTriangleIsClockwise(n1->Prev->Pos, n1->Pos, n1->Next->Pos))
1817 continue;
1818 n1->Type = ImTriangulatorNodeType_Reflex;
1819 _Reflexes.push_back(n1);
1820 }
1821}
1822
1823void ImTriangulator::BuildEars()
1824{
1825 ImTriangulatorNode* n1 = _Nodes;
1826 for (int i = _TrianglesLeft; i >= 0; i--, n1 = n1->Next)
1827 {
1828 if (n1->Type != ImTriangulatorNodeType_Convex)
1829 continue;
1830 if (!IsEar(n1->Prev->Index, n1->Index, n1->Next->Index, n1->Prev->Pos, n1->Pos, n1->Next->Pos))
1831 continue;
1832 n1->Type = ImTriangulatorNodeType_Ear;
1833 _Ears.push_back(n1);
1834 }
1835}
1836
1837void ImTriangulator::GetNextTriangle(unsigned int out_triangle[3])
1838{
1839 if (_Ears.Size == 0)
1840 {
1841 FlipNodeList();
1842
1843 ImTriangulatorNode* node = _Nodes;
1844 for (int i = _TrianglesLeft; i >= 0; i--, node = node->Next)
1845 node->Type = ImTriangulatorNodeType_Convex;
1846 _Reflexes.Size = 0;
1847 BuildReflexes();
1848 BuildEars();
1849
1850 // If we still don't have ears, it means geometry is degenerated.
1851 if (_Ears.Size == 0)
1852 {
1853 // Return first triangle available, mimicking the behavior of convex fill.
1854 IM_ASSERT(_TrianglesLeft > 0); // Geometry is degenerated
1855 _Ears.Data[0] = _Nodes;
1856 _Ears.Size = 1;
1857 }
1858 }
1859
1860 ImTriangulatorNode* ear = _Ears.Data[--_Ears.Size];
1861 out_triangle[0] = ear->Prev->Index;
1862 out_triangle[1] = ear->Index;
1863 out_triangle[2] = ear->Next->Index;
1864
1865 ear->Unlink();
1866 if (ear == _Nodes)
1867 _Nodes = ear->Next;
1868
1869 ReclassifyNode(ear->Prev);
1870 ReclassifyNode(ear->Next);
1871 _TrianglesLeft--;
1872}
1873
1874void ImTriangulator::FlipNodeList()
1875{
1876 ImTriangulatorNode* prev = _Nodes;
1877 ImTriangulatorNode* temp = _Nodes;
1878 ImTriangulatorNode* current = _Nodes->Next;
1879 prev->Next = prev;
1880 prev->Prev = prev;
1881 while (current != _Nodes)
1882 {
1883 temp = current->Next;
1884
1885 current->Next = prev;
1886 prev->Prev = current;
1887 _Nodes->Next = current;
1888 current->Prev = _Nodes;
1889
1890 prev = current;
1891 current = temp;
1892 }
1893 _Nodes = prev;
1894}
1895
1896// A triangle is an ear is no other vertex is inside it. We can test reflexes vertices only (see reference algorithm)
1897bool ImTriangulator::IsEar(int i0, int i1, int i2, const ImVec2& v0, const ImVec2& v1, const ImVec2& v2) const
1898{
1899 ImTriangulatorNode** p_end = _Reflexes.Data + _Reflexes.Size;
1900 for (ImTriangulatorNode** p = _Reflexes.Data; p < p_end; p++)
1901 {
1902 ImTriangulatorNode* reflex = *p;
1903 if (reflex->Index != i0 && reflex->Index != i1 && reflex->Index != i2)
1904 if (ImTriangleContainsPoint(v0, v1, v2, reflex->Pos))
1905 return false;
1906 }
1907 return true;
1908}
1909
1910void ImTriangulator::ReclassifyNode(ImTriangulatorNode* n1)
1911{
1912 // Classify node
1913 ImTriangulatorNodeType type;
1914 const ImTriangulatorNode* n0 = n1->Prev;
1915 const ImTriangulatorNode* n2 = n1->Next;
1916 if (!ImTriangleIsClockwise(n0->Pos, n1->Pos, n2->Pos))
1917 type = ImTriangulatorNodeType_Reflex;
1918 else if (IsEar(n0->Index, n1->Index, n2->Index, n0->Pos, n1->Pos, n2->Pos))
1919 type = ImTriangulatorNodeType_Ear;
1920 else
1921 type = ImTriangulatorNodeType_Convex;
1922
1923 // Update lists when a type changes
1924 if (type == n1->Type)
1925 return;
1926 if (n1->Type == ImTriangulatorNodeType_Reflex)
1927 _Reflexes.find_erase_unsorted(n1->Index);
1928 else if (n1->Type == ImTriangulatorNodeType_Ear)
1929 _Ears.find_erase_unsorted(n1->Index);
1930 if (type == ImTriangulatorNodeType_Reflex)
1931 _Reflexes.push_back(n1);
1932 else if (type == ImTriangulatorNodeType_Ear)
1933 _Ears.push_back(n1);
1934 n1->Type = type;
1935}
1936
1937// Use ear-clipping algorithm to triangulate a simple polygon (no self-interaction, no holes).
1938// (Reminder: we don't perform any coarse clipping/culling in ImDrawList layer!
1939// It is up to caller to ensure not making costly calls that will be outside of visible area.
1940// As concave fill is noticeably more expensive than other primitives, be mindful of this...
1941// Caller can build AABB of points, and avoid filling if 'draw_list->_CmdHeader.ClipRect.Overlays(points_bb) == false')
1942void ImDrawList::AddConcavePolyFilled(const ImVec2* points, const int points_count, ImU32 col)
1943{
1944 if (points_count < 3 || (col & IM_COL32_A_MASK) == 0)
1945 return;
1946
1947 const ImVec2 uv = _Data->TexUvWhitePixel;
1948 ImTriangulator triangulator;
1949 unsigned int triangle[3];
1950 if (Flags & ImDrawListFlags_AntiAliasedFill)
1951 {
1952 // Anti-aliased Fill
1953 const float AA_SIZE = _FringeScale;
1954 const ImU32 col_trans = col & ~IM_COL32_A_MASK;
1955 const int idx_count = (points_count - 2) * 3 + points_count * 6;
1956 const int vtx_count = (points_count * 2);
1957 PrimReserve(idx_count, vtx_count);
1958
1959 // Add indexes for fill
1960 unsigned int vtx_inner_idx = _VtxCurrentIdx;
1961 unsigned int vtx_outer_idx = _VtxCurrentIdx + 1;
1962
1963 _Data->TempBuffer.reserve_discard((ImTriangulator::EstimateScratchBufferSize(points_count) + sizeof(ImVec2)) / sizeof(ImVec2));
1964 triangulator.Init(points, points_count, _Data->TempBuffer.Data);
1965 while (triangulator._TrianglesLeft > 0)
1966 {
1967 triangulator.GetNextTriangle(triangle);
1968 _IdxWritePtr[0] = (ImDrawIdx)(vtx_inner_idx + (triangle[0] << 1)); _IdxWritePtr[1] = (ImDrawIdx)(vtx_inner_idx + (triangle[1] << 1)); _IdxWritePtr[2] = (ImDrawIdx)(vtx_inner_idx + (triangle[2] << 1));
1969 _IdxWritePtr += 3;
1970 }
1971
1972 // Compute normals
1973 _Data->TempBuffer.reserve_discard(points_count);
1974 ImVec2* temp_normals = _Data->TempBuffer.Data;
1975 for (int i0 = points_count - 1, i1 = 0; i1 < points_count; i0 = i1++)
1976 {
1977 const ImVec2& p0 = points[i0];
1978 const ImVec2& p1 = points[i1];
1979 float dx = p1.x - p0.x;
1980 float dy = p1.y - p0.y;
1981 IM_NORMALIZE2F_OVER_ZERO(dx, dy);
1982 temp_normals[i0].x = dy;
1983 temp_normals[i0].y = -dx;
1984 }
1985
1986 for (int i0 = points_count - 1, i1 = 0; i1 < points_count; i0 = i1++)
1987 {
1988 // Average normals
1989 const ImVec2& n0 = temp_normals[i0];
1990 const ImVec2& n1 = temp_normals[i1];
1991 float dm_x = (n0.x + n1.x) * 0.5f;
1992 float dm_y = (n0.y + n1.y) * 0.5f;
1993 IM_FIXNORMAL2F(dm_x, dm_y);
1994 dm_x *= AA_SIZE * 0.5f;
1995 dm_y *= AA_SIZE * 0.5f;
1996
1997 // Add vertices
1998 _VtxWritePtr[0].pos.x = (points[i1].x - dm_x); _VtxWritePtr[0].pos.y = (points[i1].y - dm_y); _VtxWritePtr[0].uv = uv; _VtxWritePtr[0].col = col; // Inner
1999 _VtxWritePtr[1].pos.x = (points[i1].x + dm_x); _VtxWritePtr[1].pos.y = (points[i1].y + dm_y); _VtxWritePtr[1].uv = uv; _VtxWritePtr[1].col = col_trans; // Outer
2000 _VtxWritePtr += 2;
2001
2002 // Add indexes for fringes
2003 _IdxWritePtr[0] = (ImDrawIdx)(vtx_inner_idx + (i1 << 1)); _IdxWritePtr[1] = (ImDrawIdx)(vtx_inner_idx + (i0 << 1)); _IdxWritePtr[2] = (ImDrawIdx)(vtx_outer_idx + (i0 << 1));
2004 _IdxWritePtr[3] = (ImDrawIdx)(vtx_outer_idx + (i0 << 1)); _IdxWritePtr[4] = (ImDrawIdx)(vtx_outer_idx + (i1 << 1)); _IdxWritePtr[5] = (ImDrawIdx)(vtx_inner_idx + (i1 << 1));
2005 _IdxWritePtr += 6;
2006 }
2007 _VtxCurrentIdx += (ImDrawIdx)vtx_count;
2008 }
2009 else
2010 {
2011 // Non Anti-aliased Fill
2012 const int idx_count = (points_count - 2) * 3;
2013 const int vtx_count = points_count;
2014 PrimReserve(idx_count, vtx_count);
2015 for (int i = 0; i < vtx_count; i++)
2016 {
2017 _VtxWritePtr[0].pos = points[i]; _VtxWritePtr[0].uv = uv; _VtxWritePtr[0].col = col;
2018 _VtxWritePtr++;
2019 }
2020 _Data->TempBuffer.reserve_discard((ImTriangulator::EstimateScratchBufferSize(points_count) + sizeof(ImVec2)) / sizeof(ImVec2));
2021 triangulator.Init(points, points_count, _Data->TempBuffer.Data);
2022 while (triangulator._TrianglesLeft > 0)
2023 {
2024 triangulator.GetNextTriangle(triangle);
2025 _IdxWritePtr[0] = (ImDrawIdx)(_VtxCurrentIdx + triangle[0]); _IdxWritePtr[1] = (ImDrawIdx)(_VtxCurrentIdx + triangle[1]); _IdxWritePtr[2] = (ImDrawIdx)(_VtxCurrentIdx + triangle[2]);
2026 _IdxWritePtr += 3;
2027 }
2028 _VtxCurrentIdx += (ImDrawIdx)vtx_count;
2029 }
2030}
2031
2032//-----------------------------------------------------------------------------
2033// [SECTION] ImDrawListSplitter
2034//-----------------------------------------------------------------------------
2035// FIXME: This may be a little confusing, trying to be a little too low-level/optimal instead of just doing vector swap..
2036//-----------------------------------------------------------------------------
2037
2038void ImDrawListSplitter::ClearFreeMemory()
2039{
2040 for (int i = 0; i < _Channels.Size; i++)
2041 {
2042 if (i == _Current)
2043 memset(&_Channels[i], 0, sizeof(_Channels[i])); // Current channel is a copy of CmdBuffer/IdxBuffer, don't destruct again
2044 _Channels[i]._CmdBuffer.clear();
2045 _Channels[i]._IdxBuffer.clear();
2046 }
2047 _Current = 0;
2048 _Count = 1;
2049 _Channels.clear();
2050}
2051
2052void ImDrawListSplitter::Split(ImDrawList* draw_list, int channels_count)
2053{
2054 IM_UNUSED(draw_list);
2055 IM_ASSERT(_Current == 0 && _Count <= 1 && "Nested channel splitting is not supported. Please use separate instances of ImDrawListSplitter.");
2056 int old_channels_count = _Channels.Size;
2057 if (old_channels_count < channels_count)
2058 {
2059 _Channels.reserve(channels_count); // Avoid over reserving since this is likely to stay stable
2060 _Channels.resize(channels_count);
2061 }
2062 _Count = channels_count;
2063
2064 // Channels[] (24/32 bytes each) hold storage that we'll swap with draw_list->_CmdBuffer/_IdxBuffer
2065 // 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.
2066 // 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
2067 memset(&_Channels[0], 0, sizeof(ImDrawChannel));
2068 for (int i = 1; i < channels_count; i++)
2069 {
2070 if (i >= old_channels_count)
2071 {
2072 IM_PLACEMENT_NEW(&_Channels[i]) ImDrawChannel();
2073 }
2074 else
2075 {
2076 _Channels[i]._CmdBuffer.resize(0);
2077 _Channels[i]._IdxBuffer.resize(0);
2078 }
2079 }
2080}
2081
2082void ImDrawListSplitter::Merge(ImDrawList* draw_list)
2083{
2084 // 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.
2085 if (_Count <= 1)
2086 return;
2087
2088 SetCurrentChannel(draw_list, 0);
2089 draw_list->_PopUnusedDrawCmd();
2090
2091 // Calculate our final buffer sizes. Also fix the incorrect IdxOffset values in each command.
2092 int new_cmd_buffer_count = 0;
2093 int new_idx_buffer_count = 0;
2094 ImDrawCmd* last_cmd = (_Count > 0 && draw_list->CmdBuffer.Size > 0) ? &draw_list->CmdBuffer.back() : NULL;
2095 int idx_offset = last_cmd ? last_cmd->IdxOffset + last_cmd->ElemCount : 0;
2096 for (int i = 1; i < _Count; i++)
2097 {
2098 ImDrawChannel& ch = _Channels[i];
2099 if (ch._CmdBuffer.Size > 0 && ch._CmdBuffer.back().ElemCount == 0 && ch._CmdBuffer.back().UserCallback == NULL) // Equivalent of PopUnusedDrawCmd()
2100 ch._CmdBuffer.pop_back();
2101
2102 if (ch._CmdBuffer.Size > 0 && last_cmd != NULL)
2103 {
2104 // Do not include ImDrawCmd_AreSequentialIdxOffset() in the compare as we rebuild IdxOffset values ourselves.
2105 // Manipulating IdxOffset (e.g. by reordering draw commands like done by RenderDimmedBackgroundBehindWindow()) is not supported within a splitter.
2106 ImDrawCmd* next_cmd = &ch._CmdBuffer[0];
2107 if (ImDrawCmd_HeaderCompare(last_cmd, next_cmd) == 0 && last_cmd->UserCallback == NULL && next_cmd->UserCallback == NULL)
2108 {
2109 // Merge previous channel last draw command with current channel first draw command if matching.
2110 last_cmd->ElemCount += next_cmd->ElemCount;
2111 idx_offset += next_cmd->ElemCount;
2112 ch._CmdBuffer.erase(ch._CmdBuffer.Data); // FIXME-OPT: Improve for multiple merges.
2113 }
2114 }
2115 if (ch._CmdBuffer.Size > 0)
2116 last_cmd = &ch._CmdBuffer.back();
2117 new_cmd_buffer_count += ch._CmdBuffer.Size;
2118 new_idx_buffer_count += ch._IdxBuffer.Size;
2119 for (int cmd_n = 0; cmd_n < ch._CmdBuffer.Size; cmd_n++)
2120 {
2121 ch._CmdBuffer.Data[cmd_n].IdxOffset = idx_offset;
2122 idx_offset += ch._CmdBuffer.Data[cmd_n].ElemCount;
2123 }
2124 }
2125 draw_list->CmdBuffer.resize(draw_list->CmdBuffer.Size + new_cmd_buffer_count);
2126 draw_list->IdxBuffer.resize(draw_list->IdxBuffer.Size + new_idx_buffer_count);
2127
2128 // Write commands and indices in order (they are fairly small structures, we don't copy vertices only indices)
2129 ImDrawCmd* cmd_write = draw_list->CmdBuffer.Data + draw_list->CmdBuffer.Size - new_cmd_buffer_count;
2130 ImDrawIdx* idx_write = draw_list->IdxBuffer.Data + draw_list->IdxBuffer.Size - new_idx_buffer_count;
2131 for (int i = 1; i < _Count; i++)
2132 {
2133 ImDrawChannel& ch = _Channels[i];
2134 if (int sz = ch._CmdBuffer.Size) { memcpy(cmd_write, ch._CmdBuffer.Data, sz * sizeof(ImDrawCmd)); cmd_write += sz; }
2135 if (int sz = ch._IdxBuffer.Size) { memcpy(idx_write, ch._IdxBuffer.Data, sz * sizeof(ImDrawIdx)); idx_write += sz; }
2136 }
2137 draw_list->_IdxWritePtr = idx_write;
2138
2139 // Ensure there's always a non-callback draw command trailing the command-buffer
2140 if (draw_list->CmdBuffer.Size == 0 || draw_list->CmdBuffer.back().UserCallback != NULL)
2141 draw_list->AddDrawCmd();
2142
2143 // If current command is used with different settings we need to add a new command
2144 ImDrawCmd* curr_cmd = &draw_list->CmdBuffer.Data[draw_list->CmdBuffer.Size - 1];
2145 if (curr_cmd->ElemCount == 0)
2146 ImDrawCmd_HeaderCopy(curr_cmd, &draw_list->_CmdHeader); // Copy ClipRect, TextureId, VtxOffset
2147 else if (ImDrawCmd_HeaderCompare(curr_cmd, &draw_list->_CmdHeader) != 0)
2148 draw_list->AddDrawCmd();
2149
2150 _Count = 1;
2151}
2152
2153void ImDrawListSplitter::SetCurrentChannel(ImDrawList* draw_list, int idx)
2154{
2155 IM_ASSERT(idx >= 0 && idx < _Count);
2156 if (_Current == idx)
2157 return;
2158
2159 // Overwrite ImVector (12/16 bytes), four times. This is merely a silly optimization instead of doing .swap()
2160 memcpy(&_Channels.Data[_Current]._CmdBuffer, &draw_list->CmdBuffer, sizeof(draw_list->CmdBuffer));
2161 memcpy(&_Channels.Data[_Current]._IdxBuffer, &draw_list->IdxBuffer, sizeof(draw_list->IdxBuffer));
2162 _Current = idx;
2163 memcpy(&draw_list->CmdBuffer, &_Channels.Data[idx]._CmdBuffer, sizeof(draw_list->CmdBuffer));
2164 memcpy(&draw_list->IdxBuffer, &_Channels.Data[idx]._IdxBuffer, sizeof(draw_list->IdxBuffer));
2165 draw_list->_IdxWritePtr = draw_list->IdxBuffer.Data + draw_list->IdxBuffer.Size;
2166
2167 // If current command is used with different settings we need to add a new command
2168 ImDrawCmd* curr_cmd = (draw_list->CmdBuffer.Size == 0) ? NULL : &draw_list->CmdBuffer.Data[draw_list->CmdBuffer.Size - 1];
2169 if (curr_cmd == NULL)
2170 draw_list->AddDrawCmd();
2171 else if (curr_cmd->ElemCount == 0)
2172 ImDrawCmd_HeaderCopy(curr_cmd, &draw_list->_CmdHeader); // Copy ClipRect, TextureId, VtxOffset
2173 else if (ImDrawCmd_HeaderCompare(curr_cmd, &draw_list->_CmdHeader) != 0)
2174 draw_list->AddDrawCmd();
2175}
2176
2177//-----------------------------------------------------------------------------
2178// [SECTION] ImDrawData
2179//-----------------------------------------------------------------------------
2180
2181void ImDrawData::Clear()
2182{
2183 Valid = false;
2184 CmdListsCount = TotalIdxCount = TotalVtxCount = 0;
2185 CmdLists.resize(0); // The ImDrawList are NOT owned by ImDrawData but e.g. by ImGuiContext, so we don't clear them.
2186 DisplayPos = DisplaySize = FramebufferScale = ImVec2(0.0f, 0.0f);
2187 OwnerViewport = NULL;
2188}
2189
2190// Important: 'out_list' is generally going to be draw_data->CmdLists, but may be another temporary list
2191// as long at it is expected that the result will be later merged into draw_data->CmdLists[].
2192void ImGui::AddDrawListToDrawDataEx(ImDrawData* draw_data, ImVector<ImDrawList*>* out_list, ImDrawList* draw_list)
2193{
2194 if (draw_list->CmdBuffer.Size == 0)
2195 return;
2196 if (draw_list->CmdBuffer.Size == 1 && draw_list->CmdBuffer[0].ElemCount == 0 && draw_list->CmdBuffer[0].UserCallback == NULL)
2197 return;
2198
2199 // Draw list sanity check. Detect mismatch between PrimReserve() calls and incrementing _VtxCurrentIdx, _VtxWritePtr etc.
2200 // May trigger for you if you are using PrimXXX functions incorrectly.
2201 IM_ASSERT(draw_list->VtxBuffer.Size == 0 || draw_list->_VtxWritePtr == draw_list->VtxBuffer.Data + draw_list->VtxBuffer.Size);
2202 IM_ASSERT(draw_list->IdxBuffer.Size == 0 || draw_list->_IdxWritePtr == draw_list->IdxBuffer.Data + draw_list->IdxBuffer.Size);
2203 if (!(draw_list->Flags & ImDrawListFlags_AllowVtxOffset))
2204 IM_ASSERT((int)draw_list->_VtxCurrentIdx == draw_list->VtxBuffer.Size);
2205
2206 // Check that draw_list doesn't use more vertices than indexable (default ImDrawIdx = unsigned short = 2 bytes = 64K vertices per ImDrawList = per window)
2207 // If this assert triggers because you are drawing lots of stuff manually:
2208 // - First, make sure you are coarse clipping yourself and not trying to draw many things outside visible bounds.
2209 // Be mindful that the lower-level ImDrawList API doesn't filter vertices. Use the Metrics/Debugger window to inspect draw list contents.
2210 // - If you want large meshes with more than 64K vertices, you can either:
2211 // (A) Handle the ImDrawCmd::VtxOffset value in your renderer backend, and set 'io.BackendFlags |= ImGuiBackendFlags_RendererHasVtxOffset'.
2212 // Most example backends already support this from 1.71. Pre-1.71 backends won't.
2213 // Some graphics API such as GL ES 1/2 don't have a way to offset the starting vertex so it is not supported for them.
2214 // (B) Or handle 32-bit indices in your renderer backend, and uncomment '#define ImDrawIdx unsigned int' line in imconfig.h.
2215 // Most example backends already support this. For example, the OpenGL example code detect index size at compile-time:
2216 // glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, idx_buffer_offset);
2217 // Your own engine or render API may use different parameters or function calls to specify index sizes.
2218 // 2 and 4 bytes indices are generally supported by most graphics API.
2219 // - If for some reason neither of those solutions works for you, a workaround is to call BeginChild()/EndChild() before reaching
2220 // the 64K limit to split your draw commands in multiple draw lists.
2221 if (sizeof(ImDrawIdx) == 2)
2222 IM_ASSERT(draw_list->_VtxCurrentIdx < (1 << 16) && "Too many vertices in ImDrawList using 16-bit indices. Read comment above");
2223
2224 // Add to output list + records state in ImDrawData
2225 out_list->push_back(draw_list);
2226 draw_data->CmdListsCount++;
2227 draw_data->TotalVtxCount += draw_list->VtxBuffer.Size;
2228 draw_data->TotalIdxCount += draw_list->IdxBuffer.Size;
2229}
2230
2231void ImDrawData::AddDrawList(ImDrawList* draw_list)
2232{
2233 IM_ASSERT(CmdLists.Size == CmdListsCount);
2234 draw_list->_PopUnusedDrawCmd();
2235 ImGui::AddDrawListToDrawDataEx(this, &CmdLists, draw_list);
2236}
2237
2238// 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!
2239void ImDrawData::DeIndexAllBuffers()
2240{
2241 ImVector<ImDrawVert> new_vtx_buffer;
2242 TotalVtxCount = TotalIdxCount = 0;
2243 for (int i = 0; i < CmdListsCount; i++)
2244 {
2245 ImDrawList* cmd_list = CmdLists[i];
2246 if (cmd_list->IdxBuffer.empty())
2247 continue;
2248 new_vtx_buffer.resize(cmd_list->IdxBuffer.Size);
2249 for (int j = 0; j < cmd_list->IdxBuffer.Size; j++)
2250 new_vtx_buffer[j] = cmd_list->VtxBuffer[cmd_list->IdxBuffer[j]];
2251 cmd_list->VtxBuffer.swap(new_vtx_buffer);
2252 cmd_list->IdxBuffer.resize(0);
2253 TotalVtxCount += cmd_list->VtxBuffer.Size;
2254 }
2255}
2256
2257// Helper to scale the ClipRect field of each ImDrawCmd.
2258// Use if your final output buffer is at a different scale than draw_data->DisplaySize,
2259// or if there is a difference between your window resolution and framebuffer resolution.
2260void ImDrawData::ScaleClipRects(const ImVec2& fb_scale)
2261{
2262 for (ImDrawList* draw_list : CmdLists)
2263 for (ImDrawCmd& cmd : draw_list->CmdBuffer)
2264 cmd.ClipRect = ImVec4(cmd.ClipRect.x * fb_scale.x, cmd.ClipRect.y * fb_scale.y, cmd.ClipRect.z * fb_scale.x, cmd.ClipRect.w * fb_scale.y);
2265}
2266
2267//-----------------------------------------------------------------------------
2268// [SECTION] Helpers ShadeVertsXXX functions
2269//-----------------------------------------------------------------------------
2270
2271// Generic linear color gradient, write to RGB fields, leave A untouched.
2272void ImGui::ShadeVertsLinearColorGradientKeepAlpha(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, ImVec2 gradient_p0, ImVec2 gradient_p1, ImU32 col0, ImU32 col1)
2273{
2274 ImVec2 gradient_extent = gradient_p1 - gradient_p0;
2275 float gradient_inv_length2 = 1.0f / ImLengthSqr(gradient_extent);
2276 ImDrawVert* vert_start = draw_list->VtxBuffer.Data + vert_start_idx;
2277 ImDrawVert* vert_end = draw_list->VtxBuffer.Data + vert_end_idx;
2278 const int col0_r = (int)(col0 >> IM_COL32_R_SHIFT) & 0xFF;
2279 const int col0_g = (int)(col0 >> IM_COL32_G_SHIFT) & 0xFF;
2280 const int col0_b = (int)(col0 >> IM_COL32_B_SHIFT) & 0xFF;
2281 const int col_delta_r = ((int)(col1 >> IM_COL32_R_SHIFT) & 0xFF) - col0_r;
2282 const int col_delta_g = ((int)(col1 >> IM_COL32_G_SHIFT) & 0xFF) - col0_g;
2283 const int col_delta_b = ((int)(col1 >> IM_COL32_B_SHIFT) & 0xFF) - col0_b;
2284 for (ImDrawVert* vert = vert_start; vert < vert_end; vert++)
2285 {
2286 float d = ImDot(vert->pos - gradient_p0, gradient_extent);
2287 float t = ImClamp(d * gradient_inv_length2, 0.0f, 1.0f);
2288 int r = (int)(col0_r + col_delta_r * t);
2289 int g = (int)(col0_g + col_delta_g * t);
2290 int b = (int)(col0_b + col_delta_b * t);
2291 vert->col = (r << IM_COL32_R_SHIFT) | (g << IM_COL32_G_SHIFT) | (b << IM_COL32_B_SHIFT) | (vert->col & IM_COL32_A_MASK);
2292 }
2293}
2294
2295// Distribute UV over (a, b) rectangle
2296void ImGui::ShadeVertsLinearUV(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, const ImVec2& a, const ImVec2& b, const ImVec2& uv_a, const ImVec2& uv_b, bool clamp)
2297{
2298 const ImVec2 size = b - a;
2299 const ImVec2 uv_size = uv_b - uv_a;
2300 const ImVec2 scale = ImVec2(
2301 size.x != 0.0f ? (uv_size.x / size.x) : 0.0f,
2302 size.y != 0.0f ? (uv_size.y / size.y) : 0.0f);
2303
2304 ImDrawVert* vert_start = draw_list->VtxBuffer.Data + vert_start_idx;
2305 ImDrawVert* vert_end = draw_list->VtxBuffer.Data + vert_end_idx;
2306 if (clamp)
2307 {
2308 const ImVec2 min = ImMin(uv_a, uv_b);
2309 const ImVec2 max = ImMax(uv_a, uv_b);
2310 for (ImDrawVert* vertex = vert_start; vertex < vert_end; ++vertex)
2311 vertex->uv = ImClamp(uv_a + ImMul(ImVec2(vertex->pos.x, vertex->pos.y) - a, scale), min, max);
2312 }
2313 else
2314 {
2315 for (ImDrawVert* vertex = vert_start; vertex < vert_end; ++vertex)
2316 vertex->uv = uv_a + ImMul(ImVec2(vertex->pos.x, vertex->pos.y) - a, scale);
2317 }
2318}
2319
2320void ImGui::ShadeVertsTransformPos(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, const ImVec2& pivot_in, float cos_a, float sin_a, const ImVec2& pivot_out)
2321{
2322 ImDrawVert* vert_start = draw_list->VtxBuffer.Data + vert_start_idx;
2323 ImDrawVert* vert_end = draw_list->VtxBuffer.Data + vert_end_idx;
2324 for (ImDrawVert* vertex = vert_start; vertex < vert_end; ++vertex)
2325 vertex->pos = ImRotate(vertex->pos- pivot_in, cos_a, sin_a) + pivot_out;
2326}
2327
2328//-----------------------------------------------------------------------------
2329// [SECTION] ImFontConfig
2330//-----------------------------------------------------------------------------
2331
2332ImFontConfig::ImFontConfig()
2333{
2334 memset(this, 0, sizeof(*this));
2335 FontDataOwnedByAtlas = true;
2336 OversampleH = 2;
2337 OversampleV = 1;
2338 GlyphMaxAdvanceX = FLT_MAX;
2339 RasterizerMultiply = 1.0f;
2340 RasterizerDensity = 1.0f;
2341 EllipsisChar = (ImWchar)-1;
2342}
2343
2344//-----------------------------------------------------------------------------
2345// [SECTION] ImFontAtlas
2346//-----------------------------------------------------------------------------
2347
2348// A work of art lies ahead! (. = white layer, X = black layer, others are blank)
2349// The 2x2 white texels on the top left are the ones we'll use everywhere in Dear ImGui to render filled shapes.
2350// (This is used when io.MouseDrawCursor = true)
2351const int FONT_ATLAS_DEFAULT_TEX_DATA_W = 122; // Actual texture will be 2 times that + 1 spacing.
2352const int FONT_ATLAS_DEFAULT_TEX_DATA_H = 27;
2353static const char FONT_ATLAS_DEFAULT_TEX_DATA_PIXELS[FONT_ATLAS_DEFAULT_TEX_DATA_W * FONT_ATLAS_DEFAULT_TEX_DATA_H + 1] =
2354{
2355 "..- -XXXXXXX- X - X -XXXXXXX - XXXXXXX- XX - XX XX "
2356 "..- -X.....X- X.X - X.X -X.....X - X.....X- X..X -X..X X..X"
2357 "--- -XXX.XXX- X...X - X...X -X....X - X....X- X..X -X...X X...X"
2358 "X - X.X - X.....X - X.....X -X...X - X...X- X..X - X...X X...X "
2359 "XX - X.X -X.......X- X.......X -X..X.X - X.X..X- X..X - X...X...X "
2360 "X.X - X.X -XXXX.XXXX- XXXX.XXXX -X.X X.X - X.X X.X- X..XXX - X.....X "
2361 "X..X - X.X - X.X - X.X -XX X.X - X.X XX- X..X..XXX - X...X "
2362 "X...X - X.X - X.X - XX X.X XX - X.X - X.X - X..X..X..XX - X.X "
2363 "X....X - X.X - X.X - X.X X.X X.X - X.X - X.X - X..X..X..X.X - X...X "
2364 "X.....X - X.X - X.X - X..X X.X X..X - X.X - X.X -XXX X..X..X..X..X- X.....X "
2365 "X......X - X.X - X.X - X...XXXXXX.XXXXXX...X - X.X XX-XX X.X -X..XX........X..X- X...X...X "
2366 "X.......X - X.X - X.X -X.....................X- X.X X.X-X.X X.X -X...X...........X- X...X X...X "
2367 "X........X - X.X - X.X - X...XXXXXX.XXXXXX...X - X.X..X-X..X.X - X..............X-X...X X...X"
2368 "X.........X -XXX.XXX- X.X - X..X X.X X..X - X...X-X...X - X.............X-X..X X..X"
2369 "X..........X-X.....X- X.X - X.X X.X X.X - X....X-X....X - X.............X- XX XX "
2370 "X......XXXXX-XXXXXXX- X.X - XX X.X XX - X.....X-X.....X - X............X--------------"
2371 "X...X..X --------- X.X - X.X - XXXXXXX-XXXXXXX - X...........X - "
2372 "X..X X..X - -XXXX.XXXX- XXXX.XXXX ------------------------------------- X..........X - "
2373 "X.X X..X - -X.......X- X.......X - XX XX - - X..........X - "
2374 "XX X..X - - X.....X - X.....X - X.X X.X - - X........X - "
2375 " X..X - - X...X - X...X - X..X X..X - - X........X - "
2376 " XX - - X.X - X.X - X...XXXXXXXXXXXXX...X - - XXXXXXXXXX - "
2377 "------------- - X - X -X.....................X- ------------------- "
2378 " ----------------------------------- X...XXXXXXXXXXXXX...X - "
2379 " - X..X X..X - "
2380 " - X.X X.X - "
2381 " - XX XX - "
2382};
2383
2384static const ImVec2 FONT_ATLAS_DEFAULT_TEX_CURSOR_DATA[ImGuiMouseCursor_COUNT][3] =
2385{
2386 // Pos ........ Size ......... Offset ......
2387 { ImVec2( 0,3), ImVec2(12,19), ImVec2( 0, 0) }, // ImGuiMouseCursor_Arrow
2388 { ImVec2(13,0), ImVec2( 7,16), ImVec2( 1, 8) }, // ImGuiMouseCursor_TextInput
2389 { ImVec2(31,0), ImVec2(23,23), ImVec2(11,11) }, // ImGuiMouseCursor_ResizeAll
2390 { ImVec2(21,0), ImVec2( 9,23), ImVec2( 4,11) }, // ImGuiMouseCursor_ResizeNS
2391 { ImVec2(55,18),ImVec2(23, 9), ImVec2(11, 4) }, // ImGuiMouseCursor_ResizeEW
2392 { ImVec2(73,0), ImVec2(17,17), ImVec2( 8, 8) }, // ImGuiMouseCursor_ResizeNESW
2393 { ImVec2(55,0), ImVec2(17,17), ImVec2( 8, 8) }, // ImGuiMouseCursor_ResizeNWSE
2394 { ImVec2(91,0), ImVec2(17,22), ImVec2( 5, 0) }, // ImGuiMouseCursor_Hand
2395 { ImVec2(109,0),ImVec2(13,15), ImVec2( 6, 7) }, // ImGuiMouseCursor_NotAllowed
2396};
2397
2398ImFontAtlas::ImFontAtlas()
2399{
2400 memset(this, 0, sizeof(*this));
2401 TexGlyphPadding = 1;
2402 PackIdMouseCursors = PackIdLines = -1;
2403}
2404
2405ImFontAtlas::~ImFontAtlas()
2406{
2407 IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!");
2408 Clear();
2409}
2410
2411void ImFontAtlas::ClearInputData()
2412{
2413 IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!");
2414 for (ImFontConfig& font_cfg : ConfigData)
2415 if (font_cfg.FontData && font_cfg.FontDataOwnedByAtlas)
2416 {
2417 IM_FREE(font_cfg.FontData);
2418 font_cfg.FontData = NULL;
2419 }
2420
2421 // When clearing this we lose access to the font name and other information used to build the font.
2422 for (ImFont* font : Fonts)
2423 if (font->ConfigData >= ConfigData.Data && font->ConfigData < ConfigData.Data + ConfigData.Size)
2424 {
2425 font->ConfigData = NULL;
2426 font->ConfigDataCount = 0;
2427 }
2428 ConfigData.clear();
2429 CustomRects.clear();
2430 PackIdMouseCursors = PackIdLines = -1;
2431 // Important: we leave TexReady untouched
2432}
2433
2434void ImFontAtlas::ClearTexData()
2435{
2436 IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!");
2437 if (TexPixelsAlpha8)
2438 IM_FREE(TexPixelsAlpha8);
2439 if (TexPixelsRGBA32)
2440 IM_FREE(TexPixelsRGBA32);
2441 TexPixelsAlpha8 = NULL;
2442 TexPixelsRGBA32 = NULL;
2443 TexPixelsUseColors = false;
2444 // Important: we leave TexReady untouched
2445}
2446
2447void ImFontAtlas::ClearFonts()
2448{
2449 IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!");
2450 Fonts.clear_delete();
2451 TexReady = false;
2452}
2453
2454void ImFontAtlas::Clear()
2455{
2456 ClearInputData();
2457 ClearTexData();
2458 ClearFonts();
2459}
2460
2461void ImFontAtlas::GetTexDataAsAlpha8(unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel)
2462{
2463 // Build atlas on demand
2464 if (TexPixelsAlpha8 == NULL)
2465 Build();
2466
2467 *out_pixels = TexPixelsAlpha8;
2468 if (out_width) *out_width = TexWidth;
2469 if (out_height) *out_height = TexHeight;
2470 if (out_bytes_per_pixel) *out_bytes_per_pixel = 1;
2471}
2472
2473void ImFontAtlas::GetTexDataAsRGBA32(unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel)
2474{
2475 // Convert to RGBA32 format on demand
2476 // Although it is likely to be the most commonly used format, our font rendering is 1 channel / 8 bpp
2477 if (!TexPixelsRGBA32)
2478 {
2479 unsigned char* pixels = NULL;
2480 GetTexDataAsAlpha8(&pixels, NULL, NULL);
2481 if (pixels)
2482 {
2483 TexPixelsRGBA32 = (unsigned int*)IM_ALLOC((size_t)TexWidth * (size_t)TexHeight * 4);
2484 const unsigned char* src = pixels;
2485 unsigned int* dst = TexPixelsRGBA32;
2486 for (int n = TexWidth * TexHeight; n > 0; n--)
2487 *dst++ = IM_COL32(255, 255, 255, (unsigned int)(*src++));
2488 }
2489 }
2490
2491 *out_pixels = (unsigned char*)TexPixelsRGBA32;
2492 if (out_width) *out_width = TexWidth;
2493 if (out_height) *out_height = TexHeight;
2494 if (out_bytes_per_pixel) *out_bytes_per_pixel = 4;
2495}
2496
2497ImFont* ImFontAtlas::AddFont(const ImFontConfig* font_cfg)
2498{
2499 IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!");
2500 IM_ASSERT(font_cfg->FontData != NULL && font_cfg->FontDataSize > 0);
2501 IM_ASSERT(font_cfg->SizePixels > 0.0f);
2502
2503 // Create new font
2504 if (!font_cfg->MergeMode)
2505 Fonts.push_back(IM_NEW(ImFont));
2506 else
2507 IM_ASSERT(!Fonts.empty() && "Cannot use MergeMode for the first font"); // When using MergeMode make sure that a font has already been added before. You can use ImGui::GetIO().Fonts->AddFontDefault() to add the default imgui font.
2508
2509 ConfigData.push_back(*font_cfg);
2510 ImFontConfig& new_font_cfg = ConfigData.back();
2511 if (new_font_cfg.DstFont == NULL)
2512 new_font_cfg.DstFont = Fonts.back();
2513 if (!new_font_cfg.FontDataOwnedByAtlas)
2514 {
2515 new_font_cfg.FontData = IM_ALLOC(new_font_cfg.FontDataSize);
2516 new_font_cfg.FontDataOwnedByAtlas = true;
2517 memcpy(new_font_cfg.FontData, font_cfg->FontData, (size_t)new_font_cfg.FontDataSize);
2518 }
2519
2520 if (new_font_cfg.DstFont->EllipsisChar == (ImWchar)-1)
2521 new_font_cfg.DstFont->EllipsisChar = font_cfg->EllipsisChar;
2522
2523 ImFontAtlasUpdateConfigDataPointers(this);
2524
2525 // Invalidate texture
2526 TexReady = false;
2527 ClearTexData();
2528 return new_font_cfg.DstFont;
2529}
2530
2531// Default font TTF is compressed with stb_compress then base85 encoded (see misc/fonts/binary_to_compressed_c.cpp for encoder)
2532static unsigned int stb_decompress_length(const unsigned char* input);
2533static unsigned int stb_decompress(unsigned char* output, const unsigned char* input, unsigned int length);
2534static const char* GetDefaultCompressedFontDataTTFBase85();
2535static unsigned int Decode85Byte(char c) { return c >= '\\' ? c-36 : c-35; }
2536static void Decode85(const unsigned char* src, unsigned char* dst)
2537{
2538 while (*src)
2539 {
2540 unsigned int tmp = Decode85Byte(src[0]) + 85 * (Decode85Byte(src[1]) + 85 * (Decode85Byte(src[2]) + 85 * (Decode85Byte(src[3]) + 85 * Decode85Byte(src[4]))));
2541 dst[0] = ((tmp >> 0) & 0xFF); dst[1] = ((tmp >> 8) & 0xFF); dst[2] = ((tmp >> 16) & 0xFF); dst[3] = ((tmp >> 24) & 0xFF); // We can't assume little-endianness.
2542 src += 5;
2543 dst += 4;
2544 }
2545}
2546
2547// Load embedded ProggyClean.ttf at size 13, disable oversampling
2548ImFont* ImFontAtlas::AddFontDefault(const ImFontConfig* font_cfg_template)
2549{
2550 ImFontConfig font_cfg = font_cfg_template ? *font_cfg_template : ImFontConfig();
2551 if (!font_cfg_template)
2552 {
2553 font_cfg.OversampleH = font_cfg.OversampleV = 1;
2554 font_cfg.PixelSnapH = true;
2555 }
2556 if (font_cfg.SizePixels <= 0.0f)
2557 font_cfg.SizePixels = 13.0f * 1.0f;
2558 if (font_cfg.Name[0] == '\0')
2559 ImFormatString(font_cfg.Name, IM_ARRAYSIZE(font_cfg.Name), "ProggyClean.ttf, %dpx", (int)font_cfg.SizePixels);
2560 font_cfg.EllipsisChar = (ImWchar)0x0085;
2561 font_cfg.GlyphOffset.y = 1.0f * IM_TRUNC(font_cfg.SizePixels / 13.0f); // Add +1 offset per 13 units
2562
2563 const char* ttf_compressed_base85 = GetDefaultCompressedFontDataTTFBase85();
2564 const ImWchar* glyph_ranges = font_cfg.GlyphRanges != NULL ? font_cfg.GlyphRanges : GetGlyphRangesDefault();
2565 ImFont* font = AddFontFromMemoryCompressedBase85TTF(ttf_compressed_base85, font_cfg.SizePixels, &font_cfg, glyph_ranges);
2566 return font;
2567}
2568
2569ImFont* ImFontAtlas::AddFontFromFileTTF(const char* filename, float size_pixels, const ImFontConfig* font_cfg_template, const ImWchar* glyph_ranges)
2570{
2571 IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!");
2572 size_t data_size = 0;
2573 void* data = ImFileLoadToMemory(filename, "rb", &data_size, 0);
2574 if (!data)
2575 {
2576 IM_ASSERT_USER_ERROR(0, "Could not load font file!");
2577 return NULL;
2578 }
2579 ImFontConfig font_cfg = font_cfg_template ? *font_cfg_template : ImFontConfig();
2580 if (font_cfg.Name[0] == '\0')
2581 {
2582 // Store a short copy of filename into into the font name for convenience
2583 const char* p;
2584 for (p = filename + strlen(filename); p > filename && p[-1] != '/' && p[-1] != '\\'; p--) {}
2585 ImFormatString(font_cfg.Name, IM_ARRAYSIZE(font_cfg.Name), "%s, %.0fpx", p, size_pixels);
2586 }
2587 return AddFontFromMemoryTTF(data, (int)data_size, size_pixels, &font_cfg, glyph_ranges);
2588}
2589
2590// NB: Transfer ownership of 'ttf_data' to ImFontAtlas, unless font_cfg_template->FontDataOwnedByAtlas == false. Owned TTF buffer will be deleted after Build().
2591ImFont* ImFontAtlas::AddFontFromMemoryTTF(void* font_data, int font_data_size, float size_pixels, const ImFontConfig* font_cfg_template, const ImWchar* glyph_ranges)
2592{
2593 IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!");
2594 ImFontConfig font_cfg = font_cfg_template ? *font_cfg_template : ImFontConfig();
2595 IM_ASSERT(font_cfg.FontData == NULL);
2596 IM_ASSERT(font_data_size > 100 && "Incorrect value for font_data_size!"); // Heuristic to prevent accidentally passing a wrong value to font_data_size.
2597 font_cfg.FontData = font_data;
2598 font_cfg.FontDataSize = font_data_size;
2599 font_cfg.SizePixels = size_pixels > 0.0f ? size_pixels : font_cfg.SizePixels;
2600 if (glyph_ranges)
2601 font_cfg.GlyphRanges = glyph_ranges;
2602 return AddFont(&font_cfg);
2603}
2604
2605ImFont* ImFontAtlas::AddFontFromMemoryCompressedTTF(const void* compressed_ttf_data, int compressed_ttf_size, float size_pixels, const ImFontConfig* font_cfg_template, const ImWchar* glyph_ranges)
2606{
2607 const unsigned int buf_decompressed_size = stb_decompress_length((const unsigned char*)compressed_ttf_data);
2608 unsigned char* buf_decompressed_data = (unsigned char*)IM_ALLOC(buf_decompressed_size);
2609 stb_decompress(buf_decompressed_data, (const unsigned char*)compressed_ttf_data, (unsigned int)compressed_ttf_size);
2610
2611 ImFontConfig font_cfg = font_cfg_template ? *font_cfg_template : ImFontConfig();
2612 IM_ASSERT(font_cfg.FontData == NULL);
2613 font_cfg.FontDataOwnedByAtlas = true;
2614 return AddFontFromMemoryTTF(buf_decompressed_data, (int)buf_decompressed_size, size_pixels, &font_cfg, glyph_ranges);
2615}
2616
2617ImFont* ImFontAtlas::AddFontFromMemoryCompressedBase85TTF(const char* compressed_ttf_data_base85, float size_pixels, const ImFontConfig* font_cfg, const ImWchar* glyph_ranges)
2618{
2619 int compressed_ttf_size = (((int)strlen(compressed_ttf_data_base85) + 4) / 5) * 4;
2620 void* compressed_ttf = IM_ALLOC((size_t)compressed_ttf_size);
2621 Decode85((const unsigned char*)compressed_ttf_data_base85, (unsigned char*)compressed_ttf);
2622 ImFont* font = AddFontFromMemoryCompressedTTF(compressed_ttf, compressed_ttf_size, size_pixels, font_cfg, glyph_ranges);
2623 IM_FREE(compressed_ttf);
2624 return font;
2625}
2626
2627int ImFontAtlas::AddCustomRectRegular(int width, int height)
2628{
2629 IM_ASSERT(width > 0 && width <= 0xFFFF);
2630 IM_ASSERT(height > 0 && height <= 0xFFFF);
2631 ImFontAtlasCustomRect r;
2632 r.Width = (unsigned short)width;
2633 r.Height = (unsigned short)height;
2634 CustomRects.push_back(r);
2635 return CustomRects.Size - 1; // Return index
2636}
2637
2638int ImFontAtlas::AddCustomRectFontGlyph(ImFont* font, ImWchar id, int width, int height, float advance_x, const ImVec2& offset)
2639{
2640#ifdef IMGUI_USE_WCHAR32
2641 IM_ASSERT(id <= IM_UNICODE_CODEPOINT_MAX);
2642#endif
2643 IM_ASSERT(font != NULL);
2644 IM_ASSERT(width > 0 && width <= 0xFFFF);
2645 IM_ASSERT(height > 0 && height <= 0xFFFF);
2646 ImFontAtlasCustomRect r;
2647 r.Width = (unsigned short)width;
2648 r.Height = (unsigned short)height;
2649 r.GlyphID = id;
2650 r.GlyphAdvanceX = advance_x;
2651 r.GlyphOffset = offset;
2652 r.Font = font;
2653 CustomRects.push_back(r);
2654 return CustomRects.Size - 1; // Return index
2655}
2656
2657void ImFontAtlas::CalcCustomRectUV(const ImFontAtlasCustomRect* rect, ImVec2* out_uv_min, ImVec2* out_uv_max) const
2658{
2659 IM_ASSERT(TexWidth > 0 && TexHeight > 0); // Font atlas needs to be built before we can calculate UV coordinates
2660 IM_ASSERT(rect->IsPacked()); // Make sure the rectangle has been packed
2661 *out_uv_min = ImVec2((float)rect->X * TexUvScale.x, (float)rect->Y * TexUvScale.y);
2662 *out_uv_max = ImVec2((float)(rect->X + rect->Width) * TexUvScale.x, (float)(rect->Y + rect->Height) * TexUvScale.y);
2663}
2664
2665bool ImFontAtlas::GetMouseCursorTexData(ImGuiMouseCursor cursor_type, ImVec2* out_offset, ImVec2* out_size, ImVec2 out_uv_border[2], ImVec2 out_uv_fill[2])
2666{
2667 if (cursor_type <= ImGuiMouseCursor_None || cursor_type >= ImGuiMouseCursor_COUNT)
2668 return false;
2669 if (Flags & ImFontAtlasFlags_NoMouseCursors)
2670 return false;
2671
2672 IM_ASSERT(PackIdMouseCursors != -1);
2673 ImFontAtlasCustomRect* r = GetCustomRectByIndex(PackIdMouseCursors);
2674 ImVec2 pos = FONT_ATLAS_DEFAULT_TEX_CURSOR_DATA[cursor_type][0] + ImVec2((float)r->X, (float)r->Y);
2675 ImVec2 size = FONT_ATLAS_DEFAULT_TEX_CURSOR_DATA[cursor_type][1];
2676 *out_size = size;
2677 *out_offset = FONT_ATLAS_DEFAULT_TEX_CURSOR_DATA[cursor_type][2];
2678 out_uv_border[0] = (pos) * TexUvScale;
2679 out_uv_border[1] = (pos + size) * TexUvScale;
2680 pos.x += FONT_ATLAS_DEFAULT_TEX_DATA_W + 1;
2681 out_uv_fill[0] = (pos) * TexUvScale;
2682 out_uv_fill[1] = (pos + size) * TexUvScale;
2683 return true;
2684}
2685
2686bool ImFontAtlas::Build()
2687{
2688 IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!");
2689
2690 // Default font is none are specified
2691 if (ConfigData.Size == 0)
2692 AddFontDefault();
2693
2694 // Select builder
2695 // - Note that we do not reassign to atlas->FontBuilderIO, since it is likely to point to static data which
2696 // may mess with some hot-reloading schemes. If you need to assign to this (for dynamic selection) AND are
2697 // using a hot-reloading scheme that messes up static data, store your own instance of ImFontBuilderIO somewhere
2698 // and point to it instead of pointing directly to return value of the GetBuilderXXX functions.
2699 const ImFontBuilderIO* builder_io = FontBuilderIO;
2700 if (builder_io == NULL)
2701 {
2702#ifdef IMGUI_ENABLE_FREETYPE
2703 builder_io = ImGuiFreeType::GetBuilderForFreeType();
2704#elif defined(IMGUI_ENABLE_STB_TRUETYPE)
2705 builder_io = ImFontAtlasGetBuilderForStbTruetype();
2706#else
2707 IM_ASSERT(0); // Invalid Build function
2708#endif
2709 }
2710
2711 // Build
2712 return builder_io->FontBuilder_Build(this);
2713}
2714
2715void ImFontAtlasBuildMultiplyCalcLookupTable(unsigned char out_table[256], float in_brighten_factor)
2716{
2717 for (unsigned int i = 0; i < 256; i++)
2718 {
2719 unsigned int value = (unsigned int)(i * in_brighten_factor);
2720 out_table[i] = value > 255 ? 255 : (value & 0xFF);
2721 }
2722}
2723
2724void ImFontAtlasBuildMultiplyRectAlpha8(const unsigned char table[256], unsigned char* pixels, int x, int y, int w, int h, int stride)
2725{
2726 IM_ASSERT_PARANOID(w <= stride);
2727 unsigned char* data = pixels + x + y * stride;
2728 for (int j = h; j > 0; j--, data += stride - w)
2729 for (int i = w; i > 0; i--, data++)
2730 *data = table[*data];
2731}
2732
2733#ifdef IMGUI_ENABLE_STB_TRUETYPE
2734// Temporary data for one source font (multiple source fonts can be merged into one destination ImFont)
2735// (C++03 doesn't allow instancing ImVector<> with function-local types so we declare the type here.)
2736struct ImFontBuildSrcData
2737{
2738 stbtt_fontinfo FontInfo;
2739 stbtt_pack_range PackRange; // Hold the list of codepoints to pack (essentially points to Codepoints.Data)
2740 stbrp_rect* Rects; // Rectangle to pack. We first fill in their size and the packer will give us their position.
2741 stbtt_packedchar* PackedChars; // Output glyphs
2742 const ImWchar* SrcRanges; // Ranges as requested by user (user is allowed to request too much, e.g. 0x0020..0xFFFF)
2743 int DstIndex; // Index into atlas->Fonts[] and dst_tmp_array[]
2744 int GlyphsHighest; // Highest requested codepoint
2745 int GlyphsCount; // Glyph count (excluding missing glyphs and glyphs already set by an earlier source font)
2746 ImBitVector GlyphsSet; // Glyph bit map (random access, 1-bit per codepoint. This will be a maximum of 8KB)
2747 ImVector<int> GlyphsList; // Glyph codepoints list (flattened version of GlyphsSet)
2748};
2749
2750// Temporary data for one destination ImFont* (multiple source fonts can be merged into one destination ImFont)
2751struct ImFontBuildDstData
2752{
2753 int SrcCount; // Number of source fonts targeting this destination font.
2754 int GlyphsHighest;
2755 int GlyphsCount;
2756 ImBitVector GlyphsSet; // This is used to resolve collision when multiple sources are merged into a same destination font.
2757};
2758
2759static void UnpackBitVectorToFlatIndexList(const ImBitVector* in, ImVector<int>* out)
2760{
2761 IM_ASSERT(sizeof(in->Storage.Data[0]) == sizeof(int));
2762 const ImU32* it_begin = in->Storage.begin();
2763 const ImU32* it_end = in->Storage.end();
2764 for (const ImU32* it = it_begin; it < it_end; it++)
2765 if (ImU32 entries_32 = *it)
2766 for (ImU32 bit_n = 0; bit_n < 32; bit_n++)
2767 if (entries_32 & ((ImU32)1 << bit_n))
2768 out->push_back((int)(((it - it_begin) << 5) + bit_n));
2769}
2770
2771static bool ImFontAtlasBuildWithStbTruetype(ImFontAtlas* atlas)
2772{
2773 IM_ASSERT(atlas->ConfigData.Size > 0);
2774
2775 ImFontAtlasBuildInit(atlas);
2776
2777 // Clear atlas
2778 atlas->TexID = (ImTextureID)NULL;
2779 atlas->TexWidth = atlas->TexHeight = 0;
2780 atlas->TexUvScale = ImVec2(0.0f, 0.0f);
2781 atlas->TexUvWhitePixel = ImVec2(0.0f, 0.0f);
2782 atlas->ClearTexData();
2783
2784 // Temporary storage for building
2785 ImVector<ImFontBuildSrcData> src_tmp_array;
2786 ImVector<ImFontBuildDstData> dst_tmp_array;
2787 src_tmp_array.resize(atlas->ConfigData.Size);
2788 dst_tmp_array.resize(atlas->Fonts.Size);
2789 memset(src_tmp_array.Data, 0, (size_t)src_tmp_array.size_in_bytes());
2790 memset(dst_tmp_array.Data, 0, (size_t)dst_tmp_array.size_in_bytes());
2791
2792 // 1. Initialize font loading structure, check font data validity
2793 for (int src_i = 0; src_i < atlas->ConfigData.Size; src_i++)
2794 {
2795 ImFontBuildSrcData& src_tmp = src_tmp_array[src_i];
2796 ImFontConfig& cfg = atlas->ConfigData[src_i];
2797 IM_ASSERT(cfg.DstFont && (!cfg.DstFont->IsLoaded() || cfg.DstFont->ContainerAtlas == atlas));
2798
2799 // Find index from cfg.DstFont (we allow the user to set cfg.DstFont. Also it makes casual debugging nicer than when storing indices)
2800 src_tmp.DstIndex = -1;
2801 for (int output_i = 0; output_i < atlas->Fonts.Size && src_tmp.DstIndex == -1; output_i++)
2802 if (cfg.DstFont == atlas->Fonts[output_i])
2803 src_tmp.DstIndex = output_i;
2804 if (src_tmp.DstIndex == -1)
2805 {
2806 IM_ASSERT(src_tmp.DstIndex != -1); // cfg.DstFont not pointing within atlas->Fonts[] array?
2807 return false;
2808 }
2809 // Initialize helper structure for font loading and verify that the TTF/OTF data is correct
2810 const int font_offset = stbtt_GetFontOffsetForIndex((unsigned char*)cfg.FontData, cfg.FontNo);
2811 IM_ASSERT(font_offset >= 0 && "FontData is incorrect, or FontNo cannot be found.");
2812 if (!stbtt_InitFont(&src_tmp.FontInfo, (unsigned char*)cfg.FontData, font_offset))
2813 {
2814 IM_ASSERT(0 && "stbtt_InitFont(): failed to parse FontData. It is correct and complete? Check FontDataSize.");
2815 return false;
2816 }
2817
2818 // Measure highest codepoints
2819 ImFontBuildDstData& dst_tmp = dst_tmp_array[src_tmp.DstIndex];
2820 src_tmp.SrcRanges = cfg.GlyphRanges ? cfg.GlyphRanges : atlas->GetGlyphRangesDefault();
2821 for (const ImWchar* src_range = src_tmp.SrcRanges; src_range[0] && src_range[1]; src_range += 2)
2822 {
2823 // Check for valid range. This may also help detect *some* dangling pointers, because a common
2824 // user error is to setup ImFontConfig::GlyphRanges with a pointer to data that isn't persistent.
2825 IM_ASSERT(src_range[0] <= src_range[1]);
2826 src_tmp.GlyphsHighest = ImMax(src_tmp.GlyphsHighest, (int)src_range[1]);
2827 }
2828 dst_tmp.SrcCount++;
2829 dst_tmp.GlyphsHighest = ImMax(dst_tmp.GlyphsHighest, src_tmp.GlyphsHighest);
2830 }
2831
2832 // 2. For every requested codepoint, check for their presence in the font data, and handle redundancy or overlaps between source fonts to avoid unused glyphs.
2833 int total_glyphs_count = 0;
2834 for (int src_i = 0; src_i < src_tmp_array.Size; src_i++)
2835 {
2836 ImFontBuildSrcData& src_tmp = src_tmp_array[src_i];
2837 ImFontBuildDstData& dst_tmp = dst_tmp_array[src_tmp.DstIndex];
2838 src_tmp.GlyphsSet.Create(src_tmp.GlyphsHighest + 1);
2839 if (dst_tmp.GlyphsSet.Storage.empty())
2840 dst_tmp.GlyphsSet.Create(dst_tmp.GlyphsHighest + 1);
2841
2842 for (const ImWchar* src_range = src_tmp.SrcRanges; src_range[0] && src_range[1]; src_range += 2)
2843 for (unsigned int codepoint = src_range[0]; codepoint <= src_range[1]; codepoint++)
2844 {
2845 if (dst_tmp.GlyphsSet.TestBit(codepoint)) // Don't overwrite existing glyphs. We could make this an option for MergeMode (e.g. MergeOverwrite==true)
2846 continue;
2847 if (!stbtt_FindGlyphIndex(&src_tmp.FontInfo, codepoint)) // It is actually in the font?
2848 continue;
2849
2850 // Add to avail set/counters
2851 src_tmp.GlyphsCount++;
2852 dst_tmp.GlyphsCount++;
2853 src_tmp.GlyphsSet.SetBit(codepoint);
2854 dst_tmp.GlyphsSet.SetBit(codepoint);
2855 total_glyphs_count++;
2856 }
2857 }
2858
2859 // 3. Unpack our bit map into a flat list (we now have all the Unicode points that we know are requested _and_ available _and_ not overlapping another)
2860 for (int src_i = 0; src_i < src_tmp_array.Size; src_i++)
2861 {
2862 ImFontBuildSrcData& src_tmp = src_tmp_array[src_i];
2863 src_tmp.GlyphsList.reserve(src_tmp.GlyphsCount);
2864 UnpackBitVectorToFlatIndexList(&src_tmp.GlyphsSet, &src_tmp.GlyphsList);
2865 src_tmp.GlyphsSet.Clear();
2866 IM_ASSERT(src_tmp.GlyphsList.Size == src_tmp.GlyphsCount);
2867 }
2868 for (int dst_i = 0; dst_i < dst_tmp_array.Size; dst_i++)
2869 dst_tmp_array[dst_i].GlyphsSet.Clear();
2870 dst_tmp_array.clear();
2871
2872 // Allocate packing character data and flag packed characters buffer as non-packed (x0=y0=x1=y1=0)
2873 // (We technically don't need to zero-clear buf_rects, but let's do it for the sake of sanity)
2874 ImVector<stbrp_rect> buf_rects;
2875 ImVector<stbtt_packedchar> buf_packedchars;
2876 buf_rects.resize(total_glyphs_count);
2877 buf_packedchars.resize(total_glyphs_count);
2878 memset(buf_rects.Data, 0, (size_t)buf_rects.size_in_bytes());
2879 memset(buf_packedchars.Data, 0, (size_t)buf_packedchars.size_in_bytes());
2880
2881 // 4. Gather glyphs sizes so we can pack them in our virtual canvas.
2882 int total_surface = 0;
2883 int buf_rects_out_n = 0;
2884 int buf_packedchars_out_n = 0;
2885 for (int src_i = 0; src_i < src_tmp_array.Size; src_i++)
2886 {
2887 ImFontBuildSrcData& src_tmp = src_tmp_array[src_i];
2888 if (src_tmp.GlyphsCount == 0)
2889 continue;
2890
2891 src_tmp.Rects = &buf_rects[buf_rects_out_n];
2892 src_tmp.PackedChars = &buf_packedchars[buf_packedchars_out_n];
2893 buf_rects_out_n += src_tmp.GlyphsCount;
2894 buf_packedchars_out_n += src_tmp.GlyphsCount;
2895
2896 // Convert our ranges in the format stb_truetype wants
2897 ImFontConfig& cfg = atlas->ConfigData[src_i];
2898 src_tmp.PackRange.font_size = cfg.SizePixels * cfg.RasterizerDensity;
2899 src_tmp.PackRange.first_unicode_codepoint_in_range = 0;
2900 src_tmp.PackRange.array_of_unicode_codepoints = src_tmp.GlyphsList.Data;
2901 src_tmp.PackRange.num_chars = src_tmp.GlyphsList.Size;
2902 src_tmp.PackRange.chardata_for_range = src_tmp.PackedChars;
2903 src_tmp.PackRange.h_oversample = (unsigned char)cfg.OversampleH;
2904 src_tmp.PackRange.v_oversample = (unsigned char)cfg.OversampleV;
2905
2906 // Gather the sizes of all rectangles we will need to pack (this loop is based on stbtt_PackFontRangesGatherRects)
2907 const float scale = (cfg.SizePixels > 0.0f) ? stbtt_ScaleForPixelHeight(&src_tmp.FontInfo, cfg.SizePixels * cfg.RasterizerDensity) : stbtt_ScaleForMappingEmToPixels(&src_tmp.FontInfo, -cfg.SizePixels * cfg.RasterizerDensity);
2908 const int padding = atlas->TexGlyphPadding;
2909 for (int glyph_i = 0; glyph_i < src_tmp.GlyphsList.Size; glyph_i++)
2910 {
2911 int x0, y0, x1, y1;
2912 const int glyph_index_in_font = stbtt_FindGlyphIndex(&src_tmp.FontInfo, src_tmp.GlyphsList[glyph_i]);
2913 IM_ASSERT(glyph_index_in_font != 0);
2914 stbtt_GetGlyphBitmapBoxSubpixel(&src_tmp.FontInfo, glyph_index_in_font, scale * cfg.OversampleH, scale * cfg.OversampleV, 0, 0, &x0, &y0, &x1, &y1);
2915 src_tmp.Rects[glyph_i].w = (stbrp_coord)(x1 - x0 + padding + cfg.OversampleH - 1);
2916 src_tmp.Rects[glyph_i].h = (stbrp_coord)(y1 - y0 + padding + cfg.OversampleV - 1);
2917 total_surface += src_tmp.Rects[glyph_i].w * src_tmp.Rects[glyph_i].h;
2918 }
2919 }
2920
2921 // We need a width for the skyline algorithm, any width!
2922 // The exact width doesn't really matter much, but some API/GPU have texture size limitations and increasing width can decrease height.
2923 // User can override TexDesiredWidth and TexGlyphPadding if they wish, otherwise we use a simple heuristic to select the width based on expected surface.
2924 const int surface_sqrt = (int)ImSqrt((float)total_surface) + 1;
2925 atlas->TexHeight = 0;
2926 if (atlas->TexDesiredWidth > 0)
2927 atlas->TexWidth = atlas->TexDesiredWidth;
2928 else
2929 atlas->TexWidth = (surface_sqrt >= 4096 * 0.7f) ? 4096 : (surface_sqrt >= 2048 * 0.7f) ? 2048 : (surface_sqrt >= 1024 * 0.7f) ? 1024 : 512;
2930
2931 // 5. Start packing
2932 // Pack our extra data rectangles first, so it will be on the upper-left corner of our texture (UV will have small values).
2933 const int TEX_HEIGHT_MAX = 1024 * 32;
2934 stbtt_pack_context spc = {};
2935 stbtt_PackBegin(&spc, NULL, atlas->TexWidth, TEX_HEIGHT_MAX, 0, atlas->TexGlyphPadding, NULL);
2936 ImFontAtlasBuildPackCustomRects(atlas, spc.pack_info);
2937
2938 // 6. Pack each source font. No rendering yet, we are working with rectangles in an infinitely tall texture at this point.
2939 for (int src_i = 0; src_i < src_tmp_array.Size; src_i++)
2940 {
2941 ImFontBuildSrcData& src_tmp = src_tmp_array[src_i];
2942 if (src_tmp.GlyphsCount == 0)
2943 continue;
2944
2945 stbrp_pack_rects((stbrp_context*)spc.pack_info, src_tmp.Rects, src_tmp.GlyphsCount);
2946
2947 // Extend texture height and mark missing glyphs as non-packed so we won't render them.
2948 // FIXME: We are not handling packing failure here (would happen if we got off TEX_HEIGHT_MAX or if a single if larger than TexWidth?)
2949 for (int glyph_i = 0; glyph_i < src_tmp.GlyphsCount; glyph_i++)
2950 if (src_tmp.Rects[glyph_i].was_packed)
2951 atlas->TexHeight = ImMax(atlas->TexHeight, src_tmp.Rects[glyph_i].y + src_tmp.Rects[glyph_i].h);
2952 }
2953
2954 // 7. Allocate texture
2955 atlas->TexHeight = (atlas->Flags & ImFontAtlasFlags_NoPowerOfTwoHeight) ? (atlas->TexHeight + 1) : ImUpperPowerOfTwo(atlas->TexHeight);
2956 atlas->TexUvScale = ImVec2(1.0f / atlas->TexWidth, 1.0f / atlas->TexHeight);
2957 atlas->TexPixelsAlpha8 = (unsigned char*)IM_ALLOC(atlas->TexWidth * atlas->TexHeight);
2958 memset(atlas->TexPixelsAlpha8, 0, atlas->TexWidth * atlas->TexHeight);
2959 spc.pixels = atlas->TexPixelsAlpha8;
2960 spc.height = atlas->TexHeight;
2961
2962 // 8. Render/rasterize font characters into the texture
2963 for (int src_i = 0; src_i < src_tmp_array.Size; src_i++)
2964 {
2965 ImFontConfig& cfg = atlas->ConfigData[src_i];
2966 ImFontBuildSrcData& src_tmp = src_tmp_array[src_i];
2967 if (src_tmp.GlyphsCount == 0)
2968 continue;
2969
2970 stbtt_PackFontRangesRenderIntoRects(&spc, &src_tmp.FontInfo, &src_tmp.PackRange, 1, src_tmp.Rects);
2971
2972 // Apply multiply operator
2973 if (cfg.RasterizerMultiply != 1.0f)
2974 {
2975 unsigned char multiply_table[256];
2976 ImFontAtlasBuildMultiplyCalcLookupTable(multiply_table, cfg.RasterizerMultiply);
2977 stbrp_rect* r = &src_tmp.Rects[0];
2978 for (int glyph_i = 0; glyph_i < src_tmp.GlyphsCount; glyph_i++, r++)
2979 if (r->was_packed)
2980 ImFontAtlasBuildMultiplyRectAlpha8(multiply_table, atlas->TexPixelsAlpha8, r->x, r->y, r->w, r->h, atlas->TexWidth * 1);
2981 }
2982 src_tmp.Rects = NULL;
2983 }
2984
2985 // End packing
2986 stbtt_PackEnd(&spc);
2987 buf_rects.clear();
2988
2989 // 9. Setup ImFont and glyphs for runtime
2990 for (int src_i = 0; src_i < src_tmp_array.Size; src_i++)
2991 {
2992 // When merging fonts with MergeMode=true:
2993 // - We can have multiple input fonts writing into a same destination font.
2994 // - dst_font->ConfigData is != from cfg which is our source configuration.
2995 ImFontBuildSrcData& src_tmp = src_tmp_array[src_i];
2996 ImFontConfig& cfg = atlas->ConfigData[src_i];
2997 ImFont* dst_font = cfg.DstFont;
2998
2999 const float font_scale = stbtt_ScaleForPixelHeight(&src_tmp.FontInfo, cfg.SizePixels);
3000 int unscaled_ascent, unscaled_descent, unscaled_line_gap;
3001 stbtt_GetFontVMetrics(&src_tmp.FontInfo, &unscaled_ascent, &unscaled_descent, &unscaled_line_gap);
3002
3003 const float ascent = ImCeil(unscaled_ascent * font_scale);
3004 const float descent = ImFloor(unscaled_descent * font_scale);
3005 ImFontAtlasBuildSetupFont(atlas, dst_font, &cfg, ascent, descent);
3006 const float font_off_x = cfg.GlyphOffset.x;
3007 const float font_off_y = cfg.GlyphOffset.y + IM_ROUND(dst_font->Ascent);
3008
3009 const float inv_rasterization_scale = 1.0f / cfg.RasterizerDensity;
3010
3011 for (int glyph_i = 0; glyph_i < src_tmp.GlyphsCount; glyph_i++)
3012 {
3013 // Register glyph
3014 const int codepoint = src_tmp.GlyphsList[glyph_i];
3015 const stbtt_packedchar& pc = src_tmp.PackedChars[glyph_i];
3016 stbtt_aligned_quad q;
3017 float unused_x = 0.0f, unused_y = 0.0f;
3018 stbtt_GetPackedQuad(src_tmp.PackedChars, atlas->TexWidth, atlas->TexHeight, glyph_i, &unused_x, &unused_y, &q, 0);
3019 float x0 = q.x0 * inv_rasterization_scale + font_off_x;
3020 float y0 = q.y0 * inv_rasterization_scale + font_off_y;
3021 float x1 = q.x1 * inv_rasterization_scale + font_off_x;
3022 float y1 = q.y1 * inv_rasterization_scale + font_off_y;
3023 dst_font->AddGlyph(&cfg, (ImWchar)codepoint, x0, y0, x1, y1, q.s0, q.t0, q.s1, q.t1, pc.xadvance * inv_rasterization_scale);
3024 }
3025 }
3026
3027 // Cleanup
3028 src_tmp_array.clear_destruct();
3029
3030 ImFontAtlasBuildFinish(atlas);
3031 return true;
3032}
3033
3034const ImFontBuilderIO* ImFontAtlasGetBuilderForStbTruetype()
3035{
3036 static ImFontBuilderIO io;
3037 io.FontBuilder_Build = ImFontAtlasBuildWithStbTruetype;
3038 return &io;
3039}
3040
3041#endif // IMGUI_ENABLE_STB_TRUETYPE
3042
3043void ImFontAtlasUpdateConfigDataPointers(ImFontAtlas* atlas)
3044{
3045 for (ImFontConfig& font_cfg : atlas->ConfigData)
3046 {
3047 ImFont* font = font_cfg.DstFont;
3048 if (!font_cfg.MergeMode)
3049 {
3050 font->ConfigData = &font_cfg;
3051 font->ConfigDataCount = 0;
3052 }
3053 font->ConfigDataCount++;
3054 }
3055}
3056
3057void ImFontAtlasBuildSetupFont(ImFontAtlas* atlas, ImFont* font, ImFontConfig* font_config, float ascent, float descent)
3058{
3059 if (!font_config->MergeMode)
3060 {
3061 font->ClearOutputData();
3062 font->FontSize = font_config->SizePixels;
3063 IM_ASSERT(font->ConfigData == font_config);
3064 font->ContainerAtlas = atlas;
3065 font->Ascent = ascent;
3066 font->Descent = descent;
3067 }
3068}
3069
3070void ImFontAtlasBuildPackCustomRects(ImFontAtlas* atlas, void* stbrp_context_opaque)
3071{
3072 stbrp_context* pack_context = (stbrp_context*)stbrp_context_opaque;
3073 IM_ASSERT(pack_context != NULL);
3074
3075 ImVector<ImFontAtlasCustomRect>& user_rects = atlas->CustomRects;
3076 IM_ASSERT(user_rects.Size >= 1); // We expect at least the default custom rects to be registered, else something went wrong.
3077#ifdef __GNUC__
3078 if (user_rects.Size < 1) { __builtin_unreachable(); } // Workaround for GCC bug if IM_ASSERT() is defined to conditionally throw (see #5343)
3079#endif
3080
3081 ImVector<stbrp_rect> pack_rects;
3082 pack_rects.resize(user_rects.Size);
3083 memset(pack_rects.Data, 0, (size_t)pack_rects.size_in_bytes());
3084 for (int i = 0; i < user_rects.Size; i++)
3085 {
3086 pack_rects[i].w = user_rects[i].Width;
3087 pack_rects[i].h = user_rects[i].Height;
3088 }
3089 stbrp_pack_rects(pack_context, &pack_rects[0], pack_rects.Size);
3090 for (int i = 0; i < pack_rects.Size; i++)
3091 if (pack_rects[i].was_packed)
3092 {
3093 user_rects[i].X = (unsigned short)pack_rects[i].x;
3094 user_rects[i].Y = (unsigned short)pack_rects[i].y;
3095 IM_ASSERT(pack_rects[i].w == user_rects[i].Width && pack_rects[i].h == user_rects[i].Height);
3096 atlas->TexHeight = ImMax(atlas->TexHeight, pack_rects[i].y + pack_rects[i].h);
3097 }
3098}
3099
3100void ImFontAtlasBuildRender8bppRectFromString(ImFontAtlas* atlas, int x, int y, int w, int h, const char* in_str, char in_marker_char, unsigned char in_marker_pixel_value)
3101{
3102 IM_ASSERT(x >= 0 && x + w <= atlas->TexWidth);
3103 IM_ASSERT(y >= 0 && y + h <= atlas->TexHeight);
3104 unsigned char* out_pixel = atlas->TexPixelsAlpha8 + x + (y * atlas->TexWidth);
3105 for (int off_y = 0; off_y < h; off_y++, out_pixel += atlas->TexWidth, in_str += w)
3106 for (int off_x = 0; off_x < w; off_x++)
3107 out_pixel[off_x] = (in_str[off_x] == in_marker_char) ? in_marker_pixel_value : 0x00;
3108}
3109
3110void ImFontAtlasBuildRender32bppRectFromString(ImFontAtlas* atlas, int x, int y, int w, int h, const char* in_str, char in_marker_char, unsigned int in_marker_pixel_value)
3111{
3112 IM_ASSERT(x >= 0 && x + w <= atlas->TexWidth);
3113 IM_ASSERT(y >= 0 && y + h <= atlas->TexHeight);
3114 unsigned int* out_pixel = atlas->TexPixelsRGBA32 + x + (y * atlas->TexWidth);
3115 for (int off_y = 0; off_y < h; off_y++, out_pixel += atlas->TexWidth, in_str += w)
3116 for (int off_x = 0; off_x < w; off_x++)
3117 out_pixel[off_x] = (in_str[off_x] == in_marker_char) ? in_marker_pixel_value : IM_COL32_BLACK_TRANS;
3118}
3119
3120static void ImFontAtlasBuildRenderDefaultTexData(ImFontAtlas* atlas)
3121{
3122 ImFontAtlasCustomRect* r = atlas->GetCustomRectByIndex(atlas->PackIdMouseCursors);
3123 IM_ASSERT(r->IsPacked());
3124
3125 const int w = atlas->TexWidth;
3126 if (!(atlas->Flags & ImFontAtlasFlags_NoMouseCursors))
3127 {
3128 // Render/copy pixels
3129 IM_ASSERT(r->Width == FONT_ATLAS_DEFAULT_TEX_DATA_W * 2 + 1 && r->Height == FONT_ATLAS_DEFAULT_TEX_DATA_H);
3130 const int x_for_white = r->X;
3131 const int x_for_black = r->X + FONT_ATLAS_DEFAULT_TEX_DATA_W + 1;
3132 if (atlas->TexPixelsAlpha8 != NULL)
3133 {
3134 ImFontAtlasBuildRender8bppRectFromString(atlas, x_for_white, r->Y, FONT_ATLAS_DEFAULT_TEX_DATA_W, FONT_ATLAS_DEFAULT_TEX_DATA_H, FONT_ATLAS_DEFAULT_TEX_DATA_PIXELS, '.', 0xFF);
3135 ImFontAtlasBuildRender8bppRectFromString(atlas, x_for_black, r->Y, FONT_ATLAS_DEFAULT_TEX_DATA_W, FONT_ATLAS_DEFAULT_TEX_DATA_H, FONT_ATLAS_DEFAULT_TEX_DATA_PIXELS, 'X', 0xFF);
3136 }
3137 else
3138 {
3139 ImFontAtlasBuildRender32bppRectFromString(atlas, x_for_white, r->Y, FONT_ATLAS_DEFAULT_TEX_DATA_W, FONT_ATLAS_DEFAULT_TEX_DATA_H, FONT_ATLAS_DEFAULT_TEX_DATA_PIXELS, '.', IM_COL32_WHITE);
3140 ImFontAtlasBuildRender32bppRectFromString(atlas, x_for_black, r->Y, FONT_ATLAS_DEFAULT_TEX_DATA_W, FONT_ATLAS_DEFAULT_TEX_DATA_H, FONT_ATLAS_DEFAULT_TEX_DATA_PIXELS, 'X', IM_COL32_WHITE);
3141 }
3142 }
3143 else
3144 {
3145 // Render 4 white pixels
3146 IM_ASSERT(r->Width == 2 && r->Height == 2);
3147 const int offset = (int)r->X + (int)r->Y * w;
3148 if (atlas->TexPixelsAlpha8 != NULL)
3149 {
3150 atlas->TexPixelsAlpha8[offset] = atlas->TexPixelsAlpha8[offset + 1] = atlas->TexPixelsAlpha8[offset + w] = atlas->TexPixelsAlpha8[offset + w + 1] = 0xFF;
3151 }
3152 else
3153 {
3154 atlas->TexPixelsRGBA32[offset] = atlas->TexPixelsRGBA32[offset + 1] = atlas->TexPixelsRGBA32[offset + w] = atlas->TexPixelsRGBA32[offset + w + 1] = IM_COL32_WHITE;
3155 }
3156 }
3157 atlas->TexUvWhitePixel = ImVec2((r->X + 0.5f) * atlas->TexUvScale.x, (r->Y + 0.5f) * atlas->TexUvScale.y);
3158}
3159
3160static void ImFontAtlasBuildRenderLinesTexData(ImFontAtlas* atlas)
3161{
3162 if (atlas->Flags & ImFontAtlasFlags_NoBakedLines)
3163 return;
3164
3165 // This generates a triangular shape in the texture, with the various line widths stacked on top of each other to allow interpolation between them
3166 ImFontAtlasCustomRect* r = atlas->GetCustomRectByIndex(atlas->PackIdLines);
3167 IM_ASSERT(r->IsPacked());
3168 for (unsigned int n = 0; n < IM_DRAWLIST_TEX_LINES_WIDTH_MAX + 1; n++) // +1 because of the zero-width row
3169 {
3170 // Each line consists of at least two empty pixels at the ends, with a line of solid pixels in the middle
3171 unsigned int y = n;
3172 unsigned int line_width = n;
3173 unsigned int pad_left = (r->Width - line_width) / 2;
3174 unsigned int pad_right = r->Width - (pad_left + line_width);
3175
3176 // Write each slice
3177 IM_ASSERT(pad_left + line_width + pad_right == r->Width && y < r->Height); // Make sure we're inside the texture bounds before we start writing pixels
3178 if (atlas->TexPixelsAlpha8 != NULL)
3179 {
3180 unsigned char* write_ptr = &atlas->TexPixelsAlpha8[r->X + ((r->Y + y) * atlas->TexWidth)];
3181 for (unsigned int i = 0; i < pad_left; i++)
3182 *(write_ptr + i) = 0x00;
3183
3184 for (unsigned int i = 0; i < line_width; i++)
3185 *(write_ptr + pad_left + i) = 0xFF;
3186
3187 for (unsigned int i = 0; i < pad_right; i++)
3188 *(write_ptr + pad_left + line_width + i) = 0x00;
3189 }
3190 else
3191 {
3192 unsigned int* write_ptr = &atlas->TexPixelsRGBA32[r->X + ((r->Y + y) * atlas->TexWidth)];
3193 for (unsigned int i = 0; i < pad_left; i++)
3194 *(write_ptr + i) = IM_COL32(255, 255, 255, 0);
3195
3196 for (unsigned int i = 0; i < line_width; i++)
3197 *(write_ptr + pad_left + i) = IM_COL32_WHITE;
3198
3199 for (unsigned int i = 0; i < pad_right; i++)
3200 *(write_ptr + pad_left + line_width + i) = IM_COL32(255, 255, 255, 0);
3201 }
3202
3203 // Calculate UVs for this line
3204 ImVec2 uv0 = ImVec2((float)(r->X + pad_left - 1), (float)(r->Y + y)) * atlas->TexUvScale;
3205 ImVec2 uv1 = ImVec2((float)(r->X + pad_left + line_width + 1), (float)(r->Y + y + 1)) * atlas->TexUvScale;
3206 float half_v = (uv0.y + uv1.y) * 0.5f; // Calculate a constant V in the middle of the row to avoid sampling artifacts
3207 atlas->TexUvLines[n] = ImVec4(uv0.x, half_v, uv1.x, half_v);
3208 }
3209}
3210
3211// Note: this is called / shared by both the stb_truetype and the FreeType builder
3212void ImFontAtlasBuildInit(ImFontAtlas* atlas)
3213{
3214 // Round font size
3215 // - We started rounding in 1.90 WIP (18991) as our layout system currently doesn't support non-rounded font size well yet.
3216 // - Note that using io.FontGlobalScale or SetWindowFontScale(), with are legacy-ish, partially supported features, can still lead to unrounded sizes.
3217 // - We may support it better later and remove this rounding.
3218 for (ImFontConfig& cfg : atlas->ConfigData)
3219 cfg.SizePixels = ImTrunc(cfg.SizePixels);
3220
3221 // Register texture region for mouse cursors or standard white pixels
3222 if (atlas->PackIdMouseCursors < 0)
3223 {
3224 if (!(atlas->Flags & ImFontAtlasFlags_NoMouseCursors))
3225 atlas->PackIdMouseCursors = atlas->AddCustomRectRegular(FONT_ATLAS_DEFAULT_TEX_DATA_W * 2 + 1, FONT_ATLAS_DEFAULT_TEX_DATA_H);
3226 else
3227 atlas->PackIdMouseCursors = atlas->AddCustomRectRegular(2, 2);
3228 }
3229
3230 // Register texture region for thick lines
3231 // The +2 here is to give space for the end caps, whilst height +1 is to accommodate the fact we have a zero-width row
3232 if (atlas->PackIdLines < 0)
3233 {
3234 if (!(atlas->Flags & ImFontAtlasFlags_NoBakedLines))
3235 atlas->PackIdLines = atlas->AddCustomRectRegular(IM_DRAWLIST_TEX_LINES_WIDTH_MAX + 2, IM_DRAWLIST_TEX_LINES_WIDTH_MAX + 1);
3236 }
3237}
3238
3239// This is called/shared by both the stb_truetype and the FreeType builder.
3240void ImFontAtlasBuildFinish(ImFontAtlas* atlas)
3241{
3242 // Render into our custom data blocks
3243 IM_ASSERT(atlas->TexPixelsAlpha8 != NULL || atlas->TexPixelsRGBA32 != NULL);
3244 ImFontAtlasBuildRenderDefaultTexData(atlas);
3245 ImFontAtlasBuildRenderLinesTexData(atlas);
3246
3247 // Register custom rectangle glyphs
3248 for (int i = 0; i < atlas->CustomRects.Size; i++)
3249 {
3250 const ImFontAtlasCustomRect* r = &atlas->CustomRects[i];
3251 if (r->Font == NULL || r->GlyphID == 0)
3252 continue;
3253
3254 // Will ignore ImFontConfig settings: GlyphMinAdvanceX, GlyphMinAdvanceY, GlyphExtraSpacing, PixelSnapH
3255 IM_ASSERT(r->Font->ContainerAtlas == atlas);
3256 ImVec2 uv0, uv1;
3257 atlas->CalcCustomRectUV(r, &uv0, &uv1);
3258 r->Font->AddGlyph(NULL, (ImWchar)r->GlyphID, r->GlyphOffset.x, r->GlyphOffset.y, r->GlyphOffset.x + r->Width, r->GlyphOffset.y + r->Height, uv0.x, uv0.y, uv1.x, uv1.y, r->GlyphAdvanceX);
3259 }
3260
3261 // Build all fonts lookup tables
3262 for (ImFont* font : atlas->Fonts)
3263 if (font->DirtyLookupTables)
3264 font->BuildLookupTable();
3265
3266 atlas->TexReady = true;
3267}
3268
3269// Retrieve list of range (2 int per range, values are inclusive)
3270const ImWchar* ImFontAtlas::GetGlyphRangesDefault()
3271{
3272 static const ImWchar ranges[] =
3273 {
3274 0x0020, 0x00FF, // Basic Latin + Latin Supplement
3275 0,
3276 };
3277 return &ranges[0];
3278}
3279
3280const ImWchar* ImFontAtlas::GetGlyphRangesGreek()
3281{
3282 static const ImWchar ranges[] =
3283 {
3284 0x0020, 0x00FF, // Basic Latin + Latin Supplement
3285 0x0370, 0x03FF, // Greek and Coptic
3286 0,
3287 };
3288 return &ranges[0];
3289}
3290
3291const ImWchar* ImFontAtlas::GetGlyphRangesKorean()
3292{
3293 static const ImWchar ranges[] =
3294 {
3295 0x0020, 0x00FF, // Basic Latin + Latin Supplement
3296 0x3131, 0x3163, // Korean alphabets
3297 0xAC00, 0xD7A3, // Korean characters
3298 0xFFFD, 0xFFFD, // Invalid
3299 0,
3300 };
3301 return &ranges[0];
3302}
3303
3304const ImWchar* ImFontAtlas::GetGlyphRangesChineseFull()
3305{
3306 static const ImWchar ranges[] =
3307 {
3308 0x0020, 0x00FF, // Basic Latin + Latin Supplement
3309 0x2000, 0x206F, // General Punctuation
3310 0x3000, 0x30FF, // CJK Symbols and Punctuations, Hiragana, Katakana
3311 0x31F0, 0x31FF, // Katakana Phonetic Extensions
3312 0xFF00, 0xFFEF, // Half-width characters
3313 0xFFFD, 0xFFFD, // Invalid
3314 0x4e00, 0x9FAF, // CJK Ideograms
3315 0,
3316 };
3317 return &ranges[0];
3318}
3319
3320static void UnpackAccumulativeOffsetsIntoRanges(int base_codepoint, const short* accumulative_offsets, int accumulative_offsets_count, ImWchar* out_ranges)
3321{
3322 for (int n = 0; n < accumulative_offsets_count; n++, out_ranges += 2)
3323 {
3324 out_ranges[0] = out_ranges[1] = (ImWchar)(base_codepoint + accumulative_offsets[n]);
3325 base_codepoint += accumulative_offsets[n];
3326 }
3327 out_ranges[0] = 0;
3328}
3329
3330//-------------------------------------------------------------------------
3331// [SECTION] ImFontAtlas glyph ranges helpers
3332//-------------------------------------------------------------------------
3333
3334const ImWchar* ImFontAtlas::GetGlyphRangesChineseSimplifiedCommon()
3335{
3336 // Store 2500 regularly used characters for Simplified Chinese.
3337 // Sourced from https://zh.wiktionary.org/wiki/%E9%99%84%E5%BD%95:%E7%8E%B0%E4%BB%A3%E6%B1%89%E8%AF%AD%E5%B8%B8%E7%94%A8%E5%AD%97%E8%A1%A8
3338 // This table covers 97.97% of all characters used during the month in July, 1987.
3339 // You can use ImFontGlyphRangesBuilder to create your own ranges derived from this, by merging existing ranges or adding new characters.
3340 // (Stored as accumulative offsets from the initial unicode codepoint 0x4E00. This encoding is designed to helps us compact the source code size.)
3341 static const short accumulative_offsets_from_0x4E00[] =
3342 {
3343 0,1,2,4,1,1,1,1,2,1,3,2,1,2,2,1,1,1,1,1,5,2,1,2,3,3,3,2,2,4,1,1,1,2,1,5,2,3,1,2,1,2,1,1,2,1,1,2,2,1,4,1,1,1,1,5,10,1,2,19,2,1,2,1,2,1,2,1,2,
3344 1,5,1,6,3,2,1,2,2,1,1,1,4,8,5,1,1,4,1,1,3,1,2,1,5,1,2,1,1,1,10,1,1,5,2,4,6,1,4,2,2,2,12,2,1,1,6,1,1,1,4,1,1,4,6,5,1,4,2,2,4,10,7,1,1,4,2,4,
3345 2,1,4,3,6,10,12,5,7,2,14,2,9,1,1,6,7,10,4,7,13,1,5,4,8,4,1,1,2,28,5,6,1,1,5,2,5,20,2,2,9,8,11,2,9,17,1,8,6,8,27,4,6,9,20,11,27,6,68,2,2,1,1,
3346 1,2,1,2,2,7,6,11,3,3,1,1,3,1,2,1,1,1,1,1,3,1,1,8,3,4,1,5,7,2,1,4,4,8,4,2,1,2,1,1,4,5,6,3,6,2,12,3,1,3,9,2,4,3,4,1,5,3,3,1,3,7,1,5,1,1,1,1,2,
3347 3,4,5,2,3,2,6,1,1,2,1,7,1,7,3,4,5,15,2,2,1,5,3,22,19,2,1,1,1,1,2,5,1,1,1,6,1,1,12,8,2,9,18,22,4,1,1,5,1,16,1,2,7,10,15,1,1,6,2,4,1,2,4,1,6,
3348 1,1,3,2,4,1,6,4,5,1,2,1,1,2,1,10,3,1,3,2,1,9,3,2,5,7,2,19,4,3,6,1,1,1,1,1,4,3,2,1,1,1,2,5,3,1,1,1,2,2,1,1,2,1,1,2,1,3,1,1,1,3,7,1,4,1,1,2,1,
3349 1,2,1,2,4,4,3,8,1,1,1,2,1,3,5,1,3,1,3,4,6,2,2,14,4,6,6,11,9,1,15,3,1,28,5,2,5,5,3,1,3,4,5,4,6,14,3,2,3,5,21,2,7,20,10,1,2,19,2,4,28,28,2,3,
3350 2,1,14,4,1,26,28,42,12,40,3,52,79,5,14,17,3,2,2,11,3,4,6,3,1,8,2,23,4,5,8,10,4,2,7,3,5,1,1,6,3,1,2,2,2,5,28,1,1,7,7,20,5,3,29,3,17,26,1,8,4,
3351 27,3,6,11,23,5,3,4,6,13,24,16,6,5,10,25,35,7,3,2,3,3,14,3,6,2,6,1,4,2,3,8,2,1,1,3,3,3,4,1,1,13,2,2,4,5,2,1,14,14,1,2,2,1,4,5,2,3,1,14,3,12,
3352 3,17,2,16,5,1,2,1,8,9,3,19,4,2,2,4,17,25,21,20,28,75,1,10,29,103,4,1,2,1,1,4,2,4,1,2,3,24,2,2,2,1,1,2,1,3,8,1,1,1,2,1,1,3,1,1,1,6,1,5,3,1,1,
3353 1,3,4,1,1,5,2,1,5,6,13,9,16,1,1,1,1,3,2,3,2,4,5,2,5,2,2,3,7,13,7,2,2,1,1,1,1,2,3,3,2,1,6,4,9,2,1,14,2,14,2,1,18,3,4,14,4,11,41,15,23,15,23,
3354 176,1,3,4,1,1,1,1,5,3,1,2,3,7,3,1,1,2,1,2,4,4,6,2,4,1,9,7,1,10,5,8,16,29,1,1,2,2,3,1,3,5,2,4,5,4,1,1,2,2,3,3,7,1,6,10,1,17,1,44,4,6,2,1,1,6,
3355 5,4,2,10,1,6,9,2,8,1,24,1,2,13,7,8,8,2,1,4,1,3,1,3,3,5,2,5,10,9,4,9,12,2,1,6,1,10,1,1,7,7,4,10,8,3,1,13,4,3,1,6,1,3,5,2,1,2,17,16,5,2,16,6,
3356 1,4,2,1,3,3,6,8,5,11,11,1,3,3,2,4,6,10,9,5,7,4,7,4,7,1,1,4,2,1,3,6,8,7,1,6,11,5,5,3,24,9,4,2,7,13,5,1,8,82,16,61,1,1,1,4,2,2,16,10,3,8,1,1,
3357 6,4,2,1,3,1,1,1,4,3,8,4,2,2,1,1,1,1,1,6,3,5,1,1,4,6,9,2,1,1,1,2,1,7,2,1,6,1,5,4,4,3,1,8,1,3,3,1,3,2,2,2,2,3,1,6,1,2,1,2,1,3,7,1,8,2,1,2,1,5,
3358 2,5,3,5,10,1,2,1,1,3,2,5,11,3,9,3,5,1,1,5,9,1,2,1,5,7,9,9,8,1,3,3,3,6,8,2,3,2,1,1,32,6,1,2,15,9,3,7,13,1,3,10,13,2,14,1,13,10,2,1,3,10,4,15,
3359 2,15,15,10,1,3,9,6,9,32,25,26,47,7,3,2,3,1,6,3,4,3,2,8,5,4,1,9,4,2,2,19,10,6,2,3,8,1,2,2,4,2,1,9,4,4,4,6,4,8,9,2,3,1,1,1,1,3,5,5,1,3,8,4,6,
3360 2,1,4,12,1,5,3,7,13,2,5,8,1,6,1,2,5,14,6,1,5,2,4,8,15,5,1,23,6,62,2,10,1,1,8,1,2,2,10,4,2,2,9,2,1,1,3,2,3,1,5,3,3,2,1,3,8,1,1,1,11,3,1,1,4,
3361 3,7,1,14,1,2,3,12,5,2,5,1,6,7,5,7,14,11,1,3,1,8,9,12,2,1,11,8,4,4,2,6,10,9,13,1,1,3,1,5,1,3,2,4,4,1,18,2,3,14,11,4,29,4,2,7,1,3,13,9,2,2,5,
3362 3,5,20,7,16,8,5,72,34,6,4,22,12,12,28,45,36,9,7,39,9,191,1,1,1,4,11,8,4,9,2,3,22,1,1,1,1,4,17,1,7,7,1,11,31,10,2,4,8,2,3,2,1,4,2,16,4,32,2,
3363 3,19,13,4,9,1,5,2,14,8,1,1,3,6,19,6,5,1,16,6,2,10,8,5,1,2,3,1,5,5,1,11,6,6,1,3,3,2,6,3,8,1,1,4,10,7,5,7,7,5,8,9,2,1,3,4,1,1,3,1,3,3,2,6,16,
3364 1,4,6,3,1,10,6,1,3,15,2,9,2,10,25,13,9,16,6,2,2,10,11,4,3,9,1,2,6,6,5,4,30,40,1,10,7,12,14,33,6,3,6,7,3,1,3,1,11,14,4,9,5,12,11,49,18,51,31,
3365 140,31,2,2,1,5,1,8,1,10,1,4,4,3,24,1,10,1,3,6,6,16,3,4,5,2,1,4,2,57,10,6,22,2,22,3,7,22,6,10,11,36,18,16,33,36,2,5,5,1,1,1,4,10,1,4,13,2,7,
3366 5,2,9,3,4,1,7,43,3,7,3,9,14,7,9,1,11,1,1,3,7,4,18,13,1,14,1,3,6,10,73,2,2,30,6,1,11,18,19,13,22,3,46,42,37,89,7,3,16,34,2,2,3,9,1,7,1,1,1,2,
3367 2,4,10,7,3,10,3,9,5,28,9,2,6,13,7,3,1,3,10,2,7,2,11,3,6,21,54,85,2,1,4,2,2,1,39,3,21,2,2,5,1,1,1,4,1,1,3,4,15,1,3,2,4,4,2,3,8,2,20,1,8,7,13,
3368 4,1,26,6,2,9,34,4,21,52,10,4,4,1,5,12,2,11,1,7,2,30,12,44,2,30,1,1,3,6,16,9,17,39,82,2,2,24,7,1,7,3,16,9,14,44,2,1,2,1,2,3,5,2,4,1,6,7,5,3,
3369 2,6,1,11,5,11,2,1,18,19,8,1,3,24,29,2,1,3,5,2,2,1,13,6,5,1,46,11,3,5,1,1,5,8,2,10,6,12,6,3,7,11,2,4,16,13,2,5,1,1,2,2,5,2,28,5,2,23,10,8,4,
3370 4,22,39,95,38,8,14,9,5,1,13,5,4,3,13,12,11,1,9,1,27,37,2,5,4,4,63,211,95,2,2,2,1,3,5,2,1,1,2,2,1,1,1,3,2,4,1,2,1,1,5,2,2,1,1,2,3,1,3,1,1,1,
3371 3,1,4,2,1,3,6,1,1,3,7,15,5,3,2,5,3,9,11,4,2,22,1,6,3,8,7,1,4,28,4,16,3,3,25,4,4,27,27,1,4,1,2,2,7,1,3,5,2,28,8,2,14,1,8,6,16,25,3,3,3,14,3,
3372 3,1,1,2,1,4,6,3,8,4,1,1,1,2,3,6,10,6,2,3,18,3,2,5,5,4,3,1,5,2,5,4,23,7,6,12,6,4,17,11,9,5,1,1,10,5,12,1,1,11,26,33,7,3,6,1,17,7,1,5,12,1,11,
3373 2,4,1,8,14,17,23,1,2,1,7,8,16,11,9,6,5,2,6,4,16,2,8,14,1,11,8,9,1,1,1,9,25,4,11,19,7,2,15,2,12,8,52,7,5,19,2,16,4,36,8,1,16,8,24,26,4,6,2,9,
3374 5,4,36,3,28,12,25,15,37,27,17,12,59,38,5,32,127,1,2,9,17,14,4,1,2,1,1,8,11,50,4,14,2,19,16,4,17,5,4,5,26,12,45,2,23,45,104,30,12,8,3,10,2,2,
3375 3,3,1,4,20,7,2,9,6,15,2,20,1,3,16,4,11,15,6,134,2,5,59,1,2,2,2,1,9,17,3,26,137,10,211,59,1,2,4,1,4,1,1,1,2,6,2,3,1,1,2,3,2,3,1,3,4,4,2,3,3,
3376 1,4,3,1,7,2,2,3,1,2,1,3,3,3,2,2,3,2,1,3,14,6,1,3,2,9,6,15,27,9,34,145,1,1,2,1,1,1,1,2,1,1,1,1,2,2,2,3,1,2,1,1,1,2,3,5,8,3,5,2,4,1,3,2,2,2,12,
3377 4,1,1,1,10,4,5,1,20,4,16,1,15,9,5,12,2,9,2,5,4,2,26,19,7,1,26,4,30,12,15,42,1,6,8,172,1,1,4,2,1,1,11,2,2,4,2,1,2,1,10,8,1,2,1,4,5,1,2,5,1,8,
3378 4,1,3,4,2,1,6,2,1,3,4,1,2,1,1,1,1,12,5,7,2,4,3,1,1,1,3,3,6,1,2,2,3,3,3,2,1,2,12,14,11,6,6,4,12,2,8,1,7,10,1,35,7,4,13,15,4,3,23,21,28,52,5,
3379 26,5,6,1,7,10,2,7,53,3,2,1,1,1,2,163,532,1,10,11,1,3,3,4,8,2,8,6,2,2,23,22,4,2,2,4,2,1,3,1,3,3,5,9,8,2,1,2,8,1,10,2,12,21,20,15,105,2,3,1,1,
3380 3,2,3,1,1,2,5,1,4,15,11,19,1,1,1,1,5,4,5,1,1,2,5,3,5,12,1,2,5,1,11,1,1,15,9,1,4,5,3,26,8,2,1,3,1,1,15,19,2,12,1,2,5,2,7,2,19,2,20,6,26,7,5,
3381 2,2,7,34,21,13,70,2,128,1,1,2,1,1,2,1,1,3,2,2,2,15,1,4,1,3,4,42,10,6,1,49,85,8,1,2,1,1,4,4,2,3,6,1,5,7,4,3,211,4,1,2,1,2,5,1,2,4,2,2,6,5,6,
3382 10,3,4,48,100,6,2,16,296,5,27,387,2,2,3,7,16,8,5,38,15,39,21,9,10,3,7,59,13,27,21,47,5,21,6
3383 };
3384 static ImWchar base_ranges[] = // not zero-terminated
3385 {
3386 0x0020, 0x00FF, // Basic Latin + Latin Supplement
3387 0x2000, 0x206F, // General Punctuation
3388 0x3000, 0x30FF, // CJK Symbols and Punctuations, Hiragana, Katakana
3389 0x31F0, 0x31FF, // Katakana Phonetic Extensions
3390 0xFF00, 0xFFEF, // Half-width characters
3391 0xFFFD, 0xFFFD // Invalid
3392 };
3393 static ImWchar full_ranges[IM_ARRAYSIZE(base_ranges) + IM_ARRAYSIZE(accumulative_offsets_from_0x4E00) * 2 + 1] = { 0 };
3394 if (!full_ranges[0])
3395 {
3396 memcpy(full_ranges, base_ranges, sizeof(base_ranges));
3397 UnpackAccumulativeOffsetsIntoRanges(0x4E00, accumulative_offsets_from_0x4E00, IM_ARRAYSIZE(accumulative_offsets_from_0x4E00), full_ranges + IM_ARRAYSIZE(base_ranges));
3398 }
3399 return &full_ranges[0];
3400}
3401
3402const ImWchar* ImFontAtlas::GetGlyphRangesJapanese()
3403{
3404 // 2999 ideograms code points for Japanese
3405 // - 2136 Joyo (meaning "for regular use" or "for common use") Kanji code points
3406 // - 863 Jinmeiyo (meaning "for personal name") Kanji code points
3407 // - Sourced from official information provided by the government agencies of Japan:
3408 // - List of Joyo Kanji by the Agency for Cultural Affairs
3409 // - https://www.bunka.go.jp/kokugo_nihongo/sisaku/joho/joho/kijun/naikaku/kanji/
3410 // - List of Jinmeiyo Kanji by the Ministry of Justice
3411 // - http://www.moj.go.jp/MINJI/minji86.html
3412 // - Available under the terms of the Creative Commons Attribution 4.0 International (CC BY 4.0).
3413 // - https://creativecommons.org/licenses/by/4.0/legalcode
3414 // - You can generate this code by the script at:
3415 // - https://github.com/vaiorabbit/everyday_use_kanji
3416 // - References:
3417 // - List of Joyo Kanji
3418 // - (Wikipedia) https://en.wikipedia.org/wiki/List_of_j%C5%8Dy%C5%8D_kanji
3419 // - List of Jinmeiyo Kanji
3420 // - (Wikipedia) https://en.wikipedia.org/wiki/Jinmeiy%C5%8D_kanji
3421 // - Missing 1 Joyo Kanji: U+20B9F (Kun'yomi: Shikaru, On'yomi: Shitsu,shichi), see https://github.com/ocornut/imgui/pull/3627 for details.
3422 // You can use ImFontGlyphRangesBuilder to create your own ranges derived from this, by merging existing ranges or adding new characters.
3423 // (Stored as accumulative offsets from the initial unicode codepoint 0x4E00. This encoding is designed to helps us compact the source code size.)
3424 static const short accumulative_offsets_from_0x4E00[] =
3425 {
3426 0,1,2,4,1,1,1,1,2,1,3,3,2,2,1,5,3,5,7,5,6,1,2,1,7,2,6,3,1,8,1,1,4,1,1,18,2,11,2,6,2,1,2,1,5,1,2,1,3,1,2,1,2,3,3,1,1,2,3,1,1,1,12,7,9,1,4,5,1,
3427 1,2,1,10,1,1,9,2,2,4,5,6,9,3,1,1,1,1,9,3,18,5,2,2,2,2,1,6,3,7,1,1,1,1,2,2,4,2,1,23,2,10,4,3,5,2,4,10,2,4,13,1,6,1,9,3,1,1,6,6,7,6,3,1,2,11,3,
3428 2,2,3,2,15,2,2,5,4,3,6,4,1,2,5,2,12,16,6,13,9,13,2,1,1,7,16,4,7,1,19,1,5,1,2,2,7,7,8,2,6,5,4,9,18,7,4,5,9,13,11,8,15,2,1,1,1,2,1,2,2,1,2,2,8,
3429 2,9,3,3,1,1,4,4,1,1,1,4,9,1,4,3,5,5,2,7,5,3,4,8,2,1,13,2,3,3,1,14,1,1,4,5,1,3,6,1,5,2,1,1,3,3,3,3,1,1,2,7,6,6,7,1,4,7,6,1,1,1,1,1,12,3,3,9,5,
3430 2,6,1,5,6,1,2,3,18,2,4,14,4,1,3,6,1,1,6,3,5,5,3,2,2,2,2,12,3,1,4,2,3,2,3,11,1,7,4,1,2,1,3,17,1,9,1,24,1,1,4,2,2,4,1,2,7,1,1,1,3,1,2,2,4,15,1,
3431 1,2,1,1,2,1,5,2,5,20,2,5,9,1,10,8,7,6,1,1,1,1,1,1,6,2,1,2,8,1,1,1,1,5,1,1,3,1,1,1,1,3,1,1,12,4,1,3,1,1,1,1,1,10,3,1,7,5,13,1,2,3,4,6,1,1,30,
3432 2,9,9,1,15,38,11,3,1,8,24,7,1,9,8,10,2,1,9,31,2,13,6,2,9,4,49,5,2,15,2,1,10,2,1,1,1,2,2,6,15,30,35,3,14,18,8,1,16,10,28,12,19,45,38,1,3,2,3,
3433 13,2,1,7,3,6,5,3,4,3,1,5,7,8,1,5,3,18,5,3,6,1,21,4,24,9,24,40,3,14,3,21,3,2,1,2,4,2,3,1,15,15,6,5,1,1,3,1,5,6,1,9,7,3,3,2,1,4,3,8,21,5,16,4,
3434 5,2,10,11,11,3,6,3,2,9,3,6,13,1,2,1,1,1,1,11,12,6,6,1,4,2,6,5,2,1,1,3,3,6,13,3,1,1,5,1,2,3,3,14,2,1,2,2,2,5,1,9,5,1,1,6,12,3,12,3,4,13,2,14,
3435 2,8,1,17,5,1,16,4,2,2,21,8,9,6,23,20,12,25,19,9,38,8,3,21,40,25,33,13,4,3,1,4,1,2,4,1,2,5,26,2,1,1,2,1,3,6,2,1,1,1,1,1,1,2,3,1,1,1,9,2,3,1,1,
3436 1,3,6,3,2,1,1,6,6,1,8,2,2,2,1,4,1,2,3,2,7,3,2,4,1,2,1,2,2,1,1,1,1,1,3,1,2,5,4,10,9,4,9,1,1,1,1,1,1,5,3,2,1,6,4,9,6,1,10,2,31,17,8,3,7,5,40,1,
3437 7,7,1,6,5,2,10,7,8,4,15,39,25,6,28,47,18,10,7,1,3,1,1,2,1,1,1,3,3,3,1,1,1,3,4,2,1,4,1,3,6,10,7,8,6,2,2,1,3,3,2,5,8,7,9,12,2,15,1,1,4,1,2,1,1,
3438 1,3,2,1,3,3,5,6,2,3,2,10,1,4,2,8,1,1,1,11,6,1,21,4,16,3,1,3,1,4,2,3,6,5,1,3,1,1,3,3,4,6,1,1,10,4,2,7,10,4,7,4,2,9,4,3,1,1,1,4,1,8,3,4,1,3,1,
3439 6,1,4,2,1,4,7,2,1,8,1,4,5,1,1,2,2,4,6,2,7,1,10,1,1,3,4,11,10,8,21,4,6,1,3,5,2,1,2,28,5,5,2,3,13,1,2,3,1,4,2,1,5,20,3,8,11,1,3,3,3,1,8,10,9,2,
3440 10,9,2,3,1,1,2,4,1,8,3,6,1,7,8,6,11,1,4,29,8,4,3,1,2,7,13,1,4,1,6,2,6,12,12,2,20,3,2,3,6,4,8,9,2,7,34,5,1,18,6,1,1,4,4,5,7,9,1,2,2,4,3,4,1,7,
3441 2,2,2,6,2,3,25,5,3,6,1,4,6,7,4,2,1,4,2,13,6,4,4,3,1,5,3,4,4,3,2,1,1,4,1,2,1,1,3,1,11,1,6,3,1,7,3,6,2,8,8,6,9,3,4,11,3,2,10,12,2,5,11,1,6,4,5,
3442 3,1,8,5,4,6,6,3,5,1,1,3,2,1,2,2,6,17,12,1,10,1,6,12,1,6,6,19,9,6,16,1,13,4,4,15,7,17,6,11,9,15,12,6,7,2,1,2,2,15,9,3,21,4,6,49,18,7,3,2,3,1,
3443 6,8,2,2,6,2,9,1,3,6,4,4,1,2,16,2,5,2,1,6,2,3,5,3,1,2,5,1,2,1,9,3,1,8,6,4,8,11,3,1,1,1,1,3,1,13,8,4,1,3,2,2,1,4,1,11,1,5,2,1,5,2,5,8,6,1,1,7,
3444 4,3,8,3,2,7,2,1,5,1,5,2,4,7,6,2,8,5,1,11,4,5,3,6,18,1,2,13,3,3,1,21,1,1,4,1,4,1,1,1,8,1,2,2,7,1,2,4,2,2,9,2,1,1,1,4,3,6,3,12,5,1,1,1,5,6,3,2,
3445 4,8,2,2,4,2,7,1,8,9,5,2,3,2,1,3,2,13,7,14,6,5,1,1,2,1,4,2,23,2,1,1,6,3,1,4,1,15,3,1,7,3,9,14,1,3,1,4,1,1,5,8,1,3,8,3,8,15,11,4,14,4,4,2,5,5,
3446 1,7,1,6,14,7,7,8,5,15,4,8,6,5,6,2,1,13,1,20,15,11,9,2,5,6,2,11,2,6,2,5,1,5,8,4,13,19,25,4,1,1,11,1,34,2,5,9,14,6,2,2,6,1,1,14,1,3,14,13,1,6,
3447 12,21,14,14,6,32,17,8,32,9,28,1,2,4,11,8,3,1,14,2,5,15,1,1,1,1,3,6,4,1,3,4,11,3,1,1,11,30,1,5,1,4,1,5,8,1,1,3,2,4,3,17,35,2,6,12,17,3,1,6,2,
3448 1,1,12,2,7,3,3,2,1,16,2,8,3,6,5,4,7,3,3,8,1,9,8,5,1,2,1,3,2,8,1,2,9,12,1,1,2,3,8,3,24,12,4,3,7,5,8,3,3,3,3,3,3,1,23,10,3,1,2,2,6,3,1,16,1,16,
3449 22,3,10,4,11,6,9,7,7,3,6,2,2,2,4,10,2,1,1,2,8,7,1,6,4,1,3,3,3,5,10,12,12,2,3,12,8,15,1,1,16,6,6,1,5,9,11,4,11,4,2,6,12,1,17,5,13,1,4,9,5,1,11,
3450 2,1,8,1,5,7,28,8,3,5,10,2,17,3,38,22,1,2,18,12,10,4,38,18,1,4,44,19,4,1,8,4,1,12,1,4,31,12,1,14,7,75,7,5,10,6,6,13,3,2,11,11,3,2,5,28,15,6,18,
3451 18,5,6,4,3,16,1,7,18,7,36,3,5,3,1,7,1,9,1,10,7,2,4,2,6,2,9,7,4,3,32,12,3,7,10,2,23,16,3,1,12,3,31,4,11,1,3,8,9,5,1,30,15,6,12,3,2,2,11,19,9,
3452 14,2,6,2,3,19,13,17,5,3,3,25,3,14,1,1,1,36,1,3,2,19,3,13,36,9,13,31,6,4,16,34,2,5,4,2,3,3,5,1,1,1,4,3,1,17,3,2,3,5,3,1,3,2,3,5,6,3,12,11,1,3,
3453 1,2,26,7,12,7,2,14,3,3,7,7,11,25,25,28,16,4,36,1,2,1,6,2,1,9,3,27,17,4,3,4,13,4,1,3,2,2,1,10,4,2,4,6,3,8,2,1,18,1,1,24,2,2,4,33,2,3,63,7,1,6,
3454 40,7,3,4,4,2,4,15,18,1,16,1,1,11,2,41,14,1,3,18,13,3,2,4,16,2,17,7,15,24,7,18,13,44,2,2,3,6,1,1,7,5,1,7,1,4,3,3,5,10,8,2,3,1,8,1,1,27,4,2,1,
3455 12,1,2,1,10,6,1,6,7,5,2,3,7,11,5,11,3,6,6,2,3,15,4,9,1,1,2,1,2,11,2,8,12,8,5,4,2,3,1,5,2,2,1,14,1,12,11,4,1,11,17,17,4,3,2,5,5,7,3,1,5,9,9,8,
3456 2,5,6,6,13,13,2,1,2,6,1,2,2,49,4,9,1,2,10,16,7,8,4,3,2,23,4,58,3,29,1,14,19,19,11,11,2,7,5,1,3,4,6,2,18,5,12,12,17,17,3,3,2,4,1,6,2,3,4,3,1,
3457 1,1,1,5,1,1,9,1,3,1,3,6,1,8,1,1,2,6,4,14,3,1,4,11,4,1,3,32,1,2,4,13,4,1,2,4,2,1,3,1,11,1,4,2,1,4,4,6,3,5,1,6,5,7,6,3,23,3,5,3,5,3,3,13,3,9,10,
3458 1,12,10,2,3,18,13,7,160,52,4,2,2,3,2,14,5,4,12,4,6,4,1,20,4,11,6,2,12,27,1,4,1,2,2,7,4,5,2,28,3,7,25,8,3,19,3,6,10,2,2,1,10,2,5,4,1,3,4,1,5,
3459 3,2,6,9,3,6,2,16,3,3,16,4,5,5,3,2,1,2,16,15,8,2,6,21,2,4,1,22,5,8,1,1,21,11,2,1,11,11,19,13,12,4,2,3,2,3,6,1,8,11,1,4,2,9,5,2,1,11,2,9,1,1,2,
3460 14,31,9,3,4,21,14,4,8,1,7,2,2,2,5,1,4,20,3,3,4,10,1,11,9,8,2,1,4,5,14,12,14,2,17,9,6,31,4,14,1,20,13,26,5,2,7,3,6,13,2,4,2,19,6,2,2,18,9,3,5,
3461 12,12,14,4,6,2,3,6,9,5,22,4,5,25,6,4,8,5,2,6,27,2,35,2,16,3,7,8,8,6,6,5,9,17,2,20,6,19,2,13,3,1,1,1,4,17,12,2,14,7,1,4,18,12,38,33,2,10,1,1,
3462 2,13,14,17,11,50,6,33,20,26,74,16,23,45,50,13,38,33,6,6,7,4,4,2,1,3,2,5,8,7,8,9,3,11,21,9,13,1,3,10,6,7,1,2,2,18,5,5,1,9,9,2,68,9,19,13,2,5,
3463 1,4,4,7,4,13,3,9,10,21,17,3,26,2,1,5,2,4,5,4,1,7,4,7,3,4,2,1,6,1,1,20,4,1,9,2,2,1,3,3,2,3,2,1,1,1,20,2,3,1,6,2,3,6,2,4,8,1,3,2,10,3,5,3,4,4,
3464 3,4,16,1,6,1,10,2,4,2,1,1,2,10,11,2,2,3,1,24,31,4,10,10,2,5,12,16,164,15,4,16,7,9,15,19,17,1,2,1,1,5,1,1,1,1,1,3,1,4,3,1,3,1,3,1,2,1,1,3,3,7,
3465 2,8,1,2,2,2,1,3,4,3,7,8,12,92,2,10,3,1,3,14,5,25,16,42,4,7,7,4,2,21,5,27,26,27,21,25,30,31,2,1,5,13,3,22,5,6,6,11,9,12,1,5,9,7,5,5,22,60,3,5,
3466 13,1,1,8,1,1,3,3,2,1,9,3,3,18,4,1,2,3,7,6,3,1,2,3,9,1,3,1,3,2,1,3,1,1,1,2,1,11,3,1,6,9,1,3,2,3,1,2,1,5,1,1,4,3,4,1,2,2,4,4,1,7,2,1,2,2,3,5,13,
3467 18,3,4,14,9,9,4,16,3,7,5,8,2,6,48,28,3,1,1,4,2,14,8,2,9,2,1,15,2,4,3,2,10,16,12,8,7,1,1,3,1,1,1,2,7,4,1,6,4,38,39,16,23,7,15,15,3,2,12,7,21,
3468 37,27,6,5,4,8,2,10,8,8,6,5,1,2,1,3,24,1,16,17,9,23,10,17,6,1,51,55,44,13,294,9,3,6,2,4,2,2,15,1,1,1,13,21,17,68,14,8,9,4,1,4,9,3,11,7,1,1,1,
3469 5,6,3,2,1,1,1,2,3,8,1,2,2,4,1,5,5,2,1,4,3,7,13,4,1,4,1,3,1,1,1,5,5,10,1,6,1,5,2,1,5,2,4,1,4,5,7,3,18,2,9,11,32,4,3,3,2,4,7,11,16,9,11,8,13,38,
3470 32,8,4,2,1,1,2,1,2,4,4,1,1,1,4,1,21,3,11,1,16,1,1,6,1,3,2,4,9,8,57,7,44,1,3,3,13,3,10,1,1,7,5,2,7,21,47,63,3,15,4,7,1,16,1,1,2,8,2,3,42,15,4,
3471 1,29,7,22,10,3,78,16,12,20,18,4,67,11,5,1,3,15,6,21,31,32,27,18,13,71,35,5,142,4,10,1,2,50,19,33,16,35,37,16,19,27,7,1,133,19,1,4,8,7,20,1,4,
3472 4,1,10,3,1,6,1,2,51,5,40,15,24,43,22928,11,1,13,154,70,3,1,1,7,4,10,1,2,1,1,2,1,2,1,2,2,1,1,2,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,
3473 3,2,1,1,1,1,2,1,1,
3474 };
3475 static ImWchar base_ranges[] = // not zero-terminated
3476 {
3477 0x0020, 0x00FF, // Basic Latin + Latin Supplement
3478 0x3000, 0x30FF, // CJK Symbols and Punctuations, Hiragana, Katakana
3479 0x31F0, 0x31FF, // Katakana Phonetic Extensions
3480 0xFF00, 0xFFEF, // Half-width characters
3481 0xFFFD, 0xFFFD // Invalid
3482 };
3483 static ImWchar full_ranges[IM_ARRAYSIZE(base_ranges) + IM_ARRAYSIZE(accumulative_offsets_from_0x4E00)*2 + 1] = { 0 };
3484 if (!full_ranges[0])
3485 {
3486 memcpy(full_ranges, base_ranges, sizeof(base_ranges));
3487 UnpackAccumulativeOffsetsIntoRanges(0x4E00, accumulative_offsets_from_0x4E00, IM_ARRAYSIZE(accumulative_offsets_from_0x4E00), full_ranges + IM_ARRAYSIZE(base_ranges));
3488 }
3489 return &full_ranges[0];
3490}
3491
3492const ImWchar* ImFontAtlas::GetGlyphRangesCyrillic()
3493{
3494 static const ImWchar ranges[] =
3495 {
3496 0x0020, 0x00FF, // Basic Latin + Latin Supplement
3497 0x0400, 0x052F, // Cyrillic + Cyrillic Supplement
3498 0x2DE0, 0x2DFF, // Cyrillic Extended-A
3499 0xA640, 0xA69F, // Cyrillic Extended-B
3500 0,
3501 };
3502 return &ranges[0];
3503}
3504
3505const ImWchar* ImFontAtlas::GetGlyphRangesThai()
3506{
3507 static const ImWchar ranges[] =
3508 {
3509 0x0020, 0x00FF, // Basic Latin
3510 0x2010, 0x205E, // Punctuations
3511 0x0E00, 0x0E7F, // Thai
3512 0,
3513 };
3514 return &ranges[0];
3515}
3516
3517const ImWchar* ImFontAtlas::GetGlyphRangesVietnamese()
3518{
3519 static const ImWchar ranges[] =
3520 {
3521 0x0020, 0x00FF, // Basic Latin
3522 0x0102, 0x0103,
3523 0x0110, 0x0111,
3524 0x0128, 0x0129,
3525 0x0168, 0x0169,
3526 0x01A0, 0x01A1,
3527 0x01AF, 0x01B0,
3528 0x1EA0, 0x1EF9,
3529 0,
3530 };
3531 return &ranges[0];
3532}
3533
3534//-----------------------------------------------------------------------------
3535// [SECTION] ImFontGlyphRangesBuilder
3536//-----------------------------------------------------------------------------
3537
3538void ImFontGlyphRangesBuilder::AddText(const char* text, const char* text_end)
3539{
3540 while (text_end ? (text < text_end) : *text)
3541 {
3542 unsigned int c = 0;
3543 int c_len = ImTextCharFromUtf8(&c, text, text_end);
3544 text += c_len;
3545 if (c_len == 0)
3546 break;
3547 AddChar((ImWchar)c);
3548 }
3549}
3550
3551void ImFontGlyphRangesBuilder::AddRanges(const ImWchar* ranges)
3552{
3553 for (; ranges[0]; ranges += 2)
3554 for (unsigned int c = ranges[0]; c <= ranges[1] && c <= IM_UNICODE_CODEPOINT_MAX; c++) //-V560
3555 AddChar((ImWchar)c);
3556}
3557
3558void ImFontGlyphRangesBuilder::BuildRanges(ImVector<ImWchar>* out_ranges)
3559{
3560 const int max_codepoint = IM_UNICODE_CODEPOINT_MAX;
3561 for (int n = 0; n <= max_codepoint; n++)
3562 if (GetBit(n))
3563 {
3564 out_ranges->push_back((ImWchar)n);
3565 while (n < max_codepoint && GetBit(n + 1))
3566 n++;
3567 out_ranges->push_back((ImWchar)n);
3568 }
3569 out_ranges->push_back(0);
3570}
3571
3572//-----------------------------------------------------------------------------
3573// [SECTION] ImFont
3574//-----------------------------------------------------------------------------
3575
3576ImFont::ImFont()
3577{
3578 FontSize = 0.0f;
3579 FallbackAdvanceX = 0.0f;
3580 FallbackChar = (ImWchar)-1;
3581 EllipsisChar = (ImWchar)-1;
3582 EllipsisWidth = EllipsisCharStep = 0.0f;
3583 EllipsisCharCount = 0;
3584 FallbackGlyph = NULL;
3585 ContainerAtlas = NULL;
3586 ConfigData = NULL;
3587 ConfigDataCount = 0;
3588 DirtyLookupTables = false;
3589 Scale = 1.0f;
3590 Ascent = Descent = 0.0f;
3591 MetricsTotalSurface = 0;
3592 memset(Used4kPagesMap, 0, sizeof(Used4kPagesMap));
3593}
3594
3595ImFont::~ImFont()
3596{
3597 ClearOutputData();
3598}
3599
3600void ImFont::ClearOutputData()
3601{
3602 FontSize = 0.0f;
3603 FallbackAdvanceX = 0.0f;
3604 Glyphs.clear();
3605 IndexAdvanceX.clear();
3606 IndexLookup.clear();
3607 FallbackGlyph = NULL;
3608 ContainerAtlas = NULL;
3609 DirtyLookupTables = true;
3610 Ascent = Descent = 0.0f;
3611 MetricsTotalSurface = 0;
3612}
3613
3614static ImWchar FindFirstExistingGlyph(ImFont* font, const ImWchar* candidate_chars, int candidate_chars_count)
3615{
3616 for (int n = 0; n < candidate_chars_count; n++)
3617 if (font->FindGlyphNoFallback(candidate_chars[n]) != NULL)
3618 return candidate_chars[n];
3619 return (ImWchar)-1;
3620}
3621
3622void ImFont::BuildLookupTable()
3623{
3624 int max_codepoint = 0;
3625 for (int i = 0; i != Glyphs.Size; i++)
3626 max_codepoint = ImMax(max_codepoint, (int)Glyphs[i].Codepoint);
3627
3628 // Build lookup table
3629 IM_ASSERT(Glyphs.Size > 0 && "Font has not loaded glyph!");
3630 IM_ASSERT(Glyphs.Size < 0xFFFF); // -1 is reserved
3631 IndexAdvanceX.clear();
3632 IndexLookup.clear();
3633 DirtyLookupTables = false;
3634 memset(Used4kPagesMap, 0, sizeof(Used4kPagesMap));
3635 GrowIndex(max_codepoint + 1);
3636 for (int i = 0; i < Glyphs.Size; i++)
3637 {
3638 int codepoint = (int)Glyphs[i].Codepoint;
3639 IndexAdvanceX[codepoint] = Glyphs[i].AdvanceX;
3640 IndexLookup[codepoint] = (ImWchar)i;
3641
3642 // Mark 4K page as used
3643 const int page_n = codepoint / 4096;
3644 Used4kPagesMap[page_n >> 3] |= 1 << (page_n & 7);
3645 }
3646
3647 // Create a glyph to handle TAB
3648 // FIXME: Needs proper TAB handling but it needs to be contextualized (or we could arbitrary say that each string starts at "column 0" ?)
3649 if (FindGlyph((ImWchar)' '))
3650 {
3651 if (Glyphs.back().Codepoint != '\t') // So we can call this function multiple times (FIXME: Flaky)
3652 Glyphs.resize(Glyphs.Size + 1);
3653 ImFontGlyph& tab_glyph = Glyphs.back();
3654 tab_glyph = *FindGlyph((ImWchar)' ');
3655 tab_glyph.Codepoint = '\t';
3656 tab_glyph.AdvanceX *= IM_TABSIZE;
3657 IndexAdvanceX[(int)tab_glyph.Codepoint] = (float)tab_glyph.AdvanceX;
3658 IndexLookup[(int)tab_glyph.Codepoint] = (ImWchar)(Glyphs.Size - 1);
3659 }
3660
3661 // Mark special glyphs as not visible (note that AddGlyph already mark as non-visible glyphs with zero-size polygons)
3662 SetGlyphVisible((ImWchar)' ', false);
3663 SetGlyphVisible((ImWchar)'\t', false);
3664
3665 // Setup Fallback character
3666 const ImWchar fallback_chars[] = { (ImWchar)IM_UNICODE_CODEPOINT_INVALID, (ImWchar)'?', (ImWchar)' ' };
3667 FallbackGlyph = FindGlyphNoFallback(FallbackChar);
3668 if (FallbackGlyph == NULL)
3669 {
3670 FallbackChar = FindFirstExistingGlyph(this, fallback_chars, IM_ARRAYSIZE(fallback_chars));
3671 FallbackGlyph = FindGlyphNoFallback(FallbackChar);
3672 if (FallbackGlyph == NULL)
3673 {
3674 FallbackGlyph = &Glyphs.back();
3675 FallbackChar = (ImWchar)FallbackGlyph->Codepoint;
3676 }
3677 }
3678 FallbackAdvanceX = FallbackGlyph->AdvanceX;
3679 for (int i = 0; i < max_codepoint + 1; i++)
3680 if (IndexAdvanceX[i] < 0.0f)
3681 IndexAdvanceX[i] = FallbackAdvanceX;
3682
3683 // Setup Ellipsis character. It is required for rendering elided text. We prefer using U+2026 (horizontal ellipsis).
3684 // However some old fonts may contain ellipsis at U+0085. Here we auto-detect most suitable ellipsis character.
3685 // FIXME: Note that 0x2026 is rarely included in our font ranges. Because of this we are more likely to use three individual dots.
3686 const ImWchar ellipsis_chars[] = { (ImWchar)0x2026, (ImWchar)0x0085 };
3687 const ImWchar dots_chars[] = { (ImWchar)'.', (ImWchar)0xFF0E };
3688 if (EllipsisChar == (ImWchar)-1)
3689 EllipsisChar = FindFirstExistingGlyph(this, ellipsis_chars, IM_ARRAYSIZE(ellipsis_chars));
3690 const ImWchar dot_char = FindFirstExistingGlyph(this, dots_chars, IM_ARRAYSIZE(dots_chars));
3691 if (EllipsisChar != (ImWchar)-1)
3692 {
3693 EllipsisCharCount = 1;
3694 EllipsisWidth = EllipsisCharStep = FindGlyph(EllipsisChar)->X1;
3695 }
3696 else if (dot_char != (ImWchar)-1)
3697 {
3698 const ImFontGlyph* glyph = FindGlyph(dot_char);
3699 EllipsisChar = dot_char;
3700 EllipsisCharCount = 3;
3701 EllipsisCharStep = (glyph->X1 - glyph->X0) + 1.0f;
3702 EllipsisWidth = EllipsisCharStep * 3.0f - 1.0f;
3703 }
3704}
3705
3706// API is designed this way to avoid exposing the 4K page size
3707// e.g. use with IsGlyphRangeUnused(0, 255)
3708bool ImFont::IsGlyphRangeUnused(unsigned int c_begin, unsigned int c_last)
3709{
3710 unsigned int page_begin = (c_begin / 4096);
3711 unsigned int page_last = (c_last / 4096);
3712 for (unsigned int page_n = page_begin; page_n <= page_last; page_n++)
3713 if ((page_n >> 3) < sizeof(Used4kPagesMap))
3714 if (Used4kPagesMap[page_n >> 3] & (1 << (page_n & 7)))
3715 return false;
3716 return true;
3717}
3718
3719void ImFont::SetGlyphVisible(ImWchar c, bool visible)
3720{
3721 if (ImFontGlyph* glyph = (ImFontGlyph*)(void*)FindGlyph((ImWchar)c))
3722 glyph->Visible = visible ? 1 : 0;
3723}
3724
3725void ImFont::GrowIndex(int new_size)
3726{
3727 IM_ASSERT(IndexAdvanceX.Size == IndexLookup.Size);
3728 if (new_size <= IndexLookup.Size)
3729 return;
3730 IndexAdvanceX.resize(new_size, -1.0f);
3731 IndexLookup.resize(new_size, (ImWchar)-1);
3732}
3733
3734// x0/y0/x1/y1 are offset from the character upper-left layout position, in pixels. Therefore x0/y0 are often fairly close to zero.
3735// Not to be mistaken with texture coordinates, which are held by u0/v0/u1/v1 in normalized format (0.0..1.0 on each texture axis).
3736// 'cfg' is not necessarily == 'this->ConfigData' because multiple source fonts+configs can be used to build one target font.
3737void ImFont::AddGlyph(const ImFontConfig* cfg, ImWchar codepoint, float x0, float y0, float x1, float y1, float u0, float v0, float u1, float v1, float advance_x)
3738{
3739 if (cfg != NULL)
3740 {
3741 // Clamp & recenter if needed
3742 const float advance_x_original = advance_x;
3743 advance_x = ImClamp(advance_x, cfg->GlyphMinAdvanceX, cfg->GlyphMaxAdvanceX);
3744 if (advance_x != advance_x_original)
3745 {
3746 float char_off_x = cfg->PixelSnapH ? ImTrunc((advance_x - advance_x_original) * 0.5f) : (advance_x - advance_x_original) * 0.5f;
3747 x0 += char_off_x;
3748 x1 += char_off_x;
3749 }
3750
3751 // Snap to pixel
3752 if (cfg->PixelSnapH)
3753 advance_x = IM_ROUND(advance_x);
3754
3755 // Bake spacing
3756 advance_x += cfg->GlyphExtraSpacing.x;
3757 }
3758
3759 Glyphs.resize(Glyphs.Size + 1);
3760 ImFontGlyph& glyph = Glyphs.back();
3761 glyph.Codepoint = (unsigned int)codepoint;
3762 glyph.Visible = (x0 != x1) && (y0 != y1);
3763 glyph.Colored = false;
3764 glyph.X0 = x0;
3765 glyph.Y0 = y0;
3766 glyph.X1 = x1;
3767 glyph.Y1 = y1;
3768 glyph.U0 = u0;
3769 glyph.V0 = v0;
3770 glyph.U1 = u1;
3771 glyph.V1 = v1;
3772 glyph.AdvanceX = advance_x;
3773
3774 // Compute rough surface usage metrics (+1 to account for average padding, +0.99 to round)
3775 // We use (U1-U0)*TexWidth instead of X1-X0 to account for oversampling.
3776 float pad = ContainerAtlas->TexGlyphPadding + 0.99f;
3777 DirtyLookupTables = true;
3778 MetricsTotalSurface += (int)((glyph.U1 - glyph.U0) * ContainerAtlas->TexWidth + pad) * (int)((glyph.V1 - glyph.V0) * ContainerAtlas->TexHeight + pad);
3779}
3780
3781void ImFont::AddRemapChar(ImWchar dst, ImWchar src, bool overwrite_dst)
3782{
3783 IM_ASSERT(IndexLookup.Size > 0); // Currently this can only be called AFTER the font has been built, aka after calling ImFontAtlas::GetTexDataAs*() function.
3784 unsigned int index_size = (unsigned int)IndexLookup.Size;
3785
3786 if (dst < index_size && IndexLookup.Data[dst] == (ImWchar)-1 && !overwrite_dst) // 'dst' already exists
3787 return;
3788 if (src >= index_size && dst >= index_size) // both 'dst' and 'src' don't exist -> no-op
3789 return;
3790
3791 GrowIndex(dst + 1);
3792 IndexLookup[dst] = (src < index_size) ? IndexLookup.Data[src] : (ImWchar)-1;
3793 IndexAdvanceX[dst] = (src < index_size) ? IndexAdvanceX.Data[src] : 1.0f;
3794}
3795
3796const ImFontGlyph* ImFont::FindGlyph(ImWchar c) const
3797{
3798 if (c >= (size_t)IndexLookup.Size)
3799 return FallbackGlyph;
3800 const ImWchar i = IndexLookup.Data[c];
3801 if (i == (ImWchar)-1)
3802 return FallbackGlyph;
3803 return &Glyphs.Data[i];
3804}
3805
3806const ImFontGlyph* ImFont::FindGlyphNoFallback(ImWchar c) const
3807{
3808 if (c >= (size_t)IndexLookup.Size)
3809 return NULL;
3810 const ImWchar i = IndexLookup.Data[c];
3811 if (i == (ImWchar)-1)
3812 return NULL;
3813 return &Glyphs.Data[i];
3814}
3815
3816// Wrapping skips upcoming blanks
3817static inline const char* CalcWordWrapNextLineStartA(const char* text, const char* text_end)
3818{
3819 while (text < text_end && ImCharIsBlankA(*text))
3820 text++;
3821 if (*text == '\n')
3822 text++;
3823 return text;
3824}
3825
3826// Simple word-wrapping for English, not full-featured. Please submit failing cases!
3827// This will return the next location to wrap from. If no wrapping if necessary, this will fast-forward to e.g. text_end.
3828// FIXME: Much possible improvements (don't cut things like "word !", "word!!!" but cut within "word,,,,", more sensible support for punctuations, support for Unicode punctuations, etc.)
3829const char* ImFont::CalcWordWrapPositionA(float scale, const char* text, const char* text_end, float wrap_width) const
3830{
3831 // For references, possible wrap point marked with ^
3832 // "aaa bbb, ccc,ddd. eee fff. ggg!"
3833 // ^ ^ ^ ^ ^__ ^ ^
3834
3835 // List of hardcoded separators: .,;!?'"
3836
3837 // Skip extra blanks after a line returns (that includes not counting them in width computation)
3838 // e.g. "Hello world" --> "Hello" "World"
3839
3840 // Cut words that cannot possibly fit within one line.
3841 // e.g.: "The tropical fish" with ~5 characters worth of width --> "The tr" "opical" "fish"
3842 float line_width = 0.0f;
3843 float word_width = 0.0f;
3844 float blank_width = 0.0f;
3845 wrap_width /= scale; // We work with unscaled widths to avoid scaling every characters
3846
3847 const char* word_end = text;
3848 const char* prev_word_end = NULL;
3849 bool inside_word = true;
3850
3851 const char* s = text;
3852 IM_ASSERT(text_end != NULL);
3853 while (s < text_end)
3854 {
3855 unsigned int c = (unsigned int)*s;
3856 const char* next_s;
3857 if (c < 0x80)
3858 next_s = s + 1;
3859 else
3860 next_s = s + ImTextCharFromUtf8(&c, s, text_end);
3861
3862 if (c < 32)
3863 {
3864 if (c == '\n')
3865 {
3866 line_width = word_width = blank_width = 0.0f;
3867 inside_word = true;
3868 s = next_s;
3869 continue;
3870 }
3871 if (c == '\r')
3872 {
3873 s = next_s;
3874 continue;
3875 }
3876 }
3877
3878 const float char_width = ((int)c < IndexAdvanceX.Size ? IndexAdvanceX.Data[c] : FallbackAdvanceX);
3879 if (ImCharIsBlankW(c))
3880 {
3881 if (inside_word)
3882 {
3883 line_width += blank_width;
3884 blank_width = 0.0f;
3885 word_end = s;
3886 }
3887 blank_width += char_width;
3888 inside_word = false;
3889 }
3890 else
3891 {
3892 word_width += char_width;
3893 if (inside_word)
3894 {
3895 word_end = next_s;
3896 }
3897 else
3898 {
3899 prev_word_end = word_end;
3900 line_width += word_width + blank_width;
3901 word_width = blank_width = 0.0f;
3902 }
3903
3904 // Allow wrapping after punctuation.
3905 inside_word = (c != '.' && c != ',' && c != ';' && c != '!' && c != '?' && c != '\"');
3906 }
3907
3908 // We ignore blank width at the end of the line (they can be skipped)
3909 if (line_width + word_width > wrap_width)
3910 {
3911 // Words that cannot possibly fit within an entire line will be cut anywhere.
3912 if (word_width < wrap_width)
3913 s = prev_word_end ? prev_word_end : word_end;
3914 break;
3915 }
3916
3917 s = next_s;
3918 }
3919
3920 // Wrap_width is too small to fit anything. Force displaying 1 character to minimize the height discontinuity.
3921 // +1 may not be a character start point in UTF-8 but it's ok because caller loops use (text >= word_wrap_eol).
3922 if (s == text && text < text_end)
3923 return s + 1;
3924 return s;
3925}
3926
3927ImVec2 ImFont::CalcTextSizeA(float size, float max_width, float wrap_width, const char* text_begin, const char* text_end, const char** remaining) const
3928{
3929 if (!text_end)
3930 text_end = text_begin + strlen(text_begin); // FIXME-OPT: Need to avoid this.
3931
3932 const float line_height = size;
3933 const float scale = size / FontSize;
3934
3935 ImVec2 text_size = ImVec2(0, 0);
3936 float line_width = 0.0f;
3937
3938 const bool word_wrap_enabled = (wrap_width > 0.0f);
3939 const char* word_wrap_eol = NULL;
3940
3941 const char* s = text_begin;
3942 while (s < text_end)
3943 {
3944 if (word_wrap_enabled)
3945 {
3946 // Calculate how far we can render. Requires two passes on the string data but keeps the code simple and not intrusive for what's essentially an uncommon feature.
3947 if (!word_wrap_eol)
3948 word_wrap_eol = CalcWordWrapPositionA(scale, s, text_end, wrap_width - line_width);
3949
3950 if (s >= word_wrap_eol)
3951 {
3952 if (text_size.x < line_width)
3953 text_size.x = line_width;
3954 text_size.y += line_height;
3955 line_width = 0.0f;
3956 word_wrap_eol = NULL;
3957 s = CalcWordWrapNextLineStartA(s, text_end); // Wrapping skips upcoming blanks
3958 continue;
3959 }
3960 }
3961
3962 // Decode and advance source
3963 const char* prev_s = s;
3964 unsigned int c = (unsigned int)*s;
3965 if (c < 0x80)
3966 s += 1;
3967 else
3968 s += ImTextCharFromUtf8(&c, s, text_end);
3969
3970 if (c < 32)
3971 {
3972 if (c == '\n')
3973 {
3974 text_size.x = ImMax(text_size.x, line_width);
3975 text_size.y += line_height;
3976 line_width = 0.0f;
3977 continue;
3978 }
3979 if (c == '\r')
3980 continue;
3981 }
3982
3983 const float char_width = ((int)c < IndexAdvanceX.Size ? IndexAdvanceX.Data[c] : FallbackAdvanceX) * scale;
3984 if (line_width + char_width >= max_width)
3985 {
3986 s = prev_s;
3987 break;
3988 }
3989
3990 line_width += char_width;
3991 }
3992
3993 if (text_size.x < line_width)
3994 text_size.x = line_width;
3995
3996 if (line_width > 0 || text_size.y == 0.0f)
3997 text_size.y += line_height;
3998
3999 if (remaining)
4000 *remaining = s;
4001
4002 return text_size;
4003}
4004
4005// Note: as with every ImDrawList drawing function, this expects that the font atlas texture is bound.
4006void ImFont::RenderChar(ImDrawList* draw_list, float size, const ImVec2& pos, ImU32 col, ImWchar c) const
4007{
4008 const ImFontGlyph* glyph = FindGlyph(c);
4009 if (!glyph || !glyph->Visible)
4010 return;
4011 if (glyph->Colored)
4012 col |= ~IM_COL32_A_MASK;
4013 float scale = (size >= 0.0f) ? (size / FontSize) : 1.0f;
4014 float x = IM_TRUNC(pos.x);
4015 float y = IM_TRUNC(pos.y);
4016 draw_list->PrimReserve(6, 4);
4017 draw_list->PrimRectUV(ImVec2(x + glyph->X0 * scale, y + glyph->Y0 * scale), ImVec2(x + glyph->X1 * scale, y + glyph->Y1 * scale), ImVec2(glyph->U0, glyph->V0), ImVec2(glyph->U1, glyph->V1), col);
4018}
4019
4020// Note: as with every ImDrawList drawing function, this expects that the font atlas texture is bound.
4021void ImFont::RenderText(ImDrawList* draw_list, float size, const ImVec2& pos, ImU32 col, const ImVec4& clip_rect, const char* text_begin, const char* text_end, float wrap_width, bool cpu_fine_clip) const
4022{
4023 if (!text_end)
4024 text_end = text_begin + strlen(text_begin); // ImGui:: functions generally already provides a valid text_end, so this is merely to handle direct calls.
4025
4026 // Align to be pixel perfect
4027 float x = IM_TRUNC(pos.x);
4028 float y = IM_TRUNC(pos.y);
4029 if (y > clip_rect.w)
4030 return;
4031
4032 const float start_x = x;
4033 const float scale = size / FontSize;
4034 const float line_height = FontSize * scale;
4035 const bool word_wrap_enabled = (wrap_width > 0.0f);
4036
4037 // Fast-forward to first visible line
4038 const char* s = text_begin;
4039 if (y + line_height < clip_rect.y)
4040 while (y + line_height < clip_rect.y && s < text_end)
4041 {
4042 const char* line_end = (const char*)memchr(s, '\n', text_end - s);
4043 if (word_wrap_enabled)
4044 {
4045 // FIXME-OPT: This is not optimal as do first do a search for \n before calling CalcWordWrapPositionA().
4046 // If the specs for CalcWordWrapPositionA() were reworked to optionally return on \n we could combine both.
4047 // However it is still better than nothing performing the fast-forward!
4048 s = CalcWordWrapPositionA(scale, s, line_end ? line_end : text_end, wrap_width);
4049 s = CalcWordWrapNextLineStartA(s, text_end);
4050 }
4051 else
4052 {
4053 s = line_end ? line_end + 1 : text_end;
4054 }
4055 y += line_height;
4056 }
4057
4058 // For large text, scan for the last visible line in order to avoid over-reserving in the call to PrimReserve()
4059 // Note that very large horizontal line will still be affected by the issue (e.g. a one megabyte string buffer without a newline will likely crash atm)
4060 if (text_end - s > 10000 && !word_wrap_enabled)
4061 {
4062 const char* s_end = s;
4063 float y_end = y;
4064 while (y_end < clip_rect.w && s_end < text_end)
4065 {
4066 s_end = (const char*)memchr(s_end, '\n', text_end - s_end);
4067 s_end = s_end ? s_end + 1 : text_end;
4068 y_end += line_height;
4069 }
4070 text_end = s_end;
4071 }
4072 if (s == text_end)
4073 return;
4074
4075 // Reserve vertices for remaining worse case (over-reserving is useful and easily amortized)
4076 const int vtx_count_max = (int)(text_end - s) * 4;
4077 const int idx_count_max = (int)(text_end - s) * 6;
4078 const int idx_expected_size = draw_list->IdxBuffer.Size + idx_count_max;
4079 draw_list->PrimReserve(idx_count_max, vtx_count_max);
4080 ImDrawVert* vtx_write = draw_list->_VtxWritePtr;
4081 ImDrawIdx* idx_write = draw_list->_IdxWritePtr;
4082 unsigned int vtx_index = draw_list->_VtxCurrentIdx;
4083
4084 const ImU32 col_untinted = col | ~IM_COL32_A_MASK;
4085 const char* word_wrap_eol = NULL;
4086
4087 while (s < text_end)
4088 {
4089 if (word_wrap_enabled)
4090 {
4091 // Calculate how far we can render. Requires two passes on the string data but keeps the code simple and not intrusive for what's essentially an uncommon feature.
4092 if (!word_wrap_eol)
4093 word_wrap_eol = CalcWordWrapPositionA(scale, s, text_end, wrap_width - (x - start_x));
4094
4095 if (s >= word_wrap_eol)
4096 {
4097 x = start_x;
4098 y += line_height;
4099 if (y > clip_rect.w)
4100 break; // break out of main loop
4101 word_wrap_eol = NULL;
4102 s = CalcWordWrapNextLineStartA(s, text_end); // Wrapping skips upcoming blanks
4103 continue;
4104 }
4105 }
4106
4107 // Decode and advance source
4108 unsigned int c = (unsigned int)*s;
4109 if (c < 0x80)
4110 s += 1;
4111 else
4112 s += ImTextCharFromUtf8(&c, s, text_end);
4113
4114 if (c < 32)
4115 {
4116 if (c == '\n')
4117 {
4118 x = start_x;
4119 y += line_height;
4120 if (y > clip_rect.w)
4121 break; // break out of main loop
4122 continue;
4123 }
4124 if (c == '\r')
4125 continue;
4126 }
4127
4128 const ImFontGlyph* glyph = FindGlyph((ImWchar)c);
4129 if (glyph == NULL)
4130 continue;
4131
4132 float char_width = glyph->AdvanceX * scale;
4133 if (glyph->Visible)
4134 {
4135 // We don't do a second finer clipping test on the Y axis as we've already skipped anything before clip_rect.y and exit once we pass clip_rect.w
4136 float x1 = x + glyph->X0 * scale;
4137 float x2 = x + glyph->X1 * scale;
4138 float y1 = y + glyph->Y0 * scale;
4139 float y2 = y + glyph->Y1 * scale;
4140 if (x1 <= clip_rect.z && x2 >= clip_rect.x)
4141 {
4142 // Render a character
4143 float u1 = glyph->U0;
4144 float v1 = glyph->V0;
4145 float u2 = glyph->U1;
4146 float v2 = glyph->V1;
4147
4148 // CPU side clipping used to fit text in their frame when the frame is too small. Only does clipping for axis aligned quads.
4149 if (cpu_fine_clip)
4150 {
4151 if (x1 < clip_rect.x)
4152 {
4153 u1 = u1 + (1.0f - (x2 - clip_rect.x) / (x2 - x1)) * (u2 - u1);
4154 x1 = clip_rect.x;
4155 }
4156 if (y1 < clip_rect.y)
4157 {
4158 v1 = v1 + (1.0f - (y2 - clip_rect.y) / (y2 - y1)) * (v2 - v1);
4159 y1 = clip_rect.y;
4160 }
4161 if (x2 > clip_rect.z)
4162 {
4163 u2 = u1 + ((clip_rect.z - x1) / (x2 - x1)) * (u2 - u1);
4164 x2 = clip_rect.z;
4165 }
4166 if (y2 > clip_rect.w)
4167 {
4168 v2 = v1 + ((clip_rect.w - y1) / (y2 - y1)) * (v2 - v1);
4169 y2 = clip_rect.w;
4170 }
4171 if (y1 >= y2)
4172 {
4173 x += char_width;
4174 continue;
4175 }
4176 }
4177
4178 // Support for untinted glyphs
4179 ImU32 glyph_col = glyph->Colored ? col_untinted : col;
4180
4181 // We are NOT calling PrimRectUV() here because non-inlined causes too much overhead in a debug builds. Inlined here:
4182 {
4183 vtx_write[0].pos.x = x1; vtx_write[0].pos.y = y1; vtx_write[0].col = glyph_col; vtx_write[0].uv.x = u1; vtx_write[0].uv.y = v1;
4184 vtx_write[1].pos.x = x2; vtx_write[1].pos.y = y1; vtx_write[1].col = glyph_col; vtx_write[1].uv.x = u2; vtx_write[1].uv.y = v1;
4185 vtx_write[2].pos.x = x2; vtx_write[2].pos.y = y2; vtx_write[2].col = glyph_col; vtx_write[2].uv.x = u2; vtx_write[2].uv.y = v2;
4186 vtx_write[3].pos.x = x1; vtx_write[3].pos.y = y2; vtx_write[3].col = glyph_col; vtx_write[3].uv.x = u1; vtx_write[3].uv.y = v2;
4187 idx_write[0] = (ImDrawIdx)(vtx_index); idx_write[1] = (ImDrawIdx)(vtx_index + 1); idx_write[2] = (ImDrawIdx)(vtx_index + 2);
4188 idx_write[3] = (ImDrawIdx)(vtx_index); idx_write[4] = (ImDrawIdx)(vtx_index + 2); idx_write[5] = (ImDrawIdx)(vtx_index + 3);
4189 vtx_write += 4;
4190 vtx_index += 4;
4191 idx_write += 6;
4192 }
4193 }
4194 }
4195 x += char_width;
4196 }
4197
4198 // Give back unused vertices (clipped ones, blanks) ~ this is essentially a PrimUnreserve() action.
4199 draw_list->VtxBuffer.Size = (int)(vtx_write - draw_list->VtxBuffer.Data); // Same as calling shrink()
4200 draw_list->IdxBuffer.Size = (int)(idx_write - draw_list->IdxBuffer.Data);
4201 draw_list->CmdBuffer[draw_list->CmdBuffer.Size - 1].ElemCount -= (idx_expected_size - draw_list->IdxBuffer.Size);
4202 draw_list->_VtxWritePtr = vtx_write;
4203 draw_list->_IdxWritePtr = idx_write;
4204 draw_list->_VtxCurrentIdx = vtx_index;
4205}
4206
4207//-----------------------------------------------------------------------------
4208// [SECTION] ImGui Internal Render Helpers
4209//-----------------------------------------------------------------------------
4210// Vaguely redesigned to stop accessing ImGui global state:
4211// - RenderArrow()
4212// - RenderBullet()
4213// - RenderCheckMark()
4214// - RenderArrowDockMenu()
4215// - RenderArrowPointingAt()
4216// - RenderRectFilledRangeH()
4217// - RenderRectFilledWithHole()
4218//-----------------------------------------------------------------------------
4219// Function in need of a redesign (legacy mess)
4220// - RenderColorRectWithAlphaCheckerboard()
4221//-----------------------------------------------------------------------------
4222
4223// Render an arrow aimed to be aligned with text (p_min is a position in the same space text would be positioned). To e.g. denote expanded/collapsed state
4224void ImGui::RenderArrow(ImDrawList* draw_list, ImVec2 pos, ImU32 col, ImGuiDir dir, float scale)
4225{
4226 const float h = draw_list->_Data->FontSize * 1.00f;
4227 float r = h * 0.40f * scale;
4228 ImVec2 center = pos + ImVec2(h * 0.50f, h * 0.50f * scale);
4229
4230 ImVec2 a, b, c;
4231 switch (dir)
4232 {
4233 case ImGuiDir_Up:
4234 case ImGuiDir_Down:
4235 if (dir == ImGuiDir_Up) r = -r;
4236 a = ImVec2(+0.000f, +0.750f) * r;
4237 b = ImVec2(-0.866f, -0.750f) * r;
4238 c = ImVec2(+0.866f, -0.750f) * r;
4239 break;
4240 case ImGuiDir_Left:
4241 case ImGuiDir_Right:
4242 if (dir == ImGuiDir_Left) r = -r;
4243 a = ImVec2(+0.750f, +0.000f) * r;
4244 b = ImVec2(-0.750f, +0.866f) * r;
4245 c = ImVec2(-0.750f, -0.866f) * r;
4246 break;
4247 case ImGuiDir_None:
4248 case ImGuiDir_COUNT:
4249 IM_ASSERT(0);
4250 break;
4251 }
4252 draw_list->AddTriangleFilled(center + a, center + b, center + c, col);
4253}
4254
4255void ImGui::RenderBullet(ImDrawList* draw_list, ImVec2 pos, ImU32 col)
4256{
4257 // FIXME-OPT: This should be baked in font.
4258 draw_list->AddCircleFilled(pos, draw_list->_Data->FontSize * 0.20f, col, 8);
4259}
4260
4261void ImGui::RenderCheckMark(ImDrawList* draw_list, ImVec2 pos, ImU32 col, float sz)
4262{
4263 float thickness = ImMax(sz / 5.0f, 1.0f);
4264 sz -= thickness * 0.5f;
4265 pos += ImVec2(thickness * 0.25f, thickness * 0.25f);
4266
4267 float third = sz / 3.0f;
4268 float bx = pos.x + third;
4269 float by = pos.y + sz - third * 0.5f;
4270 draw_list->PathLineTo(ImVec2(bx - third, by - third));
4271 draw_list->PathLineTo(ImVec2(bx, by));
4272 draw_list->PathLineTo(ImVec2(bx + third * 2.0f, by - third * 2.0f));
4273 draw_list->PathStroke(col, 0, thickness);
4274}
4275
4276// Render an arrow. 'pos' is position of the arrow tip. half_sz.x is length from base to tip. half_sz.y is length on each side.
4277void ImGui::RenderArrowPointingAt(ImDrawList* draw_list, ImVec2 pos, ImVec2 half_sz, ImGuiDir direction, ImU32 col)
4278{
4279 switch (direction)
4280 {
4281 case ImGuiDir_Left: draw_list->AddTriangleFilled(ImVec2(pos.x + half_sz.x, pos.y - half_sz.y), ImVec2(pos.x + half_sz.x, pos.y + half_sz.y), pos, col); return;
4282 case ImGuiDir_Right: draw_list->AddTriangleFilled(ImVec2(pos.x - half_sz.x, pos.y + half_sz.y), ImVec2(pos.x - half_sz.x, pos.y - half_sz.y), pos, col); return;
4283 case ImGuiDir_Up: draw_list->AddTriangleFilled(ImVec2(pos.x + half_sz.x, pos.y + half_sz.y), ImVec2(pos.x - half_sz.x, pos.y + half_sz.y), pos, col); return;
4284 case ImGuiDir_Down: draw_list->AddTriangleFilled(ImVec2(pos.x - half_sz.x, pos.y - half_sz.y), ImVec2(pos.x + half_sz.x, pos.y - half_sz.y), pos, col); return;
4285 case ImGuiDir_None: case ImGuiDir_COUNT: break; // Fix warnings
4286 }
4287}
4288
4289// This is less wide than RenderArrow() and we use in dock nodes instead of the regular RenderArrow() to denote a change of functionality,
4290// and because the saved space means that the left-most tab label can stay at exactly the same position as the label of a loose window.
4291void ImGui::RenderArrowDockMenu(ImDrawList* draw_list, ImVec2 p_min, float sz, ImU32 col)
4292{
4293 draw_list->AddRectFilled(p_min + ImVec2(sz * 0.20f, sz * 0.15f), p_min + ImVec2(sz * 0.80f, sz * 0.30f), col);
4294 RenderArrowPointingAt(draw_list, p_min + ImVec2(sz * 0.50f, sz * 0.85f), ImVec2(sz * 0.30f, sz * 0.40f), ImGuiDir_Down, col);
4295}
4296
4297static inline float ImAcos01(float x)
4298{
4299 if (x <= 0.0f) return IM_PI * 0.5f;
4300 if (x >= 1.0f) return 0.0f;
4301 return ImAcos(x);
4302 //return (-0.69813170079773212f * x * x - 0.87266462599716477f) * x + 1.5707963267948966f; // Cheap approximation, may be enough for what we do.
4303}
4304
4305// FIXME: Cleanup and move code to ImDrawList.
4306void ImGui::RenderRectFilledRangeH(ImDrawList* draw_list, const ImRect& rect, ImU32 col, float x_start_norm, float x_end_norm, float rounding)
4307{
4308 if (x_end_norm == x_start_norm)
4309 return;
4310 if (x_start_norm > x_end_norm)
4311 ImSwap(x_start_norm, x_end_norm);
4312
4313 ImVec2 p0 = ImVec2(ImLerp(rect.Min.x, rect.Max.x, x_start_norm), rect.Min.y);
4314 ImVec2 p1 = ImVec2(ImLerp(rect.Min.x, rect.Max.x, x_end_norm), rect.Max.y);
4315 if (rounding == 0.0f)
4316 {
4317 draw_list->AddRectFilled(p0, p1, col, 0.0f);
4318 return;
4319 }
4320
4321 rounding = ImClamp(ImMin((rect.Max.x - rect.Min.x) * 0.5f, (rect.Max.y - rect.Min.y) * 0.5f) - 1.0f, 0.0f, rounding);
4322 const float inv_rounding = 1.0f / rounding;
4323 const float arc0_b = ImAcos01(1.0f - (p0.x - rect.Min.x) * inv_rounding);
4324 const float arc0_e = ImAcos01(1.0f - (p1.x - rect.Min.x) * inv_rounding);
4325 const float half_pi = IM_PI * 0.5f; // We will == compare to this because we know this is the exact value ImAcos01 can return.
4326 const float x0 = ImMax(p0.x, rect.Min.x + rounding);
4327 if (arc0_b == arc0_e)
4328 {
4329 draw_list->PathLineTo(ImVec2(x0, p1.y));
4330 draw_list->PathLineTo(ImVec2(x0, p0.y));
4331 }
4332 else if (arc0_b == 0.0f && arc0_e == half_pi)
4333 {
4334 draw_list->PathArcToFast(ImVec2(x0, p1.y - rounding), rounding, 3, 6); // BL
4335 draw_list->PathArcToFast(ImVec2(x0, p0.y + rounding), rounding, 6, 9); // TR
4336 }
4337 else
4338 {
4339 draw_list->PathArcTo(ImVec2(x0, p1.y - rounding), rounding, IM_PI - arc0_e, IM_PI - arc0_b); // BL
4340 draw_list->PathArcTo(ImVec2(x0, p0.y + rounding), rounding, IM_PI + arc0_b, IM_PI + arc0_e); // TR
4341 }
4342 if (p1.x > rect.Min.x + rounding)
4343 {
4344 const float arc1_b = ImAcos01(1.0f - (rect.Max.x - p1.x) * inv_rounding);
4345 const float arc1_e = ImAcos01(1.0f - (rect.Max.x - p0.x) * inv_rounding);
4346 const float x1 = ImMin(p1.x, rect.Max.x - rounding);
4347 if (arc1_b == arc1_e)
4348 {
4349 draw_list->PathLineTo(ImVec2(x1, p0.y));
4350 draw_list->PathLineTo(ImVec2(x1, p1.y));
4351 }
4352 else if (arc1_b == 0.0f && arc1_e == half_pi)
4353 {
4354 draw_list->PathArcToFast(ImVec2(x1, p0.y + rounding), rounding, 9, 12); // TR
4355 draw_list->PathArcToFast(ImVec2(x1, p1.y - rounding), rounding, 0, 3); // BR
4356 }
4357 else
4358 {
4359 draw_list->PathArcTo(ImVec2(x1, p0.y + rounding), rounding, -arc1_e, -arc1_b); // TR
4360 draw_list->PathArcTo(ImVec2(x1, p1.y - rounding), rounding, +arc1_b, +arc1_e); // BR
4361 }
4362 }
4363 draw_list->PathFillConvex(col);
4364}
4365
4366void ImGui::RenderRectFilledWithHole(ImDrawList* draw_list, const ImRect& outer, const ImRect& inner, ImU32 col, float rounding)
4367{
4368 const bool fill_L = (inner.Min.x > outer.Min.x);
4369 const bool fill_R = (inner.Max.x < outer.Max.x);
4370 const bool fill_U = (inner.Min.y > outer.Min.y);
4371 const bool fill_D = (inner.Max.y < outer.Max.y);
4372 if (fill_L) draw_list->AddRectFilled(ImVec2(outer.Min.x, inner.Min.y), ImVec2(inner.Min.x, inner.Max.y), col, rounding, ImDrawFlags_RoundCornersNone | (fill_U ? 0 : ImDrawFlags_RoundCornersTopLeft) | (fill_D ? 0 : ImDrawFlags_RoundCornersBottomLeft));
4373 if (fill_R) draw_list->AddRectFilled(ImVec2(inner.Max.x, inner.Min.y), ImVec2(outer.Max.x, inner.Max.y), col, rounding, ImDrawFlags_RoundCornersNone | (fill_U ? 0 : ImDrawFlags_RoundCornersTopRight) | (fill_D ? 0 : ImDrawFlags_RoundCornersBottomRight));
4374 if (fill_U) draw_list->AddRectFilled(ImVec2(inner.Min.x, outer.Min.y), ImVec2(inner.Max.x, inner.Min.y), col, rounding, ImDrawFlags_RoundCornersNone | (fill_L ? 0 : ImDrawFlags_RoundCornersTopLeft) | (fill_R ? 0 : ImDrawFlags_RoundCornersTopRight));
4375 if (fill_D) draw_list->AddRectFilled(ImVec2(inner.Min.x, inner.Max.y), ImVec2(inner.Max.x, outer.Max.y), col, rounding, ImDrawFlags_RoundCornersNone | (fill_L ? 0 : ImDrawFlags_RoundCornersBottomLeft) | (fill_R ? 0 : ImDrawFlags_RoundCornersBottomRight));
4376 if (fill_L && fill_U) draw_list->AddRectFilled(ImVec2(outer.Min.x, outer.Min.y), ImVec2(inner.Min.x, inner.Min.y), col, rounding, ImDrawFlags_RoundCornersTopLeft);
4377 if (fill_R && fill_U) draw_list->AddRectFilled(ImVec2(inner.Max.x, outer.Min.y), ImVec2(outer.Max.x, inner.Min.y), col, rounding, ImDrawFlags_RoundCornersTopRight);
4378 if (fill_L && fill_D) draw_list->AddRectFilled(ImVec2(outer.Min.x, inner.Max.y), ImVec2(inner.Min.x, outer.Max.y), col, rounding, ImDrawFlags_RoundCornersBottomLeft);
4379 if (fill_R && fill_D) draw_list->AddRectFilled(ImVec2(inner.Max.x, inner.Max.y), ImVec2(outer.Max.x, outer.Max.y), col, rounding, ImDrawFlags_RoundCornersBottomRight);
4380}
4381
4382ImDrawFlags ImGui::CalcRoundingFlagsForRectInRect(const ImRect& r_in, const ImRect& r_outer, float threshold)
4383{
4384 bool round_l = r_in.Min.x <= r_outer.Min.x + threshold;
4385 bool round_r = r_in.Max.x >= r_outer.Max.x - threshold;
4386 bool round_t = r_in.Min.y <= r_outer.Min.y + threshold;
4387 bool round_b = r_in.Max.y >= r_outer.Max.y - threshold;
4388 return ImDrawFlags_RoundCornersNone
4389 | ((round_t && round_l) ? ImDrawFlags_RoundCornersTopLeft : 0) | ((round_t && round_r) ? ImDrawFlags_RoundCornersTopRight : 0)
4390 | ((round_b && round_l) ? ImDrawFlags_RoundCornersBottomLeft : 0) | ((round_b && round_r) ? ImDrawFlags_RoundCornersBottomRight : 0);
4391}
4392
4393// Helper for ColorPicker4()
4394// NB: This is rather brittle and will show artifact when rounding this enabled if rounded corners overlap multiple cells. Caller currently responsible for avoiding that.
4395// Spent a non reasonable amount of time trying to getting this right for ColorButton with rounding+anti-aliasing+ImGuiColorEditFlags_HalfAlphaPreview flag + various grid sizes and offsets, and eventually gave up... probably more reasonable to disable rounding altogether.
4396// FIXME: uses ImGui::GetColorU32
4397void ImGui::RenderColorRectWithAlphaCheckerboard(ImDrawList* draw_list, ImVec2 p_min, ImVec2 p_max, ImU32 col, float grid_step, ImVec2 grid_off, float rounding, ImDrawFlags flags)
4398{
4399 if ((flags & ImDrawFlags_RoundCornersMask_) == 0)
4400 flags = ImDrawFlags_RoundCornersDefault_;
4401 if (((col & IM_COL32_A_MASK) >> IM_COL32_A_SHIFT) < 0xFF)
4402 {
4403 ImU32 col_bg1 = GetColorU32(ImAlphaBlendColors(IM_COL32(204, 204, 204, 255), col));
4404 ImU32 col_bg2 = GetColorU32(ImAlphaBlendColors(IM_COL32(128, 128, 128, 255), col));
4405 draw_list->AddRectFilled(p_min, p_max, col_bg1, rounding, flags);
4406
4407 int yi = 0;
4408 for (float y = p_min.y + grid_off.y; y < p_max.y; y += grid_step, yi++)
4409 {
4410 float y1 = ImClamp(y, p_min.y, p_max.y), y2 = ImMin(y + grid_step, p_max.y);
4411 if (y2 <= y1)
4412 continue;
4413 for (float x = p_min.x + grid_off.x + (yi & 1) * grid_step; x < p_max.x; x += grid_step * 2.0f)
4414 {
4415 float x1 = ImClamp(x, p_min.x, p_max.x), x2 = ImMin(x + grid_step, p_max.x);
4416 if (x2 <= x1)
4417 continue;
4418 ImDrawFlags cell_flags = ImDrawFlags_RoundCornersNone;
4419 if (y1 <= p_min.y) { if (x1 <= p_min.x) cell_flags |= ImDrawFlags_RoundCornersTopLeft; if (x2 >= p_max.x) cell_flags |= ImDrawFlags_RoundCornersTopRight; }
4420 if (y2 >= p_max.y) { if (x1 <= p_min.x) cell_flags |= ImDrawFlags_RoundCornersBottomLeft; if (x2 >= p_max.x) cell_flags |= ImDrawFlags_RoundCornersBottomRight; }
4421
4422 // Combine flags
4423 cell_flags = (flags == ImDrawFlags_RoundCornersNone || cell_flags == ImDrawFlags_RoundCornersNone) ? ImDrawFlags_RoundCornersNone : (cell_flags & flags);
4424 draw_list->AddRectFilled(ImVec2(x1, y1), ImVec2(x2, y2), col_bg2, rounding, cell_flags);
4425 }
4426 }
4427 }
4428 else
4429 {
4430 draw_list->AddRectFilled(p_min, p_max, col, rounding, flags);
4431 }
4432}
4433
4434//-----------------------------------------------------------------------------
4435// [SECTION] Decompression code
4436//-----------------------------------------------------------------------------
4437// Compressed with stb_compress() then converted to a C array and encoded as base85.
4438// Use the program in misc/fonts/binary_to_compressed_c.cpp to create the array from a TTF file.
4439// The purpose of encoding as base85 instead of "0x00,0x01,..." style is only save on _source code_ size.
4440// Decompression from stb.h (public domain) by Sean Barrett https://github.com/nothings/stb/blob/master/stb.h
4441//-----------------------------------------------------------------------------
4442
4443static unsigned int stb_decompress_length(const unsigned char *input)
4444{
4445 return (input[8] << 24) + (input[9] << 16) + (input[10] << 8) + input[11];
4446}
4447
4448static unsigned char *stb__barrier_out_e, *stb__barrier_out_b;
4449static const unsigned char *stb__barrier_in_b;
4450static unsigned char *stb__dout;
4451static void stb__match(const unsigned char *data, unsigned int length)
4452{
4453 // INVERSE of memmove... write each byte before copying the next...
4454 IM_ASSERT(stb__dout + length <= stb__barrier_out_e);
4455 if (stb__dout + length > stb__barrier_out_e) { stb__dout += length; return; }
4456 if (data < stb__barrier_out_b) { stb__dout = stb__barrier_out_e+1; return; }
4457 while (length--) *stb__dout++ = *data++;
4458}
4459
4460static void stb__lit(const unsigned char *data, unsigned int length)
4461{
4462 IM_ASSERT(stb__dout + length <= stb__barrier_out_e);
4463 if (stb__dout + length > stb__barrier_out_e) { stb__dout += length; return; }
4464 if (data < stb__barrier_in_b) { stb__dout = stb__barrier_out_e+1; return; }
4465 memcpy(stb__dout, data, length);
4466 stb__dout += length;
4467}
4468
4469#define stb__in2(x) ((i[x] << 8) + i[(x)+1])
4470#define stb__in3(x) ((i[x] << 16) + stb__in2((x)+1))
4471#define stb__in4(x) ((i[x] << 24) + stb__in3((x)+1))
4472
4473static const unsigned char *stb_decompress_token(const unsigned char *i)
4474{
4475 if (*i >= 0x20) { // use fewer if's for cases that expand small
4476 if (*i >= 0x80) stb__match(stb__dout-i[1]-1, i[0] - 0x80 + 1), i += 2;
4477 else if (*i >= 0x40) stb__match(stb__dout-(stb__in2(0) - 0x4000 + 1), i[2]+1), i += 3;
4478 else /* *i >= 0x20 */ stb__lit(i+1, i[0] - 0x20 + 1), i += 1 + (i[0] - 0x20 + 1);
4479 } else { // more ifs for cases that expand large, since overhead is amortized
4480 if (*i >= 0x18) stb__match(stb__dout-(stb__in3(0) - 0x180000 + 1), i[3]+1), i += 4;
4481 else if (*i >= 0x10) stb__match(stb__dout-(stb__in3(0) - 0x100000 + 1), stb__in2(3)+1), i += 5;
4482 else if (*i >= 0x08) stb__lit(i+2, stb__in2(0) - 0x0800 + 1), i += 2 + (stb__in2(0) - 0x0800 + 1);
4483 else if (*i == 0x07) stb__lit(i+3, stb__in2(1) + 1), i += 3 + (stb__in2(1) + 1);
4484 else if (*i == 0x06) stb__match(stb__dout-(stb__in3(1)+1), i[4]+1), i += 5;
4485 else if (*i == 0x04) stb__match(stb__dout-(stb__in3(1)+1), stb__in2(4)+1), i += 6;
4486 }
4487 return i;
4488}
4489
4490static unsigned int stb_adler32(unsigned int adler32, unsigned char *buffer, unsigned int buflen)
4491{
4492 const unsigned long ADLER_MOD = 65521;
4493 unsigned long s1 = adler32 & 0xffff, s2 = adler32 >> 16;
4494 unsigned long blocklen = buflen % 5552;
4495
4496 unsigned long i;
4497 while (buflen) {
4498 for (i=0; i + 7 < blocklen; i += 8) {
4499 s1 += buffer[0], s2 += s1;
4500 s1 += buffer[1], s2 += s1;
4501 s1 += buffer[2], s2 += s1;
4502 s1 += buffer[3], s2 += s1;
4503 s1 += buffer[4], s2 += s1;
4504 s1 += buffer[5], s2 += s1;
4505 s1 += buffer[6], s2 += s1;
4506 s1 += buffer[7], s2 += s1;
4507
4508 buffer += 8;
4509 }
4510
4511 for (; i < blocklen; ++i)
4512 s1 += *buffer++, s2 += s1;
4513
4514 s1 %= ADLER_MOD, s2 %= ADLER_MOD;
4515 buflen -= blocklen;
4516 blocklen = 5552;
4517 }
4518 return (unsigned int)(s2 << 16) + (unsigned int)s1;
4519}
4520
4521static unsigned int stb_decompress(unsigned char *output, const unsigned char *i, unsigned int /*length*/)
4522{
4523 if (stb__in4(0) != 0x57bC0000) return 0;
4524 if (stb__in4(4) != 0) return 0; // error! stream is > 4GB
4525 const unsigned int olen = stb_decompress_length(i);
4526 stb__barrier_in_b = i;
4527 stb__barrier_out_e = output + olen;
4528 stb__barrier_out_b = output;
4529 i += 16;
4530
4531 stb__dout = output;
4532 for (;;) {
4533 const unsigned char *old_i = i;
4534 i = stb_decompress_token(i);
4535 if (i == old_i) {
4536 if (*i == 0x05 && i[1] == 0xfa) {
4537 IM_ASSERT(stb__dout == output + olen);
4538 if (stb__dout != output + olen) return 0;
4539 if (stb_adler32(1, output, olen) != (unsigned int) stb__in4(2))
4540 return 0;
4541 return olen;
4542 } else {
4543 IM_ASSERT(0); /* NOTREACHED */
4544 return 0;
4545 }
4546 }
4547 IM_ASSERT(stb__dout <= output + olen);
4548 if (stb__dout > output + olen)
4549 return 0;
4550 }
4551}
4552
4553//-----------------------------------------------------------------------------
4554// [SECTION] Default font data (ProggyClean.ttf)
4555//-----------------------------------------------------------------------------
4556// ProggyClean.ttf
4557// Copyright (c) 2004, 2005 Tristan Grimmer
4558// MIT license (see License.txt in http://www.proggyfonts.net/index.php?menu=download)
4559// Download and more information at http://www.proggyfonts.net or http://upperboundsinteractive.com/fonts.php
4560//-----------------------------------------------------------------------------
4561// File: 'ProggyClean.ttf' (41208 bytes)
4562// Exported using misc/fonts/binary_to_compressed_c.cpp (with compression + base85 string encoding).
4563// The purpose of encoding as base85 instead of "0x00,0x01,..." style is only save on _source code_ size.
4564//-----------------------------------------------------------------------------
4565static const char proggy_clean_ttf_compressed_data_base85[11980 + 1] =
4566 "7])#######hV0qs'/###[),##/l:$#Q6>##5[n42>c-TH`->>#/e>11NNV=Bv(*:.F?uu#(gRU.o0XGH`$vhLG1hxt9?W`#,5LsCp#-i>.r$<$6pD>Lb';9Crc6tgXmKVeU2cD4Eo3R/"
4567 "2*>]b(MC;$jPfY.;h^`IWM9<Lh2TlS+f-s$o6Q<BWH`YiU.xfLq$N;$0iR/GX:U(jcW2p/W*q?-qmnUCI;jHSAiFWM.R*kU@C=GH?a9wp8f$e.-4^Qg1)Q-GL(lf(r/7GrRgwV%MS=C#"
4568 "`8ND>Qo#t'X#(v#Y9w0#1D$CIf;W'#pWUPXOuxXuU(H9M(1<q-UE31#^-V'8IRUo7Qf./L>=Ke$$'5F%)]0^#0X@U.a<r:QLtFsLcL6##lOj)#.Y5<-R&KgLwqJfLgN&;Q?gI^#DY2uL"
4569 "i@^rMl9t=cWq6##weg>$FBjVQTSDgEKnIS7EM9>ZY9w0#L;>>#Mx&4Mvt//L[MkA#W@lK.N'[0#7RL_&#w+F%HtG9M#XL`N&.,GM4Pg;-<nLENhvx>-VsM.M0rJfLH2eTM`*oJMHRC`N"
4570 "kfimM2J,W-jXS:)r0wK#@Fge$U>`w'N7G#$#fB#$E^$#:9:hk+eOe--6x)F7*E%?76%^GMHePW-Z5l'&GiF#$956:rS?dA#fiK:)Yr+`&#0j@'DbG&#^$PG.Ll+DNa<XCMKEV*N)LN/N"
4571 "*b=%Q6pia-Xg8I$<MR&,VdJe$<(7G;Ckl'&hF;;$<_=X(b.RS%%)###MPBuuE1V:v&cX&#2m#(&cV]`k9OhLMbn%s$G2,B$BfD3X*sp5#l,$R#]x_X1xKX%b5U*[r5iMfUo9U`N99hG)"
4572 "tm+/Us9pG)XPu`<0s-)WTt(gCRxIg(%6sfh=ktMKn3j)<6<b5Sk_/0(^]AaN#(p/L>&VZ>1i%h1S9u5o@YaaW$e+b<TWFn/Z:Oh(Cx2$lNEoN^e)#CFY@@I;BOQ*sRwZtZxRcU7uW6CX"
4573 "ow0i(?$Q[cjOd[P4d)]>ROPOpxTO7Stwi1::iB1q)C_=dV26J;2,]7op$]uQr@_V7$q^%lQwtuHY]=DX,n3L#0PHDO4f9>dC@O>HBuKPpP*E,N+b3L#lpR/MrTEH.IAQk.a>D[.e;mc."
4574 "x]Ip.PH^'/aqUO/$1WxLoW0[iLA<QT;5HKD+@qQ'NQ(3_PLhE48R.qAPSwQ0/WK?Z,[x?-J;jQTWA0X@KJ(_Y8N-:/M74:/-ZpKrUss?d#dZq]DAbkU*JqkL+nwX@@47`5>w=4h(9.`G"
4575 "CRUxHPeR`5Mjol(dUWxZa(>STrPkrJiWx`5U7F#.g*jrohGg`cg:lSTvEY/EV_7H4Q9[Z%cnv;JQYZ5q.l7Zeas:HOIZOB?G<Nald$qs]@]L<J7bR*>gv:[7MI2k).'2($5FNP&EQ(,)"
4576 "U]W]+fh18.vsai00);D3@4ku5P?DP8aJt+;qUM]=+b'8@;mViBKx0DE[-auGl8:PJ&Dj+M6OC]O^((##]`0i)drT;-7X`=-H3[igUnPG-NZlo.#k@h#=Ork$m>a>$-?Tm$UV(?#P6YY#"
4577 "'/###xe7q.73rI3*pP/$1>s9)W,JrM7SN]'/4C#v$U`0#V.[0>xQsH$fEmPMgY2u7Kh(G%siIfLSoS+MK2eTM$=5,M8p`A.;_R%#u[K#$x4AG8.kK/HSB==-'Ie/QTtG?-.*^N-4B/ZM"
4578 "_3YlQC7(p7q)&](`6_c)$/*JL(L-^(]$wIM`dPtOdGA,U3:w2M-0<q-]L_?^)1vw'.,MRsqVr.L;aN&#/EgJ)PBc[-f>+WomX2u7lqM2iEumMTcsF?-aT=Z-97UEnXglEn1K-bnEO`gu"
4579 "Ft(c%=;Am_Qs@jLooI&NX;]0#j4#F14;gl8-GQpgwhrq8'=l_f-b49'UOqkLu7-##oDY2L(te+Mch&gLYtJ,MEtJfLh'x'M=$CS-ZZ%P]8bZ>#S?YY#%Q&q'3^Fw&?D)UDNrocM3A76/"
4580 "/oL?#h7gl85[qW/NDOk%16ij;+:1a'iNIdb-ou8.P*w,v5#EI$TWS>Pot-R*H'-SEpA:g)f+O$%%`kA#G=8RMmG1&O`>to8bC]T&$,n.LoO>29sp3dt-52U%VM#q7'DHpg+#Z9%H[K<L"
4581 "%a2E-grWVM3@2=-k22tL]4$##6We'8UJCKE[d_=%wI;'6X-GsLX4j^SgJ$##R*w,vP3wK#iiW&#*h^D&R?jp7+/u&#(AP##XU8c$fSYW-J95_-Dp[g9wcO&#M-h1OcJlc-*vpw0xUX&#"
4582 "OQFKNX@QI'IoPp7nb,QU//MQ&ZDkKP)X<WSVL(68uVl&#c'[0#(s1X&xm$Y%B7*K:eDA323j998GXbA#pwMs-jgD$9QISB-A_(aN4xoFM^@C58D0+Q+q3n0#3U1InDjF682-SjMXJK)("
4583 "h$hxua_K]ul92%'BOU&#BRRh-slg8KDlr:%L71Ka:.A;%YULjDPmL<LYs8i#XwJOYaKPKc1h:'9Ke,g)b),78=I39B;xiY$bgGw-&.Zi9InXDuYa%G*f2Bq7mn9^#p1vv%#(Wi-;/Z5h"
4584 "o;#2:;%d&#x9v68C5g?ntX0X)pT`;%pB3q7mgGN)3%(P8nTd5L7GeA-GL@+%J3u2:(Yf>et`e;)f#Km8&+DC$I46>#Kr]]u-[=99tts1.qb#q72g1WJO81q+eN'03'eM>&1XxY-caEnO"
4585 "j%2n8)),?ILR5^.Ibn<-X-Mq7[a82Lq:F&#ce+S9wsCK*x`569E8ew'He]h:sI[2LM$[guka3ZRd6:t%IG:;$%YiJ:Nq=?eAw;/:nnDq0(CYcMpG)qLN4$##&J<j$UpK<Q4a1]MupW^-"
4586 "sj_$%[HK%'F####QRZJ::Y3EGl4'@%FkiAOg#p[##O`gukTfBHagL<LHw%q&OV0##F=6/:chIm0@eCP8X]:kFI%hl8hgO@RcBhS-@Qb$%+m=hPDLg*%K8ln(wcf3/'DW-$.lR?n[nCH-"
4587 "eXOONTJlh:.RYF%3'p6sq:UIMA945&^HFS87@$EP2iG<-lCO$%c`uKGD3rC$x0BL8aFn--`ke%#HMP'vh1/R&O_J9'um,.<tx[@%wsJk&bUT2`0uMv7gg#qp/ij.L56'hl;.s5CUrxjO"
4588 "M7-##.l+Au'A&O:-T72L]P`&=;ctp'XScX*rU.>-XTt,%OVU4)S1+R-#dg0/Nn?Ku1^0f$B*P:Rowwm-`0PKjYDDM'3]d39VZHEl4,.j']Pk-M.h^&:0FACm$maq-&sgw0t7/6(^xtk%"
4589 "LuH88Fj-ekm>GA#_>568x6(OFRl-IZp`&b,_P'$M<Jnq79VsJW/mWS*PUiq76;]/NM_>hLbxfc$mj`,O;&%W2m`Zh:/)Uetw:aJ%]K9h:TcF]u_-Sj9,VK3M.*'&0D[Ca]J9gp8,kAW]"
4590 "%(?A%R$f<->Zts'^kn=-^@c4%-pY6qI%J%1IGxfLU9CP8cbPlXv);C=b),<2mOvP8up,UVf3839acAWAW-W?#ao/^#%KYo8fRULNd2.>%m]UK:n%r$'sw]J;5pAoO_#2mO3n,'=H5(et"
4591 "Hg*`+RLgv>=4U8guD$I%D:W>-r5V*%j*W:Kvej.Lp$<M-SGZ':+Q_k+uvOSLiEo(<aD/K<CCc`'Lx>'?;++O'>()jLR-^u68PHm8ZFWe+ej8h:9r6L*0//c&iH&R8pRbA#Kjm%upV1g:"
4592 "a_#Ur7FuA#(tRh#.Y5K+@?3<-8m0$PEn;J:rh6?I6uG<-`wMU'ircp0LaE_OtlMb&1#6T.#FDKu#1Lw%u%+GM+X'e?YLfjM[VO0MbuFp7;>Q&#WIo)0@F%q7c#4XAXN-U&VB<HFF*qL("
4593 "$/V,;(kXZejWO`<[5?\?ewY(*9=%wDc;,u<'9t3W-(H1th3+G]ucQ]kLs7df($/*JL]@*t7Bu_G3_7mp7<iaQjO@.kLg;x3B0lqp7Hf,^Ze7-##@/c58Mo(3;knp0%)A7?-W+eI'o8)b<"
4594 "nKnw'Ho8C=Y>pqB>0ie&jhZ[?iLR@@_AvA-iQC(=ksRZRVp7`.=+NpBC%rh&3]R:8XDmE5^V8O(x<<aG/1N$#FX$0V5Y6x'aErI3I$7x%E`v<-BY,)%-?Psf*l?%C3.mM(=/M0:JxG'?"
4595 "7WhH%o'a<-80g0NBxoO(GH<dM]n.+%q@jH?f.UsJ2Ggs&4<-e47&Kl+f//9@`b+?.TeN_&B8Ss?v;^Trk;f#YvJkl&w$]>-+k?'(<S:68tq*WoDfZu';mM?8X[ma8W%*`-=;D.(nc7/;"
4596 ")g:T1=^J$&BRV(-lTmNB6xqB[@0*o.erM*<SWF]u2=st-*(6v>^](H.aREZSi,#1:[IXaZFOm<-ui#qUq2$##Ri;u75OK#(RtaW-K-F`S+cF]uN`-KMQ%rP/Xri.LRcB##=YL3BgM/3M"
4597 "D?@f&1'BW-)Ju<L25gl8uhVm1hL$##*8###'A3/LkKW+(^rWX?5W_8g)a(m&K8P>#bmmWCMkk&#TR`C,5d>g)F;t,4:@_l8G/5h4vUd%&%950:VXD'QdWoY-F$BtUwmfe$YqL'8(PWX("
4598 "P?^@Po3$##`MSs?DWBZ/S>+4%>fX,VWv/w'KD`LP5IbH;rTV>n3cEK8U#bX]l-/V+^lj3;vlMb&[5YQ8#pekX9JP3XUC72L,,?+Ni&co7ApnO*5NK,((W-i:$,kp'UDAO(G0Sq7MVjJs"
4599 "bIu)'Z,*[>br5fX^:FPAWr-m2KgL<LUN098kTF&#lvo58=/vjDo;.;)Ka*hLR#/k=rKbxuV`>Q_nN6'8uTG&#1T5g)uLv:873UpTLgH+#FgpH'_o1780Ph8KmxQJ8#H72L4@768@Tm&Q"
4600 "h4CB/5OvmA&,Q&QbUoi$a_%3M01H)4x7I^&KQVgtFnV+;[Pc>[m4k//,]1?#`VY[Jr*3&&slRfLiVZJ:]?=K3Sw=[$=uRB?3xk48@aeg<Z'<$#4H)6,>e0jT6'N#(q%.O=?2S]u*(m<-"
4601 "V8J'(1)G][68hW$5'q[GC&5j`TE?m'esFGNRM)j,ffZ?-qx8;->g4t*:CIP/[Qap7/9'#(1sao7w-.qNUdkJ)tCF&#B^;xGvn2r9FEPFFFcL@.iFNkTve$m%#QvQS8U@)2Z+3K:AKM5i"
4602 "sZ88+dKQ)W6>J%CL<KE>`.d*(B`-n8D9oK<Up]c$X$(,)M8Zt7/[rdkqTgl-0cuGMv'?>-XV1q['-5k'cAZ69e;D_?$ZPP&s^+7])$*$#@QYi9,5P&#9r+$%CE=68>K8r0=dSC%%(@p7"
4603 ".m7jilQ02'0-VWAg<a/''3u.=4L$Y)6k/K:_[3=&jvL<L0C/2'v:^;-DIBW,B4E68:kZ;%?8(Q8BH=kO65BW?xSG&#@uU,DS*,?.+(o(#1vCS8#CHF>TlGW'b)Tq7VT9q^*^$$.:&N@@"
4604 "$&)WHtPm*5_rO0&e%K&#-30j(E4#'Zb.o/(Tpm$>K'f@[PvFl,hfINTNU6u'0pao7%XUp9]5.>%h`8_=VYbxuel.NTSsJfLacFu3B'lQSu/m6-Oqem8T+oE--$0a/k]uj9EwsG>%veR*"
4605 "hv^BFpQj:K'#SJ,sB-'#](j.Lg92rTw-*n%@/;39rrJF,l#qV%OrtBeC6/,;qB3ebNW[?,Hqj2L.1NP&GjUR=1D8QaS3Up&@*9wP?+lo7b?@%'k4`p0Z$22%K3+iCZj?XJN4Nm&+YF]u"
4606 "@-W$U%VEQ/,,>>#)D<h#`)h0:<Q6909ua+&VU%n2:cG3FJ-%@Bj-DgLr`Hw&HAKjKjseK</xKT*)B,N9X3]krc12t'pgTV(Lv-tL[xg_%=M_q7a^x?7Ubd>#%8cY#YZ?=,`Wdxu/ae&#"
4607 "w6)R89tI#6@s'(6Bf7a&?S=^ZI_kS&ai`&=tE72L_D,;^R)7[$s<Eh#c&)q.MXI%#v9ROa5FZO%sF7q7Nwb&#ptUJ:aqJe$Sl68%.D###EC><?-aF&#RNQv>o8lKN%5/$(vdfq7+ebA#"
4608 "u1p]ovUKW&Y%q]'>$1@-[xfn$7ZTp7mM,G,Ko7a&Gu%G[RMxJs[0MM%wci.LFDK)(<c`Q8N)jEIF*+?P2a8g%)$q]o2aH8C&<SibC/q,(e:v;-b#6[$NtDZ84Je2KNvB#$P5?tQ3nt(0"
4609 "d=j.LQf./Ll33+(;q3L-w=8dX$#WF&uIJ@-bfI>%:_i2B5CsR8&9Z&#=mPEnm0f`<&c)QL5uJ#%u%lJj+D-r;BoF&#4DoS97h5g)E#o:&S4weDF,9^Hoe`h*L+_a*NrLW-1pG_&2UdB8"
4610 "6e%B/:=>)N4xeW.*wft-;$'58-ESqr<b?UI(_%@[P46>#U`'6AQ]m&6/`Z>#S?YY#Vc;r7U2&326d=w&H####?TZ`*4?&.MK?LP8Vxg>$[QXc%QJv92.(Db*B)gb*BM9dM*hJMAo*c&#"
4611 "b0v=Pjer]$gG&JXDf->'StvU7505l9$AFvgYRI^&<^b68?j#q9QX4SM'RO#&sL1IM.rJfLUAj221]d##DW=m83u5;'bYx,*Sl0hL(W;;$doB&O/TQ:(Z^xBdLjL<Lni;''X.`$#8+1GD"
4612 ":k$YUWsbn8ogh6rxZ2Z9]%nd+>V#*8U_72Lh+2Q8Cj0i:6hp&$C/:p(HK>T8Y[gHQ4`4)'$Ab(Nof%V'8hL&#<NEdtg(n'=S1A(Q1/I&4([%dM`,Iu'1:_hL>SfD07&6D<fp8dHM7/g+"
4613 "tlPN9J*rKaPct&?'uBCem^jn%9_K)<,C5K3s=5g&GmJb*[SYq7K;TRLGCsM-$$;S%:Y@r7AK0pprpL<Lrh,q7e/%KWK:50I^+m'vi`3?%Zp+<-d+$L-Sv:@.o19n$s0&39;kn;S%BSq*"
4614 "$3WoJSCLweV[aZ'MQIjO<7;X-X;&+dMLvu#^UsGEC9WEc[X(wI7#2.(F0jV*eZf<-Qv3J-c+J5AlrB#$p(H68LvEA'q3n0#m,[`*8Ft)FcYgEud]CWfm68,(aLA$@EFTgLXoBq/UPlp7"
4615 ":d[/;r_ix=:TF`S5H-b<LI&HY(K=h#)]Lk$K14lVfm:x$H<3^Ql<M`$OhapBnkup'D#L$Pb_`N*g]2e;X/Dtg,bsj&K#2[-:iYr'_wgH)NUIR8a1n#S?Yej'h8^58UbZd+^FKD*T@;6A"
4616 "7aQC[K8d-(v6GI$x:T<&'Gp5Uf>@M.*J:;$-rv29'M]8qMv-tLp,'886iaC=Hb*YJoKJ,(j%K=H`K.v9HggqBIiZu'QvBT.#=)0ukruV&.)3=(^1`o*Pj4<-<aN((^7('#Z0wK#5GX@7"
4617 "u][`*S^43933A4rl][`*O4CgLEl]v$1Q3AeF37dbXk,.)vj#x'd`;qgbQR%FW,2(?LO=s%Sc68%NP'##Aotl8x=BE#j1UD([3$M(]UI2LX3RpKN@;/#f'f/&_mt&F)XdF<9t4)Qa.*kT"
4618 "LwQ'(TTB9.xH'>#MJ+gLq9-##@HuZPN0]u:h7.T..G:;$/Usj(T7`Q8tT72LnYl<-qx8;-HV7Q-&Xdx%1a,hC=0u+HlsV>nuIQL-5<N?)NBS)QN*_I,?&)2'IM%L3I)X((e/dl2&8'<M"
4619 ":^#M*Q+[T.Xri.LYS3v%fF`68h;b-X[/En'CR.q7E)p'/kle2HM,u;^%OKC-N+Ll%F9CF<Nf'^#t2L,;27W:0O@6##U6W7:$rJfLWHj$#)woqBefIZ.PK<b*t7ed;p*_m;4ExK#h@&]>"
4620 "_>@kXQtMacfD.m-VAb8;IReM3$wf0''hra*so568'Ip&vRs849'MRYSp%:t:h5qSgwpEr$B>Q,;s(C#$)`svQuF$##-D,##,g68@2[T;.XSdN9Qe)rpt._K-#5wF)sP'##p#C0c%-Gb%"
4621 "hd+<-j'Ai*x&&HMkT]C'OSl##5RG[JXaHN;d'uA#x._U;.`PU@(Z3dt4r152@:v,'R.Sj'w#0<-;kPI)FfJ&#AYJ&#//)>-k=m=*XnK$>=)72L]0I%>.G690a:$##<,);?;72#?x9+d;"
4622 "^V'9;jY@;)br#q^YQpx:X#Te$Z^'=-=bGhLf:D6&bNwZ9-ZD#n^9HhLMr5G;']d&6'wYmTFmL<LD)F^%[tC'8;+9E#C$g%#5Y>q9wI>P(9mI[>kC-ekLC/R&CH+s'B;K-M6$EB%is00:"
4623 "+A4[7xks.LrNk0&E)wILYF@2L'0Nb$+pv<(2.768/FrY&h$^3i&@+G%JT'<-,v`3;_)I9M^AE]CN?Cl2AZg+%4iTpT3<n-&%H%b<FDj2M<hH=&Eh<2Len$b*aTX=-8QxN)k11IM1c^j%"
4624 "9s<L<NFSo)B?+<-(GxsF,^-Eh@$4dXhN$+#rxK8'je'D7k`e;)2pYwPA'_p9&@^18ml1^[@g4t*[JOa*[=Qp7(qJ_oOL^('7fB&Hq-:sf,sNj8xq^>$U4O]GKx'm9)b@p7YsvK3w^YR-"
4625 "CdQ*:Ir<($u&)#(&?L9Rg3H)4fiEp^iI9O8KnTj,]H?D*r7'M;PwZ9K0E^k&-cpI;.p/6_vwoFMV<->#%Xi.LxVnrU(4&8/P+:hLSKj$#U%]49t'I:rgMi'FL@a:0Y-uA[39',(vbma*"
4626 "hU%<-SRF`Tt:542R_VV$p@[p8DV[A,?1839FWdF<TddF<9Ah-6&9tWoDlh]&1SpGMq>Ti1O*H&#(AL8[_P%.M>v^-))qOT*F5Cq0`Ye%+$B6i:7@0IX<N+T+0MlMBPQ*Vj>SsD<U4JHY"
4627 "8kD2)2fU/M#$e.)T4,_=8hLim[&);?UkK'-x?'(:siIfL<$pFM`i<?%W(mGDHM%>iWP,##P`%/L<eXi:@Z9C.7o=@(pXdAO/NLQ8lPl+HPOQa8wD8=^GlPa8TKI1CjhsCTSLJM'/Wl>-"
4628 "S(qw%sf/@%#B6;/U7K]uZbi^Oc^2n<bhPmUkMw>%t<)'mEVE''n`WnJra$^TKvX5B>;_aSEK',(hwa0:i4G?.Bci.(X[?b*($,=-n<.Q%`(X=?+@Am*Js0&=3bh8K]mL<LoNs'6,'85`"
4629 "0?t/'_U59@]ddF<#LdF<eWdF<OuN/45rY<-L@&#+fm>69=Lb,OcZV/);TTm8VI;?%OtJ<(b4mq7M6:u?KRdF<gR@2L=FNU-<b[(9c/ML3m;Z[$oF3g)GAWqpARc=<ROu7cL5l;-[A]%/"
4630 "+fsd;l#SafT/f*W]0=O'$(Tb<[)*@e775R-:Yob%g*>l*:xP?Yb.5)%w_I?7uk5JC+FS(m#i'k.'a0i)9<7b'fs'59hq$*5Uhv##pi^8+hIEBF`nvo`;'l0.^S1<-wUK2/Coh58KKhLj"
4631 "M=SO*rfO`+qC`W-On.=AJ56>>i2@2LH6A:&5q`?9I3@@'04&p2/LVa*T-4<-i3;M9UvZd+N7>b*eIwg:CC)c<>nO&#<IGe;__.thjZl<%w(Wk2xmp4Q@I#I9,DF]u7-P=.-_:YJ]aS@V"
4632 "?6*C()dOp7:WL,b&3Rg/.cmM9&r^>$(>.Z-I&J(Q0Hd5Q%7Co-b`-c<N(6r@ip+AurK<m86QIth*#v;-OBqi+L7wDE-Ir8K['m+DDSLwK&/.?-V%U_%3:qKNu$_b*B-kp7NaD'QdWQPK"
4633 "Yq[@>P)hI;*_F]u`Rb[.j8_Q/<&>uu+VsH$sM9TA%?)(vmJ80),P7E>)tjD%2L=-t#fK[%`v=Q8<FfNkgg^oIbah*#8/Qt$F&:K*-(N/'+1vMB,u()-a.VUU*#[e%gAAO(S>WlA2);Sa"
4634 ">gXm8YB`1d@K#n]76-a$U,mF<fX]idqd)<3,]J7JmW4`6]uks=4-72L(jEk+:bJ0M^q-8Dm_Z?0olP1C9Sa&H[d&c$ooQUj]Exd*3ZM@-WGW2%s',B-_M%>%Ul:#/'xoFM9QX-$.QN'>"
4635 "[%$Z$uF6pA6Ki2O5:8w*vP1<-1`[G,)-m#>0`P&#eb#.3i)rtB61(o'$?X3B</R90;eZ]%Ncq;-Tl]#F>2Qft^ae_5tKL9MUe9b*sLEQ95C&`=G?@Mj=wh*'3E>=-<)Gt*Iw)'QG:`@I"
4636 "wOf7&]1i'S01B+Ev/Nac#9S;=;YQpg_6U`*kVY39xK,[/6Aj7:'1Bm-_1EYfa1+o&o4hp7KN_Q(OlIo@S%;jVdn0'1<Vc52=u`3^o-n1'g4v58Hj&6_t7$##?M)c<$bgQ_'SY((-xkA#"
4637 "Y(,p'H9rIVY-b,'%bCPF7.J<Up^,(dU1VY*5#WkTU>h19w,WQhLI)3S#f$2(eb,jr*b;3Vw]*7NH%$c4Vs,eD9>XW8?N]o+(*pgC%/72LV-u<Hp,3@e^9UB1J+ak9-TN/mhKPg+AJYd$"
4638 "MlvAF_jCK*.O-^(63adMT->W%iewS8W6m2rtCpo'RS1R84=@paTKt)>=%&1[)*vp'u+x,VrwN;&]kuO9JDbg=pO$J*.jVe;u'm0dr9l,<*wMK*Oe=g8lV_KEBFkO'oU]^=[-792#ok,)"
4639 "i]lR8qQ2oA8wcRCZ^7w/Njh;?.stX?Q1>S1q4Bn$)K1<-rGdO'$Wr.Lc.CG)$/*JL4tNR/,SVO3,aUw'DJN:)Ss;wGn9A32ijw%FL+Z0Fn.U9;reSq)bmI32U==5ALuG&#Vf1398/pVo"
4640 "1*c-(aY168o<`JsSbk-,1N;$>0:OUas(3:8Z972LSfF8eb=c-;>SPw7.6hn3m`9^Xkn(r.qS[0;T%&Qc=+STRxX'q1BNk3&*eu2;&8q$&x>Q#Q7^Tf+6<(d%ZVmj2bDi%.3L2n+4W'$P"
4641 "iDDG)g,r%+?,$@?uou5tSe2aN_AQU*<h`e-GI7)?OK2A.d7_c)?wQ5AS@DL3r#7fSkgl6-++D:'A,uq7SvlB$pcpH'q3n0#_%dY#xCpr-l<F0NR@-##FEV6NTF6##$l84N1w?AO>'IAO"
4642 "URQ##V^Fv-XFbGM7Fl(N<3DhLGF%q.1rC$#:T__&Pi68%0xi_&[qFJ(77j_&JWoF.V735&T,[R*:xFR*K5>>#`bW-?4Ne_&6Ne_&6Ne_&n`kr-#GJcM6X;uM6X;uM(.a..^2TkL%oR(#"
4643 ";u.T%fAr%4tJ8&><1=GHZ_+m9/#H1F^R#SC#*N=BA9(D?v[UiFY>>^8p,KKF.W]L29uLkLlu/+4T<XoIB&hx=T1PcDaB&;HH+-AFr?(m9HZV)FKS8JCw;SD=6[^/DZUL`EUDf]GGlG&>"
4644 "w$)F./^n3+rlo+DB;5sIYGNk+i1t-69Jg--0pao7Sm#K)pdHW&;LuDNH@H>#/X-TI(;P>#,Gc>#0Su>#4`1?#8lC?#<xU?#@.i?#D:%@#HF7@#LRI@#P_[@#Tkn@#Xw*A#]-=A#a9OA#"
4645 "d<F&#*;G##.GY##2Sl##6`($#:l:$#>xL$#B.`$#F:r$#JF.%#NR@%#R_R%#Vke%#Zww%#_-4&#3^Rh%Sflr-k'MS.o?.5/sWel/wpEM0%3'/1)K^f1-d>G21&v(35>V`39V7A4=onx4"
4646 "A1OY5EI0;6Ibgr6M$HS7Q<)58C5w,;WoA*#[%T*#`1g*#d=#+#hI5+#lUG+#pbY+#tnl+#x$),#&1;,#*=M,#.I`,#2Ur,#6b.-#;w[H#iQtA#m^0B#qjBB#uvTB##-hB#'9$C#+E6C#"
4647 "/QHC#3^ZC#7jmC#;v)D#?,<D#C8ND#GDaD#KPsD#O]/E#g1A5#KA*1#gC17#MGd;#8(02#L-d3#rWM4#Hga1#,<w0#T.j<#O#'2#CYN1#qa^:#_4m3#o@/=#eG8=#t8J5#`+78#4uI-#"
4648 "m3B2#SB[8#Q0@8#i[*9#iOn8#1Nm;#^sN9#qh<9#:=x-#P;K2#$%X9#bC+.#Rg;<#mN=.#MTF.#RZO.#2?)4#Y#(/#[)1/#b;L/#dAU/#0Sv;#lY$0#n`-0#sf60#(F24#wrH0#%/e0#"
4649 "TmD<#%JSMFove:CTBEXI:<eh2g)B,3h2^G3i;#d3jD>)4kMYD4lVu`4m`:&5niUA5@(A5BA1]PBB:xlBCC=2CDLXMCEUtiCf&0g2'tN?PGT4CPGT4CPGT4CPGT4CPGT4CPGT4CPGT4CP"
4650 "GT4CPGT4CPGT4CPGT4CPGT4CPGT4CP-qekC`.9kEg^+F$kwViFJTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5KTB&5o,^<-28ZI'O?;xp"
4651 "O?;xpO?;xpO?;xpO?;xpO?;xpO?;xpO?;xpO?;xpO?;xpO?;xpO?;xpO?;xpO?;xp;7q-#lLYI:xvD=#";
4652
4653static const char* GetDefaultCompressedFontDataTTFBase85()
4654{
4655 return proggy_clean_ttf_compressed_data_base85;
4656}
4657
4658#endif // #ifndef IMGUI_DISABLE
id
uintptr_t id
Definition Interpreter.cc:31
g
int g
Definition ScopedAssign_test.cc:20
t
TclObject t
Definition TclObject_test.cc:265
p4
mat4 p4(vec4(1, 2, 3, 4), vec4(3, 4, 5, 6), vec4(5, 0, 7, 8), vec4(7, 8, 9, 0))
p3
mat3 p3(vec3(1, 2, 3), vec3(4, 5, 6), vec3(7, 0, 9))
w3
vec3 w3(-1, -2, 2)
w4
vec4 w4(-1, 2, 2, -6)
ImFormatString
int ImFormatString(char *buf, size_t buf_size, const char *fmt,...)
Definition imgui.cc:2092
ImAlphaBlendColors
IM_MSVC_RUNTIME_CHECKS_RESTORE IMGUI_API ImU32 ImAlphaBlendColors(ImU32 col_a, ImU32 col_b)
Definition imgui.cc:2529
ImTriangleContainsPoint
bool ImTriangleContainsPoint(const ImVec2 &a, const ImVec2 &b, const ImVec2 &c, const ImVec2 &p)
Definition imgui.cc:1911
ImTextCharFromUtf8
IM_MSVC_RUNTIME_CHECKS_OFF int ImTextCharFromUtf8(unsigned int *out_char, const char *in_text, const char *in_text_end)
Definition imgui.cc:2328
ImFileLoadToMemory
void * ImFileLoadToMemory(const char *filename, const char *mode, size_t *out_file_size, int padding_bytes)
Definition imgui.cc:2280
IM_STATIC_ASSERT
IM_STATIC_ASSERT(ImGuiKey_NamedKey_COUNT==IM_ARRAYSIZE(GKeyNames))
ImDrawCmd_HeaderCopy
#define ImDrawCmd_HeaderCopy(CMD_DST, CMD_SRC)
Definition imgui_draw.cc:498
stb__in4
#define stb__in4(x)
Definition imgui_draw.cc:4471
FONT_ATLAS_DEFAULT_TEX_DATA_H
const int FONT_ATLAS_DEFAULT_TEX_DATA_H
Definition imgui_draw.cc:2352
ImBezierCubicCalc
ImVec2 ImBezierCubicCalc(const ImVec2 &p1, const ImVec2 &p2, const ImVec2 &p3, const ImVec2 &p4, float t)
Definition imgui_draw.cc:1258
ImFontAtlasBuildSetupFont
void ImFontAtlasBuildSetupFont(ImFontAtlas *atlas, ImFont *font, ImFontConfig *font_config, float ascent, float descent)
Definition imgui_draw.cc:3057
IM_FIXNORMAL2F
#define IM_FIXNORMAL2F(VX, VY)
Definition imgui_draw.cc:723
ImFontAtlasBuildRender32bppRectFromString
void ImFontAtlasBuildRender32bppRectFromString(ImFontAtlas *atlas, int x, int y, int w, int h, const char *in_str, char in_marker_char, unsigned int in_marker_pixel_value)
Definition imgui_draw.cc:3110
stb__in2
#define stb__in2(x)
Definition imgui_draw.cc:4469
ImFontAtlasBuildMultiplyCalcLookupTable
void ImFontAtlasBuildMultiplyCalcLookupTable(unsigned char out_table[256], float in_brighten_factor)
Definition imgui_draw.cc:2715
ImFontAtlasBuildMultiplyRectAlpha8
void ImFontAtlasBuildMultiplyRectAlpha8(const unsigned char table[256], unsigned char *pixels, int x, int y, int w, int h, int stride)
Definition imgui_draw.cc:2724
ImBezierQuadraticCalc
ImVec2 ImBezierQuadraticCalc(const ImVec2 &p1, const ImVec2 &p2, const ImVec2 &p3, float t)
Definition imgui_draw.cc:1268
IM_NORMALIZE2F_OVER_ZERO
#define IM_NORMALIZE2F_OVER_ZERO(VX, VY)
Definition imgui_draw.cc:721
ImFontAtlasUpdateConfigDataPointers
void ImFontAtlasUpdateConfigDataPointers(ImFontAtlas *atlas)
Definition imgui_draw.cc:3043
ImFontAtlasBuildInit
void ImFontAtlasBuildInit(ImFontAtlas *atlas)
Definition imgui_draw.cc:3212
ImDrawCmd_HeaderCompare
#define ImDrawCmd_HeaderCompare(CMD_LHS, CMD_RHS)
Definition imgui_draw.cc:497
ImDrawCmd_AreSequentialIdxOffset
#define ImDrawCmd_AreSequentialIdxOffset(CMD_0, CMD_1)
Definition imgui_draw.cc:499
ImFontAtlasBuildRender8bppRectFromString
void ImFontAtlasBuildRender8bppRectFromString(ImFontAtlas *atlas, int x, int y, int w, int h, const char *in_str, char in_marker_char, unsigned char in_marker_pixel_value)
Definition imgui_draw.cc:3100
stb__in3
#define stb__in3(x)
Definition imgui_draw.cc:4470
ImFontAtlasBuildFinish
void ImFontAtlasBuildFinish(ImFontAtlas *atlas)
Definition imgui_draw.cc:3240
ImFontAtlasBuildPackCustomRects
void ImFontAtlasBuildPackCustomRects(ImFontAtlas *atlas, void *stbrp_context_opaque)
Definition imgui_draw.cc:3070
FONT_ATLAS_DEFAULT_TEX_DATA_W
const int FONT_ATLAS_DEFAULT_TEX_DATA_W
Definition imgui_draw.cc:2351
ImTriangulatorNodeType
ImTriangulatorNodeType
Definition imgui_draw.cc:1733
ImTriangulatorNodeType_Ear
@ ImTriangulatorNodeType_Ear
Definition imgui_draw.cc:1735
ImTriangulatorNodeType_Reflex
@ ImTriangulatorNodeType_Reflex
Definition imgui_draw.cc:1736
ImTriangulatorNodeType_Convex
@ ImTriangulatorNodeType_Convex
Definition imgui_draw.cc:1734
gl::length
T length(const vecN< N, T > &x)
Definition gl_vec.hh:376
gl::min
constexpr vecN< N, T > min(const vecN< N, T > &x, const vecN< N, T > &y)
Definition gl_vec.hh:302
gl::max
constexpr vecN< N, T > max(const vecN< N, T > &x, const vecN< N, T > &y)
Definition gl_vec.hh:320
gl::scale
constexpr mat4 scale(const vec3 &xyz)
Definition gl_transform.hh:19
utf8::unchecked::size
size_t size(std::string_view utf8)
Definition utf8_unchecked.hh:227
ImTriangulatorNodeSpan::Data
ImTriangulatorNode ** Data
Definition imgui_draw.cc:1752
ImTriangulatorNodeSpan::push_back
void push_back(ImTriangulatorNode *node)
Definition imgui_draw.cc:1755
ImTriangulatorNodeSpan::find_erase_unsorted
void find_erase_unsorted(int idx)
Definition imgui_draw.cc:1756
ImTriangulatorNode::Next
ImTriangulatorNode * Next
Definition imgui_draw.cc:1744
ImTriangulatorNode::Type
ImTriangulatorNodeType Type
Definition imgui_draw.cc:1741
ImTriangulatorNode::Prev
ImTriangulatorNode * Prev
Definition imgui_draw.cc:1745
ImTriangulator::_Reflexes
ImTriangulatorNodeSpan _Reflexes
Definition imgui_draw.cc:1779
ImTriangulator::_Nodes
ImTriangulatorNode * _Nodes
Definition imgui_draw.cc:1777
ImTriangulator::IsEar
bool IsEar(int i0, int i1, int i2, const ImVec2 &v0, const ImVec2 &v1, const ImVec2 &v2) const
Definition imgui_draw.cc:1897
ImTriangulator::EstimateTriangleCount
static int EstimateTriangleCount(int points_count)
Definition imgui_draw.cc:1761
ImTriangulator::BuildNodes
void BuildNodes(const ImVec2 *points, int points_count)
Definition imgui_draw.cc:1797
ImTriangulator::ReclassifyNode
void ReclassifyNode(ImTriangulatorNode *node)
Definition imgui_draw.cc:1910
ImTriangulator::EstimateScratchBufferSize
static int EstimateScratchBufferSize(int points_count)
Definition imgui_draw.cc:1762
ImTriangulator::_Ears
ImTriangulatorNodeSpan _Ears
Definition imgui_draw.cc:1778
ImTriangulator::Init
void Init(const ImVec2 *points, int points_count, void *scratch_buffer)
Definition imgui_draw.cc:1785
ImTriangulator::GetNextTriangle
void GetNextTriangle(unsigned int out_triangle[3])
Definition imgui_draw.cc:1837
Generated on Mon Sep 16 2024 20:13:44 for openMSX by doxygen 1.9.8