VR-Vantage 2.3 API Documentation
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
imgui.h
Go to the documentation of this file.
1 // dear imgui, v1.51
2 // (headers)
3 
4 // See imgui.cpp file for documentation.
5 // See ImGui::ShowTestWindow() in imgui_demo.cpp for demo code.
6 // Read 'Programmer guide' in imgui.cpp for notes on how to setup ImGui in your codebase.
7 // Get latest version at https://github.com/ocornut/imgui
8 
9 #pragma once
10 
11 #if !defined(IMGUI_DISABLE_INCLUDE_IMCONFIG_H) || defined(IMGUI_INCLUDE_IMCONFIG_H)
12 #include "imconfig.h" // User-editable configuration file
13 #endif
14 #include <float.h> // FLT_MAX
15 #include <stdarg.h> // va_list
16 #include <stddef.h> // ptrdiff_t, NULL
17 #include <string.h> // memset, memmove, memcpy, strlen, strchr, strcpy, strcmp
18 
19 #define IMGUI_VERSION "1.51"
20 
21 // Define attributes of all API symbols declarations, e.g. for DLL under Windows.
22 #ifndef IMGUI_API
23 #define IMGUI_API
24 #endif
25 
26 // Define assertion handler.
27 #ifndef IM_ASSERT
28 #include <assert.h>
29 #define IM_ASSERT(_EXPR) assert(_EXPR)
30 #endif
31 
32 // Some compilers support applying printf-style warnings to user functions.
33 #if defined(__clang__) || defined(__GNUC__)
34 #define IM_PRINTFARGS(FMT) __attribute__((format(printf, FMT, (FMT+1))))
35 #else
36 #define IM_PRINTFARGS(FMT)
37 #endif
38 
39 #if defined(__clang__)
40 #pragma clang diagnostic push
41 #pragma clang diagnostic ignored "-Wold-style-cast"
42 #endif
43 
44 // Forward declarations
45 struct ImDrawChannel; // Temporary storage for outputting drawing commands out of order, used by ImDrawList::ChannelsSplit()
46 struct ImDrawCmd; // A single draw command within a parent ImDrawList (generally maps to 1 GPU draw call)
47 struct ImDrawData; // All draw command lists required to render the frame
48 struct ImDrawList; // A single draw command list (generally one per window)
49 struct ImDrawVert; // A single vertex (20 bytes by default, override layout with IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT)
50 struct ImFont; // Runtime data for a single font within a parent ImFontAtlas
51 struct ImFontAtlas; // Runtime data for multiple fonts, bake multiple fonts into a single texture, TTF/OTF font loader
52 struct ImFontConfig; // Configuration data when adding a font or merging fonts
53 struct ImColor; // Helper functions to create a color that can be converted to either u32 or float4
54 struct ImGuiIO; // Main configuration and I/O between your application and ImGui
55 struct ImGuiOnceUponAFrame; // Simple helper for running a block of code not more than once a frame, used by IMGUI_ONCE_UPON_A_FRAME macro
56 struct ImGuiStorage; // Simple custom key value storage
57 struct ImGuiStyle; // Runtime data for styling/colors
58 struct ImGuiTextFilter; // Parse and apply text filters. In format "aaaaa[,bbbb][,ccccc]"
59 struct ImGuiTextBuffer; // Text buffer for logging/accumulating text
60 struct ImGuiTextEditCallbackData; // Shared state of ImGui::InputText() when using custom ImGuiTextEditCallback (rare/advanced use)
61 struct ImGuiSizeConstraintCallbackData;// Structure used to constraint window size in custom ways when using custom ImGuiSizeConstraintCallback (rare/advanced use)
62 struct ImGuiListClipper; // Helper to manually clip large list of items
63 struct ImGuiContext; // ImGui context (opaque)
64 
65 // Typedefs and Enumerations (declared as int for compatibility and to not pollute the top of this file)
66 typedef unsigned int ImU32; // 32-bit unsigned integer (typically used to store packed colors)
67 typedef unsigned int ImGuiID; // unique ID used by widgets (typically hashed from a stack of string)
68 typedef unsigned short ImWchar; // character for keyboard input/display
69 typedef void* ImTextureID; // user data to identify a texture (this is whatever to you want it to be! read the FAQ about ImTextureID in imgui.cpp)
70 typedef int ImGuiCol; // a color identifier for styling // enum ImGuiCol_
71 typedef int ImGuiStyleVar; // a variable identifier for styling // enum ImGuiStyleVar_
72 typedef int ImGuiKey; // a key identifier (ImGui-side enum) // enum ImGuiKey_
73 typedef int ImGuiColorEditFlags; // color edit flags for Color*() // enum ImGuiColorEditFlags_
74 typedef int ImGuiMouseCursor; // a mouse cursor identifier // enum ImGuiMouseCursor_
75 typedef int ImGuiWindowFlags; // window flags for Begin*() // enum ImGuiWindowFlags_
76 typedef int ImGuiCond; // condition flags for Set*() // enum ImGuiCond_
77 typedef int ImGuiColumnsFlags; // flags for *Columns*() // enum ImGuiColumnsFlags_
78 typedef int ImGuiInputTextFlags; // flags for InputText*() // enum ImGuiInputTextFlags_
79 typedef int ImGuiSelectableFlags; // flags for Selectable() // enum ImGuiSelectableFlags_
80 typedef int ImGuiTreeNodeFlags; // flags for TreeNode*(), Collapsing*() // enum ImGuiTreeNodeFlags_
81 typedef int (*ImGuiTextEditCallback)(ImGuiTextEditCallbackData *data);
82 typedef void (*ImGuiSizeConstraintCallback)(ImGuiSizeConstraintCallbackData* data);
83 #ifdef _MSC_VER
84 typedef unsigned __int64 ImU64; // 64-bit unsigned integer
85 #else
86 typedef unsigned long long ImU64; // 64-bit unsigned integer
87 #endif
88 
89 // Others helpers at bottom of the file:
90 // class ImVector<> // Lightweight std::vector like class.
91 // IMGUI_ONCE_UPON_A_FRAME // Execute a block of code once per frame only (convenient for creating UI within deep-nested code that runs multiple times)
92 
93 struct ImVec2
94 {
95  float x, y;
96  ImVec2() { x = y = 0.0f; }
97  ImVec2(float _x, float _y) { x = _x; y = _y; }
98 #ifdef IM_VEC2_CLASS_EXTRA // Define constructor and implicit cast operators in imconfig.h to convert back<>forth from your math types and ImVec2.
99  IM_VEC2_CLASS_EXTRA
100 #endif
101 };
102 
103 struct ImVec4
104 {
105  float x, y, z, w;
106  ImVec4() { x = y = z = w = 0.0f; }
107  ImVec4(float _x, float _y, float _z, float _w) { x = _x; y = _y; z = _z; w = _w; }
108 #ifdef IM_VEC4_CLASS_EXTRA // Define constructor and implicit cast operators in imconfig.h to convert back<>forth from your math types and ImVec4.
109  IM_VEC4_CLASS_EXTRA
110 #endif
111 };
112 
113 // ImGui end-user API
114 // In a namespace so that user can add extra functions in a separate file (e.g. Value() helpers for your vector or common types)
115 namespace ImGui
116 {
117  // Main
118  IMGUI_API ImGuiIO& GetIO();
119  IMGUI_API ImGuiStyle& GetStyle();
120  IMGUI_API ImDrawData* GetDrawData(); // same value as passed to your io.RenderDrawListsFn() function. valid after Render() and until the next call to NewFrame()
121  IMGUI_API void NewFrame(); // start a new ImGui frame, you can submit any command from this point until NewFrame()/Render().
122  IMGUI_API void Render(); // ends the ImGui frame, finalize rendering data, then call your io.RenderDrawListsFn() function if set.
123  IMGUI_API void Shutdown();
124 
125  // Demo/Debug/Info
126  IMGUI_API void ShowTestWindow(bool* p_open = NULL); // create demo/test window. demonstrate most ImGui features. call this to learn about the library! try to make it always available in your application!
127  IMGUI_API void ShowMetricsWindow(bool* p_open = NULL); // create metrics window. display ImGui internals: browse window list, draw commands, individual vertices, basic internal state, etc.
128  IMGUI_API void ShowStyleEditor(ImGuiStyle* ref = NULL); // add style editor block (not a window). you can pass in a reference ImGuiStyle structure to compare to, revert to and save to (else it uses the default style)
129  IMGUI_API void ShowUserGuide(); // add basic help/info block (not a window): how to manipulate ImGui as a end-user (mouse/keyboard controls).
130 
131  // Window
132  IMGUI_API bool Begin(const char* name, bool* p_open = NULL, ImGuiWindowFlags flags = 0); // push window to the stack and start appending to it. see .cpp for details. return false when window is collapsed, so you can early out in your code. 'bool* p_open' creates a widget on the upper-right to close the window (which sets your bool to false).
133  IMGUI_API bool Begin(const char* name, bool* p_open, const ImVec2& size_on_first_use, float bg_alpha = -1.0f, ImGuiWindowFlags flags = 0); // OBSOLETE. this is the older/longer API. the extra parameters aren't very relevant. call SetNextWindowSize() instead if you want to set a window size. For regular windows, 'size_on_first_use' only applies to the first time EVER the window is created and probably not what you want! might obsolete this API eventually.
134  IMGUI_API void End(); // finish appending to current window, pop it off the window stack.
135  IMGUI_API bool BeginChild(const char* str_id, const ImVec2& size = ImVec2(0,0), bool border = false, ImGuiWindowFlags extra_flags = 0); // begin a scrolling region. size==0.0f: use remaining window size, size<0.0f: use remaining window size minus abs(size). size>0.0f: fixed size. each axis can use a different mode, e.g. ImVec2(0,400).
136  IMGUI_API bool BeginChild(ImGuiID id, const ImVec2& size = ImVec2(0,0), bool border = false, ImGuiWindowFlags extra_flags = 0); // "
137  IMGUI_API void EndChild();
138  IMGUI_API ImVec2 GetContentRegionMax(); // current content boundaries (typically window boundaries including scrolling, or current column boundaries), in windows coordinates
139  IMGUI_API ImVec2 GetContentRegionAvail(); // == GetContentRegionMax() - GetCursorPos()
140  IMGUI_API float GetContentRegionAvailWidth(); //
141  IMGUI_API ImVec2 GetWindowContentRegionMin(); // content boundaries min (roughly (0,0)-Scroll), in window coordinates
142  IMGUI_API ImVec2 GetWindowContentRegionMax(); // content boundaries max (roughly (0,0)+Size-Scroll) where Size can be override with SetNextWindowContentSize(), in window coordinates
143  IMGUI_API float GetWindowContentRegionWidth(); //
144  IMGUI_API ImDrawList* GetWindowDrawList(); // get rendering command-list if you want to append your own draw primitives
145  IMGUI_API ImVec2 GetWindowPos(); // get current window position in screen space (useful if you want to do your own drawing via the DrawList api)
146  IMGUI_API ImVec2 GetWindowSize(); // get current window size
147  IMGUI_API float GetWindowWidth();
148  IMGUI_API float GetWindowHeight();
149  IMGUI_API bool IsWindowCollapsed();
150  IMGUI_API void SetWindowFontScale(float scale); // per-window font scale. Adjust IO.FontGlobalScale if you want to scale all windows
151 
152  IMGUI_API void SetNextWindowPos(const ImVec2& pos, ImGuiCond cond = 0); // set next window position. call before Begin()
153  IMGUI_API void SetNextWindowPosCenter(ImGuiCond cond = 0); // set next window position to be centered on screen. call before Begin()
154  IMGUI_API void SetNextWindowSize(const ImVec2& size, ImGuiCond cond = 0); // set next window size. set axis to 0.0f to force an auto-fit on this axis. call before Begin()
155  IMGUI_API void SetNextWindowSizeConstraints(const ImVec2& size_min, const ImVec2& size_max, ImGuiSizeConstraintCallback custom_callback = NULL, void* custom_callback_data = NULL); // set next window size limits. use -1,-1 on either X/Y axis to preserve the current size. Use callback to apply non-trivial programmatic constraints.
156  IMGUI_API void SetNextWindowContentSize(const ImVec2& size); // set next window content size (enforce the range of scrollbars). set axis to 0.0f to leave it automatic. call before Begin()
157  IMGUI_API void SetNextWindowContentWidth(float width); // set next window content width (enforce the range of horizontal scrollbar). call before Begin()
158  IMGUI_API void SetNextWindowCollapsed(bool collapsed, ImGuiCond cond = 0); // set next window collapsed state. call before Begin()
159  IMGUI_API void SetNextWindowFocus(); // set next window to be focused / front-most. call before Begin()
160  IMGUI_API void SetWindowPos(const ImVec2& pos, ImGuiCond cond = 0); // (not recommended) set current window position - call within Begin()/End(). prefer using SetNextWindowPos(), as this may incur tearing and side-effects.
161  IMGUI_API void SetWindowSize(const ImVec2& size, ImGuiCond cond = 0); // (not recommended) set current window size - call within Begin()/End(). set to ImVec2(0,0) to force an auto-fit. prefer using SetNextWindowSize(), as this may incur tearing and minor side-effects.
162  IMGUI_API void SetWindowCollapsed(bool collapsed, ImGuiCond cond = 0); // (not recommended) set current window collapsed state. prefer using SetNextWindowCollapsed().
163  IMGUI_API void SetWindowFocus(); // (not recommended) set current window to be focused / front-most. prefer using SetNextWindowFocus().
164  IMGUI_API void SetWindowPos(const char* name, const ImVec2& pos, ImGuiCond cond = 0); // set named window position.
165  IMGUI_API void SetWindowSize(const char* name, const ImVec2& size, ImGuiCond cond = 0); // set named window size. set axis to 0.0f to force an auto-fit on this axis.
166  IMGUI_API void SetWindowCollapsed(const char* name, bool collapsed, ImGuiCond cond = 0); // set named window collapsed state
167  IMGUI_API void SetWindowFocus(const char* name); // set named window to be focused / front-most. use NULL to remove focus.
168 
169  IMGUI_API float GetScrollX(); // get scrolling amount [0..GetScrollMaxX()]
170  IMGUI_API float GetScrollY(); // get scrolling amount [0..GetScrollMaxY()]
171  IMGUI_API float GetScrollMaxX(); // get maximum scrolling amount ~~ ContentSize.X - WindowSize.X
172  IMGUI_API float GetScrollMaxY(); // get maximum scrolling amount ~~ ContentSize.Y - WindowSize.Y
173  IMGUI_API void SetScrollX(float scroll_x); // set scrolling amount [0..GetScrollMaxX()]
174  IMGUI_API void SetScrollY(float scroll_y); // set scrolling amount [0..GetScrollMaxY()]
175  IMGUI_API void SetScrollHere(float center_y_ratio = 0.5f); // adjust scrolling amount to make current cursor position visible. center_y_ratio=0.0: top, 0.5: center, 1.0: bottom.
176  IMGUI_API void SetScrollFromPosY(float pos_y, float center_y_ratio = 0.5f); // adjust scrolling amount to make given position valid. use GetCursorPos() or GetCursorStartPos()+offset to get valid positions.
177  IMGUI_API void SetKeyboardFocusHere(int offset = 0); // focus keyboard on the next widget. Use positive 'offset' to access sub components of a multiple component widget. Use negative 'offset' to access previous widgets.
178  IMGUI_API void SetStateStorage(ImGuiStorage* tree); // replace tree state storage with our own (if you want to manipulate it yourself, typically clear subsection of it)
179  IMGUI_API ImGuiStorage* GetStateStorage();
180 
181  // Parameters stacks (shared)
182  IMGUI_API void PushFont(ImFont* font); // use NULL as a shortcut to push default font
183  IMGUI_API void PopFont();
184  IMGUI_API void PushStyleColor(ImGuiCol idx, ImU32 col);
185  IMGUI_API void PushStyleColor(ImGuiCol idx, const ImVec4& col);
186  IMGUI_API void PopStyleColor(int count = 1);
187  IMGUI_API void PushStyleVar(ImGuiStyleVar idx, float val);
188  IMGUI_API void PushStyleVar(ImGuiStyleVar idx, const ImVec2& val);
189  IMGUI_API void PopStyleVar(int count = 1);
190  IMGUI_API const ImVec4& GetStyleColorVec4(ImGuiCol idx); // retrieve style color as stored in ImGuiStyle structure. use to feed back into PushStyleColor(), otherwhise use GetColorU32() to get style color + style alpha.
191  IMGUI_API ImFont* GetFont(); // get current font
192  IMGUI_API float GetFontSize(); // get current font size (= height in pixels) of current font with current scale applied
193  IMGUI_API ImVec2 GetFontTexUvWhitePixel(); // get UV coordinate for a while pixel, useful to draw custom shapes via the ImDrawList API
194  IMGUI_API ImU32 GetColorU32(ImGuiCol idx, float alpha_mul = 1.0f); // retrieve given style color with style alpha applied and optional extra alpha multiplier
195  IMGUI_API ImU32 GetColorU32(const ImVec4& col); // retrieve given color with style alpha applied
196  IMGUI_API ImU32 GetColorU32(ImU32 col); // retrieve given color with style alpha applied
197 
198  // Parameters stacks (current window)
199  IMGUI_API void PushItemWidth(float item_width); // width of items for the common item+label case, pixels. 0.0f = default to ~2/3 of windows width, >0.0f: width in pixels, <0.0f align xx pixels to the right of window (so -1.0f always align width to the right side)
200  IMGUI_API void PopItemWidth();
201  IMGUI_API float CalcItemWidth(); // width of item given pushed settings and current cursor position
202  IMGUI_API void PushTextWrapPos(float wrap_pos_x = 0.0f); // word-wrapping for Text*() commands. < 0.0f: no wrapping; 0.0f: wrap to end of window (or column); > 0.0f: wrap at 'wrap_pos_x' position in window local space
203  IMGUI_API void PopTextWrapPos();
204  IMGUI_API void PushAllowKeyboardFocus(bool v); // allow focusing using TAB/Shift-TAB, enabled by default but you can disable it for certain widgets
205  IMGUI_API void PopAllowKeyboardFocus();
206  IMGUI_API void PushButtonRepeat(bool repeat); // in 'repeat' mode, Button*() functions return repeated true in a typematic manner (uses io.KeyRepeatDelay/io.KeyRepeatRate for now). Note that you can call IsItemActive() after any Button() to tell if the button is held in the current frame.
207  IMGUI_API void PopButtonRepeat();
208 
209  // Cursor / Layout
210  IMGUI_API void Separator(); // horizontal line
211  IMGUI_API void SameLine(float pos_x = 0.0f, float spacing_w = -1.0f); // call between widgets or groups to layout them horizontally
212  IMGUI_API void NewLine(); // undo a SameLine()
213  IMGUI_API void Spacing(); // add vertical spacing
214  IMGUI_API void Dummy(const ImVec2& size); // add a dummy item of given size
215  IMGUI_API void Indent(float indent_w = 0.0f); // move content position toward the right, by style.IndentSpacing or indent_w if >0
216  IMGUI_API void Unindent(float indent_w = 0.0f); // move content position back to the left, by style.IndentSpacing or indent_w if >0
217  IMGUI_API void BeginGroup(); // lock horizontal starting position + capture group bounding box into one "item" (so you can use IsItemHovered() or layout primitives such as SameLine() on whole group, etc.)
218  IMGUI_API void EndGroup();
219  IMGUI_API ImVec2 GetCursorPos(); // cursor position is relative to window position
220  IMGUI_API float GetCursorPosX(); // "
221  IMGUI_API float GetCursorPosY(); // "
222  IMGUI_API void SetCursorPos(const ImVec2& local_pos); // "
223  IMGUI_API void SetCursorPosX(float x); // "
224  IMGUI_API void SetCursorPosY(float y); // "
225  IMGUI_API ImVec2 GetCursorStartPos(); // initial cursor position
226  IMGUI_API ImVec2 GetCursorScreenPos(); // cursor position in absolute screen coordinates [0..io.DisplaySize] (useful to work with ImDrawList API)
227  IMGUI_API void SetCursorScreenPos(const ImVec2& pos); // cursor position in absolute screen coordinates [0..io.DisplaySize]
228  IMGUI_API void AlignFirstTextHeightToWidgets(); // call once if the first item on the line is a Text() item and you want to vertically lower it to match subsequent (bigger) widgets
229  IMGUI_API float GetTextLineHeight(); // height of font == GetWindowFontSize()
230  IMGUI_API float GetTextLineHeightWithSpacing(); // distance (in pixels) between 2 consecutive lines of text == GetWindowFontSize() + GetStyle().ItemSpacing.y
231  IMGUI_API float GetItemsLineHeightWithSpacing(); // distance (in pixels) between 2 consecutive lines of standard height widgets == GetWindowFontSize() + GetStyle().FramePadding.y*2 + GetStyle().ItemSpacing.y
232 
233  // Columns
234  // You can also use SameLine(pos_x) for simplified columns. The columns API is still work-in-progress and rather lacking.
235  IMGUI_API void Columns(int count = 1, const char* id = NULL, bool border = true);
236  IMGUI_API void NextColumn(); // next column, defaults to current row or next row if the current row is finished
237  IMGUI_API int GetColumnIndex(); // get current column index
238  IMGUI_API float GetColumnWidth(int column_index = -1); // get column width (in pixels). pass -1 to use current column
239  IMGUI_API void SetColumnWidth(int column_index, float width); // set column width (in pixels). pass -1 to use current column
240  IMGUI_API float GetColumnOffset(int column_index = -1); // get position of column line (in pixels, from the left side of the contents region). pass -1 to use current column, otherwise 0..GetColumnsCount() inclusive. column 0 is typically 0.0f
241  IMGUI_API void SetColumnOffset(int column_index, float offset_x); // set position of column line (in pixels, from the left side of the contents region). pass -1 to use current column
242  IMGUI_API int GetColumnsCount();
243 
244  // ID scopes
245  // If you are creating widgets in a loop you most likely want to push a unique identifier so ImGui can differentiate them.
246  // You can also use the "##foobar" syntax within widget label to distinguish them from each others. Read "A primer on the use of labels/IDs" in the FAQ for more details.
247  IMGUI_API void PushID(const char* str_id); // push identifier into the ID stack. IDs are hash of the *entire* stack!
248  IMGUI_API void PushID(const char* str_id_begin, const char* str_id_end);
249  IMGUI_API void PushID(const void* ptr_id);
250  IMGUI_API void PushID(int int_id);
251  IMGUI_API void PopID();
252  IMGUI_API ImGuiID GetID(const char* str_id); // calculate unique ID (hash of whole ID stack + given parameter). useful if you want to query into ImGuiStorage yourself
253  IMGUI_API ImGuiID GetID(const char* str_id_begin, const char* str_id_end);
254  IMGUI_API ImGuiID GetID(const void* ptr_id);
255 
256  // Widgets
257  IMGUI_API void Text(const char* fmt, ...) IM_PRINTFARGS(1);
258  IMGUI_API void TextV(const char* fmt, va_list args);
259  IMGUI_API void TextColored(const ImVec4& col, const char* fmt, ...) IM_PRINTFARGS(2); // shortcut for PushStyleColor(ImGuiCol_Text, col); Text(fmt, ...); PopStyleColor();
260  IMGUI_API void TextColoredV(const ImVec4& col, const char* fmt, va_list args);
261  IMGUI_API void TextDisabled(const char* fmt, ...) IM_PRINTFARGS(1); // shortcut for PushStyleColor(ImGuiCol_Text, style.Colors[ImGuiCol_TextDisabled]); Text(fmt, ...); PopStyleColor();
262  IMGUI_API void TextDisabledV(const char* fmt, va_list args);
263  IMGUI_API void TextWrapped(const char* fmt, ...) IM_PRINTFARGS(1); // shortcut for PushTextWrapPos(0.0f); Text(fmt, ...); PopTextWrapPos();. Note that this won't work on an auto-resizing window if there's no other widgets to extend the window width, yoy may need to set a size using SetNextWindowSize().
264  IMGUI_API void TextWrappedV(const char* fmt, va_list args);
265  IMGUI_API void TextUnformatted(const char* text, const char* text_end = NULL); // doesn't require null terminated string if 'text_end' is specified. no copy done to any bounded stack buffer, recommended for long chunks of text
266  IMGUI_API void LabelText(const char* label, const char* fmt, ...) IM_PRINTFARGS(2); // display text+label aligned the same way as value+label widgets
267  IMGUI_API void LabelTextV(const char* label, const char* fmt, va_list args);
268  IMGUI_API void Bullet(); // draw a small circle and keep the cursor on the same line. advance cursor x position by GetTreeNodeToLabelSpacing(), same distance that TreeNode() uses
269  IMGUI_API void BulletText(const char* fmt, ...) IM_PRINTFARGS(1); // shortcut for Bullet()+Text()
270  IMGUI_API void BulletTextV(const char* fmt, va_list args);
271  IMGUI_API bool Button(const char* label, const ImVec2& size = ImVec2(0,0)); // button
272  IMGUI_API bool SmallButton(const char* label); // button with FramePadding=(0,0) to easily embed in text
273  IMGUI_API bool InvisibleButton(const char* str_id, const ImVec2& size);
274  IMGUI_API void Image(ImTextureID user_texture_id, const ImVec2& size, const ImVec2& uv0 = ImVec2(0,0), const ImVec2& uv1 = ImVec2(1,1), const ImVec4& tint_col = ImVec4(1,1,1,1), const ImVec4& border_col = ImVec4(0,0,0,0));
275  IMGUI_API bool ImageButton(ImTextureID user_texture_id, const ImVec2& size, const ImVec2& uv0 = ImVec2(0,0), const ImVec2& uv1 = ImVec2(1,1), int frame_padding = -1, const ImVec4& bg_col = ImVec4(0,0,0,0), const ImVec4& tint_col = ImVec4(1,1,1,1)); // <0 frame_padding uses default frame padding settings. 0 for no padding
276  IMGUI_API bool Checkbox(const char* label, bool* v);
277  IMGUI_API bool CheckboxFlags(const char* label, unsigned int* flags, unsigned int flags_value);
278  IMGUI_API bool RadioButton(const char* label, bool active);
279  IMGUI_API bool RadioButton(const char* label, int* v, int v_button);
280  IMGUI_API bool Combo(const char* label, int* current_item, const char* const* items, int items_count, int height_in_items = -1);
281  IMGUI_API bool Combo(const char* label, int* current_item, const char* items_separated_by_zeros, int height_in_items = -1); // separate items with \0, end item-list with \0\0
282  IMGUI_API bool Combo(const char* label, int* current_item, bool (*items_getter)(void* data, int idx, const char** out_text), void* data, int items_count, int height_in_items = -1);
283  IMGUI_API void PlotLines(const char* label, const float* values, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0,0), int stride = sizeof(float));
284  IMGUI_API void PlotLines(const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0,0));
285  IMGUI_API void PlotHistogram(const char* label, const float* values, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0,0), int stride = sizeof(float));
286  IMGUI_API void PlotHistogram(const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0,0));
287  IMGUI_API void ProgressBar(float fraction, const ImVec2& size_arg = ImVec2(-1,0), const char* overlay = NULL);
288 
289  // Widgets: Drags (tip: ctrl+click on a drag box to input with keyboard. manually input values aren't clamped, can go off-bounds)
290  // For all the Float2/Float3/Float4/Int2/Int3/Int4 versions of every functions, note that a 'float v[X]' function argument is the same as 'float* v', the array syntax is just a way to document the number of elements that are expected to be accessible. You can pass address of your first element out of a contiguous set, e.g. &myvector.x
291  IMGUI_API bool DragFloat(const char* label, float* v, float v_speed = 1.0f, float v_min = 0.0f, float v_max = 0.0f, const char* display_format = "%.3f", float power = 1.0f); // If v_min >= v_max we have no bound
292  IMGUI_API bool DragFloat2(const char* label, float v[2], float v_speed = 1.0f, float v_min = 0.0f, float v_max = 0.0f, const char* display_format = "%.3f", float power = 1.0f);
293  IMGUI_API bool DragFloat3(const char* label, float v[3], float v_speed = 1.0f, float v_min = 0.0f, float v_max = 0.0f, const char* display_format = "%.3f", float power = 1.0f);
294  IMGUI_API bool DragFloat4(const char* label, float v[4], float v_speed = 1.0f, float v_min = 0.0f, float v_max = 0.0f, const char* display_format = "%.3f", float power = 1.0f);
295  IMGUI_API bool DragFloatRange2(const char* label, float* v_current_min, float* v_current_max, float v_speed = 1.0f, float v_min = 0.0f, float v_max = 0.0f, const char* display_format = "%.3f", const char* display_format_max = NULL, float power = 1.0f);
296  IMGUI_API bool DragInt(const char* label, int* v, float v_speed = 1.0f, int v_min = 0, int v_max = 0, const char* display_format = "%.0f"); // If v_min >= v_max we have no bound
297  IMGUI_API bool DragInt2(const char* label, int v[2], float v_speed = 1.0f, int v_min = 0, int v_max = 0, const char* display_format = "%.0f");
298  IMGUI_API bool DragInt3(const char* label, int v[3], float v_speed = 1.0f, int v_min = 0, int v_max = 0, const char* display_format = "%.0f");
299  IMGUI_API bool DragInt4(const char* label, int v[4], float v_speed = 1.0f, int v_min = 0, int v_max = 0, const char* display_format = "%.0f");
300  IMGUI_API bool DragIntRange2(const char* label, int* v_current_min, int* v_current_max, float v_speed = 1.0f, int v_min = 0, int v_max = 0, const char* display_format = "%.0f", const char* display_format_max = NULL);
301 
302  // Widgets: Input with Keyboard
303  IMGUI_API bool InputText(const char* label, char* buf, size_t buf_size, ImGuiInputTextFlags flags = 0, ImGuiTextEditCallback callback = NULL, void* user_data = NULL);
304  IMGUI_API bool InputTextMultiline(const char* label, char* buf, size_t buf_size, const ImVec2& size = ImVec2(0,0), ImGuiInputTextFlags flags = 0, ImGuiTextEditCallback callback = NULL, void* user_data = NULL);
305  IMGUI_API bool InputFloat(const char* label, float* v, float step = 0.0f, float step_fast = 0.0f, int decimal_precision = -1, ImGuiInputTextFlags extra_flags = 0);
306  IMGUI_API bool InputFloat2(const char* label, float v[2], int decimal_precision = -1, ImGuiInputTextFlags extra_flags = 0);
307  IMGUI_API bool InputFloat3(const char* label, float v[3], int decimal_precision = -1, ImGuiInputTextFlags extra_flags = 0);
308  IMGUI_API bool InputFloat4(const char* label, float v[4], int decimal_precision = -1, ImGuiInputTextFlags extra_flags = 0);
309  IMGUI_API bool InputInt(const char* label, int* v, int step = 1, int step_fast = 100, ImGuiInputTextFlags extra_flags = 0);
310  IMGUI_API bool InputInt2(const char* label, int v[2], ImGuiInputTextFlags extra_flags = 0);
311  IMGUI_API bool InputInt3(const char* label, int v[3], ImGuiInputTextFlags extra_flags = 0);
312  IMGUI_API bool InputInt4(const char* label, int v[4], ImGuiInputTextFlags extra_flags = 0);
313 
314  // Widgets: Sliders (tip: ctrl+click on a slider to input with keyboard. manually input values aren't clamped, can go off-bounds)
315  IMGUI_API bool SliderFloat(const char* label, float* v, float v_min, float v_max, const char* display_format = "%.3f", float power = 1.0f); // adjust display_format to decorate the value with a prefix or a suffix for in-slider labels or unit display. Use power!=1.0 for logarithmic sliders
316  IMGUI_API bool SliderFloat2(const char* label, float v[2], float v_min, float v_max, const char* display_format = "%.3f", float power = 1.0f);
317  IMGUI_API bool SliderFloat3(const char* label, float v[3], float v_min, float v_max, const char* display_format = "%.3f", float power = 1.0f);
318  IMGUI_API bool SliderFloat4(const char* label, float v[4], float v_min, float v_max, const char* display_format = "%.3f", float power = 1.0f);
319  IMGUI_API bool SliderAngle(const char* label, float* v_rad, float v_degrees_min = -360.0f, float v_degrees_max = +360.0f);
320  IMGUI_API bool SliderInt(const char* label, int* v, int v_min, int v_max, const char* display_format = "%.0f");
321  IMGUI_API bool SliderInt2(const char* label, int v[2], int v_min, int v_max, const char* display_format = "%.0f");
322  IMGUI_API bool SliderInt3(const char* label, int v[3], int v_min, int v_max, const char* display_format = "%.0f");
323  IMGUI_API bool SliderInt4(const char* label, int v[4], int v_min, int v_max, const char* display_format = "%.0f");
324  IMGUI_API bool VSliderFloat(const char* label, const ImVec2& size, float* v, float v_min, float v_max, const char* display_format = "%.3f", float power = 1.0f);
325  IMGUI_API bool VSliderInt(const char* label, const ImVec2& size, int* v, int v_min, int v_max, const char* display_format = "%.0f");
326 
327  // Widgets: Color Editor/Picker (tip: the ColorEdit* functions have a little colored preview square that can be left-clicked to open a picker, and right-clicked to open an option menu.)
328  // Note that a 'float v[X]' function argument is the same as 'float* v', the array syntax is just a way to document the number of elements that are expected to be accessible. You can the pass the address of a first float element out of a contiguous structure, e.g. &myvector.x
329  IMGUI_API bool ColorEdit3(const char* label, float col[3], ImGuiColorEditFlags flags = 0);
330  IMGUI_API bool ColorEdit4(const char* label, float col[4], ImGuiColorEditFlags flags = 0);
331  IMGUI_API bool ColorPicker3(const char* label, float col[3], ImGuiColorEditFlags flags = 0);
332  IMGUI_API bool ColorPicker4(const char* label, float col[4], ImGuiColorEditFlags flags = 0, const float* ref_col = NULL);
333  IMGUI_API bool ColorButton(const char* desc_id, const ImVec4& col, ImGuiColorEditFlags flags = 0, ImVec2 size = ImVec2(0,0)); // display a colored square/button, hover for details, return true when pressed.
334  IMGUI_API void SetColorEditOptions(ImGuiColorEditFlags flags); // initialize current options (generally on application startup) if you want to select a default format, picker type, etc. User will be able to change many settings, unless you pass the _NoOptions flag to your calls.
335 
336  // Widgets: Trees
337  IMGUI_API bool TreeNode(const char* label); // if returning 'true' the node is open and the tree id is pushed into the id stack. user is responsible for calling TreePop().
338  IMGUI_API bool TreeNode(const char* str_id, const char* fmt, ...) IM_PRINTFARGS(2); // read the FAQ about why and how to use ID. to align arbitrary text at the same level as a TreeNode() you can use Bullet().
339  IMGUI_API bool TreeNode(const void* ptr_id, const char* fmt, ...) IM_PRINTFARGS(2); // "
340  IMGUI_API bool TreeNodeV(const char* str_id, const char* fmt, va_list args); // "
341  IMGUI_API bool TreeNodeV(const void* ptr_id, const char* fmt, va_list args); // "
342  IMGUI_API bool TreeNodeEx(const char* label, ImGuiTreeNodeFlags flags = 0);
343  IMGUI_API bool TreeNodeEx(const char* str_id, ImGuiTreeNodeFlags flags, const char* fmt, ...) IM_PRINTFARGS(3);
344  IMGUI_API bool TreeNodeEx(const void* ptr_id, ImGuiTreeNodeFlags flags, const char* fmt, ...) IM_PRINTFARGS(3);
345  IMGUI_API bool TreeNodeExV(const char* str_id, ImGuiTreeNodeFlags flags, const char* fmt, va_list args);
346  IMGUI_API bool TreeNodeExV(const void* ptr_id, ImGuiTreeNodeFlags flags, const char* fmt, va_list args);
347  IMGUI_API void TreePush(const char* str_id = NULL); // ~ Indent()+PushId(). Already called by TreeNode() when returning true, but you can call Push/Pop yourself for layout purpose
348  IMGUI_API void TreePush(const void* ptr_id = NULL); // "
349  IMGUI_API void TreePop(); // ~ Unindent()+PopId()
350  IMGUI_API void TreeAdvanceToLabelPos(); // advance cursor x position by GetTreeNodeToLabelSpacing()
351  IMGUI_API float GetTreeNodeToLabelSpacing(); // horizontal distance preceding label when using TreeNode*() or Bullet() == (g.FontSize + style.FramePadding.x*2) for a regular unframed TreeNode
352  IMGUI_API void SetNextTreeNodeOpen(bool is_open, ImGuiCond cond = 0); // set next TreeNode/CollapsingHeader open state.
353  IMGUI_API bool CollapsingHeader(const char* label, ImGuiTreeNodeFlags flags = 0); // if returning 'true' the header is open. doesn't indent nor push on ID stack. user doesn't have to call TreePop().
354  IMGUI_API bool CollapsingHeader(const char* label, bool* p_open, ImGuiTreeNodeFlags flags = 0); // when 'p_open' isn't NULL, display an additional small close button on upper right of the header
355 
356  // Widgets: Selectable / Lists
357  IMGUI_API bool Selectable(const char* label, bool selected = false, ImGuiSelectableFlags flags = 0, const ImVec2& size = ImVec2(0,0)); // size.x==0.0: use remaining width, size.x>0.0: specify width. size.y==0.0: use label height, size.y>0.0: specify height
358  IMGUI_API bool Selectable(const char* label, bool* p_selected, ImGuiSelectableFlags flags = 0, const ImVec2& size = ImVec2(0,0));
359  IMGUI_API bool ListBox(const char* label, int* current_item, const char* const* items, int items_count, int height_in_items = -1);
360  IMGUI_API bool ListBox(const char* label, int* current_item, bool (*items_getter)(void* data, int idx, const char** out_text), void* data, int items_count, int height_in_items = -1);
361  IMGUI_API bool ListBoxHeader(const char* label, const ImVec2& size = ImVec2(0,0)); // use if you want to reimplement ListBox() will custom data or interactions. make sure to call ListBoxFooter() afterwards.
362  IMGUI_API bool ListBoxHeader(const char* label, int items_count, int height_in_items = -1); // "
363  IMGUI_API void ListBoxFooter(); // terminate the scrolling region
364 
365  // Widgets: Value() Helpers. Output single value in "name: value" format (tip: freely declare more in your code to handle your types. you can add functions to the ImGui namespace)
366  IMGUI_API void Value(const char* prefix, bool b);
367  IMGUI_API void Value(const char* prefix, int v);
368  IMGUI_API void Value(const char* prefix, unsigned int v);
369  IMGUI_API void Value(const char* prefix, float v, const char* float_format = NULL);
370 
371  // Tooltips
372  IMGUI_API void SetTooltip(const char* fmt, ...) IM_PRINTFARGS(1); // set text tooltip under mouse-cursor, typically use with ImGui::IsItemHovered(). overidde any previous call to SetTooltip().
373  IMGUI_API void SetTooltipV(const char* fmt, va_list args);
374  IMGUI_API void BeginTooltip(); // begin/append a tooltip window. to create full-featured tooltip (with any kind of contents).
375  IMGUI_API void EndTooltip();
376 
377  // Menus
378  IMGUI_API bool BeginMainMenuBar(); // create and append to a full screen menu-bar. only call EndMainMenuBar() if this returns true!
379  IMGUI_API void EndMainMenuBar();
380  IMGUI_API bool BeginMenuBar(); // append to menu-bar of current window (requires ImGuiWindowFlags_MenuBar flag set). only call EndMenuBar() if this returns true!
381  IMGUI_API void EndMenuBar();
382  IMGUI_API bool BeginMenu(const char* label, bool enabled = true); // create a sub-menu entry. only call EndMenu() if this returns true!
383  IMGUI_API void EndMenu();
384  IMGUI_API bool MenuItem(const char* label, const char* shortcut = NULL, bool selected = false, bool enabled = true); // return true when activated. shortcuts are displayed for convenience but not processed by ImGui at the moment
385  IMGUI_API bool MenuItem(const char* label, const char* shortcut, bool* p_selected, bool enabled = true); // return true when activated + toggle (*p_selected) if p_selected != NULL
386 
387  // Popups
388  IMGUI_API void OpenPopup(const char* str_id); // call to mark popup as open (don't call every frame!). popups are closed when user click outside, or if CloseCurrentPopup() is called within a BeginPopup()/EndPopup() block. By default, Selectable()/MenuItem() are calling CloseCurrentPopup(). Popup identifiers are relative to the current ID-stack (so OpenPopup and BeginPopup needs to be at the same level).
389  IMGUI_API bool BeginPopup(const char* str_id); // return true if the popup is open, and you can start outputting to it. only call EndPopup() if BeginPopup() returned true!
390  IMGUI_API bool BeginPopupModal(const char* name, bool* p_open = NULL, ImGuiWindowFlags extra_flags = 0); // modal dialog (block interactions behind the modal window, can't close the modal window by clicking outside)
391  IMGUI_API bool BeginPopupContextItem(const char* str_id, int mouse_button = 1); // helper to open and begin popup when clicked on last item. read comments in .cpp!
392  IMGUI_API bool BeginPopupContextWindow(const char* str_id = NULL, int mouse_button = 1, bool also_over_items = true); // helper to open and begin popup when clicked on current window.
393  IMGUI_API bool BeginPopupContextVoid(const char* str_id = NULL, int mouse_button = 1); // helper to open and begin popup when clicked in void (no window).
394  IMGUI_API void EndPopup();
395  IMGUI_API bool IsPopupOpen(const char* str_id); // return true if the popup is open
396  IMGUI_API void CloseCurrentPopup(); // close the popup we have begin-ed into. clicking on a MenuItem or Selectable automatically close the current popup.
397 
398  // Logging: all text output from interface is redirected to tty/file/clipboard. By default, tree nodes are automatically opened during logging.
399  IMGUI_API void LogToTTY(int max_depth = -1); // start logging to tty
400  IMGUI_API void LogToFile(int max_depth = -1, const char* filename = NULL); // start logging to file
401  IMGUI_API void LogToClipboard(int max_depth = -1); // start logging to OS clipboard
402  IMGUI_API void LogFinish(); // stop logging (close file, etc.)
403  IMGUI_API void LogButtons(); // helper to display buttons for logging to tty/file/clipboard
404  IMGUI_API void LogText(const char* fmt, ...) IM_PRINTFARGS(1); // pass text data straight to log (without being displayed)
405 
406  // Clipping
407  IMGUI_API void PushClipRect(const ImVec2& clip_rect_min, const ImVec2& clip_rect_max, bool intersect_with_current_clip_rect);
408  IMGUI_API void PopClipRect();
409 
410  // Utilities
411  IMGUI_API bool IsItemHovered(); // was the last item hovered by mouse?
412  IMGUI_API bool IsItemRectHovered(); // was the last item hovered by mouse? even if another item is active or window is blocked by popup while we are hovering this
413  IMGUI_API bool IsItemActive(); // was the last item active? (e.g. button being held, text field being edited- items that don't interact will always return false)
414  IMGUI_API bool IsItemClicked(int mouse_button = 0); // was the last item clicked? (e.g. button/node just clicked on)
415  IMGUI_API bool IsItemVisible(); // was the last item visible? (aka not out of sight due to clipping/scrolling.)
416  IMGUI_API bool IsAnyItemHovered();
417  IMGUI_API bool IsAnyItemActive();
418  IMGUI_API ImVec2 GetItemRectMin(); // get bounding rect of last item in screen space
419  IMGUI_API ImVec2 GetItemRectMax(); // "
420  IMGUI_API ImVec2 GetItemRectSize(); // "
421  IMGUI_API void SetItemAllowOverlap(); // allow last item to be overlapped by a subsequent item. sometimes useful with invisible buttons, selectables, etc. to catch unused area.
422  IMGUI_API bool IsWindowFocused(); // is current window focused
423  IMGUI_API bool IsWindowHovered(); // is current window hovered and hoverable (not blocked by a popup) (differentiate child windows from each others)
424  IMGUI_API bool IsWindowRectHovered(); // is current window rectnagle hovered, disregarding of any consideration of being blocked by a popup. (unlike IsWindowHovered() this will return true even if the window is blocked because of a popup)
425  IMGUI_API bool IsRootWindowFocused(); // is current root window focused (root = top-most parent of a child, otherwise self)
426  IMGUI_API bool IsRootWindowOrAnyChildFocused(); // is current root window or any of its child (including current window) focused
427  IMGUI_API bool IsRootWindowOrAnyChildHovered(); // is current root window or any of its child (including current window) hovered and hoverable (not blocked by a popup)
428  IMGUI_API bool IsAnyWindowHovered(); // is mouse hovering any visible window
429  IMGUI_API bool IsRectVisible(const ImVec2& size); // test if rectangle (of given size, starting from cursor position) is visible / not clipped.
430  IMGUI_API bool IsRectVisible(const ImVec2& rect_min, const ImVec2& rect_max); // test if rectangle (in screen space) is visible / not clipped. to perform coarse clipping on user's side.
431  IMGUI_API float GetTime();
432  IMGUI_API int GetFrameCount();
433  IMGUI_API const char* GetStyleColorName(ImGuiCol idx);
434  IMGUI_API ImVec2 CalcItemRectClosestPoint(const ImVec2& pos, bool on_edge = false, float outward = +0.0f); // utility to find the closest point the last item bounding rectangle edge. useful to visually link items
435  IMGUI_API ImVec2 CalcTextSize(const char* text, const char* text_end = NULL, bool hide_text_after_double_hash = false, float wrap_width = -1.0f);
436  IMGUI_API void CalcListClipping(int items_count, float items_height, int* out_items_display_start, int* out_items_display_end); // calculate coarse clipping for large list of evenly sized items. Prefer using the ImGuiListClipper higher-level helper if you can.
437 
438  IMGUI_API bool BeginChildFrame(ImGuiID id, const ImVec2& size, ImGuiWindowFlags extra_flags = 0); // helper to create a child window / scrolling region that looks like a normal widget frame
439  IMGUI_API void EndChildFrame();
440 
441  IMGUI_API ImVec4 ColorConvertU32ToFloat4(ImU32 in);
442  IMGUI_API ImU32 ColorConvertFloat4ToU32(const ImVec4& in);
443  IMGUI_API void ColorConvertRGBtoHSV(float r, float g, float b, float& out_h, float& out_s, float& out_v);
444  IMGUI_API void ColorConvertHSVtoRGB(float h, float s, float v, float& out_r, float& out_g, float& out_b);
445 
446  // Inputs
447  IMGUI_API int GetKeyIndex(ImGuiKey imgui_key); // map ImGuiKey_* values into user's key index. == io.KeyMap[key]
448  IMGUI_API bool IsKeyDown(int user_key_index); // is key being held. == io.KeysDown[user_key_index]. note that imgui doesn't know the semantic of each entry of io.KeyDown[]. Use your own indices/enums according to how your backend/engine stored them into KeyDown[]!
449  IMGUI_API bool IsKeyPressed(int user_key_index, bool repeat = true); // was key pressed (went from !Down to Down). if repeat=true, uses io.KeyRepeatDelay / KeyRepeatRate
450  IMGUI_API bool IsKeyReleased(int user_key_index); // was key released (went from Down to !Down)..
451  IMGUI_API bool IsMouseDown(int button); // is mouse button held
452  IMGUI_API bool IsMouseClicked(int button, bool repeat = false); // did mouse button clicked (went from !Down to Down)
453  IMGUI_API bool IsMouseDoubleClicked(int button); // did mouse button double-clicked. a double-click returns false in IsMouseClicked(). uses io.MouseDoubleClickTime.
454  IMGUI_API bool IsMouseReleased(int button); // did mouse button released (went from Down to !Down)
455  IMGUI_API bool IsMouseDragging(int button = 0, float lock_threshold = -1.0f); // is mouse dragging. if lock_threshold < -1.0f uses io.MouseDraggingThreshold
456  IMGUI_API bool IsMouseHoveringRect(const ImVec2& r_min, const ImVec2& r_max, bool clip = true); // is mouse hovering given bounding rect (in screen space). clipped by current clipping settings. disregarding of consideration of focus/window ordering/blocked by a popup.
457  IMGUI_API ImVec2 GetMousePos(); // shortcut to ImGui::GetIO().MousePos provided by user, to be consistent with other calls
458  IMGUI_API ImVec2 GetMousePosOnOpeningCurrentPopup(); // retrieve backup of mouse positioning at the time of opening popup we have BeginPopup() into
459  IMGUI_API ImVec2 GetMouseDragDelta(int button = 0, float lock_threshold = -1.0f); // dragging amount since clicking. if lock_threshold < -1.0f uses io.MouseDraggingThreshold
460  IMGUI_API void ResetMouseDragDelta(int button = 0); //
461  IMGUI_API ImGuiMouseCursor GetMouseCursor(); // get desired cursor type, reset in ImGui::NewFrame(), this is updated during the frame. valid before Render(). If you use software rendering by setting io.MouseDrawCursor ImGui will render those for you
462  IMGUI_API void SetMouseCursor(ImGuiMouseCursor type); // set desired cursor type
463  IMGUI_API void CaptureKeyboardFromApp(bool capture = true); // manually override io.WantCaptureKeyboard flag next frame (said flag is entirely left for your application handle). e.g. force capture keyboard when your widget is being hovered.
464  IMGUI_API void CaptureMouseFromApp(bool capture = true); // manually override io.WantCaptureMouse flag next frame (said flag is entirely left for your application handle).
465 
466  // Helpers functions to access functions pointers in ImGui::GetIO()
467  IMGUI_API void* MemAlloc(size_t sz);
468  IMGUI_API void MemFree(void* ptr);
469  IMGUI_API const char* GetClipboardText();
470  IMGUI_API void SetClipboardText(const char* text);
471 
472  // Internal context access - if you want to use multiple context, share context between modules (e.g. DLL). There is a default context created and active by default.
473  // All contexts share a same ImFontAtlas by default. If you want different font atlas, you can new() them and overwrite the GetIO().Fonts variable of an ImGui context.
474  IMGUI_API const char* GetVersion();
475  IMGUI_API ImGuiContext* CreateContext(void* (*malloc_fn)(size_t) = NULL, void (*free_fn)(void*) = NULL);
476  IMGUI_API void DestroyContext(ImGuiContext* ctx);
477  IMGUI_API ImGuiContext* GetCurrentContext();
478  IMGUI_API void SetCurrentContext(ImGuiContext* ctx);
479 
480  // Obsolete functions (Will be removed! Also see 'API BREAKING CHANGES' section in imgui.cpp)
481 #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
482  static inline bool IsItemHoveredRect() { return IsItemRectHovered(); } // OBSOLETE 1.51+
483  static inline bool IsPosHoveringAnyWindow(const ImVec2&) { IM_ASSERT(0); return false; } // OBSOLETE 1.51+. This was partly broken. You probably wanted to use ImGui::GetIO().WantCaptureMouse instead.
484  static inline bool IsMouseHoveringAnyWindow() { return IsAnyWindowHovered(); } // OBSOLETE 1.51+
485  static inline bool IsMouseHoveringWindow() { return IsWindowRectHovered(); } // OBSOLETE 1.51+
486  static inline bool CollapsingHeader(const char* label, const char* str_id, bool framed = true, bool default_open = false) { (void)str_id; (void)framed; ImGuiTreeNodeFlags default_open_flags = 1<<5; return CollapsingHeader(label, (default_open ? default_open_flags : 0)); } // OBSOLETE 1.49+
487  static inline ImFont* GetWindowFont() { return GetFont(); } // OBSOLETE 1.48+
488  static inline float GetWindowFontSize() { return GetFontSize(); } // OBSOLETE 1.48+
489  static inline void SetScrollPosHere() { SetScrollHere(); } // OBSOLETE 1.42+
490  static inline bool GetWindowCollapsed() { return ImGui::IsWindowCollapsed(); } // OBSOLETE 1.39+
491  static inline bool IsRectClipped(const ImVec2& size) { return !IsRectVisible(size); } // OBSOLETE 1.39+
492 #endif
493 
494 } // namespace ImGui
495 
496 // Flags for ImGui::Begin()
497 enum ImGuiWindowFlags_
498 {
499  // Default: 0
500  ImGuiWindowFlags_NoTitleBar = 1 << 0, // Disable title-bar
501  ImGuiWindowFlags_NoResize = 1 << 1, // Disable user resizing with the lower-right grip
502  ImGuiWindowFlags_NoMove = 1 << 2, // Disable user moving the window
503  ImGuiWindowFlags_NoScrollbar = 1 << 3, // Disable scrollbars (window can still scroll with mouse or programatically)
504  ImGuiWindowFlags_NoScrollWithMouse = 1 << 4, // Disable user vertically scrolling with mouse wheel
505  ImGuiWindowFlags_NoCollapse = 1 << 5, // Disable user collapsing window by double-clicking on it
506  ImGuiWindowFlags_AlwaysAutoResize = 1 << 6, // Resize every window to its content every frame
507  ImGuiWindowFlags_ShowBorders = 1 << 7, // Show borders around windows and items
508  ImGuiWindowFlags_NoSavedSettings = 1 << 8, // Never load/save settings in .ini file
509  ImGuiWindowFlags_NoInputs = 1 << 9, // Disable catching mouse or keyboard inputs
510  ImGuiWindowFlags_MenuBar = 1 << 10, // Has a menu-bar
511  ImGuiWindowFlags_HorizontalScrollbar = 1 << 11, // Allow horizontal scrollbar to appear (off by default). You may use SetNextWindowContentSize(ImVec2(width,0.0f)); prior to calling Begin() to specify width. Read code in imgui_demo in the "Horizontal Scrolling" section.
512  ImGuiWindowFlags_NoFocusOnAppearing = 1 << 12, // Disable taking focus when transitioning from hidden to visible state
513  ImGuiWindowFlags_NoBringToFrontOnFocus = 1 << 13, // Disable bringing window to front when taking focus (e.g. clicking on it or programatically giving it focus)
514  ImGuiWindowFlags_AlwaysVerticalScrollbar= 1 << 14, // Always show vertical scrollbar (even if ContentSize.y < Size.y)
515  ImGuiWindowFlags_AlwaysHorizontalScrollbar=1<< 15, // Always show horizontal scrollbar (even if ContentSize.x < Size.x)
516  ImGuiWindowFlags_AlwaysUseWindowPadding = 1 << 16, // Ensure child windows without border uses style.WindowPadding (ignored by default for non-bordered child windows, because more convenient)
517  // [Internal]
518  ImGuiWindowFlags_ChildWindow = 1 << 22, // Don't use! For internal use by BeginChild()
519  ImGuiWindowFlags_ComboBox = 1 << 23, // Don't use! For internal use by ComboBox()
520  ImGuiWindowFlags_Tooltip = 1 << 24, // Don't use! For internal use by BeginTooltip()
521  ImGuiWindowFlags_Popup = 1 << 25, // Don't use! For internal use by BeginPopup()
522  ImGuiWindowFlags_Modal = 1 << 26, // Don't use! For internal use by BeginPopupModal()
523  ImGuiWindowFlags_ChildMenu = 1 << 27 // Don't use! For internal use by BeginMenu()
524 };
525 
526 // Flags for ImGui::InputText()
527 enum ImGuiInputTextFlags_
528 {
529  // Default: 0
530  ImGuiInputTextFlags_CharsDecimal = 1 << 0, // Allow 0123456789.+-*/
531  ImGuiInputTextFlags_CharsHexadecimal = 1 << 1, // Allow 0123456789ABCDEFabcdef
532  ImGuiInputTextFlags_CharsUppercase = 1 << 2, // Turn a..z into A..Z
533  ImGuiInputTextFlags_CharsNoBlank = 1 << 3, // Filter out spaces, tabs
534  ImGuiInputTextFlags_AutoSelectAll = 1 << 4, // Select entire text when first taking mouse focus
535  ImGuiInputTextFlags_EnterReturnsTrue = 1 << 5, // Return 'true' when Enter is pressed (as opposed to when the value was modified)
536  ImGuiInputTextFlags_CallbackCompletion = 1 << 6, // Call user function on pressing TAB (for completion handling)
537  ImGuiInputTextFlags_CallbackHistory = 1 << 7, // Call user function on pressing Up/Down arrows (for history handling)
538  ImGuiInputTextFlags_CallbackAlways = 1 << 8, // Call user function every time. User code may query cursor position, modify text buffer.
539  ImGuiInputTextFlags_CallbackCharFilter = 1 << 9, // Call user function to filter character. Modify data->EventChar to replace/filter input, or return 1 to discard character.
540  ImGuiInputTextFlags_AllowTabInput = 1 << 10, // Pressing TAB input a '\t' character into the text field
541  ImGuiInputTextFlags_CtrlEnterForNewLine = 1 << 11, // In multi-line mode, unfocus with Enter, add new line with Ctrl+Enter (default is opposite: unfocus with Ctrl+Enter, add line with Enter).
542  ImGuiInputTextFlags_NoHorizontalScroll = 1 << 12, // Disable following the cursor horizontally
543  ImGuiInputTextFlags_AlwaysInsertMode = 1 << 13, // Insert mode
544  ImGuiInputTextFlags_ReadOnly = 1 << 14, // Read-only mode
545  ImGuiInputTextFlags_Password = 1 << 15, // Password mode, display all characters as '*'
546  // [Internal]
547  ImGuiInputTextFlags_Multiline = 1 << 20 // For internal use by InputTextMultiline()
548 };
549 
550 // Flags for ImGui::TreeNodeEx(), ImGui::CollapsingHeader*()
551 enum ImGuiTreeNodeFlags_
552 {
553  ImGuiTreeNodeFlags_Selected = 1 << 0, // Draw as selected
554  ImGuiTreeNodeFlags_Framed = 1 << 1, // Full colored frame (e.g. for CollapsingHeader)
555  ImGuiTreeNodeFlags_AllowOverlapMode = 1 << 2, // Hit testing to allow subsequent widgets to overlap this one
556  ImGuiTreeNodeFlags_NoTreePushOnOpen = 1 << 3, // Don't do a TreePush() when open (e.g. for CollapsingHeader) = no extra indent nor pushing on ID stack
557  ImGuiTreeNodeFlags_NoAutoOpenOnLog = 1 << 4, // Don't automatically and temporarily open node when Logging is active (by default logging will automatically open tree nodes)
558  ImGuiTreeNodeFlags_DefaultOpen = 1 << 5, // Default node to be open
559  ImGuiTreeNodeFlags_OpenOnDoubleClick = 1 << 6, // Need double-click to open node
560  ImGuiTreeNodeFlags_OpenOnArrow = 1 << 7, // Only open when clicking on the arrow part. If ImGuiTreeNodeFlags_OpenOnDoubleClick is also set, single-click arrow or double-click all box to open.
561  ImGuiTreeNodeFlags_Leaf = 1 << 8, // No collapsing, no arrow (use as a convenience for leaf nodes).
562  ImGuiTreeNodeFlags_Bullet = 1 << 9, // Display a bullet instead of arrow
563  //ImGuITreeNodeFlags_SpanAllAvailWidth = 1 << 10, // FIXME: TODO: Extend hit box horizontally even if not framed
564  //ImGuiTreeNodeFlags_NoScrollOnOpen = 1 << 11, // FIXME: TODO: Disable automatic scroll on TreePop() if node got just open and contents is not visible
565  ImGuiTreeNodeFlags_CollapsingHeader = ImGuiTreeNodeFlags_Framed | ImGuiTreeNodeFlags_NoAutoOpenOnLog
566 };
567 
568 // Flags for ImGui::Selectable()
569 enum ImGuiSelectableFlags_
570 {
571  // Default: 0
572  ImGuiSelectableFlags_DontClosePopups = 1 << 0, // Clicking this don't close parent popup window
573  ImGuiSelectableFlags_SpanAllColumns = 1 << 1, // Selectable frame can span all columns (text will still fit in current column)
574  ImGuiSelectableFlags_AllowDoubleClick = 1 << 2 // Generate press events on double clicks too
575 };
576 
577 // User fill ImGuiIO.KeyMap[] array with indices into the ImGuiIO.KeysDown[512] array
578 enum ImGuiKey_
579 {
580  ImGuiKey_Tab, // for tabbing through fields
581  ImGuiKey_LeftArrow, // for text edit
582  ImGuiKey_RightArrow,// for text edit
583  ImGuiKey_UpArrow, // for text edit
584  ImGuiKey_DownArrow, // for text edit
585  ImGuiKey_PageUp,
586  ImGuiKey_PageDown,
587  ImGuiKey_Home, // for text edit
588  ImGuiKey_End, // for text edit
589  ImGuiKey_Delete, // for text edit
590  ImGuiKey_Backspace, // for text edit
591  ImGuiKey_Enter, // for text edit
592  ImGuiKey_Escape, // for text edit
593  ImGuiKey_A, // for text edit CTRL+A: select all
594  ImGuiKey_C, // for text edit CTRL+C: copy
595  ImGuiKey_V, // for text edit CTRL+V: paste
596  ImGuiKey_X, // for text edit CTRL+X: cut
597  ImGuiKey_Y, // for text edit CTRL+Y: redo
598  ImGuiKey_Z, // for text edit CTRL+Z: undo
599  ImGuiKey_COUNT
600 };
601 
602 // Enumeration for PushStyleColor() / PopStyleColor()
603 enum ImGuiCol_
604 {
605  ImGuiCol_Text,
606  ImGuiCol_TextDisabled,
607  ImGuiCol_WindowBg, // Background of normal windows
608  ImGuiCol_ChildWindowBg, // Background of child windows
609  ImGuiCol_PopupBg, // Background of popups, menus, tooltips windows
610  ImGuiCol_Border,
611  ImGuiCol_BorderShadow,
612  ImGuiCol_FrameBg, // Background of checkbox, radio button, plot, slider, text input
613  ImGuiCol_FrameBgHovered,
614  ImGuiCol_FrameBgActive,
615  ImGuiCol_TitleBg,
616  ImGuiCol_TitleBgCollapsed,
617  ImGuiCol_TitleBgActive,
618  ImGuiCol_MenuBarBg,
619  ImGuiCol_ScrollbarBg,
620  ImGuiCol_ScrollbarGrab,
621  ImGuiCol_ScrollbarGrabHovered,
622  ImGuiCol_ScrollbarGrabActive,
623  ImGuiCol_ComboBg,
624  ImGuiCol_CheckMark,
625  ImGuiCol_SliderGrab,
626  ImGuiCol_SliderGrabActive,
627  ImGuiCol_Button,
628  ImGuiCol_ButtonHovered,
629  ImGuiCol_ButtonActive,
630  ImGuiCol_Header,
631  ImGuiCol_HeaderHovered,
632  ImGuiCol_HeaderActive,
633  ImGuiCol_Separator,
634  ImGuiCol_SeparatorHovered,
635  ImGuiCol_SeparatorActive,
636  ImGuiCol_ResizeGrip,
637  ImGuiCol_ResizeGripHovered,
638  ImGuiCol_ResizeGripActive,
639  ImGuiCol_CloseButton,
640  ImGuiCol_CloseButtonHovered,
641  ImGuiCol_CloseButtonActive,
642  ImGuiCol_PlotLines,
643  ImGuiCol_PlotLinesHovered,
644  ImGuiCol_PlotHistogram,
645  ImGuiCol_PlotHistogramHovered,
646  ImGuiCol_TextSelectedBg,
647  ImGuiCol_ModalWindowDarkening, // darken entire screen when a modal window is active
648  ImGuiCol_COUNT
649 
650  // Obsolete names (will be removed)
651 #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
652  , ImGuiCol_Column = ImGuiCol_Separator, ImGuiCol_ColumnHovered = ImGuiCol_SeparatorHovered, ImGuiCol_ColumnActive = ImGuiCol_SeparatorActive
653 #endif
654 };
655 
656 // Enumeration for PushStyleVar() / PopStyleVar() to temporarily modify the ImGuiStyle structure.
657 // NB: the enum only refers to fields of ImGuiStyle which makes sense to be pushed/poped inside UI code. During initialization, feel free to just poke into ImGuiStyle directly.
658 // NB: if changing this enum, you need to update the associated internal table GStyleVarInfo[] accordingly. This is where we link enum values to members offset/type.
659 enum ImGuiStyleVar_
660 {
661  // Enum name ......................// Member in ImGuiStyle structure (see ImGuiStyle for descriptions)
662  ImGuiStyleVar_Alpha, // float Alpha
663  ImGuiStyleVar_WindowPadding, // ImVec2 WindowPadding
664  ImGuiStyleVar_WindowRounding, // float WindowRounding
665  ImGuiStyleVar_WindowMinSize, // ImVec2 WindowMinSize
666  ImGuiStyleVar_ChildWindowRounding, // float ChildWindowRounding
667  ImGuiStyleVar_FramePadding, // ImVec2 FramePadding
668  ImGuiStyleVar_FrameRounding, // float FrameRounding
669  ImGuiStyleVar_ItemSpacing, // ImVec2 ItemSpacing
670  ImGuiStyleVar_ItemInnerSpacing, // ImVec2 ItemInnerSpacing
671  ImGuiStyleVar_IndentSpacing, // float IndentSpacing
672  ImGuiStyleVar_GrabMinSize, // float GrabMinSize
673  ImGuiStyleVar_ButtonTextAlign, // ImVec2 ButtonTextAlign
674  ImGuiStyleVar_Count_
675 };
676 
677 // Enumeration for ColorEdit3() / ColorEdit4() / ColorPicker3() / ColorPicker4() / ColorButton()
678 enum ImGuiColorEditFlags_
679 {
680  ImGuiColorEditFlags_NoAlpha = 1 << 1, // // ColorEdit, ColorPicker, ColorButton: ignore Alpha component (read 3 components from the input pointer).
681  ImGuiColorEditFlags_NoPicker = 1 << 2, // // ColorEdit: disable picker when clicking on colored square.
682  ImGuiColorEditFlags_NoOptions = 1 << 3, // // ColorEdit: disable toggling options menu when right-clicking on inputs/small preview.
683  ImGuiColorEditFlags_NoSmallPreview = 1 << 4, // // ColorEdit, ColorPicker: disable colored square preview next to the inputs. (e.g. to show only the inputs)
684  ImGuiColorEditFlags_NoInputs = 1 << 5, // // ColorEdit, ColorPicker: disable inputs sliders/text widgets (e.g. to show only the small preview colored square).
685  ImGuiColorEditFlags_NoTooltip = 1 << 6, // // ColorEdit, ColorPicker, ColorButton: disable tooltip when hovering the preview.
686  ImGuiColorEditFlags_NoLabel = 1 << 7, // // ColorEdit, ColorPicker: disable display of inline text label (the label is still forwarded to the tooltip and picker).
687  ImGuiColorEditFlags_NoSidePreview = 1 << 8, // // ColorPicker: disable bigger color preview on right side of the picker, use small colored square preview instead.
688  // User Options (right-click on widget to change some of them). You can set application defaults using SetColorEditOptions(). The idea is that you probably don't want to override them in most of your calls, let the user choose and/or call SetColorEditOptions() during startup.
689  ImGuiColorEditFlags_AlphaBar = 1 << 9, // // ColorEdit, ColorPicker: show vertical alpha bar/gradient in picker.
690  ImGuiColorEditFlags_AlphaPreview = 1 << 10, // // ColorEdit, ColorPicker, ColorButton: display preview as a transparent color over a checkerboard, instead of opaque.
691  ImGuiColorEditFlags_AlphaPreviewHalf= 1 << 11, // // ColorEdit, ColorPicker, ColorButton: display half opaque / half checkerboard, instead of opaque.
692  ImGuiColorEditFlags_HDR = 1 << 12, // // (WIP) ColorEdit: Currently only disable 0.0f..1.0f limits in RGBA edition (note: you probably want to use ImGuiColorEditFlags_Float flag as well).
693  ImGuiColorEditFlags_RGB = 1 << 13, // [Inputs] // ColorEdit: choose one among RGB/HSV/HEX. ColorPicker: choose any combination using RGB/HSV/HEX.
694  ImGuiColorEditFlags_HSV = 1 << 14, // [Inputs] // "
695  ImGuiColorEditFlags_HEX = 1 << 15, // [Inputs] // "
696  ImGuiColorEditFlags_Uint8 = 1 << 16, // [DataType] // ColorEdit, ColorPicker, ColorButton: _display_ values formatted as 0..255.
697  ImGuiColorEditFlags_Float = 1 << 17, // [DataType] // ColorEdit, ColorPicker, ColorButton: _display_ values formatted as 0.0f..1.0f floats instead of 0..255 integers. No round-trip of value via integers.
698  ImGuiColorEditFlags_PickerHueBar = 1 << 18, // [PickerMode] // ColorPicker: bar for Hue, rectangle for Sat/Value.
699  ImGuiColorEditFlags_PickerHueWheel = 1 << 19, // [PickerMode] // ColorPicker: wheel for Hue, triangle for Sat/Value.
700  // Internals/Masks
701  ImGuiColorEditFlags__InputsMask = ImGuiColorEditFlags_RGB|ImGuiColorEditFlags_HSV|ImGuiColorEditFlags_HEX,
702  ImGuiColorEditFlags__DataTypeMask = ImGuiColorEditFlags_Uint8|ImGuiColorEditFlags_Float,
703  ImGuiColorEditFlags__PickerMask = ImGuiColorEditFlags_PickerHueWheel|ImGuiColorEditFlags_PickerHueBar,
704  ImGuiColorEditFlags__OptionsDefault = ImGuiColorEditFlags_Uint8|ImGuiColorEditFlags_RGB|ImGuiColorEditFlags_PickerHueBar // Change application default using SetColorEditOptions()
705 };
706 
707 // Enumeration for GetMouseCursor()
708 enum ImGuiMouseCursor_
709 {
710  ImGuiMouseCursor_None = -1,
711  ImGuiMouseCursor_Arrow = 0,
712  ImGuiMouseCursor_TextInput, // When hovering over InputText, etc.
713  ImGuiMouseCursor_Move, // Unused
714  ImGuiMouseCursor_ResizeNS, // Unused
715  ImGuiMouseCursor_ResizeEW, // When hovering over a column
716  ImGuiMouseCursor_ResizeNESW, // Unused
717  ImGuiMouseCursor_ResizeNWSE, // When hovering over the bottom-right corner of a window
718  ImGuiMouseCursor_Count_
719 };
720 
721 // Condition flags for ImGui::SetWindow***(), SetNextWindow***(), SetNextTreeNode***() functions
722 // All those functions treat 0 as a shortcut to ImGuiCond_Always
723 enum ImGuiCond_
724 {
725  ImGuiCond_Always = 1 << 0, // Set the variable
726  ImGuiCond_Once = 1 << 1, // Set the variable once per runtime session (only the first call with succeed)
727  ImGuiCond_FirstUseEver = 1 << 2, // Set the variable if the window has no saved data (if doesn't exist in the .ini file)
728  ImGuiCond_Appearing = 1 << 3 // Set the variable if the window is appearing after being hidden/inactive (or the first time)
729 
730  // Obsolete names (will be removed)
731 #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
732  , ImGuiSetCond_Always = ImGuiCond_Always, ImGuiSetCond_Once = ImGuiCond_Once, ImGuiSetCond_FirstUseEver = ImGuiCond_FirstUseEver, ImGuiSetCond_Appearing = ImGuiCond_Appearing
733 #endif
734 };
735 
736 struct ImGuiStyle
737 {
738  float Alpha; // Global alpha applies to everything in ImGui
739  ImVec2 WindowPadding; // Padding within a window
740  ImVec2 WindowMinSize; // Minimum window size
741  float WindowRounding; // Radius of window corners rounding. Set to 0.0f to have rectangular windows
742  ImVec2 WindowTitleAlign; // Alignment for title bar text. Defaults to (0.0f,0.5f) for left-aligned,vertically centered.
743  float ChildWindowRounding; // Radius of child window corners rounding. Set to 0.0f to have rectangular windows
744  ImVec2 FramePadding; // Padding within a framed rectangle (used by most widgets)
745  float FrameRounding; // Radius of frame corners rounding. Set to 0.0f to have rectangular frame (used by most widgets).
746  ImVec2 ItemSpacing; // Horizontal and vertical spacing between widgets/lines
747  ImVec2 ItemInnerSpacing; // Horizontal and vertical spacing between within elements of a composed widget (e.g. a slider and its label)
748  ImVec2 TouchExtraPadding; // Expand reactive bounding box for touch-based system where touch position is not accurate enough. Unfortunately we don't sort widgets so priority on overlap will always be given to the first widget. So don't grow this too much!
749  float IndentSpacing; // Horizontal indentation when e.g. entering a tree node. Generally == (FontSize + FramePadding.x*2).
750  float ColumnsMinSpacing; // Minimum horizontal spacing between two columns
751  float ScrollbarSize; // Width of the vertical scrollbar, Height of the horizontal scrollbar
752  float ScrollbarRounding; // Radius of grab corners for scrollbar
753  float GrabMinSize; // Minimum width/height of a grab box for slider/scrollbar.
754  float GrabRounding; // Radius of grabs corners rounding. Set to 0.0f to have rectangular slider grabs.
755  ImVec2 ButtonTextAlign; // Alignment of button text when button is larger than text. Defaults to (0.5f,0.5f) for horizontally+vertically centered.
756  ImVec2 DisplayWindowPadding; // Window positions are clamped to be visible within the display area by at least this amount. Only covers regular windows.
757  ImVec2 DisplaySafeAreaPadding; // If you cannot see the edge of your screen (e.g. on a TV) increase the safe area padding. Covers popups/tooltips as well regular windows.
758  bool AntiAliasedLines; // Enable anti-aliasing on lines/borders. Disable if you are really tight on CPU/GPU.
759  bool AntiAliasedShapes; // Enable anti-aliasing on filled shapes (rounded rectangles, circles, etc.)
760  float CurveTessellationTol; // Tessellation tolerance. Decrease for highly tessellated curves (higher quality, more polygons), increase to reduce quality.
761  ImVec4 Colors[ImGuiCol_COUNT];
762 
763  IMGUI_API ImGuiStyle();
764 };
765 
766 // This is where your app communicate with ImGui. Access via ImGui::GetIO().
767 // Read 'Programmer guide' section in .cpp file for general usage.
768 struct ImGuiIO
769 {
770  //------------------------------------------------------------------
771  // Settings (fill once) // Default value:
772  //------------------------------------------------------------------
773 
774  ImVec2 DisplaySize; // <unset> // Display size, in pixels. For clamping windows positions.
775  float DeltaTime; // = 1.0f/60.0f // Time elapsed since last frame, in seconds.
776  float IniSavingRate; // = 5.0f // Maximum time between saving positions/sizes to .ini file, in seconds.
777  const char* IniFilename; // = "imgui.ini" // Path to .ini file. NULL to disable .ini saving.
778  const char* LogFilename; // = "imgui_log.txt" // Path to .log file (default parameter to ImGui::LogToFile when no file is specified).
779  float MouseDoubleClickTime; // = 0.30f // Time for a double-click, in seconds.
780  float MouseDoubleClickMaxDist; // = 6.0f // Distance threshold to stay in to validate a double-click, in pixels.
781  float MouseDragThreshold; // = 6.0f // Distance threshold before considering we are dragging
782  int KeyMap[ImGuiKey_COUNT]; // <unset> // Map of indices into the KeysDown[512] entries array
783  float KeyRepeatDelay; // = 0.250f // When holding a key/button, time before it starts repeating, in seconds (for buttons in Repeat mode, etc.).
784  float KeyRepeatRate; // = 0.020f // When holding a key/button, rate at which it repeats, in seconds.
785  void* UserData; // = NULL // Store your own data for retrieval by callbacks.
786 
787  ImFontAtlas* Fonts; // <auto> // Load and assemble one or more fonts into a single tightly packed texture. Output to Fonts array.
788  float FontGlobalScale; // = 1.0f // Global scale all fonts
789  bool FontAllowUserScaling; // = false // Allow user scaling text of individual window with CTRL+Wheel.
790  ImFont* FontDefault; // = NULL // Font to use on NewFrame(). Use NULL to uses Fonts->Fonts[0].
791  ImVec2 DisplayFramebufferScale; // = (1.0f,1.0f) // For retina display or other situations where window coordinates are different from framebuffer coordinates. User storage only, presently not used by ImGui.
792  ImVec2 DisplayVisibleMin; // <unset> (0.0f,0.0f) // If you use DisplaySize as a virtual space larger than your screen, set DisplayVisibleMin/Max to the visible area.
793  ImVec2 DisplayVisibleMax; // <unset> (0.0f,0.0f) // If the values are the same, we defaults to Min=(0.0f) and Max=DisplaySize
794 
795  // Advanced/subtle behaviors
796  bool OSXBehaviors; // = defined(__APPLE__) // OS X style: Text editing cursor movement using Alt instead of Ctrl, Shortcuts using Cmd/Super instead of Ctrl, Line/Text Start and End using Cmd+Arrows instead of Home/End, Double click selects by word instead of selecting whole text, Multi-selection in lists uses Cmd/Super instead of Ctrl
797 
798  //------------------------------------------------------------------
799  // Settings (User Functions)
800  //------------------------------------------------------------------
801 
802  // Rendering function, will be called in Render().
803  // Alternatively you can keep this to NULL and call GetDrawData() after Render() to get the same pointer.
804  // See example applications if you are unsure of how to implement this.
805  void (*RenderDrawListsFn)(ImDrawData* data);
806 
807  // Optional: access OS clipboard
808  // (default to use native Win32 clipboard on Windows, otherwise uses a private clipboard. Override to access OS clipboard on other architectures)
809  const char* (*GetClipboardTextFn)(void* user_data);
810  void (*SetClipboardTextFn)(void* user_data, const char* text);
811  void* ClipboardUserData;
812 
813  // Optional: override memory allocations. MemFreeFn() may be called with a NULL pointer.
814  // (default to posix malloc/free)
815  void* (*MemAllocFn)(size_t sz);
816  void (*MemFreeFn)(void* ptr);
817 
818  // Optional: notify OS Input Method Editor of the screen position of your cursor for text input position (e.g. when using Japanese/Chinese IME in Windows)
819  // (default to use native imm32 api on Windows)
820  void (*ImeSetInputScreenPosFn)(int x, int y);
821  void* ImeWindowHandle; // (Windows) Set this to your HWND to get automatic IME cursor positioning.
822 
823  //------------------------------------------------------------------
824  // Input - Fill before calling NewFrame()
825  //------------------------------------------------------------------
826 
827  ImVec2 MousePos; // Mouse position, in pixels (set to -1,-1 if no mouse / on another screen, etc.)
828  bool MouseDown[5]; // Mouse buttons: left, right, middle + extras. ImGui itself mostly only uses left button (BeginPopupContext** are using right button). Others buttons allows us to track if the mouse is being used by your application + available to user as a convenience via IsMouse** API.
829  float MouseWheel; // Mouse wheel: 1 unit scrolls about 5 lines text.
830  bool MouseDrawCursor; // Request ImGui to draw a mouse cursor for you (if you are on a platform without a mouse cursor).
831  bool KeyCtrl; // Keyboard modifier pressed: Control
832  bool KeyShift; // Keyboard modifier pressed: Shift
833  bool KeyAlt; // Keyboard modifier pressed: Alt
834  bool KeySuper; // Keyboard modifier pressed: Cmd/Super/Windows
835  bool KeysDown[512]; // Keyboard keys that are pressed (in whatever storage order you naturally have access to keyboard data)
836  ImWchar InputCharacters[16+1]; // List of characters input (translated by user from keypress+keyboard state). Fill using AddInputCharacter() helper.
837 
838  // Functions
839  IMGUI_API void AddInputCharacter(ImWchar c); // Add new character into InputCharacters[]
840  IMGUI_API void AddInputCharactersUTF8(const char* utf8_chars); // Add new characters into InputCharacters[] from an UTF-8 string
841  inline void ClearInputCharacters() { InputCharacters[0] = 0; } // Clear the text input buffer manually
842 
843  //------------------------------------------------------------------
844  // Output - Retrieve after calling NewFrame()
845  //------------------------------------------------------------------
846 
847  bool WantCaptureMouse; // Mouse is hovering a window or widget is active (= ImGui will use your mouse input). Use to hide mouse from the rest of your application
848  bool WantCaptureKeyboard; // Widget is active (= ImGui will use your keyboard input). Use to hide keyboard from the rest of your application
849  bool WantTextInput; // Some text input widget is active, which will read input characters from the InputCharacters array. Use to activate on screen keyboard if your system needs one
850  float Framerate; // Application framerate estimation, in frame per second. Solely for convenience. Rolling average estimation based on IO.DeltaTime over 120 frames
851  int MetricsAllocs; // Number of active memory allocations
852  int MetricsRenderVertices; // Vertices output during last call to Render()
853  int MetricsRenderIndices; // Indices output during last call to Render() = number of triangles * 3
854  int MetricsActiveWindows; // Number of visible root windows (exclude child windows)
855  ImVec2 MouseDelta; // Mouse delta. Note that this is zero if either current or previous position are negative, so a disappearing/reappearing mouse won't have a huge delta for one frame.
856 
857  //------------------------------------------------------------------
858  // [Private] ImGui will maintain those fields. Forward compatibility not guaranteed!
859  //------------------------------------------------------------------
860 
861  ImVec2 MousePosPrev; // Previous mouse position temporary storage (nb: not for public use, set to MousePos in NewFrame())
862  bool MouseClicked[5]; // Mouse button went from !Down to Down
863  ImVec2 MouseClickedPos[5]; // Position at time of clicking
864  float MouseClickedTime[5]; // Time of last click (used to figure out double-click)
865  bool MouseDoubleClicked[5]; // Has mouse button been double-clicked?
866  bool MouseReleased[5]; // Mouse button went from Down to !Down
867  bool MouseDownOwned[5]; // Track if button was clicked inside a window. We don't request mouse capture from the application if click started outside ImGui bounds.
868  float MouseDownDuration[5]; // Duration the mouse button has been down (0.0f == just clicked)
869  float MouseDownDurationPrev[5]; // Previous time the mouse button has been down
870  float MouseDragMaxDistanceSqr[5]; // Squared maximum distance of how much mouse has traveled from the click point
871  float KeysDownDuration[512]; // Duration the keyboard key has been down (0.0f == just pressed)
872  float KeysDownDurationPrev[512]; // Previous duration the key has been down
873 
874  IMGUI_API ImGuiIO();
875 };
876 
877 //-----------------------------------------------------------------------------
878 // Helpers
879 //-----------------------------------------------------------------------------
880 
881 // Lightweight std::vector<> like class to avoid dragging dependencies (also: windows implementation of STL with debug enabled is absurdly slow, so let's bypass it so our code runs fast in debug).
882 // Our implementation does NOT call c++ constructors because we don't use them in ImGui. Don't use this class as a straight std::vector replacement in your code!
883 template<typename T>
884 class ImVector
885 {
886 public:
887  int Size;
888  int Capacity;
889  T* Data;
890 
891  typedef T value_type;
892  typedef value_type* iterator;
893  typedef const value_type* const_iterator;
894 
895  ImVector() { Size = Capacity = 0; Data = NULL; }
896  ~ImVector() { if (Data) ImGui::MemFree(Data); }
897 
898  inline bool empty() const { return Size == 0; }
899  inline int size() const { return Size; }
900  inline int capacity() const { return Capacity; }
901 
902  inline value_type& operator[](int i) { IM_ASSERT(i < Size); return Data[i]; }
903  inline const value_type& operator[](int i) const { IM_ASSERT(i < Size); return Data[i]; }
904 
905  inline void clear() { if (Data) { Size = Capacity = 0; ImGui::MemFree(Data); Data = NULL; } }
906  inline iterator begin() { return Data; }
907  inline const_iterator begin() const { return Data; }
908  inline iterator end() { return Data + Size; }
909  inline const_iterator end() const { return Data + Size; }
910  inline value_type& front() { IM_ASSERT(Size > 0); return Data[0]; }
911  inline const value_type& front() const { IM_ASSERT(Size > 0); return Data[0]; }
912  inline value_type& back() { IM_ASSERT(Size > 0); return Data[Size-1]; }
913  inline const value_type& back() const { IM_ASSERT(Size > 0); return Data[Size-1]; }
914  inline void swap(ImVector<T>& rhs) { int rhs_size = rhs.Size; rhs.Size = Size; Size = rhs_size; int rhs_cap = rhs.Capacity; rhs.Capacity = Capacity; Capacity = rhs_cap; value_type* rhs_data = rhs.Data; rhs.Data = Data; Data = rhs_data; }
915 
916  inline int _grow_capacity(int size) const { int new_capacity = Capacity ? (Capacity + Capacity/2) : 8; return new_capacity > size ? new_capacity : size; }
917 
918  inline void resize(int new_size) { if (new_size > Capacity) reserve(_grow_capacity(new_size)); Size = new_size; }
919  inline void reserve(int new_capacity)
920  {
921  if (new_capacity <= Capacity) return;
922  T* new_data = (value_type*)ImGui::MemAlloc((size_t)new_capacity * sizeof(value_type));
923  if (Data)
924  memcpy(new_data, Data, (size_t)Size * sizeof(value_type));
925  ImGui::MemFree(Data);
926  Data = new_data;
927  Capacity = new_capacity;
928  }
929 
930  inline void push_back(const value_type& v) { if (Size == Capacity) reserve(_grow_capacity(Size+1)); Data[Size++] = v; }
931  inline void pop_back() { IM_ASSERT(Size > 0); Size--; }
932 
933  inline iterator erase(const_iterator it) { IM_ASSERT(it >= Data && it < Data+Size); const ptrdiff_t off = it - Data; memmove(Data + off, Data + off + 1, ((size_t)Size - (size_t)off - 1) * sizeof(value_type)); Size--; return Data + off; }
934  inline iterator insert(const_iterator it, const value_type& v) { IM_ASSERT(it >= Data && it <= Data+Size); const ptrdiff_t off = it - Data; if (Size == Capacity) reserve(Capacity ? Capacity * 2 : 4); if (off < (int)Size) memmove(Data + off + 1, Data + off, ((size_t)Size - (size_t)off) * sizeof(value_type)); Data[off] = v; Size++; return Data + off; }
935 };
936 
937 // Helper: execute a block of code at maximum once a frame. Convenient if you want to quickly create an UI within deep-nested code that runs multiple times every frame.
938 // Usage:
939 // static ImGuiOnceUponAFrame oaf;
940 // if (oaf)
941 // ImGui::Text("This will be called only once per frame");
942 struct ImGuiOnceUponAFrame
943 {
944  ImGuiOnceUponAFrame() { RefFrame = -1; }
945  mutable int RefFrame;
946  operator bool() const { int current_frame = ImGui::GetFrameCount(); if (RefFrame == current_frame) return false; RefFrame = current_frame; return true; }
947 };
948 
949 // Helper macro for ImGuiOnceUponAFrame. Attention: The macro expands into 2 statement so make sure you don't use it within e.g. an if() statement without curly braces.
950 #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS // Will obsolete
951 #define IMGUI_ONCE_UPON_A_FRAME static ImGuiOnceUponAFrame imgui_oaf; if (imgui_oaf)
952 #endif
953 
954 // Helper: Parse and apply text filters. In format "aaaaa[,bbbb][,ccccc]"
955 struct ImGuiTextFilter
956 {
957  struct TextRange
958  {
959  const char* b;
960  const char* e;
961 
962  TextRange() { b = e = NULL; }
963  TextRange(const char* _b, const char* _e) { b = _b; e = _e; }
964  const char* begin() const { return b; }
965  const char* end() const { return e; }
966  bool empty() const { return b == e; }
967  char front() const { return *b; }
968  static bool is_blank(char c) { return c == ' ' || c == '\t'; }
969  void trim_blanks() { while (b < e && is_blank(*b)) b++; while (e > b && is_blank(*(e-1))) e--; }
970  IMGUI_API void split(char separator, ImVector<TextRange>& out);
971  };
972 
973  char InputBuf[256];
974  ImVector<TextRange> Filters;
975  int CountGrep;
976 
977  IMGUI_API ImGuiTextFilter(const char* default_filter = "");
978  ~ImGuiTextFilter() {}
979  void Clear() { InputBuf[0] = 0; Build(); }
980  IMGUI_API bool Draw(const char* label = "Filter (inc,-exc)", float width = 0.0f); // Helper calling InputText+Build
981  IMGUI_API bool PassFilter(const char* text, const char* text_end = NULL) const;
982  bool IsActive() const { return !Filters.empty(); }
983  IMGUI_API void Build();
984 };
985 
986 // Helper: Text buffer for logging/accumulating text
987 struct ImGuiTextBuffer
988 {
989  ImVector<char> Buf;
990 
991  ImGuiTextBuffer() { Buf.push_back(0); }
992  inline char operator[](int i) { return Buf.Data[i]; }
993  const char* begin() const { return &Buf.front(); }
994  const char* end() const { return &Buf.back(); } // Buf is zero-terminated, so end() will point on the zero-terminator
995  int size() const { return Buf.Size - 1; }
996  bool empty() { return Buf.Size <= 1; }
997  void clear() { Buf.clear(); Buf.push_back(0); }
998  const char* c_str() const { return Buf.Data; }
999  IMGUI_API void append(const char* fmt, ...) IM_PRINTFARGS(2);
1000  IMGUI_API void appendv(const char* fmt, va_list args);
1001 };
1002 
1003 // Helper: Simple Key->value storage
1004 // Typically you don't have to worry about this since a storage is held within each Window.
1005 // We use it to e.g. store collapse state for a tree (Int 0/1), store color edit options.
1006 // This is optimized for efficient reading (dichotomy into a contiguous buffer), rare writing (typically tied to user interactions)
1007 // You can use it as custom user storage for temporary values. Declare your own storage if, for example:
1008 // - You want to manipulate the open/close state of a particular sub-tree in your interface (tree node uses Int 0/1 to store their state).
1009 // - You want to store custom debug data easily without adding or editing structures in your code (probably not efficient, but convenient)
1010 // Types are NOT stored, so it is up to you to make sure your Key don't collide with different types.
1011 struct ImGuiStorage
1012 {
1013  struct Pair
1014  {
1015  ImGuiID key;
1016  union { int val_i; float val_f; void* val_p; };
1017  Pair(ImGuiID _key, int _val_i) { key = _key; val_i = _val_i; }
1018  Pair(ImGuiID _key, float _val_f) { key = _key; val_f = _val_f; }
1019  Pair(ImGuiID _key, void* _val_p) { key = _key; val_p = _val_p; }
1020  };
1021  ImVector<Pair> Data;
1022 
1023  // - Get***() functions find pair, never add/allocate. Pairs are sorted so a query is O(log N)
1024  // - Set***() functions find pair, insertion on demand if missing.
1025  // - Sorted insertion is costly, paid once. A typical frame shouldn't need to insert any new pair.
1026  IMGUI_API void Clear();
1027  IMGUI_API int GetInt(ImGuiID key, int default_val = 0) const;
1028  IMGUI_API void SetInt(ImGuiID key, int val);
1029  IMGUI_API bool GetBool(ImGuiID key, bool default_val = false) const;
1030  IMGUI_API void SetBool(ImGuiID key, bool val);
1031  IMGUI_API float GetFloat(ImGuiID key, float default_val = 0.0f) const;
1032  IMGUI_API void SetFloat(ImGuiID key, float val);
1033  IMGUI_API void* GetVoidPtr(ImGuiID key) const; // default_val is NULL
1034  IMGUI_API void SetVoidPtr(ImGuiID key, void* val);
1035 
1036  // - Get***Ref() functions finds pair, insert on demand if missing, return pointer. Useful if you intend to do Get+Set.
1037  // - References are only valid until a new value is added to the storage. Calling a Set***() function or a Get***Ref() function invalidates the pointer.
1038  // - A typical use case where this is convenient for quick hacking (e.g. add storage during a live Edit&Continue session if you can't modify existing struct)
1039  // float* pvar = ImGui::GetFloatRef(key); ImGui::SliderFloat("var", pvar, 0, 100.0f); some_var += *pvar;
1040  IMGUI_API int* GetIntRef(ImGuiID key, int default_val = 0);
1041  IMGUI_API bool* GetBoolRef(ImGuiID key, bool default_val = false);
1042  IMGUI_API float* GetFloatRef(ImGuiID key, float default_val = 0.0f);
1043  IMGUI_API void** GetVoidPtrRef(ImGuiID key, void* default_val = NULL);
1044 
1045  // Use on your own storage if you know only integer are being stored (open/close all tree nodes)
1046  IMGUI_API void SetAllInt(int val);
1047 };
1048 
1049 // Shared state of InputText(), passed to callback when a ImGuiInputTextFlags_Callback* flag is used and the corresponding callback is triggered.
1050 struct ImGuiTextEditCallbackData
1051 {
1052  ImGuiInputTextFlags EventFlag; // One of ImGuiInputTextFlags_Callback* // Read-only
1053  ImGuiInputTextFlags Flags; // What user passed to InputText() // Read-only
1054  void* UserData; // What user passed to InputText() // Read-only
1055  bool ReadOnly; // Read-only mode // Read-only
1056 
1057  // CharFilter event:
1058  ImWchar EventChar; // Character input // Read-write (replace character or set to zero)
1059 
1060  // Completion,History,Always events:
1061  // If you modify the buffer contents make sure you update 'BufTextLen' and set 'BufDirty' to true.
1062  ImGuiKey EventKey; // Key pressed (Up/Down/TAB) // Read-only
1063  char* Buf; // Current text buffer // Read-write (pointed data only, can't replace the actual pointer)
1064  int BufTextLen; // Current text length in bytes // Read-write
1065  int BufSize; // Maximum text length in bytes // Read-only
1066  bool BufDirty; // Set if you modify Buf/BufTextLen!! // Write
1067  int CursorPos; // // Read-write
1068  int SelectionStart; // // Read-write (== to SelectionEnd when no selection)
1069  int SelectionEnd; // // Read-write
1070 
1071  // NB: Helper functions for text manipulation. Calling those function loses selection.
1072  IMGUI_API void DeleteChars(int pos, int bytes_count);
1073  IMGUI_API void InsertChars(int pos, const char* text, const char* text_end = NULL);
1074  bool HasSelection() const { return SelectionStart != SelectionEnd; }
1075 };
1076 
1077 // Resizing callback data to apply custom constraint. As enabled by SetNextWindowSizeConstraints(). Callback is called during the next Begin().
1078 // NB: For basic min/max size constraint on each axis you don't need to use the callback! The SetNextWindowSizeConstraints() parameters are enough.
1079 struct ImGuiSizeConstraintCallbackData
1080 {
1081  void* UserData; // Read-only. What user passed to SetNextWindowSizeConstraints()
1082  ImVec2 Pos; // Read-only. Window position, for reference.
1083  ImVec2 CurrentSize; // Read-only. Current window size.
1084  ImVec2 DesiredSize; // Read-write. Desired size, based on user's mouse position. Write to this field to restrain resizing.
1085 };
1086 
1087 // Helpers macros to generate 32-bits encoded colors
1088 #ifdef IMGUI_USE_BGRA_PACKED_COLOR
1089 #define IM_COL32_R_SHIFT 16
1090 #define IM_COL32_G_SHIFT 8
1091 #define IM_COL32_B_SHIFT 0
1092 #define IM_COL32_A_SHIFT 24
1093 #define IM_COL32_A_MASK 0xFF000000
1094 #else
1095 #define IM_COL32_R_SHIFT 0
1096 #define IM_COL32_G_SHIFT 8
1097 #define IM_COL32_B_SHIFT 16
1098 #define IM_COL32_A_SHIFT 24
1099 #define IM_COL32_A_MASK 0xFF000000
1100 #endif
1101 #define IM_COL32(R,G,B,A) (((ImU32)(A)<<IM_COL32_A_SHIFT) | ((ImU32)(B)<<IM_COL32_B_SHIFT) | ((ImU32)(G)<<IM_COL32_G_SHIFT) | ((ImU32)(R)<<IM_COL32_R_SHIFT))
1102 #define IM_COL32_WHITE IM_COL32(255,255,255,255) // Opaque white = 0xFFFFFFFF
1103 #define IM_COL32_BLACK IM_COL32(0,0,0,255) // Opaque black
1104 #define IM_COL32_BLACK_TRANS IM_COL32(0,0,0,0) // Transparent black = 0x00000000
1105 
1106 // ImColor() helper to implicity converts colors to either ImU32 (packed 4x1 byte) or ImVec4 (4x1 float)
1107 // Prefer using IM_COL32() macros if you want a guaranteed compile-time ImU32 for usage with ImDrawList API.
1108 // **Avoid storing ImColor! Store either u32 of ImVec4. This is not a full-featured color class. MAY OBSOLETE.
1109 // **None of the ImGui API are using ImColor directly but you can use it as a convenience to pass colors in either ImU32 or ImVec4 formats. Explicitly cast to ImU32 or ImVec4 if needed.
1110 struct ImColor
1111 {
1112  ImVec4 Value;
1113 
1114  ImColor() { Value.x = Value.y = Value.z = Value.w = 0.0f; }
1115  ImColor(int r, int g, int b, int a = 255) { float sc = 1.0f/255.0f; Value.x = (float)r * sc; Value.y = (float)g * sc; Value.z = (float)b * sc; Value.w = (float)a * sc; }
1116  ImColor(ImU32 rgba) { float sc = 1.0f/255.0f; Value.x = (float)((rgba>>IM_COL32_R_SHIFT)&0xFF) * sc; Value.y = (float)((rgba>>IM_COL32_G_SHIFT)&0xFF) * sc; Value.z = (float)((rgba>>IM_COL32_B_SHIFT)&0xFF) * sc; Value.w = (float)((rgba>>IM_COL32_A_SHIFT)&0xFF) * sc; }
1117  ImColor(float r, float g, float b, float a = 1.0f) { Value.x = r; Value.y = g; Value.z = b; Value.w = a; }
1118  ImColor(const ImVec4& col) { Value = col; }
1119  inline operator ImU32() const { return ImGui::ColorConvertFloat4ToU32(Value); }
1120  inline operator ImVec4() const { return Value; }
1121 
1122  // FIXME-OBSOLETE: May need to obsolete/cleanup those helpers.
1123  inline void SetHSV(float h, float s, float v, float a = 1.0f){ ImGui::ColorConvertHSVtoRGB(h, s, v, Value.x, Value.y, Value.z); Value.w = a; }
1124  static ImColor HSV(float h, float s, float v, float a = 1.0f) { float r,g,b; ImGui::ColorConvertHSVtoRGB(h, s, v, r, g, b); return ImColor(r,g,b,a); }
1125 };
1126 
1127 // Helper: Manually clip large list of items.
1128 // If you are submitting lots of evenly spaced items and you have a random access to the list, you can perform coarse clipping based on visibility to save yourself from processing those items at all.
1129 // The clipper calculates the range of visible items and advance the cursor to compensate for the non-visible items we have skipped.
1130 // ImGui already clip items based on their bounds but it needs to measure text size to do so. Coarse clipping before submission makes this cost and your own data fetching/submission cost null.
1131 // Usage:
1132 // ImGuiListClipper clipper(1000); // we have 1000 elements, evenly spaced.
1133 // while (clipper.Step())
1134 // for (int i = clipper.DisplayStart; i < clipper.DisplayEnd; i++)
1135 // ImGui::Text("line number %d", i);
1136 // - Step 0: the clipper let you process the first element, regardless of it being visible or not, so we can measure the element height (step skipped if we passed a known height as second arg to constructor).
1137 // - Step 1: the clipper infer height from first element, calculate the actual range of elements to display, and position the cursor before the first element.
1138 // - (Step 2: dummy step only required if an explicit items_height was passed to constructor or Begin() and user call Step(). Does nothing and switch to Step 3.)
1139 // - Step 3: the clipper validate that we have reached the expected Y position (corresponding to element DisplayEnd), advance the cursor to the end of the list and then returns 'false' to end the loop.
1140 struct ImGuiListClipper
1141 {
1142  float StartPosY;
1143  float ItemsHeight;
1144  int ItemsCount, StepNo, DisplayStart, DisplayEnd;
1145 
1146  // items_count: Use -1 to ignore (you can call Begin later). Use INT_MAX if you don't know how many items you have (in which case the cursor won't be advanced in the final step).
1147  // items_height: Use -1.0f to be calculated automatically on first step. Otherwise pass in the distance between your items, typically GetTextLineHeightWithSpacing() or GetItemsLineHeightWithSpacing().
1148  // If you don't specify an items_height, you NEED to call Step(). If you specify items_height you may call the old Begin()/End() api directly, but prefer calling Step().
1149  ImGuiListClipper(int items_count = -1, float items_height = -1.0f) { Begin(items_count, items_height); } // NB: Begin() initialize every fields (as we allow user to call Begin/End multiple times on a same instance if they want).
1150  ~ImGuiListClipper() { IM_ASSERT(ItemsCount == -1); } // Assert if user forgot to call End() or Step() until false.
1151 
1152  IMGUI_API bool Step(); // Call until it returns false. The DisplayStart/DisplayEnd fields will be set and you can process/draw those items.
1153  IMGUI_API void Begin(int items_count, float items_height = -1.0f); // Automatically called by constructor if you passed 'items_count' or by Step() in Step 1.
1154  IMGUI_API void End(); // Automatically called on the last call of Step() that returns false.
1155 };
1156 
1157 //-----------------------------------------------------------------------------
1158 // Draw List
1159 // Hold a series of drawing commands. The user provides a renderer for ImDrawData which essentially contains an array of ImDrawList.
1160 //-----------------------------------------------------------------------------
1161 
1162 // Draw callbacks for advanced uses.
1163 // NB- You most likely do NOT need to use draw callbacks just to create your own widget or customized UI rendering (you can poke into the draw list for that)
1164 // Draw callback may be useful for example, A) Change your GPU render state, B) render a complex 3D scene inside a UI element (without an intermediate texture/render target), etc.
1165 // The expected behavior from your rendering function is 'if (cmd.UserCallback != NULL) cmd.UserCallback(parent_list, cmd); else RenderTriangles()'
1166 typedef void (*ImDrawCallback)(const ImDrawList* parent_list, const ImDrawCmd* cmd);
1167 
1168 // Typically, 1 command = 1 gpu draw call (unless command is a callback)
1169 struct ImDrawCmd
1170 {
1171  unsigned int ElemCount; // Number of indices (multiple of 3) to be rendered as triangles. Vertices are stored in the callee ImDrawList's vtx_buffer[] array, indices in idx_buffer[].
1172  ImVec4 ClipRect; // Clipping rectangle (x1, y1, x2, y2)
1173  ImTextureID TextureId; // User-provided texture ID. Set by user in ImfontAtlas::SetTexID() for fonts or passed to Image*() functions. Ignore if never using images or multiple fonts atlas.
1174  ImDrawCallback UserCallback; // If != NULL, call the function instead of rendering the vertices. clip_rect and texture_id will be set normally.
1175  void* UserCallbackData; // The draw callback code can access this.
1176 
1177  ImDrawCmd() { ElemCount = 0; ClipRect.x = ClipRect.y = -8192.0f; ClipRect.z = ClipRect.w = +8192.0f; TextureId = NULL; UserCallback = NULL; UserCallbackData = NULL; }
1178 };
1179 
1180 // Vertex index (override with '#define ImDrawIdx unsigned int' inside in imconfig.h)
1181 #ifndef ImDrawIdx
1182 typedef unsigned short ImDrawIdx;
1183 #endif
1184 
1185 // Vertex layout
1186 #ifndef IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT
1187 struct ImDrawVert
1188 {
1189  ImVec2 pos;
1190  ImVec2 uv;
1191  ImU32 col;
1192 };
1193 #else
1194 // You can override the vertex format layout by defining IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT in imconfig.h
1195 // The code expect ImVec2 pos (8 bytes), ImVec2 uv (8 bytes), ImU32 col (4 bytes), but you can re-order them or add other fields as needed to simplify integration in your engine.
1196 // The type has to be described within the macro (you can either declare the struct or use a typedef)
1197 // NOTE: IMGUI DOESN'T CLEAR THE STRUCTURE AND DOESN'T CALL A CONSTRUCTOR SO ANY CUSTOM FIELD WILL BE UNINITIALIZED. IF YOU ADD EXTRA FIELDS (SUCH AS A 'Z' COORDINATES) YOU WILL NEED TO CLEAR THEM DURING RENDER OR TO IGNORE THEM.
1198 IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT;
1199 #endif
1200 
1201 // Draw channels are used by the Columns API to "split" the render list into different channels while building, so items of each column can be batched together.
1202 // You can also use them to simulate drawing layers and submit primitives in a different order than how they will be rendered.
1203 struct ImDrawChannel
1204 {
1205  ImVector<ImDrawCmd> CmdBuffer;
1206  ImVector<ImDrawIdx> IdxBuffer;
1207 };
1208 
1209 // Draw command list
1210 // This is the low-level list of polygons that ImGui functions are filling. At the end of the frame, all command lists are passed to your ImGuiIO::RenderDrawListFn function for rendering.
1211 // At the moment, each ImGui window contains its own ImDrawList but they could potentially be merged in the future.
1212 // If you want to add custom rendering within a window, you can use ImGui::GetWindowDrawList() to access the current draw list and add your own primitives.
1213 // You can interleave normal ImGui:: calls and adding primitives to the current draw list.
1214 // All positions are generally in pixel coordinates (top-left at (0,0), bottom-right at io.DisplaySize), however you are totally free to apply whatever transformation matrix to want to the data (if you apply such transformation you'll want to apply it to ClipRect as well)
1215 // Primitives are always added to the list and not culled (culling is done at higher-level by ImGui:: functions).
1216 struct ImDrawList
1217 {
1218  // This is what you have to render
1219  ImVector<ImDrawCmd> CmdBuffer; // Commands. Typically 1 command = 1 GPU draw call.
1220  ImVector<ImDrawIdx> IdxBuffer; // Index buffer. Each command consume ImDrawCmd::ElemCount of those
1221  ImVector<ImDrawVert> VtxBuffer; // Vertex buffer.
1222 
1223  // [Internal, used while building lists]
1224  const char* _OwnerName; // Pointer to owner window's name for debugging
1225  unsigned int _VtxCurrentIdx; // [Internal] == VtxBuffer.Size
1226  ImDrawVert* _VtxWritePtr; // [Internal] point within VtxBuffer.Data after each add command (to avoid using the ImVector<> operators too much)
1227  ImDrawIdx* _IdxWritePtr; // [Internal] point within IdxBuffer.Data after each add command (to avoid using the ImVector<> operators too much)
1228  ImVector<ImVec4> _ClipRectStack; // [Internal]
1229  ImVector<ImTextureID> _TextureIdStack; // [Internal]
1230  ImVector<ImVec2> _Path; // [Internal] current path building
1231  int _ChannelsCurrent; // [Internal] current channel number (0)
1232  int _ChannelsCount; // [Internal] number of active channels (1+)
1233  ImVector<ImDrawChannel> _Channels; // [Internal] draw channels for columns API (not resized down so _ChannelsCount may be smaller than _Channels.Size)
1234 
1235  ImDrawList() { _OwnerName = NULL; Clear(); }
1236  ~ImDrawList() { ClearFreeMemory(); }
1237  IMGUI_API void PushClipRect(ImVec2 clip_rect_min, ImVec2 clip_rect_max, bool intersect_with_current_clip_rect = false); // 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)
1238  IMGUI_API void PushClipRectFullScreen();
1239  IMGUI_API void PopClipRect();
1240  IMGUI_API void PushTextureID(const ImTextureID& texture_id);
1241  IMGUI_API void PopTextureID();
1242  inline ImVec2 GetClipRectMin() const { const ImVec4& cr = _ClipRectStack.back(); return ImVec2(cr.x, cr.y); }
1243  inline ImVec2 GetClipRectMax() const { const ImVec4& cr = _ClipRectStack.back(); return ImVec2(cr.z, cr.w); }
1244 
1245  // Primitives
1246  IMGUI_API void AddLine(const ImVec2& a, const ImVec2& b, ImU32 col, float thickness = 1.0f);
1247  IMGUI_API void AddRect(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding = 0.0f, int rounding_corners_flags = ~0, float thickness = 1.0f); // a: upper-left, b: lower-right, rounding_corners_flags: 4-bits corresponding to which corner to round
1248  IMGUI_API void AddRectFilled(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding = 0.0f, int rounding_corners_flags = ~0); // a: upper-left, b: lower-right
1249  IMGUI_API void AddRectFilledMultiColor(const ImVec2& a, const ImVec2& b, ImU32 col_upr_left, ImU32 col_upr_right, ImU32 col_bot_right, ImU32 col_bot_left);
1250  IMGUI_API void AddQuad(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& d, ImU32 col, float thickness = 1.0f);
1251  IMGUI_API void AddQuadFilled(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& d, ImU32 col);
1252  IMGUI_API void AddTriangle(const ImVec2& a, const ImVec2& b, const ImVec2& c, ImU32 col, float thickness = 1.0f);
1253  IMGUI_API void AddTriangleFilled(const ImVec2& a, const ImVec2& b, const ImVec2& c, ImU32 col);
1254  IMGUI_API void AddCircle(const ImVec2& centre, float radius, ImU32 col, int num_segments = 12, float thickness = 1.0f);
1255  IMGUI_API void AddCircleFilled(const ImVec2& centre, float radius, ImU32 col, int num_segments = 12);
1256  IMGUI_API void AddText(const ImVec2& pos, ImU32 col, const char* text_begin, const char* text_end = NULL);
1257  IMGUI_API void AddText(const ImFont* font, float font_size, const ImVec2& pos, ImU32 col, const char* text_begin, const char* text_end = NULL, float wrap_width = 0.0f, const ImVec4* cpu_fine_clip_rect = NULL);
1258  IMGUI_API void AddImage(ImTextureID user_texture_id, const ImVec2& a, const ImVec2& b, const ImVec2& uv_a = ImVec2(0,0), const ImVec2& uv_b = ImVec2(1,1), ImU32 col = 0xFFFFFFFF);
1259  IMGUI_API void AddImageQuad(ImTextureID user_texture_id, const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& d, const ImVec2& uv_a = ImVec2(0,0), const ImVec2& uv_b = ImVec2(1,0), const ImVec2& uv_c = ImVec2(1,1), const ImVec2& uv_d = ImVec2(0,1), ImU32 col = 0xFFFFFFFF);
1260  IMGUI_API void AddPolyline(const ImVec2* points, const int num_points, ImU32 col, bool closed, float thickness, bool anti_aliased);
1261  IMGUI_API void AddConvexPolyFilled(const ImVec2* points, const int num_points, ImU32 col, bool anti_aliased);
1262  IMGUI_API void AddBezierCurve(const ImVec2& pos0, const ImVec2& cp0, const ImVec2& cp1, const ImVec2& pos1, ImU32 col, float thickness, int num_segments = 0);
1263 
1264  // Stateful path API, add points then finish with PathFill() or PathStroke()
1265  inline void PathClear() { _Path.resize(0); }
1266  inline void PathLineTo(const ImVec2& pos) { _Path.push_back(pos); }
1267  inline void PathLineToMergeDuplicate(const ImVec2& pos) { if (_Path.Size == 0 || memcmp(&_Path[_Path.Size-1], &pos, 8) != 0) _Path.push_back(pos); }
1268  inline void PathFillConvex(ImU32 col) { AddConvexPolyFilled(_Path.Data, _Path.Size, col, true); PathClear(); }
1269  inline void PathStroke(ImU32 col, bool closed, float thickness = 1.0f) { AddPolyline(_Path.Data, _Path.Size, col, closed, thickness, true); PathClear(); }
1270  IMGUI_API void PathArcTo(const ImVec2& centre, float radius, float a_min, float a_max, int num_segments = 10);
1271  IMGUI_API void PathArcToFast(const ImVec2& centre, float radius, int a_min_of_12, int a_max_of_12); // Use precomputed angles for a 12 steps circle
1272  IMGUI_API void PathBezierCurveTo(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, int num_segments = 0);
1273  IMGUI_API void PathRect(const ImVec2& rect_min, const ImVec2& rect_max, float rounding = 0.0f, int rounding_corners_flags = ~0); // rounding_corners_flags: 4-bits corresponding to which corner to round
1274 
1275  // Channels
1276  // - Use to simulate layers. By switching channels to can render out-of-order (e.g. submit foreground primitives before background primitives)
1277  // - Use to minimize draw calls (e.g. if going back-and-forth between multiple non-overlapping clipping rectangles, prefer to append into separate channels then merge at the end)
1278  IMGUI_API void ChannelsSplit(int channels_count);
1279  IMGUI_API void ChannelsMerge();
1280  IMGUI_API void ChannelsSetCurrent(int channel_index);
1281 
1282  // Advanced
1283  IMGUI_API void AddCallback(ImDrawCallback callback, void* callback_data); // Your rendering function must check for 'UserCallback' in ImDrawCmd and call the function instead of rendering triangles.
1284  IMGUI_API void AddDrawCmd(); // This is useful if you need to forcefully create a new draw call (to allow for dependent rendering / blending). Otherwise primitives are merged into the same draw-call as much as possible
1285 
1286  // Internal helpers
1287  // NB: all primitives needs to be reserved via PrimReserve() beforehand!
1288  IMGUI_API void Clear();
1289  IMGUI_API void ClearFreeMemory();
1290  IMGUI_API void PrimReserve(int idx_count, int vtx_count);
1291  IMGUI_API void PrimRect(const ImVec2& a, const ImVec2& b, ImU32 col); // Axis aligned rectangle (composed of two triangles)
1292  IMGUI_API void PrimRectUV(const ImVec2& a, const ImVec2& b, const ImVec2& uv_a, const ImVec2& uv_b, ImU32 col);
1293  IMGUI_API void 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);
1294  inline void PrimWriteVtx(const ImVec2& pos, const ImVec2& uv, ImU32 col){ _VtxWritePtr->pos = pos; _VtxWritePtr->uv = uv; _VtxWritePtr->col = col; _VtxWritePtr++; _VtxCurrentIdx++; }
1295  inline void PrimWriteIdx(ImDrawIdx idx) { *_IdxWritePtr = idx; _IdxWritePtr++; }
1296  inline void PrimVtx(const ImVec2& pos, const ImVec2& uv, ImU32 col) { PrimWriteIdx((ImDrawIdx)_VtxCurrentIdx); PrimWriteVtx(pos, uv, col); }
1297  IMGUI_API void UpdateClipRect();
1298  IMGUI_API void UpdateTextureID();
1299 };
1300 
1301 // All draw data to render an ImGui frame
1302 struct ImDrawData
1303 {
1304  bool Valid; // Only valid after Render() is called and before the next NewFrame() is called.
1305  ImDrawList** CmdLists;
1306  int CmdListsCount;
1307  int TotalVtxCount; // For convenience, sum of all cmd_lists vtx_buffer.Size
1308  int TotalIdxCount; // For convenience, sum of all cmd_lists idx_buffer.Size
1309 
1310  // Functions
1311  ImDrawData() { Valid = false; CmdLists = NULL; CmdListsCount = TotalVtxCount = TotalIdxCount = 0; }
1312  IMGUI_API void DeIndexAllBuffers(); // For backward compatibility or convenience: 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!
1313  IMGUI_API void ScaleClipRects(const ImVec2& sc); // Helper to scale the ClipRect field of each ImDrawCmd. Use if your final output buffer is at a different scale than ImGui expects, or if there is a difference between your window resolution and framebuffer resolution.
1314 };
1315 
1316 struct ImFontConfig
1317 {
1318  void* FontData; // // TTF/OTF data
1319  int FontDataSize; // // TTF/OTF data size
1320  bool FontDataOwnedByAtlas; // true // TTF/OTF data ownership taken by the container ImFontAtlas (will delete memory itself). Set to true
1321  int FontNo; // 0 // Index of font within TTF/OTF file
1322  float SizePixels; // // Size in pixels for rasterizer
1323  int OversampleH, OversampleV; // 3, 1 // Rasterize at higher quality for sub-pixel positioning. We don't use sub-pixel positions on the Y axis.
1324  bool PixelSnapH; // false // Align every glyph to pixel boundary. Useful e.g. if you are merging a non-pixel aligned font with the default font. If enabled, you can set OversampleH/V to 1.
1325  ImVec2 GlyphExtraSpacing; // 0, 0 // Extra spacing (in pixels) between glyphs. Only X axis is supported for now.
1326  ImVec2 GlyphOffset; // 0, 0 // Offset all glyphs from this font input
1327  const ImWchar* GlyphRanges; // // Pointer to a user-provided list of Unicode range (2 value per range, values are inclusive, zero-terminated list). THE ARRAY DATA NEEDS TO PERSIST AS LONG AS THE FONT IS ALIVE.
1328  bool MergeMode; // false // Merge into previous ImFont, so you can combine multiple inputs font into one ImFont (e.g. ASCII font + icons + Japanese glyphs). You may want to use GlyphOffset.y when merge font of different heights.
1329 
1330  // [Internal]
1331  char Name[32]; // Name (strictly to ease debugging)
1332  ImFont* DstFont;
1333 
1334  IMGUI_API ImFontConfig();
1335 };
1336 
1337 // Load and rasterize multiple TTF/OTF fonts into a same texture.
1338 // Sharing a texture for multiple fonts allows us to reduce the number of draw calls during rendering.
1339 // We also add custom graphic data into the texture that serves for ImGui.
1340 // 1. (Optional) Call AddFont*** functions. If you don't call any, the default font will be loaded for you.
1341 // 2. Call GetTexDataAsAlpha8() or GetTexDataAsRGBA32() to build and retrieve pixels data.
1342 // 3. Upload the pixels data into a texture within your graphics system.
1343 // 4. Call SetTexID(my_tex_id); and pass the pointer/identifier to your texture. This value will be passed back to you during rendering to identify the texture.
1344 // IMPORTANT: If you pass a 'glyph_ranges' array to AddFont*** functions, you need to make sure that your array persist up until the ImFont is build (when calling GetTextData*** or Build()). We only copy the pointer, not the data.
1345 struct ImFontAtlas
1346 {
1347  IMGUI_API ImFontAtlas();
1348  IMGUI_API ~ImFontAtlas();
1349  IMGUI_API ImFont* AddFont(const ImFontConfig* font_cfg);
1350  IMGUI_API ImFont* AddFontDefault(const ImFontConfig* font_cfg = NULL);
1351  IMGUI_API ImFont* AddFontFromFileTTF(const char* filename, float size_pixels, const ImFontConfig* font_cfg = NULL, const ImWchar* glyph_ranges = NULL);
1352  IMGUI_API ImFont* AddFontFromMemoryTTF(void* font_data, int font_size, float size_pixels, const ImFontConfig* font_cfg = NULL, const ImWchar* glyph_ranges = NULL); // Transfer ownership of 'ttf_data' to ImFontAtlas, will be deleted after Build()
1353  IMGUI_API ImFont* AddFontFromMemoryCompressedTTF(const void* compressed_font_data, int compressed_font_size, float size_pixels, const ImFontConfig* font_cfg = NULL, const ImWchar* glyph_ranges = NULL); // 'compressed_font_data' still owned by caller. Compress with binary_to_compressed_c.cpp
1354  IMGUI_API ImFont* AddFontFromMemoryCompressedBase85TTF(const char* compressed_font_data_base85, float size_pixels, const ImFontConfig* font_cfg = NULL, const ImWchar* glyph_ranges = NULL); // 'compressed_font_data_base85' still owned by caller. Compress with binary_to_compressed_c.cpp with -base85 paramaeter
1355  IMGUI_API void ClearTexData(); // Clear the CPU-side texture data. Saves RAM once the texture has been copied to graphics memory.
1356  IMGUI_API void ClearInputData(); // Clear the input TTF data (inc sizes, glyph ranges)
1357  IMGUI_API void ClearFonts(); // Clear the ImGui-side font data (glyphs storage, UV coordinates)
1358  IMGUI_API void Clear(); // Clear all
1359 
1360  // Retrieve texture data
1361  // User is in charge of copying the pixels into graphics memory, then call SetTextureUserID()
1362  // After loading the texture into your graphic system, store your texture handle in 'TexID' (ignore if you aren't using multiple fonts nor images)
1363  // RGBA32 format is provided for convenience and high compatibility, but note that all RGB pixels are white, so 75% of the memory is wasted.
1364  // Pitch = Width * BytesPerPixels
1365  IMGUI_API void GetTexDataAsAlpha8(unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel = NULL); // 1 byte per-pixel
1366  IMGUI_API void GetTexDataAsRGBA32(unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel = NULL); // 4 bytes-per-pixel
1367  void SetTexID(ImTextureID id) { TexID = id; }
1368 
1369  // Helpers to retrieve list of common Unicode ranges (2 value per range, values are inclusive, zero-terminated list)
1370  // NB: Make sure that your string are UTF-8 and NOT in your local code page. In C++11, you can create UTF-8 string literal using the u8"Hello world" syntax. See FAQ for details.
1371  IMGUI_API const ImWchar* GetGlyphRangesDefault(); // Basic Latin, Extended Latin
1372  IMGUI_API const ImWchar* GetGlyphRangesKorean(); // Default + Korean characters
1373  IMGUI_API const ImWchar* GetGlyphRangesJapanese(); // Default + Hiragana, Katakana, Half-Width, Selection of 1946 Ideographs
1374  IMGUI_API const ImWchar* GetGlyphRangesChinese(); // Japanese + full set of about 21000 CJK Unified Ideographs
1375  IMGUI_API const ImWchar* GetGlyphRangesCyrillic(); // Default + about 400 Cyrillic characters
1376  IMGUI_API const ImWchar* GetGlyphRangesThai(); // Default + Thai characters
1377 
1378  // Helpers to build glyph ranges from text data. Feed all your application strings/characters to it then call BuildRanges().
1379  struct GlyphRangesBuilder
1380  {
1381  ImVector<unsigned char> UsedChars; // Store 1-bit per Unicode code point (0=unused, 1=used)
1382  GlyphRangesBuilder() { UsedChars.resize(0x10000 / 8); memset(UsedChars.Data, 0, 0x10000 / 8); }
1383  bool GetBit(int n) { return (UsedChars[n >> 3] & (1 << (n & 7))) != 0; }
1384  void SetBit(int n) { UsedChars[n >> 3] |= 1 << (n & 7); } // Set bit 'c' in the array
1385  void AddChar(ImWchar c) { SetBit(c); } // Add character
1386  IMGUI_API void AddText(const char* text, const char* text_end = NULL); // Add string (each character of the UTF-8 string are added)
1387  IMGUI_API void AddRanges(const ImWchar* ranges); // Add ranges, e.g. builder.AddRanges(ImFontAtlas::GetGlyphRangesDefault) to force add all of ASCII/Latin+Ext
1388  IMGUI_API void BuildRanges(ImVector<ImWchar>* out_ranges); // Output new ranges
1389  };
1390 
1391  // Members
1392  // (Access texture data via GetTexData*() calls which will setup a default font for you.)
1393  ImTextureID TexID; // User data to refer to the texture once it has been uploaded to user's graphic systems. It is passed back to you during rendering via the ImDrawCmd structure.
1394  unsigned char* TexPixelsAlpha8; // 1 component per pixel, each component is unsigned 8-bit. Total size = TexWidth * TexHeight
1395  unsigned int* TexPixelsRGBA32; // 4 component per pixel, each component is unsigned 8-bit. Total size = TexWidth * TexHeight * 4
1396  int TexWidth; // Texture width calculated during Build().
1397  int TexHeight; // Texture height calculated during Build().
1398  int TexDesiredWidth; // Texture width desired by user before Build(). Must be a power-of-two. If have many glyphs your graphics API have texture size restrictions you may want to increase texture width to decrease height.
1399  int TexGlyphPadding; // Padding between glyphs within texture in pixels. Defaults to 1.
1400  ImVec2 TexUvWhitePixel; // Texture coordinates to a white pixel
1401  ImVector<ImFont*> Fonts; // Hold all the fonts returned by AddFont*. Fonts[0] is the default font upon calling ImGui::NewFrame(), use ImGui::PushFont()/PopFont() to change the current font.
1402 
1403  // [Private] User rectangle for packing custom texture data into the atlas.
1404  struct CustomRect
1405  {
1406  unsigned int ID; // Input // User ID. <0x10000 for font mapped data (WIP/UNSUPPORTED), >=0x10000 for other texture data
1407  unsigned short Width, Height; // Input // Desired rectangle dimension
1408  unsigned short X, Y; // Output // Packed position in Atlas
1409  CustomRect() { ID = 0xFFFFFFFF; Width = Height = 0; X = Y = 0xFFFF; }
1410  bool IsPacked() const { return X != 0xFFFF; }
1411  };
1412 
1413  // [Private] Members
1414  ImVector<CustomRect> CustomRects; // Rectangles for packing custom texture data into the atlas.
1415  ImVector<ImFontConfig> ConfigData; // Internal data
1416  IMGUI_API bool Build(); // Build pixels data. This is automatically for you by the GetTexData*** functions.
1417  IMGUI_API int CustomRectRegister(unsigned int id, int width, int height);
1418  IMGUI_API void CustomRectCalcUV(const CustomRect* rect, ImVec2* out_uv_min, ImVec2* out_uv_max);
1419 };
1420 
1421 // Font runtime data and rendering
1422 // ImFontAtlas automatically loads a default embedded font for you when you call GetTexDataAsAlpha8() or GetTexDataAsRGBA32().
1423 struct ImFont
1424 {
1425  struct Glyph
1426  {
1427  ImWchar Codepoint;
1428  float XAdvance;
1429  float X0, Y0, X1, Y1;
1430  float U0, V0, U1, V1; // Texture coordinates
1431  };
1432 
1433  // Members: Hot ~62/78 bytes
1434  float FontSize; // <user set> // Height of characters, set during loading (don't change after loading)
1435  float Scale; // = 1.f // Base font scale, multiplied by the per-window font scale which you can adjust with SetFontScale()
1436  ImVec2 DisplayOffset; // = (0.f,1.f) // Offset font rendering by xx pixels
1437  ImVector<Glyph> Glyphs; // // All glyphs.
1438  ImVector<float> IndexXAdvance; // // Sparse. Glyphs->XAdvance in a directly indexable way (more cache-friendly, for CalcTextSize functions which are often bottleneck in large UI).
1439  ImVector<unsigned short> IndexLookup; // // Sparse. Index glyphs by Unicode code-point.
1440  const Glyph* FallbackGlyph; // == FindGlyph(FontFallbackChar)
1441  float FallbackXAdvance; // == FallbackGlyph->XAdvance
1442  ImWchar FallbackChar; // = '?' // Replacement glyph if one isn't found. Only set via SetFallbackChar()
1443 
1444  // Members: Cold ~18/26 bytes
1445  short ConfigDataCount; // ~ 1 // Number of ImFontConfig involved in creating this font. Bigger than 1 when merging multiple font sources into one ImFont.
1446  ImFontConfig* ConfigData; // // Pointer within ContainerAtlas->ConfigData
1447  ImFontAtlas* ContainerAtlas; // // What we has been loaded into
1448  float Ascent, Descent; // // Ascent: distance from top to bottom of e.g. 'A' [0..FontSize]
1449  int MetricsTotalSurface;// // Total surface in pixels to get an idea of the font rasterization/texture cost (not exact, we approximate the cost of padding between glyphs)
1450 
1451  // Methods
1452  IMGUI_API ImFont();
1453  IMGUI_API ~ImFont();
1454  IMGUI_API void Clear();
1455  IMGUI_API void BuildLookupTable();
1456  IMGUI_API const Glyph* FindGlyph(ImWchar c) const;
1457  IMGUI_API void SetFallbackChar(ImWchar c);
1458  float GetCharAdvance(ImWchar c) const { return ((int)c < IndexXAdvance.Size) ? IndexXAdvance[(int)c] : FallbackXAdvance; }
1459  bool IsLoaded() const { return ContainerAtlas != NULL; }
1460 
1461  // 'max_width' stops rendering after a certain width (could be turned into a 2d size). FLT_MAX to disable.
1462  // 'wrap_width' enable automatic word-wrapping across multiple lines to fit into given width. 0.0f to disable.
1463  IMGUI_API ImVec2 CalcTextSizeA(float size, float max_width, float wrap_width, const char* text_begin, const char* text_end = NULL, const char** remaining = NULL) const; // utf8
1464  IMGUI_API const char* CalcWordWrapPositionA(float scale, const char* text, const char* text_end, float wrap_width) const;
1465  IMGUI_API void RenderChar(ImDrawList* draw_list, float size, ImVec2 pos, ImU32 col, unsigned short c) const;
1466  IMGUI_API void RenderText(ImDrawList* draw_list, float size, ImVec2 pos, ImU32 col, const ImVec4& clip_rect, const char* text_begin, const char* text_end, float wrap_width = 0.0f, bool cpu_fine_clip = false) const;
1467 
1468  // Private
1469  IMGUI_API void GrowIndex(int new_size);
1470  IMGUI_API void AddRemapChar(ImWchar dst, ImWchar src, bool overwrite_dst = true); // Makes 'dst' character/glyph points to 'src' character/glyph. Currently needs to be called AFTER fonts have been built.
1471 };
1472 
1473 #if defined(__clang__)
1474 #pragma clang diagnostic pop
1475 #endif
1476 
1477 // Include imgui_user.h at the end of imgui.h (convenient for user to only explicitly include vanilla imgui.h)
1478 #ifdef IMGUI_INCLUDE_IMGUI_USER_H
1479 #include "imgui_user.h"
1480 #endif

Copyright © 2005-2018 VT MAK. All Rights Reserved (www.mak.com)