// dear imgui, v1.92.9 WIP

// (internal structures/api)

// You may use this file to debug, understand or extend Dear ImGui features but we don't provide any guarantee of forward compatibility.

/*

Index of this file:

// [SECTION] Header mess

// [SECTION] Forward declarations

// [SECTION] Context pointer

// [SECTION] STB libraries includes

// [SECTION] Macros

// [SECTION] Generic helpers

// [SECTION] ImDrawList support

// [SECTION] Style support

// [SECTION] Data types support

// [SECTION] Widgets support: flags, enums, data structures

// [SECTION] Popup support

// [SECTION] Inputs support

// [SECTION] Clipper support

// [SECTION] Navigation support

// [SECTION] Typing-select support

// [SECTION] Columns support

// [SECTION] Box-select support

// [SECTION] Multi-select support

// [SECTION] Docking support

// [SECTION] Viewport support

// [SECTION] Settings support

// [SECTION] Localization support

// [SECTION] Error handling, State recovery support

// [SECTION] Metrics, Debug tools

// [SECTION] Generic context hooks

// [SECTION] ImGuiContext (main imgui context)

// [SECTION] ImGuiWindowTempData, ImGuiWindow

// [SECTION] Tab bar, Tab item support

// [SECTION] Table support + internal API

// [SECTION] ImGui internal API

// [SECTION] ImFontLoader

// [SECTION] ImFontAtlas internal API

// [SECTION] Test Engine specific hooks (imgui_test_engine)

*/

#pragma once

#ifndef IMGUI_DISABLE

//-----------------------------------------------------------------------------

// [SECTION] Header mess

//-----------------------------------------------------------------------------

#ifndef IMGUI_VERSION

#include "imgui.h"

#endif

#include <stdio.h>      // FILE*, sscanf

#include <stdlib.h>     // NULL, malloc, free, qsort, atoi, atof

#include <math.h>       // sqrtf, fabsf, fmodf, powf, floorf, ceilf, cosf, sinf

#include <limits.h>     // INT_MIN, INT_MAX

// Enable SSE intrinsics if available

#if (defined __SSE__ || defined __x86_64__ || defined _M_X64 || (defined(_M_IX86_FP) && (_M_IX86_FP >= 1))) && !defined(IMGUI_DISABLE_SSE) && !defined(_M_ARM64) && !defined(_M_ARM64EC)

#define IMGUI_ENABLE_SSE

#include <immintrin.h>

#if (defined __AVX__ || defined __SSE4_2__)

#define IMGUI_ENABLE_SSE4_2

#include <nmmintrin.h>

#endif

#endif

// Emscripten has partial SSE 4.2 support where _mm_crc32_u32 is not available. See https://emscripten.org/docs/porting/simd.html#id11 and #8213

#if defined(IMGUI_ENABLE_SSE4_2) && !defined(IMGUI_USE_LEGACY_CRC32_ADLER) && !defined(__EMSCRIPTEN__)

#define IMGUI_ENABLE_SSE4_2_CRC

#endif

// Visual Studio warnings

#ifdef _MSC_VER

#pragma warning (push)

#pragma warning (disable: 4251)     // class 'xxx' needs to have dll-interface to be used by clients of struct 'xxx' // when IMGUI_API is set to__declspec(dllexport)

#pragma warning (disable: 26495)    // [Static Analyzer] Variable 'XXX' is uninitialized. Always initialize a member variable (type.6).

#pragma warning (disable: 26812)    // [Static Analyzer] The enum type 'xxx' is unscoped. Prefer 'enum class' over 'enum' (Enum.3).

#if defined(_MSC_VER) && _MSC_VER >= 1922 // MSVC 2019 16.2 or later

#pragma warning (disable: 5054)     // operator '|': deprecated between enumerations of different types

#endif

#endif

// Clang/GCC warnings with -Weverything

#if defined(__clang__)

#pragma clang diagnostic push

#if __has_warning("-Wunknown-warning-option")

#pragma clang diagnostic ignored "-Wunknown-warning-option"         // warning: unknown warning group 'xxx'

#endif

#pragma clang diagnostic ignored "-Wunknown-pragmas"                // warning: unknown warning group 'xxx'

#pragma clang diagnostic ignored "-Wfloat-equal"                    // warning: comparing floating point with == or != is unsafe // storing and comparing against same constants ok, for ImFloor()

#pragma clang diagnostic ignored "-Wold-style-cast"                 // warning: use of old-style cast

#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"  // warning: zero as null pointer constant

#pragma clang diagnostic ignored "-Wdouble-promotion"               // warning: implicit conversion from 'float' to 'double' when passing argument to function

#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion"  // warning: implicit conversion from 'xxx' to 'float' may lose precision

#pragma clang diagnostic ignored "-Wmissing-noreturn"               // warning: function 'xxx' could be declared with attribute 'noreturn'

#pragma clang diagnostic ignored "-Wdeprecated-enum-enum-conversion"// warning: bitwise operation between different enumeration types ('XXXFlags_' and 'XXXFlagsPrivate_') is deprecated

#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"            // warning: 'xxx' is an unsafe pointer used for buffer access

#pragma clang diagnostic ignored "-Wnontrivial-memaccess"           // warning: first argument in call to 'memset' is a pointer to non-trivially copyable type

#elif defined(__GNUC__)

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wpragmas"                          // warning: unknown option after '#pragma GCC diagnostic' kind

#pragma GCC diagnostic ignored "-Wfloat-equal"                      // warning: comparing floating-point with '==' or '!=' is unsafe

#pragma GCC diagnostic ignored "-Wclass-memaccess"                  // [__GNUC__ >= 8] warning: 'memset/memcpy' clearing/writing an object of type 'xxxx' with no trivial copy-assignment; use assignment or value-initialization instead

#pragma GCC diagnostic ignored "-Wdeprecated-enum-enum-conversion"  // warning: bitwise operation between different enumeration types ('XXXFlags_' and 'XXXFlagsPrivate_') is deprecated

#pragma GCC diagnostic ignored "-Wsign-conversion"                  // warning: conversion to 'xxxx' from 'xxxx' may change the sign of the result

#endif

// In 1.89.4, we moved the implementation of "courtesy maths operators" from imgui_internal.h in imgui.h

// As they are frequently requested, we do not want to encourage to many people using imgui_internal.h

#if defined(IMGUI_DEFINE_MATH_OPERATORS) && !defined(IMGUI_DEFINE_MATH_OPERATORS_IMPLEMENTED)

#error Please '#define IMGUI_DEFINE_MATH_OPERATORS' _BEFORE_ including imgui.h!

#endif

// Legacy defines

#ifdef IMGUI_DISABLE_FORMAT_STRING_FUNCTIONS            // Renamed in 1.74

#error Use IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS

#endif

#ifdef IMGUI_DISABLE_MATH_FUNCTIONS                     // Renamed in 1.74

#error Use IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS

#endif

// Enable stb_truetype by default unless FreeType is enabled.

// You can compile with both by defining both IMGUI_ENABLE_FREETYPE and IMGUI_ENABLE_STB_TRUETYPE together.

#ifndef IMGUI_ENABLE_FREETYPE

#define IMGUI_ENABLE_STB_TRUETYPE

#endif

//-----------------------------------------------------------------------------

// [SECTION] Forward declarations

//-----------------------------------------------------------------------------

// Utilities

// (other types which are not forwarded declared are: ImBitArray<>, ImSpan<>, ImSpanAllocator<>, ImStableVector<>, ImPool<>, ImChunkStream<>)

struct ImBitVector;                 // Store 1-bit per value

struct ImRect;                      // An axis-aligned rectangle (2 points)

struct ImGuiTextIndex;              // Maintain a line index for a text buffer.

// ImDrawList/ImFontAtlas

struct ImDrawDataBuilder;           // Helper to build a ImDrawData instance

struct ImDrawListSharedData;        // Data shared between all ImDrawList instances

struct ImFontAtlasBuilder;          // Internal storage for incrementally packing and building a ImFontAtlas

struct ImFontAtlasPostProcessData;  // Data available to potential texture post-processing functions

struct ImFontAtlasRectEntry;        // Packed rectangle lookup entry

// ImGui

struct ImGuiBoxSelectState;         // Box-selection state (currently used by multi-selection, could potentially be used by others)

struct ImGuiColorMod;               // Stacked color modifier, backup of modified data so we can restore it

struct ImGuiContext;                // Main Dear ImGui context

struct ImGuiContextHook;            // Hook for extensions like ImGuiTestEngine

struct ImGuiDataTypeInfo;           // Type information associated to a ImGuiDataType enum

struct ImGuiDeactivatedItemData;    // Data for IsItemDeactivated()/IsItemDeactivatedAfterEdit() function.

struct ImGuiDockContext;            // Docking system context

struct ImGuiDockRequest;            // Docking system dock/undock queued request

struct ImGuiDockNode;               // Docking system node (hold a list of Windows OR two child dock nodes)

struct ImGuiDockNodeSettings;       // Storage for a dock node in .ini file (we preserve those even if the associated dock node isn't active during the session)

struct ImGuiErrorRecoveryState;     // Storage of stack sizes for error handling and recovery

struct ImGuiGroupData;              // Stacked storage data for BeginGroup()/EndGroup()

struct ImGuiInputTextState;         // Internal state of the currently focused/edited text input box

struct ImGuiInputTextDeactivateData;// Short term storage to backup text of a deactivating InputText() while another is stealing active id

struct ImGuiLastItemData;           // Status storage for last submitted items

struct ImGuiLocEntry;               // A localization entry.

struct ImGuiMenuColumns;            // Simple column measurement, currently used for MenuItem() only

struct ImGuiMultiSelectState;       // Multi-selection persistent state (for focused selection).

struct ImGuiMultiSelectTempData;    // Multi-selection temporary state (while traversing).

struct ImGuiNavItemData;            // Result of a keyboard/gamepad directional navigation move query result

struct ImGuiMetricsConfig;          // Storage for ShowMetricsWindow() and DebugNodeXXX() functions

struct ImGuiNextWindowData;         // Storage for SetNextWindow** functions

struct ImGuiNextItemData;           // Storage for SetNextItem** functions

struct ImGuiOldColumnData;          // Storage data for a single column for legacy Columns() api

struct ImGuiOldColumns;             // Storage data for a columns set for legacy Columns() api

struct ImGuiPopupData;              // Storage for current popup stack

struct ImGuiSettingsHandler;        // Storage for one type registered in the .ini file

struct ImGuiStyleMod;               // Stacked style modifier, backup of modified data so we can restore it

struct ImGuiStyleVarInfo;           // Style variable information (e.g. to access style variables from an enum)

struct ImGuiTabBar;                 // Storage for a tab bar

struct ImGuiTabItem;                // Storage for a tab item (within a tab bar)

struct ImGuiTable;                  // Storage for a table

struct ImGuiTableHeaderData;        // Storage for TableAngledHeadersRow()

struct ImGuiTableColumn;            // Storage for one column of a table

struct ImGuiTableInstanceData;      // Storage for one instance of a same table

struct ImGuiTableTempData;          // Temporary storage for one table (one per table in the stack), shared between tables.

struct ImGuiTableSettings;          // Storage for a table .ini settings

struct ImGuiTableColumnsSettings;   // Storage for a column .ini settings

struct ImGuiTreeNodeStackData;      // Temporary storage for TreeNode().

struct ImGuiTypingSelectState;      // Storage for GetTypingSelectRequest()

struct ImGuiTypingSelectRequest;    // Storage for GetTypingSelectRequest() (aimed to be public)

struct ImGuiWindow;                 // Storage for one window

struct ImGuiWindowDockStyle;        // Storage for window-style data which needs to be stored for docking purpose

struct ImGuiWindowTempData;         // Temporary storage for one window (that's the data which in theory we could ditch at the end of the frame, in practice we currently keep it for each window)

struct ImGuiWindowSettings;         // Storage for a window .ini settings (we keep one of those even if the actual window wasn't instanced during this session)

// Enumerations

// Use your programming IDE "Go to definition" facility on the names of the center columns to find the actual flags/enum lists.

enum ImGuiLocKey : int;                 // -> enum ImGuiLocKey              // Enum: a localization entry for translation.

typedef int ImGuiDataAuthority;         // -> enum ImGuiDataAuthority_      // Enum: for storing the source authority (dock node vs window) of a field

typedef int ImGuiLayoutType;            // -> enum ImGuiLayoutType_         // Enum: Horizontal or vertical

// Flags

typedef int ImDrawTextFlags;            // -> enum ImDrawTextFlags_         // Flags: for ImTextCalcWordWrapPositionEx()

typedef int ImGuiActivateFlags;         // -> enum ImGuiActivateFlags_      // Flags: for navigation/focus function (will be for ActivateItem() later)

typedef int ImGuiDebugLogFlags;         // -> enum ImGuiDebugLogFlags_      // Flags: for ShowDebugLogWindow(), g.DebugLogFlags

typedef int ImGuiFocusRequestFlags;     // -> enum ImGuiFocusRequestFlags_  // Flags: for FocusWindow()

typedef int ImGuiItemStatusFlags;       // -> enum ImGuiItemStatusFlags_    // Flags: for g.LastItemData.StatusFlags

typedef int ImGuiOldColumnFlags;        // -> enum ImGuiOldColumnFlags_     // Flags: for BeginColumns()

typedef int ImGuiLogFlags;              // -> enum ImGuiLogFlags_           // Flags: for LogBegin() text capturing function

typedef int ImGuiNavRenderCursorFlags;  // -> enum ImGuiNavRenderCursorFlags_//Flags: for RenderNavCursor()

typedef int ImGuiNavMoveFlags;          // -> enum ImGuiNavMoveFlags_       // Flags: for navigation requests

typedef int ImGuiNextItemDataFlags;     // -> enum ImGuiNextItemDataFlags_  // Flags: for SetNextItemXXX() functions

typedef int ImGuiNextWindowDataFlags;   // -> enum ImGuiNextWindowDataFlags_// Flags: for SetNextWindowXXX() functions

typedef int ImGuiScrollFlags;           // -> enum ImGuiScrollFlags_        // Flags: for ScrollToItem() and navigation requests

typedef int ImGuiSeparatorFlags;        // -> enum ImGuiSeparatorFlags_     // Flags: for SeparatorEx()

typedef int ImGuiTextFlags;             // -> enum ImGuiTextFlags_          // Flags: for TextEx()

typedef int ImGuiTooltipFlags;          // -> enum ImGuiTooltipFlags_       // Flags: for BeginTooltipEx()

typedef int ImGuiTypingSelectFlags;     // -> enum ImGuiTypingSelectFlags_  // Flags: for GetTypingSelectRequest()

typedef int ImGuiWindowBgClickFlags;    // -> enum ImGuiWindowBgClickFlags_ // Flags: for overriding behavior of clicking on window background/void.

typedef int ImGuiWindowRefreshFlags;    // -> enum ImGuiWindowRefreshFlags_ // Flags: for SetNextWindowRefreshPolicy()

// Table column indexing

typedef ImS16 ImGuiTableColumnIdx;

typedef ImU16 ImGuiTableDrawChannelIdx;

//-----------------------------------------------------------------------------

// [SECTION] Context pointer

// See implementation of this variable in imgui.cpp for comments and details.

//-----------------------------------------------------------------------------

#ifndef GImGui

extern IMGUI_API ImGuiContext* GImGui;  // Current implicit context pointer

#endif

//-----------------------------------------------------------------------------

// [SECTION] Macros

//-----------------------------------------------------------------------------

// Internal Drag and Drop payload types. String starting with '_' are reserved for Dear ImGui.

#define IMGUI_PAYLOAD_TYPE_WINDOW       "_IMWINDOW"     // Payload == ImGuiWindow*

// Debug Printing Into TTY

// (since IMGUI_VERSION_NUM >= 18729: IMGUI_DEBUG_LOG was reworked into IMGUI_DEBUG_PRINTF (and removed framecount from it). If you were using a #define IMGUI_DEBUG_LOG please rename)

#ifndef IMGUI_DEBUG_PRINTF

#ifndef IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS

#define IMGUI_DEBUG_PRINTF(_FMT,...)    printf(_FMT, __VA_ARGS__)

#else

#define IMGUI_DEBUG_PRINTF(_FMT,...)    ((void)0)

#endif

#endif

// Debug Logging for ShowDebugLogWindow(). This is designed for relatively rare events so please don't spam.

#define IMGUI_DEBUG_LOG_ERROR(...)      do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventError)       IMGUI_DEBUG_LOG(__VA_ARGS__); else g.DebugLogSkippedErrors++; } while (0)

#define IMGUI_DEBUG_LOG_ACTIVEID(...)   do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventActiveId)    IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)

#define IMGUI_DEBUG_LOG_FOCUS(...)      do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventFocus)       IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)

#define IMGUI_DEBUG_LOG_POPUP(...)      do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventPopup)       IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)

#define IMGUI_DEBUG_LOG_NAV(...)        do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventNav)         IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)

#define IMGUI_DEBUG_LOG_SELECTION(...)  do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventSelection)   IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)

#define IMGUI_DEBUG_LOG_TABLE(...)      do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventTable)       IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)

#define IMGUI_DEBUG_LOG_CLIPPER(...)    do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventClipper)     IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)

#define IMGUI_DEBUG_LOG_IO(...)         do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventIO)          IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)

#define IMGUI_DEBUG_LOG_FONT(...)       do { ImGuiContext* g2 = GImGui; if (g2 && g2->DebugLogFlags & ImGuiDebugLogFlags_EventFont) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0) // Called from ImFontAtlas function which may operate without a context.

#define IMGUI_DEBUG_LOG_INPUTROUTING(...) do{if (g.DebugLogFlags & ImGuiDebugLogFlags_EventInputRouting)IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)

#define IMGUI_DEBUG_LOG_DOCKING(...)    do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventDocking)     IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)

#define IMGUI_DEBUG_LOG_VIEWPORT(...)   do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventViewport)    IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)

// Debug options (also see ones on top of imgui.cpp)

//#define IMGUI_DEBUG_BOXSELECT

// Static Asserts

#define IM_STATIC_ASSERT(_COND)         static_assert(_COND, "")

// "Paranoid" Debug Asserts are meant to only be enabled during specific debugging/work, otherwise would slow down the code too much.

// We currently don't have many of those so the effect is currently negligible, but onward intent to add more aggressive ones in the code.

//#define IMGUI_DEBUG_PARANOID

#ifdef IMGUI_DEBUG_PARANOID

#define IM_ASSERT_PARANOID(_EXPR)       IM_ASSERT(_EXPR)

#else

#define IM_ASSERT_PARANOID(_EXPR)

#endif

// Misc Macros

#define IM_PI                           3.14159265358979323846f

#ifdef _WIN32

#define IM_NEWLINE                      "\r\n"   // Play it nice with Windows users (Update: since 2018-05, Notepad finally appears to support Unix-style carriage returns!)

#else

#define IM_NEWLINE                      "\n"

#endif

#ifndef IM_TABSIZE                      // Until we move this to runtime and/or add proper tab support, at least allow users to compile-time override

#define IM_TABSIZE                      (4)

#endif

#define IM_MEMALIGN(_OFF,_ALIGN)        (((_OFF) + ((_ALIGN) - 1)) & ~((_ALIGN) - 1))           // Memory align e.g. IM_ALIGN(0,4)=0, IM_ALIGN(1,4)=4, IM_ALIGN(4,4)=4, IM_ALIGN(5,4)=8

#define IM_F32_TO_INT8_UNBOUND(_VAL)    ((int)((_VAL) * 255.0f + ((_VAL)>=0 ? 0.5f : -0.5f)))   // Unsaturated, for display purpose

#define IM_F32_TO_INT8_SAT(_VAL)        ((int)(ImSaturate(_VAL) * 255.0f + 0.5f))               // Saturated, always output 0..255

#define IM_TRUNC(_VAL)                  ((float)(int)(_VAL))                                    // Positive values only! ImTrunc() is not inlined in MSVC debug builds

#define IM_ROUND(_VAL)                  ((float)(int)((_VAL) + 0.5f))                           // Positive values only! 

//#define IM_FLOOR IM_TRUNC             // [OBSOLETE] Renamed in 1.90.0 (Sept 2023)

// Hint for branch prediction

#if (defined(__cplusplus) && (__cplusplus >= 202002L)) || (defined(_MSVC_LANG) && (_MSVC_LANG >= 202002L))

#define IM_LIKELY   [[likely]]

#define IM_UNLIKELY [[unlikely]]

#else

#define IM_LIKELY

#define IM_UNLIKELY

#endif

// Enforce cdecl calling convention for functions called by the standard library, in case compilation settings changed the default to e.g. __vectorcall

#ifdef _MSC_VER

#define IMGUI_CDECL __cdecl

#else

#define IMGUI_CDECL

#endif

// Warnings

#if defined(_MSC_VER) && !defined(__clang__)

#define IM_MSVC_WARNING_SUPPRESS(XXXX)  __pragma(warning(suppress: XXXX))

#else

#define IM_MSVC_WARNING_SUPPRESS(XXXX)

#endif

// Debug Tools

// Use 'Metrics/Debugger->Tools->Item Picker' to break into the call-stack of a specific item.

// This will call IM_DEBUG_BREAK() which you may redefine yourself. See https://github.com/scottt/debugbreak for more reference.

#ifndef IM_DEBUG_BREAK

#if defined (_MSC_VER)

#define IM_DEBUG_BREAK()    __debugbreak()

#elif defined(__clang__)

#define IM_DEBUG_BREAK()    __builtin_debugtrap()

#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))

#define IM_DEBUG_BREAK()    __asm__ volatile("int3;nop")

#elif defined(__GNUC__) && defined(__thumb__)

#define IM_DEBUG_BREAK()    __asm__ volatile(".inst 0xde01")

#elif defined(__GNUC__) && defined(__arm__) && !defined(__thumb__)

#define IM_DEBUG_BREAK()    __asm__ volatile(".inst 0xe7f001f0")

#elif defined(__GNUC__) && defined(__aarch64__)

#define IM_DEBUG_BREAK()    __asm__ volatile(".inst 0xd4200000")    // GDB needs 'set $pc=($pc+4)' to skip this :(

#else

#define IM_DEBUG_BREAK()    IM_ASSERT(0)    // It is expected that you define IM_DEBUG_BREAK() into something that will break nicely in a debugger!

#endif

#endif // #ifndef IM_DEBUG_BREAK

// Format specifiers, printing 64-bit hasn't been decently standardized...

// In a real application you should be using PRId64 and PRIu64 from <inttypes.h> (non-windows) and on Windows define them yourself.

#if defined(_MSC_VER) && !defined(__clang__)

#define IM_PRId64   "I64d"

#define IM_PRIu64   "I64u"

#define IM_PRIX64   "I64X"

#else

#define IM_PRId64   "lld"

#define IM_PRIu64   "llu"

#define IM_PRIX64   "llX"

#endif

//-----------------------------------------------------------------------------

// [SECTION] Generic helpers

// Note that the ImXXX helpers functions are lower-level than ImGui functions.

// ImGui functions or the ImGui context are never called/used from other ImXXX functions.

//-----------------------------------------------------------------------------

// - Helpers: Hashing

// - Helpers: Sorting

// - Helpers: Bit manipulation

// - Helpers: String

// - Helpers: Formatting

// - Helpers: UTF-8 <> wchar conversions

// - Helpers: ImVec2/ImVec4 operators

// - Helpers: Maths

// - Helpers: Geometry

// - Helper: ImVec1

// - Helper: ImVec2ih

// - Helper: ImRect

// - Helper: ImBitArray

// - Helper: ImBitVector

// - Helper: ImSpan<>, ImSpanAllocator<>

// - Helper: ImStableVector<>

// - Helper: ImPool<>

// - Helper: ImChunkStream<>

// - Helper: ImGuiTextIndex

// - Helper: ImGuiStorage

//-----------------------------------------------------------------------------

// Helpers: Hashing

IMGUI_API ImGuiID       ImHashData(const void* data, size_t data_size, ImGuiID seed = 0);

IMGUI_API ImGuiID       ImHashStr(const char* data, size_t data_size = 0, ImGuiID seed = 0);

IMGUI_API const char*   ImHashSkipUncontributingPrefix(const char* label);

// Helpers: Sorting

#ifndef ImQsort

inline void             ImQsort(void* base, size_t count, size_t size_of_element, int(IMGUI_CDECL *compare_func)(void const*, void const*)) { if (count > 1) qsort(base, count, size_of_element, compare_func); }

#endif

// Helpers: Color Blending

IMGUI_API ImU32         ImAlphaBlendColors(ImU32 col_a, ImU32 col_b);

// Helpers: Bit manipulation

inline bool             ImIsPowerOfTwo(int v)               { return v != 0 && (v & (v - 1)) == 0; }

inline bool             ImIsPowerOfTwo(ImU64 v)             { return v != 0 && (v & (v - 1)) == 0; }

inline int              ImUpperPowerOfTwo(int v)            { v--; v |= v >> 1; v |= v >> 2; v |= v >> 4; v |= v >> 8; v |= v >> 16; v++; return v; }

inline unsigned int     ImCountSetBits(unsigned int v)      { unsigned int count = 0; while (v > 0) { v = v & (v - 1); count++; } return count; }

// Helpers: String

#define ImStrlen strlen

#define ImMemchr memchr

IMGUI_API int           ImStricmp(const char* str1, const char* str2);                      // Case insensitive compare.

IMGUI_API int           ImStrnicmp(const char* str1, const char* str2, size_t count);       // Case insensitive compare to a certain count.

IMGUI_API void          ImStrncpy(char* dst, const char* src, size_t count);                // Copy to a certain count and always zero terminate (strncpy doesn't).

IMGUI_API char*         ImStrdup(const char* str);                                          // Duplicate a string.

IMGUI_API void*         ImMemdup(const void* src, size_t size);                             // Duplicate a chunk of memory.

IMGUI_API char*         ImStrdupcpy(char* dst, size_t* p_dst_size, const char* str);        // Copy in provided buffer, recreate buffer if needed.

IMGUI_API const char*   ImStrchrRange(const char* str_begin, const char* str_end, char c);  // Find first occurrence of 'c' in string range.

IMGUI_API const char*   ImStreolRange(const char* str, const char* str_end);                // End end-of-line

IMGUI_API const char*   ImStristr(const char* haystack, const char* haystack_end, const char* needle, const char* needle_end);  // Find a substring in a string range.

IMGUI_API void          ImStrTrimBlanks(char* str);                                         // Remove leading and trailing blanks from a buffer.

IMGUI_API const char*   ImStrSkipBlank(const char* str);                                    // Find first non-blank character.

IMGUI_API int           ImStrlenW(const ImWchar* str);                                      // Computer string length (ImWchar string)

IMGUI_API const char*   ImStrbol(const char* buf_mid_line, const char* buf_begin);          // Find beginning-of-line

IM_MSVC_RUNTIME_CHECKS_OFF

inline char             ImToUpper(char c)               { return (c >= 'a' && c <= 'z') ? c &= ~32 : c; }

inline bool             ImCharIsBlankA(char c)          { return c == ' ' || c == '\t'; }

inline bool             ImCharIsBlankW(unsigned int c)  { return c == ' ' || c == '\t' || c == 0x3000; }

inline bool             ImCharIsXdigitA(char c)         { return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f'); }

IM_MSVC_RUNTIME_CHECKS_RESTORE

// Helpers: Formatting

IMGUI_API int           ImFormatString(char* buf, size_t buf_size, const char* fmt, ...) IM_FMTARGS(3);

IMGUI_API int           ImFormatStringV(char* buf, size_t buf_size, const char* fmt, va_list args) IM_FMTLIST(3);

IMGUI_API void          ImFormatStringToTempBuffer(const char** out_buf, const char** out_buf_end, const char* fmt, ...) IM_FMTARGS(3);

IMGUI_API void          ImFormatStringToTempBufferV(const char** out_buf, const char** out_buf_end, const char* fmt, va_list args) IM_FMTLIST(3);

IMGUI_API const char*   ImParseFormatFindStart(const char* format);

IMGUI_API const char*   ImParseFormatFindEnd(const char* format);

IMGUI_API const char*   ImParseFormatTrimDecorations(const char* format, char* buf, size_t buf_size);

IMGUI_API void          ImParseFormatSanitizeForPrinting(const char* fmt_in, char* fmt_out, size_t fmt_out_size);

IMGUI_API const char*   ImParseFormatSanitizeForScanning(const char* fmt_in, char* fmt_out, size_t fmt_out_size);

IMGUI_API int           ImParseFormatPrecision(const char* format, int default_value);

// Helpers: UTF-8 <> wchar conversions

IMGUI_API int           ImTextCharToUtf8(char out_buf[5], unsigned int c);                                                      // return output UTF-8 bytes count

IMGUI_API int           ImTextStrToUtf8(char* out_buf, int out_buf_size, const ImWchar* in_text, const ImWchar* in_text_end);   // return output UTF-8 bytes count

IMGUI_API int           ImTextCharFromUtf8(unsigned int* out_char, const char* in_text, const char* in_text_end);               // read one character. return input UTF-8 bytes count

IMGUI_API int           ImTextStrFromUtf8(ImWchar* out_buf, int out_buf_size, const char* in_text, const char* in_text_end, const char** in_remaining = NULL);   // return input UTF-8 bytes count

IMGUI_API int           ImTextCountCharsFromUtf8(const char* in_text, const char* in_text_end);                                 // return number of UTF-8 code-points (NOT bytes count)

IMGUI_API int           ImTextCountUtf8BytesFromChar(const char* in_text, const char* in_text_end);                             // return number of bytes to express one char in UTF-8

IMGUI_API int           ImTextCountUtf8BytesFromStr(const ImWchar* in_text, const ImWchar* in_text_end);                        // return number of bytes to express string in UTF-8

IMGUI_API const char*   ImTextFindPreviousUtf8Codepoint(const char* in_text_start, const char* in_p);                           // return previous UTF-8 code-point.

IMGUI_API const char*   ImTextFindValidUtf8CodepointEnd(const char* in_text_start, const char* in_text_end, const char* in_p);  // return previous UTF-8 code-point if 'in_p' is not the end of a valid one.

IMGUI_API int           ImTextCountLines(const char* in_text, const char* in_text_end);                                         // return number of lines taken by text. trailing carriage return doesn't count as an extra line.

// Helpers: High-level text functions (DO NOT USE!!! THIS IS A MINIMAL SUBSET OF LARGER UPCOMING CHANGES)

enum ImDrawTextFlags_

{

    ImDrawTextFlags_None                = 0,

    ImDrawTextFlags_CpuFineClip         = 1 << 0,    // Must be == 1/true for legacy with 'bool cpu_fine_clip' arg to RenderText()

    ImDrawTextFlags_WrapKeepBlanks      = 1 << 1,

    ImDrawTextFlags_StopOnNewLine       = 1 << 2,

};

IMGUI_API ImVec2        ImFontCalcTextSizeEx(ImFont* font, float size, float max_width, float wrap_width, const char* text_begin, const char* text_end_display, const char* text_end, const char** out_remaining, ImVec2* out_offset, ImDrawTextFlags flags);

IMGUI_API const char*   ImFontCalcWordWrapPositionEx(ImFont* font, float size, const char* text, const char* text_end, float wrap_width, ImDrawTextFlags flags = 0);

IMGUI_API const char*   ImTextCalcWordWrapNextLineStart(const char* text, const char* text_end, ImDrawTextFlags flags = 0); // trim trailing space and find beginning of next line

// Character classification for word-wrapping logic

enum ImWcharClass

{

    ImWcharClass_Blank, ImWcharClass_Punct, ImWcharClass_Other

};

IMGUI_API void          ImTextInitClassifiers();

IMGUI_API void          ImTextClassifierClear(ImU32* bits, unsigned int codepoint_min, unsigned int codepoint_end, ImWcharClass char_class);

IMGUI_API void          ImTextClassifierSetCharClass(ImU32* bits, unsigned int codepoint_min, unsigned int codepoint_end, ImWcharClass char_class, unsigned int c);

IMGUI_API void          ImTextClassifierSetCharClassFromStr(ImU32* bits, unsigned int codepoint_min, unsigned int codepoint_end, ImWcharClass char_class, const char* s);

// Helpers: File System

#ifdef IMGUI_DISABLE_FILE_FUNCTIONS

#define IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS

typedef void* ImFileHandle;

inline ImFileHandle         ImFileOpen(const char*, const char*)                    { return NULL; }

inline bool                 ImFileClose(ImFileHandle)                               { return false; }

inline ImU64                ImFileGetSize(ImFileHandle)                             { return (ImU64)-1; }

inline ImU64                ImFileRead(void*, ImU64, ImU64, ImFileHandle)           { return 0; }

inline ImU64                ImFileWrite(const void*, ImU64, ImU64, ImFileHandle)    { return 0; }

#endif

#ifndef IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS

typedef FILE* ImFileHandle;

IMGUI_API ImFileHandle      ImFileOpen(const char* filename, const char* mode);

IMGUI_API bool              ImFileClose(ImFileHandle file);

IMGUI_API ImU64             ImFileGetSize(ImFileHandle file);

IMGUI_API ImU64             ImFileRead(void* data, ImU64 size, ImU64 count, ImFileHandle file);

IMGUI_API ImU64             ImFileWrite(const void* data, ImU64 size, ImU64 count, ImFileHandle file);

#else

#define IMGUI_DISABLE_TTY_FUNCTIONS // Can't use stdout, fflush if we are not using default file functions

#endif

IMGUI_API void*             ImFileLoadToMemory(const char* filename, const char* mode, size_t* out_file_size = NULL, int padding_bytes = 0);

// Helpers: Maths

IM_MSVC_RUNTIME_CHECKS_OFF

// - Wrapper for standard libs functions. (Note that imgui_demo.cpp does _not_ use them to keep the code easy to copy)

#ifndef IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS

#define ImFabs(X)           fabsf(X)

#define ImSqrt(X)           sqrtf(X)

#define ImFmod(X, Y)        fmodf((X), (Y))

#define ImCos(X)            cosf(X)

#define ImSin(X)            sinf(X)

#define ImAcos(X)           acosf(X)

#define ImAtan2(Y, X)       atan2f((Y), (X))

#define ImAtof(STR)         atof(STR)

#define ImCeil(X)           ceilf(X)

inline float  ImPow(float x, float y)    { return powf(x, y); }          // DragBehaviorT/SliderBehaviorT uses ImPow with either float/double and need the precision

inline double ImPow(double x, double y)  { return pow(x, y); }

inline float  ImLog(float x)             { return logf(x); }             // DragBehaviorT/SliderBehaviorT uses ImLog with either float/double and need the precision

inline double ImLog(double x)            { return log(x); }

inline int    ImAbs(int x)               { return x < 0 ? -x : x; }

inline float  ImAbs(float x)             { return fabsf(x); }

inline double ImAbs(double x)            { return fabs(x); }

inline float  ImSign(float x)            { return (x < 0.0f) ? -1.0f : (x > 0.0f) ? 1.0f : 0.0f; } // Sign operator - returns -1, 0 or 1 based on sign of argument

inline double ImSign(double x)           { return (x < 0.0) ? -1.0 : (x > 0.0) ? 1.0 : 0.0; }

#ifdef IMGUI_ENABLE_SSE

inline float  ImRsqrt(float x)           { return _mm_cvtss_f32(_mm_rsqrt_ss(_mm_set_ss(x))); }

#else

inline float  ImRsqrt(float x)           { return 1.0f / sqrtf(x); }

#endif

inline double ImRsqrt(double x)          { return 1.0 / sqrt(x); }

#endif

// - ImMin/ImMax/ImClamp/ImLerp/ImSwap are used by widgets which support variety of types: signed/unsigned int/long long float/double

// (Exceptionally using templates here but we could also redefine them for those types)

template<typename T> T ImMin(T lhs, T rhs)                              { return lhs < rhs ? lhs : rhs; }

template<typename T> T ImMax(T lhs, T rhs)                              { return lhs >= rhs ? lhs : rhs; }

template<typename T> T ImClamp(T v, T mn, T mx)                         { return (v < mn) ? mn : (v > mx) ? mx : v; }

template<typename T> T ImLerp(double a, double b, float t)              { return (T)(a + (b - a) * (double)t); }

template<typename T> T ImLerp(T a, T b, float t)                        { return (T)((float)a + (float)(b - a) * t); }

template<typename T> void ImSwap(T& a, T& b)                            { T tmp = a; a = b; b = tmp; }

template<typename T> T ImAddClampOverflow(T a, T b, T mn, T mx)         { if (b < 0 && (a < mn - b)) return mn; if (b > 0 && (a > mx - b)) return mx; return a + b; }

template<typename T> T ImSubClampOverflow(T a, T b, T mn, T mx)         { if (b > 0 && (a < mn + b)) return mn; if (b < 0 && (a > mx + b)) return mx; return a - b; }

// - Misc maths helpers

inline ImVec2 ImMin(const ImVec2& lhs, const ImVec2& rhs)               { return ImVec2(lhs.x < rhs.x ? lhs.x : rhs.x, lhs.y < rhs.y ? lhs.y : rhs.y); }

inline ImVec2 ImMax(const ImVec2& lhs, const ImVec2& rhs)               { return ImVec2(lhs.x >= rhs.x ? lhs.x : rhs.x, lhs.y >= rhs.y ? lhs.y : rhs.y); }

inline ImVec2 ImClamp(const ImVec2& v, const ImVec2&mn, const ImVec2&mx){ return ImVec2((v.x < mn.x) ? mn.x : (v.x > mx.x) ? mx.x : v.x, (v.y < mn.y) ? mn.y : (v.y > mx.y) ? mx.y : v.y); }

inline ImVec2 ImLerp(const ImVec2& a, const ImVec2& b, float t)         { return ImVec2(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t); }