blame: source/code/Libs/imgui/imgui_draw.cpp

// dear imgui, v1.91.4

// (drawing and font code)

/*

Index of this file:

// [SECTION] STB libraries implementation

// [SECTION] Style functions

// [SECTION] ImDrawList

// [SECTION] ImTriangulator, ImDrawList concave polygon fill

// [SECTION] ImDrawListSplitter

// [SECTION] ImDrawData

// [SECTION] Helpers ShadeVertsXXX functions

// [SECTION] ImFontConfig

// [SECTION] ImFontAtlas

// [SECTION] ImFontAtlas glyph ranges helpers

// [SECTION] ImFontGlyphRangesBuilder

// [SECTION] ImFont

// [SECTION] ImGui Internal Render Helpers

// [SECTION] Decompression code

// [SECTION] Default font data (ProggyClean.ttf)

*/

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

#define _CRT_SECURE_NO_WARNINGS

#endif

#ifndef IMGUI_DEFINE_MATH_OPERATORS

#define IMGUI_DEFINE_MATH_OPERATORS

#endif

#include "imgui.h"

#ifndef IMGUI_DISABLE

#include "imgui_internal.h"

#ifdef IMGUI_ENABLE_FREETYPE

#include "misc/freetype/imgui_freetype.h"

#endif

#include <stdio.h>      // vsnprintf, sscanf, printf

// Visual Studio warnings

#ifdef _MSC_VER

#pragma warning (disable: 4127)     // condition expression is constant

#pragma warning (disable: 4505)     // unreferenced local function has been removed (stb stuff)

#pragma warning (disable: 4996)     // 'This function or variable may be unsafe': strcpy, strdup, sprintf, vsnprintf, sscanf, fopen

#pragma warning (disable: 26451)    // [Static Analyzer] Arithmetic overflow : Using operator 'xxx' on a 4 byte value and then casting the result to a 8 byte value. Cast the value to the wider type before calling operator 'xxx' to avoid overflow(io.2).

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

#endif

// Clang/GCC warnings with -Weverything

#if defined(__clang__)

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

#pragma clang diagnostic ignored "-Wunknown-warning-option"         // warning: unknown warning group 'xxx'                      // not all warnings are known by all Clang versions and they tend to be rename-happy.. so ignoring warnings triggers new warnings on some configuration. Great!

#endif

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

#pragma clang diagnostic ignored "-Wold-style-cast"                 // warning: use of old-style cast                            // yes, they are more terse.

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

#pragma clang diagnostic ignored "-Wglobal-constructors"            // warning: declaration requires a global destructor         // similar to above, not sure what the exact difference is.

#pragma clang diagnostic ignored "-Wsign-conversion"                // warning: implicit conversion changes signedness

#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"  // warning: zero as null pointer constant                    // some standard header variations use #define NULL 0

#pragma clang diagnostic ignored "-Wcomma"                          // warning: possible misuse of comma operator here

#pragma clang diagnostic ignored "-Wreserved-id-macro"              // warning: macro name is a reserved identifier

#pragma clang diagnostic ignored "-Wdouble-promotion"               // warning: implicit conversion from 'float' to 'double' when passing argument to function  // using printf() is a misery with this as C++ va_arg ellipsis changes float to double.

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

#pragma clang diagnostic ignored "-Wreserved-identifier"            // warning: identifier '_Xxx' is reserved because it starts with '_' followed by a capital letter

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

#elif defined(__GNUC__)

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

#pragma GCC diagnostic ignored "-Wunused-function"          // warning: 'xxxx' defined but not used

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

#pragma GCC diagnostic ignored "-Wconversion"               // warning: conversion to 'xxxx' from 'xxxx' may alter its value

#pragma GCC diagnostic ignored "-Wstack-protector"          // warning: stack protector not protecting local variables: variable length buffer

#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

#endif

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

// [SECTION] STB libraries implementation (for stb_truetype and stb_rect_pack)

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

// Compile time options:

//#define IMGUI_STB_NAMESPACE           ImStb

//#define IMGUI_STB_TRUETYPE_FILENAME   "my_folder/stb_truetype.h"

//#define IMGUI_STB_RECT_PACK_FILENAME  "my_folder/stb_rect_pack.h"

//#define IMGUI_DISABLE_STB_TRUETYPE_IMPLEMENTATION

//#define IMGUI_DISABLE_STB_RECT_PACK_IMPLEMENTATION

#ifdef IMGUI_STB_NAMESPACE

namespace IMGUI_STB_NAMESPACE

{

#endif

#ifdef _MSC_VER

#pragma warning (push)

#pragma warning (disable: 4456)                             // declaration of 'xx' hides previous local declaration

#pragma warning (disable: 6011)                             // (stb_rectpack) Dereferencing NULL pointer 'cur->next'.

#pragma warning (disable: 6385)                             // (stb_truetype) Reading invalid data from 'buffer':  the readable size is '_Old_3`kernel_width' bytes, but '3' bytes may be read.

#pragma warning (disable: 28182)                            // (stb_rectpack) Dereferencing NULL pointer. 'cur' contains the same NULL value as 'cur->next' did.

#endif

#if defined(__clang__)

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wunused-function"

#pragma clang diagnostic ignored "-Wmissing-prototypes"

#pragma clang diagnostic ignored "-Wimplicit-fallthrough"

#pragma clang diagnostic ignored "-Wcast-qual"              // warning: cast from 'const xxxx *' to 'xxx *' drops const qualifier

#endif

#if defined(__GNUC__)

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wtype-limits"              // warning: comparison is always true due to limited range of data type [-Wtype-limits]

#pragma GCC diagnostic ignored "-Wcast-qual"                // warning: cast from type 'const xxxx *' to type 'xxxx *' casts away qualifiers

#endif

#ifndef STB_RECT_PACK_IMPLEMENTATION                        // in case the user already have an implementation in the _same_ compilation unit (e.g. unity builds)

#ifndef IMGUI_DISABLE_STB_RECT_PACK_IMPLEMENTATION          // in case the user already have an implementation in another compilation unit

#define STBRP_STATIC

#define STBRP_ASSERT(x)     do { IM_ASSERT(x); } while (0)

#define STBRP_SORT          ImQsort

#define STB_RECT_PACK_IMPLEMENTATION

#endif

#ifdef IMGUI_STB_RECT_PACK_FILENAME

#include IMGUI_STB_RECT_PACK_FILENAME

#else

#include "imstb_rectpack.h"

#endif

#endif

#ifdef  IMGUI_ENABLE_STB_TRUETYPE

#ifndef STB_TRUETYPE_IMPLEMENTATION                         // in case the user already have an implementation in the _same_ compilation unit (e.g. unity builds)

#ifndef IMGUI_DISABLE_STB_TRUETYPE_IMPLEMENTATION           // in case the user already have an implementation in another compilation unit

#define STBTT_malloc(x,u)   ((void)(u), IM_ALLOC(x))

#define STBTT_free(x,u)     ((void)(u), IM_FREE(x))

#define STBTT_assert(x)     do { IM_ASSERT(x); } while(0)

#define STBTT_fmod(x,y)     ImFmod(x,y)

#define STBTT_sqrt(x)       ImSqrt(x)

#define STBTT_pow(x,y)      ImPow(x,y)

#define STBTT_fabs(x)       ImFabs(x)

#define STBTT_ifloor(x)     ((int)ImFloor(x))

#define STBTT_iceil(x)      ((int)ImCeil(x))

#define STBTT_STATIC

#define STB_TRUETYPE_IMPLEMENTATION

#else

#define STBTT_DEF extern

#endif

#ifdef IMGUI_STB_TRUETYPE_FILENAME

#include IMGUI_STB_TRUETYPE_FILENAME

#else

#include "imstb_truetype.h"

#endif

#endif

#endif // IMGUI_ENABLE_STB_TRUETYPE

#if defined(__GNUC__)

#pragma GCC diagnostic pop

#endif

#if defined(__clang__)

#pragma clang diagnostic pop

#endif

#if defined(_MSC_VER)

#pragma warning (pop)

#endif

#ifdef IMGUI_STB_NAMESPACE

} // namespace ImStb

using namespace IMGUI_STB_NAMESPACE;

#endif

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

// [SECTION] Style functions

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

void ImGui::StyleColorsDark(ImGuiStyle* dst)

{

    ImGuiStyle* style = dst ? dst : &ImGui::GetStyle();

    ImVec4* colors = style->Colors;

    colors[ImGuiCol_Text]                   = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);

    colors[ImGuiCol_TextDisabled]           = ImVec4(0.50f, 0.50f, 0.50f, 1.00f);

    colors[ImGuiCol_WindowBg]               = ImVec4(0.06f, 0.06f, 0.06f, 0.94f);

    colors[ImGuiCol_ChildBg]                = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);

    colors[ImGuiCol_PopupBg]                = ImVec4(0.08f, 0.08f, 0.08f, 0.94f);

    colors[ImGuiCol_Border]                 = ImVec4(0.43f, 0.43f, 0.50f, 0.50f);

    colors[ImGuiCol_BorderShadow]           = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);

    colors[ImGuiCol_FrameBg]                = ImVec4(0.16f, 0.29f, 0.48f, 0.54f);

    colors[ImGuiCol_FrameBgHovered]         = ImVec4(0.26f, 0.59f, 0.98f, 0.40f);

    colors[ImGuiCol_FrameBgActive]          = ImVec4(0.26f, 0.59f, 0.98f, 0.67f);

    colors[ImGuiCol_TitleBg]                = ImVec4(0.04f, 0.04f, 0.04f, 1.00f);

    colors[ImGuiCol_TitleBgActive]          = ImVec4(0.16f, 0.29f, 0.48f, 1.00f);

    colors[ImGuiCol_TitleBgCollapsed]       = ImVec4(0.00f, 0.00f, 0.00f, 0.51f);

    colors[ImGuiCol_MenuBarBg]              = ImVec4(0.14f, 0.14f, 0.14f, 1.00f);

    colors[ImGuiCol_ScrollbarBg]            = ImVec4(0.02f, 0.02f, 0.02f, 0.53f);

    colors[ImGuiCol_ScrollbarGrab]          = ImVec4(0.31f, 0.31f, 0.31f, 1.00f);

    colors[ImGuiCol_ScrollbarGrabHovered]   = ImVec4(0.41f, 0.41f, 0.41f, 1.00f);

    colors[ImGuiCol_ScrollbarGrabActive]    = ImVec4(0.51f, 0.51f, 0.51f, 1.00f);

    colors[ImGuiCol_CheckMark]              = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);

    colors[ImGuiCol_SliderGrab]             = ImVec4(0.24f, 0.52f, 0.88f, 1.00f);

    colors[ImGuiCol_SliderGrabActive]       = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);

    colors[ImGuiCol_Button]                 = ImVec4(0.26f, 0.59f, 0.98f, 0.40f);

    colors[ImGuiCol_ButtonHovered]          = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);

    colors[ImGuiCol_ButtonActive]           = ImVec4(0.06f, 0.53f, 0.98f, 1.00f);

    colors[ImGuiCol_Header]                 = ImVec4(0.26f, 0.59f, 0.98f, 0.31f);

    colors[ImGuiCol_HeaderHovered]          = ImVec4(0.26f, 0.59f, 0.98f, 0.80f);

    colors[ImGuiCol_HeaderActive]           = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);

    colors[ImGuiCol_Separator]              = colors[ImGuiCol_Border];

    colors[ImGuiCol_SeparatorHovered]       = ImVec4(0.10f, 0.40f, 0.75f, 0.78f);

    colors[ImGuiCol_SeparatorActive]        = ImVec4(0.10f, 0.40f, 0.75f, 1.00f);

    colors[ImGuiCol_ResizeGrip]             = ImVec4(0.26f, 0.59f, 0.98f, 0.20f);

    colors[ImGuiCol_ResizeGripHovered]      = ImVec4(0.26f, 0.59f, 0.98f, 0.67f);

    colors[ImGuiCol_ResizeGripActive]       = ImVec4(0.26f, 0.59f, 0.98f, 0.95f);

    colors[ImGuiCol_TabHovered]             = colors[ImGuiCol_HeaderHovered];

    colors[ImGuiCol_Tab]                    = ImLerp(colors[ImGuiCol_Header],       colors[ImGuiCol_TitleBgActive], 0.80f);

    colors[ImGuiCol_TabSelected]            = ImLerp(colors[ImGuiCol_HeaderActive], colors[ImGuiCol_TitleBgActive], 0.60f);

    colors[ImGuiCol_TabSelectedOverline]    = colors[ImGuiCol_HeaderActive];

    colors[ImGuiCol_TabDimmed]              = ImLerp(colors[ImGuiCol_Tab],          colors[ImGuiCol_TitleBg], 0.80f);

    colors[ImGuiCol_TabDimmedSelected]      = ImLerp(colors[ImGuiCol_TabSelected],  colors[ImGuiCol_TitleBg], 0.40f);

    colors[ImGuiCol_TabDimmedSelectedOverline] = ImVec4(0.50f, 0.50f, 0.50f, 1.00f);

    colors[ImGuiCol_DockingPreview]         = colors[ImGuiCol_HeaderActive] * ImVec4(1.0f, 1.0f, 1.0f, 0.7f);

    colors[ImGuiCol_DockingEmptyBg]         = ImVec4(0.20f, 0.20f, 0.20f, 1.00f);

    colors[ImGuiCol_PlotLines]              = ImVec4(0.61f, 0.61f, 0.61f, 1.00f);

    colors[ImGuiCol_PlotLinesHovered]       = ImVec4(1.00f, 0.43f, 0.35f, 1.00f);

    colors[ImGuiCol_PlotHistogram]          = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);

    colors[ImGuiCol_PlotHistogramHovered]   = ImVec4(1.00f, 0.60f, 0.00f, 1.00f);

    colors[ImGuiCol_TableHeaderBg]          = ImVec4(0.19f, 0.19f, 0.20f, 1.00f);

    colors[ImGuiCol_TableBorderStrong]      = ImVec4(0.31f, 0.31f, 0.35f, 1.00f);   // Prefer using Alpha=1.0 here

    colors[ImGuiCol_TableBorderLight]       = ImVec4(0.23f, 0.23f, 0.25f, 1.00f);   // Prefer using Alpha=1.0 here

    colors[ImGuiCol_TableRowBg]             = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);

    colors[ImGuiCol_TableRowBgAlt]          = ImVec4(1.00f, 1.00f, 1.00f, 0.06f);

    colors[ImGuiCol_TextLink]               = colors[ImGuiCol_HeaderActive];

    colors[ImGuiCol_TextSelectedBg]         = ImVec4(0.26f, 0.59f, 0.98f, 0.35f);

    colors[ImGuiCol_DragDropTarget]         = ImVec4(1.00f, 1.00f, 0.00f, 0.90f);

    colors[ImGuiCol_NavCursor]              = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);

    colors[ImGuiCol_NavWindowingHighlight]  = ImVec4(1.00f, 1.00f, 1.00f, 0.70f);

    colors[ImGuiCol_NavWindowingDimBg]      = ImVec4(0.80f, 0.80f, 0.80f, 0.20f);

    colors[ImGuiCol_ModalWindowDimBg]       = ImVec4(0.80f, 0.80f, 0.80f, 0.35f);

}

void ImGui::StyleColorsClassic(ImGuiStyle* dst)

{

    ImGuiStyle* style = dst ? dst : &ImGui::GetStyle();

    ImVec4* colors = style->Colors;

    colors[ImGuiCol_Text]                   = ImVec4(0.90f, 0.90f, 0.90f, 1.00f);

    colors[ImGuiCol_TextDisabled]           = ImVec4(0.60f, 0.60f, 0.60f, 1.00f);

    colors[ImGuiCol_WindowBg]               = ImVec4(0.00f, 0.00f, 0.00f, 0.85f);

    colors[ImGuiCol_ChildBg]                = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);

    colors[ImGuiCol_PopupBg]                = ImVec4(0.11f, 0.11f, 0.14f, 0.92f);

    colors[ImGuiCol_Border]                 = ImVec4(0.50f, 0.50f, 0.50f, 0.50f);

    colors[ImGuiCol_BorderShadow]           = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);

    colors[ImGuiCol_FrameBg]                = ImVec4(0.43f, 0.43f, 0.43f, 0.39f);

    colors[ImGuiCol_FrameBgHovered]         = ImVec4(0.47f, 0.47f, 0.69f, 0.40f);

    colors[ImGuiCol_FrameBgActive]          = ImVec4(0.42f, 0.41f, 0.64f, 0.69f);

    colors[ImGuiCol_TitleBg]                = ImVec4(0.27f, 0.27f, 0.54f, 0.83f);

    colors[ImGuiCol_TitleBgActive]          = ImVec4(0.32f, 0.32f, 0.63f, 0.87f);

    colors[ImGuiCol_TitleBgCollapsed]       = ImVec4(0.40f, 0.40f, 0.80f, 0.20f);

    colors[ImGuiCol_MenuBarBg]              = ImVec4(0.40f, 0.40f, 0.55f, 0.80f);

    colors[ImGuiCol_ScrollbarBg]            = ImVec4(0.20f, 0.25f, 0.30f, 0.60f);

    colors[ImGuiCol_ScrollbarGrab]          = ImVec4(0.40f, 0.40f, 0.80f, 0.30f);

    colors[ImGuiCol_ScrollbarGrabHovered]   = ImVec4(0.40f, 0.40f, 0.80f, 0.40f);

    colors[ImGuiCol_ScrollbarGrabActive]    = ImVec4(0.41f, 0.39f, 0.80f, 0.60f);

    colors[ImGuiCol_CheckMark]              = ImVec4(0.90f, 0.90f, 0.90f, 0.50f);

    colors[ImGuiCol_SliderGrab]             = ImVec4(1.00f, 1.00f, 1.00f, 0.30f);

    colors[ImGuiCol_SliderGrabActive]       = ImVec4(0.41f, 0.39f, 0.80f, 0.60f);

    colors[ImGuiCol_Button]                 = ImVec4(0.35f, 0.40f, 0.61f, 0.62f);

    colors[ImGuiCol_ButtonHovered]          = ImVec4(0.40f, 0.48f, 0.71f, 0.79f);

    colors[ImGuiCol_ButtonActive]           = ImVec4(0.46f, 0.54f, 0.80f, 1.00f);

    colors[ImGuiCol_Header]                 = ImVec4(0.40f, 0.40f, 0.90f, 0.45f);

    colors[ImGuiCol_HeaderHovered]          = ImVec4(0.45f, 0.45f, 0.90f, 0.80f);

    colors[ImGuiCol_HeaderActive]           = ImVec4(0.53f, 0.53f, 0.87f, 0.80f);

    colors[ImGuiCol_Separator]              = ImVec4(0.50f, 0.50f, 0.50f, 0.60f);

    colors[ImGuiCol_SeparatorHovered]       = ImVec4(0.60f, 0.60f, 0.70f, 1.00f);

    colors[ImGuiCol_SeparatorActive]        = ImVec4(0.70f, 0.70f, 0.90f, 1.00f);

    colors[ImGuiCol_ResizeGrip]             = ImVec4(1.00f, 1.00f, 1.00f, 0.10f);

    colors[ImGuiCol_ResizeGripHovered]      = ImVec4(0.78f, 0.82f, 1.00f, 0.60f);

    colors[ImGuiCol_ResizeGripActive]       = ImVec4(0.78f, 0.82f, 1.00f, 0.90f);

    colors[ImGuiCol_TabHovered]             = colors[ImGuiCol_HeaderHovered];

    colors[ImGuiCol_Tab]                    = ImLerp(colors[ImGuiCol_Header],       colors[ImGuiCol_TitleBgActive], 0.80f);

    colors[ImGuiCol_TabSelected]            = ImLerp(colors[ImGuiCol_HeaderActive], colors[ImGuiCol_TitleBgActive], 0.60f);

    colors[ImGuiCol_TabSelectedOverline]    = colors[ImGuiCol_HeaderActive];

    colors[ImGuiCol_TabDimmed]              = ImLerp(colors[ImGuiCol_Tab],          colors[ImGuiCol_TitleBg], 0.80f);

    colors[ImGuiCol_TabDimmedSelected]      = ImLerp(colors[ImGuiCol_TabSelected],  colors[ImGuiCol_TitleBg], 0.40f);

    colors[ImGuiCol_TabDimmedSelectedOverline] = colors[ImGuiCol_HeaderActive];

    colors[ImGuiCol_DockingPreview]         = colors[ImGuiCol_Header] * ImVec4(1.0f, 1.0f, 1.0f, 0.7f);

    colors[ImGuiCol_DockingEmptyBg]         = ImVec4(0.20f, 0.20f, 0.20f, 1.00f);

    colors[ImGuiCol_PlotLines]              = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);

    colors[ImGuiCol_PlotLinesHovered]       = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);

    colors[ImGuiCol_PlotHistogram]          = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);

    colors[ImGuiCol_PlotHistogramHovered]   = ImVec4(1.00f, 0.60f, 0.00f, 1.00f);

    colors[ImGuiCol_TableHeaderBg]          = ImVec4(0.27f, 0.27f, 0.38f, 1.00f);

    colors[ImGuiCol_TableBorderStrong]      = ImVec4(0.31f, 0.31f, 0.45f, 1.00f);   // Prefer using Alpha=1.0 here

    colors[ImGuiCol_TableBorderLight]       = ImVec4(0.26f, 0.26f, 0.28f, 1.00f);   // Prefer using Alpha=1.0 here

    colors[ImGuiCol_TableRowBg]             = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);

    colors[ImGuiCol_TableRowBgAlt]          = ImVec4(1.00f, 1.00f, 1.00f, 0.07f);

    colors[ImGuiCol_TextLink]               = colors[ImGuiCol_HeaderActive];

    colors[ImGuiCol_TextSelectedBg]         = ImVec4(0.00f, 0.00f, 1.00f, 0.35f);

    colors[ImGuiCol_DragDropTarget]         = ImVec4(1.00f, 1.00f, 0.00f, 0.90f);

    colors[ImGuiCol_NavCursor]              = colors[ImGuiCol_HeaderHovered];

    colors[ImGuiCol_NavWindowingHighlight]  = ImVec4(1.00f, 1.00f, 1.00f, 0.70f);

    colors[ImGuiCol_NavWindowingDimBg]      = ImVec4(0.80f, 0.80f, 0.80f, 0.20f);

    colors[ImGuiCol_ModalWindowDimBg]       = ImVec4(0.20f, 0.20f, 0.20f, 0.35f);

}

// Those light colors are better suited with a thicker font than the default one + FrameBorder

void ImGui::StyleColorsLight(ImGuiStyle* dst)

{

    ImGuiStyle* style = dst ? dst : &ImGui::GetStyle();

    ImVec4* colors = style->Colors;

    colors[ImGuiCol_Text]                   = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);

    colors[ImGuiCol_TextDisabled]           = ImVec4(0.60f, 0.60f, 0.60f, 1.00f);

    colors[ImGuiCol_WindowBg]               = ImVec4(0.94f, 0.94f, 0.94f, 1.00f);

    colors[ImGuiCol_ChildBg]                = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);

    colors[ImGuiCol_PopupBg]                = ImVec4(1.00f, 1.00f, 1.00f, 0.98f);

    colors[ImGuiCol_Border]                 = ImVec4(0.00f, 0.00f, 0.00f, 0.30f);

    colors[ImGuiCol_BorderShadow]           = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);

    colors[ImGuiCol_FrameBg]                = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);

    colors[ImGuiCol_FrameBgHovered]         = ImVec4(0.26f, 0.59f, 0.98f, 0.40f);

    colors[ImGuiCol_FrameBgActive]          = ImVec4(0.26f, 0.59f, 0.98f, 0.67f);

    colors[ImGuiCol_TitleBg]                = ImVec4(0.96f, 0.96f, 0.96f, 1.00f);

    colors[ImGuiCol_TitleBgActive]          = ImVec4(0.82f, 0.82f, 0.82f, 1.00f);

    colors[ImGuiCol_TitleBgCollapsed]       = ImVec4(1.00f, 1.00f, 1.00f, 0.51f);

    colors[ImGuiCol_MenuBarBg]              = ImVec4(0.86f, 0.86f, 0.86f, 1.00f);

    colors[ImGuiCol_ScrollbarBg]            = ImVec4(0.98f, 0.98f, 0.98f, 0.53f);

    colors[ImGuiCol_ScrollbarGrab]          = ImVec4(0.69f, 0.69f, 0.69f, 0.80f);

    colors[ImGuiCol_ScrollbarGrabHovered]   = ImVec4(0.49f, 0.49f, 0.49f, 0.80f);

    colors[ImGuiCol_ScrollbarGrabActive]    = ImVec4(0.49f, 0.49f, 0.49f, 1.00f);

    colors[ImGuiCol_CheckMark]              = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);

    colors[ImGuiCol_SliderGrab]             = ImVec4(0.26f, 0.59f, 0.98f, 0.78f);

    colors[ImGuiCol_SliderGrabActive]       = ImVec4(0.46f, 0.54f, 0.80f, 0.60f);

    colors[ImGuiCol_Button]                 = ImVec4(0.26f, 0.59f, 0.98f, 0.40f);

    colors[ImGuiCol_ButtonHovered]          = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);

    colors[ImGuiCol_ButtonActive]           = ImVec4(0.06f, 0.53f, 0.98f, 1.00f);

    colors[ImGuiCol_Header]                 = ImVec4(0.26f, 0.59f, 0.98f, 0.31f);

    colors[ImGuiCol_HeaderHovered]          = ImVec4(0.26f, 0.59f, 0.98f, 0.80f);

    colors[ImGuiCol_HeaderActive]           = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);

    colors[ImGuiCol_Separator]              = ImVec4(0.39f, 0.39f, 0.39f, 0.62f);

    colors[ImGuiCol_SeparatorHovered]       = ImVec4(0.14f, 0.44f, 0.80f, 0.78f);

    colors[ImGuiCol_SeparatorActive]        = ImVec4(0.14f, 0.44f, 0.80f, 1.00f);

    colors[ImGuiCol_ResizeGrip]             = ImVec4(0.35f, 0.35f, 0.35f, 0.17f);

    colors[ImGuiCol_ResizeGripHovered]      = ImVec4(0.26f, 0.59f, 0.98f, 0.67f);

    colors[ImGuiCol_ResizeGripActive]       = ImVec4(0.26f, 0.59f, 0.98f, 0.95f);

    colors[ImGuiCol_TabHovered]             = colors[ImGuiCol_HeaderHovered];

    colors[ImGuiCol_Tab]                    = ImLerp(colors[ImGuiCol_Header],       colors[ImGuiCol_TitleBgActive], 0.90f);

    colors[ImGuiCol_TabSelected]            = ImLerp(colors[ImGuiCol_HeaderActive], colors[ImGuiCol_TitleBgActive], 0.60f);

    colors[ImGuiCol_TabSelectedOverline]    = colors[ImGuiCol_HeaderActive];

    colors[ImGuiCol_TabDimmed]              = ImLerp(colors[ImGuiCol_Tab],          colors[ImGuiCol_TitleBg], 0.80f);

    colors[ImGuiCol_TabDimmedSelected]      = ImLerp(colors[ImGuiCol_TabSelected],  colors[ImGuiCol_TitleBg], 0.40f);

    colors[ImGuiCol_TabDimmedSelectedOverline] = ImVec4(0.26f, 0.59f, 1.00f, 1.00f);

    colors[ImGuiCol_DockingPreview]         = colors[ImGuiCol_Header] * ImVec4(1.0f, 1.0f, 1.0f, 0.7f);

    colors[ImGuiCol_DockingEmptyBg]         = ImVec4(0.20f, 0.20f, 0.20f, 1.00f);

    colors[ImGuiCol_PlotLines]              = ImVec4(0.39f, 0.39f, 0.39f, 1.00f);

    colors[ImGuiCol_PlotLinesHovered]       = ImVec4(1.00f, 0.43f, 0.35f, 1.00f);

    colors[ImGuiCol_PlotHistogram]          = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);

    colors[ImGuiCol_PlotHistogramHovered]   = ImVec4(1.00f, 0.45f, 0.00f, 1.00f);

    colors[ImGuiCol_TableHeaderBg]          = ImVec4(0.78f, 0.87f, 0.98f, 1.00f);

    colors[ImGuiCol_TableBorderStrong]      = ImVec4(0.57f, 0.57f, 0.64f, 1.00f);   // Prefer using Alpha=1.0 here

    colors[ImGuiCol_TableBorderLight]       = ImVec4(0.68f, 0.68f, 0.74f, 1.00f);   // Prefer using Alpha=1.0 here

    colors[ImGuiCol_TableRowBg]             = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);

    colors[ImGuiCol_TableRowBgAlt]          = ImVec4(0.30f, 0.30f, 0.30f, 0.09f);

    colors[ImGuiCol_TextLink]               = colors[ImGuiCol_HeaderActive];

    colors[ImGuiCol_TextSelectedBg]         = ImVec4(0.26f, 0.59f, 0.98f, 0.35f);

    colors[ImGuiCol_DragDropTarget]         = ImVec4(0.26f, 0.59f, 0.98f, 0.95f);

    colors[ImGuiCol_NavCursor]              = colors[ImGuiCol_HeaderHovered];

    colors[ImGuiCol_NavWindowingHighlight]  = ImVec4(0.70f, 0.70f, 0.70f, 0.70f);

    colors[ImGuiCol_NavWindowingDimBg]      = ImVec4(0.20f, 0.20f, 0.20f, 0.20f);

    colors[ImGuiCol_ModalWindowDimBg]       = ImVec4(0.20f, 0.20f, 0.20f, 0.35f);

}

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

// [SECTION] ImDrawList

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

ImDrawListSharedData::ImDrawListSharedData()

{

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

    for (int i = 0; i < IM_ARRAYSIZE(ArcFastVtx); i++)

    {

        const float a = ((float)i * 2 * IM_PI) / (float)IM_ARRAYSIZE(ArcFastVtx);

        ArcFastVtx[i] = ImVec2(ImCos(a), ImSin(a));

    }

    ArcFastRadiusCutoff = IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC_R(IM_DRAWLIST_ARCFAST_SAMPLE_MAX, CircleSegmentMaxError);

}

void ImDrawListSharedData::SetCircleTessellationMaxError(float max_error)

{

    if (CircleSegmentMaxError == max_error)

        return;

    IM_ASSERT(max_error > 0.0f);

    CircleSegmentMaxError = max_error;

    for (int i = 0; i < IM_ARRAYSIZE(CircleSegmentCounts); i++)

    {

        const float radius = (float)i;

        CircleSegmentCounts[i] = (ImU8)((i > 0) ? IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC(radius, CircleSegmentMaxError) : IM_DRAWLIST_ARCFAST_SAMPLE_MAX);

    }

    ArcFastRadiusCutoff = IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC_R(IM_DRAWLIST_ARCFAST_SAMPLE_MAX, CircleSegmentMaxError);

}

// Initialize before use in a new frame. We always have a command ready in the buffer.

// In the majority of cases, you would want to call PushClipRect() and PushTextureID() after this.

void ImDrawList::_ResetForNewFrame()

{

    // Verify that the ImDrawCmd fields we want to memcmp() are contiguous in memory.

    IM_STATIC_ASSERT(offsetof(ImDrawCmd, ClipRect) == 0);

    IM_STATIC_ASSERT(offsetof(ImDrawCmd, TextureId) == sizeof(ImVec4));

    IM_STATIC_ASSERT(offsetof(ImDrawCmd, VtxOffset) == sizeof(ImVec4) + sizeof(ImTextureID));

    if (_Splitter._Count > 1)

        _Splitter.Merge(this);

    CmdBuffer.resize(0);

    IdxBuffer.resize(0);

    VtxBuffer.resize(0);

    Flags = _Data->InitialFlags;

    memset(&_CmdHeader, 0, sizeof(_CmdHeader));

    _VtxCurrentIdx = 0;

    _VtxWritePtr = NULL;

    _IdxWritePtr = NULL;

    _ClipRectStack.resize(0);

    _TextureIdStack.resize(0);

    _CallbacksDataBuf.resize(0);

    _Path.resize(0);

    _Splitter.Clear();

    CmdBuffer.push_back(ImDrawCmd());

    _FringeScale = 1.0f;

}

void ImDrawList::_ClearFreeMemory()

{

    CmdBuffer.clear();

    IdxBuffer.clear();

    VtxBuffer.clear();

    Flags = ImDrawListFlags_None;

    _VtxCurrentIdx = 0;

    _VtxWritePtr = NULL;

    _IdxWritePtr = NULL;

    _ClipRectStack.clear();

    _TextureIdStack.clear();

    _CallbacksDataBuf.clear();

    _Path.clear();

    _Splitter.ClearFreeMemory();

}

ImDrawList* ImDrawList::CloneOutput() const

{

    ImDrawList* dst = IM_NEW(ImDrawList(_Data));

    dst->CmdBuffer = CmdBuffer;

    dst->IdxBuffer = IdxBuffer;

    dst->VtxBuffer = VtxBuffer;

    dst->Flags = Flags;

    return dst;

}

void ImDrawList::AddDrawCmd()

{

    ImDrawCmd draw_cmd;

    draw_cmd.ClipRect = _CmdHeader.ClipRect;    // Same as calling ImDrawCmd_HeaderCopy()

    draw_cmd.TextureId = _CmdHeader.TextureId;

    draw_cmd.VtxOffset = _CmdHeader.VtxOffset;

    draw_cmd.IdxOffset = IdxBuffer.Size;

    IM_ASSERT(draw_cmd.ClipRect.x <= draw_cmd.ClipRect.z && draw_cmd.ClipRect.y <= draw_cmd.ClipRect.w);

    CmdBuffer.push_back(draw_cmd);

}

// Pop trailing draw command (used before merging or presenting to user)

// Note that this leaves the ImDrawList in a state unfit for further commands, as most code assume that CmdBuffer.Size > 0 && CmdBuffer.back().UserCallback == NULL

void ImDrawList::_PopUnusedDrawCmd()

{

    while (CmdBuffer.Size > 0)

    {

        ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];

        if (curr_cmd->ElemCount != 0 || curr_cmd->UserCallback != NULL)

            return;// break;

        CmdBuffer.pop_back();

    }

}

void ImDrawList::AddCallback(ImDrawCallback callback, void* userdata, size_t userdata_size)

{

    IM_ASSERT_PARANOID(CmdBuffer.Size > 0);

    ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];

    IM_ASSERT(curr_cmd->UserCallback == NULL);

    if (curr_cmd->ElemCount != 0)

    {

        AddDrawCmd();

        curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];

    }

    curr_cmd->UserCallback = callback;

    if (userdata_size == 0)

    {

        // Store user data directly in command (no indirection)

        curr_cmd->UserCallbackData = userdata;

        curr_cmd->UserCallbackDataSize = 0;

        curr_cmd->UserCallbackDataOffset = -1;

    }

    else

    {

        // Copy and store user data in a buffer

        IM_ASSERT(userdata != NULL);

        IM_ASSERT(userdata_size < (1u << 31));

        curr_cmd->UserCallbackData = NULL; // Will be resolved during Render()

        curr_cmd->UserCallbackDataSize = (int)userdata_size;

        curr_cmd->UserCallbackDataOffset = _CallbacksDataBuf.Size;

        _CallbacksDataBuf.resize(_CallbacksDataBuf.Size + (int)userdata_size);

        memcpy(_CallbacksDataBuf.Data + (size_t)curr_cmd->UserCallbackDataOffset, userdata, userdata_size);

    }

    AddDrawCmd(); // Force a new command after us (see comment below)

}

// Compare ClipRect, TextureId and VtxOffset with a single memcmp()

#define ImDrawCmd_HeaderSize                            (offsetof(ImDrawCmd, VtxOffset) + sizeof(unsigned int))

#define ImDrawCmd_HeaderCompare(CMD_LHS, CMD_RHS)       (memcmp(CMD_LHS, CMD_RHS, ImDrawCmd_HeaderSize))    // Compare ClipRect, TextureId, VtxOffset

#define ImDrawCmd_HeaderCopy(CMD_DST, CMD_SRC)          (memcpy(CMD_DST, CMD_SRC, ImDrawCmd_HeaderSize))    // Copy ClipRect, TextureId, VtxOffset

#define ImDrawCmd_AreSequentialIdxOffset(CMD_0, CMD_1)  (CMD_0->IdxOffset + CMD_0->ElemCount == CMD_1->IdxOffset)

// Try to merge two last draw commands

void ImDrawList::_TryMergeDrawCmds()

{

    IM_ASSERT_PARANOID(CmdBuffer.Size > 0);

    ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];

    ImDrawCmd* prev_cmd = curr_cmd - 1;

    if (ImDrawCmd_HeaderCompare(curr_cmd, prev_cmd) == 0 && ImDrawCmd_AreSequentialIdxOffset(prev_cmd, curr_cmd) && curr_cmd->UserCallback == NULL && prev_cmd->UserCallback == NULL)

    {

        prev_cmd->ElemCount += curr_cmd->ElemCount;

        CmdBuffer.pop_back();

    }

}

// Our scheme may appears a bit unusual, basically we want the most-common calls AddLine AddRect etc. to not have to perform any check so we always have a command ready in the stack.

// The cost of figuring out if a new command has to be added or if we can merge is paid in those Update** functions only.

void ImDrawList::_OnChangedClipRect()

{

    // If current command is used with different settings we need to add a new command

    IM_ASSERT_PARANOID(CmdBuffer.Size > 0);

    ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];

    if (curr_cmd->ElemCount != 0 && memcmp(&curr_cmd->ClipRect, &_CmdHeader.ClipRect, sizeof(ImVec4)) != 0)

    {

        AddDrawCmd();

        return;

    }

    IM_ASSERT(curr_cmd->UserCallback == NULL);

    // Try to merge with previous command if it matches, else use current command

    ImDrawCmd* prev_cmd = curr_cmd - 1;

    if (curr_cmd->ElemCount == 0 && CmdBuffer.Size > 1 && ImDrawCmd_HeaderCompare(&_CmdHeader, prev_cmd) == 0 && ImDrawCmd_AreSequentialIdxOffset(prev_cmd, curr_cmd) && prev_cmd->UserCallback == NULL)

    {

        CmdBuffer.pop_back();

        return;

    }

    curr_cmd->ClipRect = _CmdHeader.ClipRect;

}

void ImDrawList::_OnChangedTextureID()

{

    // If current command is used with different settings we need to add a new command

    IM_ASSERT_PARANOID(CmdBuffer.Size > 0);

    ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];

    if (curr_cmd->ElemCount != 0 && curr_cmd->TextureId != _CmdHeader.TextureId)

    {

        AddDrawCmd();

        return;

    }

    IM_ASSERT(curr_cmd->UserCallback == NULL);

    // Try to merge with previous command if it matches, else use current command

    ImDrawCmd* prev_cmd = curr_cmd - 1;

    if (curr_cmd->ElemCount == 0 && CmdBuffer.Size > 1 && ImDrawCmd_HeaderCompare(&_CmdHeader, prev_cmd) == 0 && ImDrawCmd_AreSequentialIdxOffset(prev_cmd, curr_cmd) && prev_cmd->UserCallback == NULL)

    {

        CmdBuffer.pop_back();

        return;

    }

    curr_cmd->TextureId = _CmdHeader.TextureId;

}

void ImDrawList::_OnChangedVtxOffset()

{

    // We don't need to compare curr_cmd->VtxOffset != _CmdHeader.VtxOffset because we know it'll be different at the time we call this.

    _VtxCurrentIdx = 0;

    IM_ASSERT_PARANOID(CmdBuffer.Size > 0);

    ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];

    //IM_ASSERT(curr_cmd->VtxOffset != _CmdHeader.VtxOffset); // See #3349

    if (curr_cmd->ElemCount != 0)

    {

        AddDrawCmd();

        return;

    }

    IM_ASSERT(curr_cmd->UserCallback == NULL);

    curr_cmd->VtxOffset = _CmdHeader.VtxOffset;

}

int ImDrawList::_CalcCircleAutoSegmentCount(float radius) const

{

    // Automatic segment count

    const int radius_idx = (int)(radius + 0.999999f); // ceil to never reduce accuracy

    if (radius_idx >= 0 && radius_idx < IM_ARRAYSIZE(_Data->CircleSegmentCounts))

        return _Data->CircleSegmentCounts[radius_idx]; // Use cached value

    else

        return IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC(radius, _Data->CircleSegmentMaxError);

}

// 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)

void ImDrawList::PushClipRect(const ImVec2& cr_min, const ImVec2& cr_max, bool intersect_with_current_clip_rect)

{

    ImVec4 cr(cr_min.x, cr_min.y, cr_max.x, cr_max.y);

    if (intersect_with_current_clip_rect)

    {

        ImVec4 current = _CmdHeader.ClipRect;

        if (cr.x < current.x) cr.x = current.x;

        if (cr.y < current.y) cr.y = current.y;

        if (cr.z > current.z) cr.z = current.z;

        if (cr.w > current.w) cr.w = current.w;

    }

    cr.z = ImMax(cr.x, cr.z);

    cr.w = ImMax(cr.y, cr.w);

    _ClipRectStack.push_back(cr);

    _CmdHeader.ClipRect = cr;

    _OnChangedClipRect();

}

void ImDrawList::PushClipRectFullScreen()

{

    PushClipRect(ImVec2(_Data->ClipRectFullscreen.x, _Data->ClipRectFullscreen.y), ImVec2(_Data->ClipRectFullscreen.z, _Data->ClipRectFullscreen.w));

}

void ImDrawList::PopClipRect()

{

    _ClipRectStack.pop_back();

    _CmdHeader.ClipRect = (_ClipRectStack.Size == 0) ? _Data->ClipRectFullscreen : _ClipRectStack.Data[_ClipRectStack.Size - 1];

    _OnChangedClipRect();

}

void ImDrawList::PushTextureID(ImTextureID texture_id)

{

    _TextureIdStack.push_back(texture_id);

    _CmdHeader.TextureId = texture_id;

    _OnChangedTextureID();

}

void ImDrawList::PopTextureID()

{

    _TextureIdStack.pop_back();

    _CmdHeader.TextureId = (_TextureIdStack.Size == 0) ? (ImTextureID)NULL : _TextureIdStack.Data[_TextureIdStack.Size - 1];

    _OnChangedTextureID();

}

// This is used by ImGui::PushFont()/PopFont(). It works because we never use _TextureIdStack[] elsewhere than in PushTextureID()/PopTextureID().

void ImDrawList::_SetTextureID(ImTextureID texture_id)

{

    if (_CmdHeader.TextureId == texture_id)

        return;

    _CmdHeader.TextureId = texture_id;

    _OnChangedTextureID();

}

// Reserve space for a number of vertices and indices.

// You must finish filling your reserved data before calling PrimReserve() again, as it may reallocate or

// submit the intermediate results. PrimUnreserve() can be used to release unused allocations.

void ImDrawList::PrimReserve(int idx_count, int vtx_count)

{

    // Large mesh support (when enabled)

    IM_ASSERT_PARANOID(idx_count >= 0 && vtx_count >= 0);

    if (sizeof(ImDrawIdx) == 2 && (_VtxCurrentIdx + vtx_count >= (1 << 16)) && (Flags & ImDrawListFlags_AllowVtxOffset))

    {

        // FIXME: In theory we should be testing that vtx_count <64k here.

        // In practice, RenderText() relies on reserving ahead for a worst case scenario so it is currently useful for us

        // to not make that check until we rework the text functions to handle clipping and large horizontal lines better.

        _CmdHeader.VtxOffset = VtxBuffer.Size;

        _OnChangedVtxOffset();

    }

    ImDrawCmd* draw_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];

    draw_cmd->ElemCount += idx_count;

    int vtx_buffer_old_size = VtxBuffer.Size;

    VtxBuffer.resize(vtx_buffer_old_size + vtx_count);

    _VtxWritePtr = VtxBuffer.Data + vtx_buffer_old_size;

    int idx_buffer_old_size = IdxBuffer.Size;

    IdxBuffer.resize(idx_buffer_old_size + idx_count);

    _IdxWritePtr = IdxBuffer.Data + idx_buffer_old_size;

}

// Release the number of reserved vertices/indices from the end of the last reservation made with PrimReserve().

void ImDrawList::PrimUnreserve(int idx_count, int vtx_count)

{

    IM_ASSERT_PARANOID(idx_count >= 0 && vtx_count >= 0);

    ImDrawCmd* draw_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];

    draw_cmd->ElemCount -= idx_count;

    VtxBuffer.shrink(VtxBuffer.Size - vtx_count);

    IdxBuffer.shrink(IdxBuffer.Size - idx_count);

}

// Fully unrolled with inline call to keep our debug builds decently fast.

void ImDrawList::PrimRect(const ImVec2& a, const ImVec2& c, ImU32 col)

{

    ImVec2 b(c.x, a.y), d(a.x, c.y), uv(_Data->TexUvWhitePixel);

    ImDrawIdx idx = (ImDrawIdx)_VtxCurrentIdx;

    _IdxWritePtr[0] = idx; _IdxWritePtr[1] = (ImDrawIdx)(idx+1); _IdxWritePtr[2] = (ImDrawIdx)(idx+2);

    _IdxWritePtr[3] = idx; _IdxWritePtr[4] = (ImDrawIdx)(idx+2); _IdxWritePtr[5] = (ImDrawIdx)(idx+3);

    _VtxWritePtr[0].pos = a; _VtxWritePtr[0].uv = uv; _VtxWritePtr[0].col = col;

    _VtxWritePtr[1].pos = b; _VtxWritePtr[1].uv = uv; _VtxWritePtr[1].col = col;

    _VtxWritePtr[2].pos = c; _VtxWritePtr[2].uv = uv; _VtxWritePtr[2].col = col;

    _VtxWritePtr[3].pos = d; _VtxWritePtr[3].uv = uv; _VtxWritePtr[3].col = col;

    _VtxWritePtr += 4;

    _VtxCurrentIdx += 4;

    _IdxWritePtr += 6;

}

void ImDrawList::PrimRectUV(const ImVec2& a, const ImVec2& c, const ImVec2& uv_a, const ImVec2& uv_c, ImU32 col)

{

    ImVec2 b(c.x, a.y), d(a.x, c.y), uv_b(uv_c.x, uv_a.y), uv_d(uv_a.x, uv_c.y);

    ImDrawIdx idx = (ImDrawIdx)_VtxCurrentIdx;

    _IdxWritePtr[0] = idx; _IdxWritePtr[1] = (ImDrawIdx)(idx+1); _IdxWritePtr[2] = (ImDrawIdx)(idx+2);

    _IdxWritePtr[3] = idx; _IdxWritePtr[4] = (ImDrawIdx)(idx+2); _IdxWritePtr[5] = (ImDrawIdx)(idx+3);

    _VtxWritePtr[0].pos = a; _VtxWritePtr[0].uv = uv_a; _VtxWritePtr[0].col = col;

    _VtxWritePtr[1].pos = b; _VtxWritePtr[1].uv = uv_b; _VtxWritePtr[1].col = col;

    _VtxWritePtr[2].pos = c; _VtxWritePtr[2].uv = uv_c; _VtxWritePtr[2].col = col;

    _VtxWritePtr[3].pos = d; _VtxWritePtr[3].uv = uv_d; _VtxWritePtr[3].col = col;

    _VtxWritePtr += 4;

    _VtxCurrentIdx += 4;

    _IdxWritePtr += 6;

}

void ImDrawList::PrimQuadUV(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& d, const ImVec2& uv_a, const ImVec2& uv_b, const ImVec2& uv_c, const ImVec2& uv_d, ImU32 col)

{

    ImDrawIdx idx = (ImDrawIdx)_VtxCurrentIdx;

    _IdxWritePtr[0] = idx; _IdxWritePtr[1] = (ImDrawIdx)(idx+1); _IdxWritePtr[2] = (ImDrawIdx)(idx+2);

    _IdxWritePtr[3] = idx; _IdxWritePtr[4] = (ImDrawIdx)(idx+2); _IdxWritePtr[5] = (ImDrawIdx)(idx+3);

    _VtxWritePtr[0].pos = a; _VtxWritePtr[0].uv = uv_a; _VtxWritePtr[0].col = col;

    _VtxWritePtr[1].pos = b; _VtxWritePtr[1].uv = uv_b; _VtxWritePtr[1].col = col;

    _VtxWritePtr[2].pos = c; _VtxWritePtr[2].uv = uv_c; _VtxWritePtr[2].col = col;

    _VtxWritePtr[3].pos = d; _VtxWritePtr[3].uv = uv_d; _VtxWritePtr[3].col = col;

    _VtxWritePtr += 4;

    _VtxCurrentIdx += 4;

    _IdxWritePtr += 6;

}

// On AddPolyline() and AddConvexPolyFilled() we intentionally avoid using ImVec2 and superfluous function calls to optimize debug/non-inlined builds.

// - Those macros expects l-values and need to be used as their own statement.

// - Those macros are intentionally not surrounded by the 'do {} while (0)' idiom because even that translates to runtime with debug compilers.

#define IM_NORMALIZE2F_OVER_ZERO(VX,VY)     { float d2 = VX*VX + VY*VY; if (d2 > 0.0f) { float inv_len = ImRsqrt(d2); VX *= inv_len; VY *= inv_len; } } (void)0

#define IM_FIXNORMAL2F_MAX_INVLEN2          100.0f // 500.0f (see #4053, #3366)

#define IM_FIXNORMAL2F(VX,VY)               { float d2 = VX*VX + VY*VY; if (d2 > 0.000001f) { float inv_len2 = 1.0f / d2; if (inv_len2 > IM_FIXNORMAL2F_MAX_INVLEN2) inv_len2 = IM_FIXNORMAL2F_MAX_INVLEN2; VX *= inv_len2; VY *= inv_len2; } } (void)0

// TODO: Thickness anti-aliased lines cap are missing their AA fringe.

// We avoid using the ImVec2 math operators here to reduce cost to a minimum for debug/non-inlined builds.

void ImDrawList::AddPolyline(const ImVec2* points, const int points_count, ImU32 col, ImDrawFlags flags, float thickness)

{

    if (points_count < 2 || (col & IM_COL32_A_MASK) == 0)

        return;

    const bool closed = (flags & ImDrawFlags_Closed) != 0;

    const ImVec2 opaque_uv = _Data->TexUvWhitePixel;

    const int count = closed ? points_count : points_count - 1; // The number of line segments we need to draw

    const bool thick_line = (thickness > _FringeScale);

    if (Flags & ImDrawListFlags_AntiAliasedLines)

    {

        // Anti-aliased stroke

        const float AA_SIZE = _FringeScale;

        const ImU32 col_trans = col & ~IM_COL32_A_MASK;

        // Thicknesses <1.0 should behave like thickness 1.0

        thickness = ImMax(thickness, 1.0f);

        const int integer_thickness = (int)thickness;

        const float fractional_thickness = thickness - integer_thickness;

        // Do we want to draw this line using a texture?

        // - For now, only draw integer-width lines using textures to avoid issues with the way scaling occurs, could be improved.

        // - If AA_SIZE is not 1.0f we cannot use the texture path.

        const bool use_texture = (Flags & ImDrawListFlags_AntiAliasedLinesUseTex) && (integer_thickness < IM_DRAWLIST_TEX_LINES_WIDTH_MAX) && (fractional_thickness <= 0.00001f) && (AA_SIZE == 1.0f);

        // We should never hit this, because NewFrame() doesn't set ImDrawListFlags_AntiAliasedLinesUseTex unless ImFontAtlasFlags_NoBakedLines is off

        IM_ASSERT_PARANOID(!use_texture || !(_Data->Font->ContainerAtlas->Flags & ImFontAtlasFlags_NoBakedLines));

        const int idx_count = use_texture ? (count * 6) : (thick_line ? count * 18 : count * 12);

        const int vtx_count = use_texture ? (points_count * 2) : (thick_line ? points_count * 4 : points_count * 3);

        PrimReserve(idx_count, vtx_count);

        // Temporary buffer

        // The first <points_count> items are normals at each line point, then after that there are either 2 or 4 temp points for each line point

        _Data->TempBuffer.reserve_discard(points_count * ((use_texture || !thick_line) ? 3 : 5));

        ImVec2* temp_normals = _Data->TempBuffer.Data;

        ImVec2* temp_points = temp_normals + points_count;

        // Calculate normals (tangents) for each line segment

        for (int i1 = 0; i1 < count; i1++)

        {

            const int i2 = (i1 + 1) == points_count ? 0 : i1 + 1;

            float dx = points[i2].x - points[i1].x;

            float dy = points[i2].y - points[i1].y;

            IM_NORMALIZE2F_OVER_ZERO(dx, dy);

            temp_normals[i1].x = dy;

            temp_normals[i1].y = -dx;

        }

        if (!closed)

            temp_normals[points_count - 1] = temp_normals[points_count - 2];

        // If we are drawing a one-pixel-wide line without a texture, or a textured line of any width, we only need 2 or 3 vertices per point

        if (use_texture || !thick_line)

        {

            // [PATH 1] Texture-based lines (thick or non-thick)

            // [PATH 2] Non texture-based lines (non-thick)

            // The width of the geometry we need to draw - this is essentially <thickness> pixels for the line itself, plus "one pixel" for AA.

            // - In the texture-based path, we don't use AA_SIZE here because the +1 is tied to the generated texture

            //   (see ImFontAtlasBuildRenderLinesTexData() function), and so alternate values won't work without changes to that code.

            // - In the non texture-based paths, we would allow AA_SIZE to potentially be != 1.0f with a patch (e.g. fringe_scale patch to

            //   allow scaling geometry while preserving one-screen-pixel AA fringe).

            const float half_draw_size = use_texture ? ((thickness * 0.5f) + 1) : AA_SIZE;

            // If line is not closed, the first and last points need to be generated differently as there are no normals to blend

            if (!closed)

            {

                temp_points[0] = points[0] + temp_normals[0] * half_draw_size;

                temp_points[1] = points[0] - temp_normals[0] * half_draw_size;

                temp_points[(points_count-1)*2+0] = points[points_count-1] + temp_normals[points_count-1] * half_draw_size;

                temp_points[(points_count-1)*2+1] = points[points_count-1] - temp_normals[points_count-1] * half_draw_size;

            }

            // Generate the indices to form a number of triangles for each line segment, and the vertices for the line edges

            // This takes points n and n+1 and writes into n+1, with the first point in a closed line being generated from the final one (as n+1 wraps)

            // FIXME-OPT: Merge the different loops, possibly remove the temporary buffer.

            unsigned int idx1 = _VtxCurrentIdx; // Vertex index for start of line segment

            for (int i1 = 0; i1 < count; i1++) // i1 is the first point of the line segment

            {

                const int i2 = (i1 + 1) == points_count ? 0 : i1 + 1; // i2 is the second point of the line segment

                const unsigned int idx2 = ((i1 + 1) == points_count) ? _VtxCurrentIdx : (idx1 + (use_texture ? 2 : 3)); // Vertex index for end of segment

                // Average normals

                float dm_x = (temp_normals[i1].x + temp_normals[i2].x) * 0.5f;

                float dm_y = (temp_normals[i1].y + temp_normals[i2].y) * 0.5f;

                IM_FIXNORMAL2F(dm_x, dm_y);

                dm_x *= half_draw_size; // dm_x, dm_y are offset to the outer edge of the AA area

                dm_y *= half_draw_size;

                // Add temporary vertexes for the outer edges

                ImVec2* out_vtx = &temp_points[i2 * 2];

                out_vtx[0].x = points[i2].x + dm_x;

                out_vtx[0].y = points[i2].y + dm_y;

                out_vtx[1].x = points[i2].x - dm_x;

                out_vtx[1].y = points[i2].y - dm_y;

                if (use_texture)

                {

                    // Add indices for two triangles

                    _IdxWritePtr[0] = (ImDrawIdx)(idx2 + 0); _IdxWritePtr[1] = (ImDrawIdx)(idx1 + 0); _IdxWritePtr[2] = (ImDrawIdx)(idx1 + 1); // Right tri

                    _IdxWritePtr[3] = (ImDrawIdx)(idx2 + 1); _IdxWritePtr[4] = (ImDrawIdx)(idx1 + 1); _IdxWritePtr[5] = (ImDrawIdx)(idx2 + 0); // Left tri

                    _IdxWritePtr += 6;

                }

                else

                {

                    // Add indexes for four triangles

                    _IdxWritePtr[0] = (ImDrawIdx)(idx2 + 0); _IdxWritePtr[1] = (ImDrawIdx)(idx1 + 0); _IdxWritePtr[2] = (ImDrawIdx)(idx1 + 2); // Right tri 1

                    _IdxWritePtr[3] = (ImDrawIdx)(idx1 + 2); _IdxWritePtr[4] = (ImDrawIdx)(idx2 + 2); _IdxWritePtr[5] = (ImDrawIdx)(idx2 + 0); // Right tri 2

                    _IdxWritePtr[6] = (ImDrawIdx)(idx2 + 1); _IdxWritePtr[7] = (ImDrawIdx)(idx1 + 1); _IdxWritePtr[8] = (ImDrawIdx)(idx1 + 0); // Left tri 1

                    _IdxWritePtr[9] = (ImDrawIdx)(idx1 + 0); _IdxWritePtr[10] = (ImDrawIdx)(idx2 + 0); _IdxWritePtr[11] = (ImDrawIdx)(idx2 + 1); // Left tri 2

                    _IdxWritePtr += 12;

                }

                idx1 = idx2;

            }

            // Add vertexes for each point on the line

            if (use_texture)

            {

                // If we're using textures we only need to emit the left/right edge vertices

                ImVec4 tex_uvs = _Data->TexUvLines[integer_thickness];

                /*if (fractional_thickness != 0.0f) // Currently always zero when use_texture==false!

                {

                    const ImVec4 tex_uvs_1 = _Data->TexUvLines[integer_thickness + 1];

                    tex_uvs.x = tex_uvs.x + (tex_uvs_1.x - tex_uvs.x) * fractional_thickness; // inlined ImLerp()

                    tex_uvs.y = tex_uvs.y + (tex_uvs_1.y - tex_uvs.y) * fractional_thickness;

                    tex_uvs.z = tex_uvs.z + (tex_uvs_1.z - tex_uvs.z) * fractional_thickness;

                    tex_uvs.w = tex_uvs.w + (tex_uvs_1.w - tex_uvs.w) * fractional_thickness;

                }*/

                ImVec2 tex_uv0(tex_uvs.x, tex_uvs.y);

                ImVec2 tex_uv1(tex_uvs.z, tex_uvs.w);

                for (int i = 0; i < points_count; i++)

                {

                    _VtxWritePtr[0].pos = temp_points[i * 2 + 0]; _VtxWritePtr[0].uv = tex_uv0; _VtxWritePtr[0].col = col; // Left-side outer edge