| // dear imgui, v1.75 |
| // (drawing and font code) |
| |
| /* |
| |
| Index of this file: |
| |
| // [SECTION] STB libraries implementation |
| // [SECTION] Style functions |
| // [SECTION] ImDrawList |
| // [SECTION] ImDrawListSplitter |
| // [SECTION] ImDrawData |
| // [SECTION] Helpers ShadeVertsXXX functions |
| // [SECTION] ImFontConfig |
| // [SECTION] ImFontAtlas |
| // [SECTION] ImFontAtlas glyph ranges helpers |
| // [SECTION] ImFontGlyphRangesBuilder |
| // [SECTION] ImFont |
| // [SECTION] 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 |
| |
| #include "imgui.h" |
| #ifndef IMGUI_DISABLE |
| |
| #ifndef IMGUI_DEFINE_MATH_OPERATORS |
| #define IMGUI_DEFINE_MATH_OPERATORS |
| #endif |
| #include "imgui_internal.h" |
| |
| #include <stdio.h> // vsnprintf, sscanf, printf |
| #if !defined(alloca) |
| #if defined(__GLIBC__) || defined(__sun) || defined(__CYGWIN__) || defined(__APPLE__) || defined(__SWITCH__) |
| #include <alloca.h> // alloca (glibc uses <alloca.h>. Note that Cygwin may have _WIN32 defined, so the order matters here) |
| #elif defined(_WIN32) |
| #include <malloc.h> // alloca |
| #if !defined(alloca) |
| #define alloca _alloca // for clang with MS Codegen |
| #endif |
| #else |
| #include <stdlib.h> // alloca |
| #endif |
| #endif |
| |
| // Visual Studio warnings |
| #ifdef _MSC_VER |
| #pragma warning (disable: 4127) // condition expression is constant |
| #pragma warning (disable: 4505) // unreferenced local function has been removed (stb stuff) |
| #pragma warning (disable: 4996) // 'This function or variable may be unsafe': strcpy, strdup, sprintf, vsnprintf, sscanf, fopen |
| #endif |
| |
| // Clang/GCC warnings with -Weverything |
| #if defined(__clang__) |
| #pragma clang diagnostic ignored "-Wold-style-cast" // warning : use of old-style cast // yes, they are more terse. |
| #pragma clang diagnostic ignored "-Wfloat-equal" // warning : comparing floating point with == or != is unsafe // storing and comparing against same constants ok. |
| #pragma clang diagnostic ignored "-Wglobal-constructors" // warning : declaration requires a global destructor // similar to above, not sure what the exact difference is. |
| #pragma clang diagnostic ignored "-Wsign-conversion" // warning : implicit conversion changes signedness // |
| #if __has_warning("-Wzero-as-null-pointer-constant") |
| #pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant" // warning : zero as null pointer constant // some standard header variations use #define NULL 0 |
| #endif |
| #if __has_warning("-Wcomma") |
| #pragma clang diagnostic ignored "-Wcomma" // warning : possible misuse of comma operator here // |
| #endif |
| #if __has_warning("-Wreserved-id-macro") |
| #pragma clang diagnostic ignored "-Wreserved-id-macro" // warning : macro name is a reserved identifier // |
| #endif |
| #if __has_warning("-Wdouble-promotion") |
| #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. |
| #endif |
| #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 |
| //------------------------------------------------------------------------- |
| |
| // 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 |
| #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 |
| #define STBRP_STATIC |
| #define STBRP_ASSERT(x) IM_ASSERT(x) |
| #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 |
| |
| #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 |
| #define STBTT_malloc(x,u) ((void)(u), IM_ALLOC(x)) |
| #define STBTT_free(x,u) ((void)(u), IM_FREE(x)) |
| #define STBTT_assert(x) IM_ASSERT(x) |
| #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)ImFloorStd(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 |
| |
| #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.25f); |
| 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_Tab] = ImLerp(colors[ImGuiCol_Header], colors[ImGuiCol_TitleBgActive], 0.80f); |
| colors[ImGuiCol_TabHovered] = colors[ImGuiCol_HeaderHovered]; |
| colors[ImGuiCol_TabActive] = ImLerp(colors[ImGuiCol_HeaderActive], colors[ImGuiCol_TitleBgActive], 0.60f); |
| colors[ImGuiCol_TabUnfocused] = ImLerp(colors[ImGuiCol_Tab], colors[ImGuiCol_TitleBg], 0.80f); |
| colors[ImGuiCol_TabUnfocusedActive] = ImLerp(colors[ImGuiCol_TabActive], colors[ImGuiCol_TitleBg], 0.40f); |
| 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_TextSelectedBg] = ImVec4(0.26f, 0.59f, 0.98f, 0.35f); |
| colors[ImGuiCol_DragDropTarget] = ImVec4(1.00f, 1.00f, 0.00f, 0.90f); |
| colors[ImGuiCol_NavHighlight] = 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.70f); |
| 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.16f); |
| 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_Tab] = ImLerp(colors[ImGuiCol_Header], colors[ImGuiCol_TitleBgActive], 0.80f); |
| colors[ImGuiCol_TabHovered] = colors[ImGuiCol_HeaderHovered]; |
| colors[ImGuiCol_TabActive] = ImLerp(colors[ImGuiCol_HeaderActive], colors[ImGuiCol_TitleBgActive], 0.60f); |
| colors[ImGuiCol_TabUnfocused] = ImLerp(colors[ImGuiCol_Tab], colors[ImGuiCol_TitleBg], 0.80f); |
| colors[ImGuiCol_TabUnfocusedActive] = ImLerp(colors[ImGuiCol_TabActive], colors[ImGuiCol_TitleBg], 0.40f); |
| 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_TextSelectedBg] = ImVec4(0.00f, 0.00f, 1.00f, 0.35f); |
| colors[ImGuiCol_DragDropTarget] = ImVec4(1.00f, 1.00f, 0.00f, 0.90f); |
| colors[ImGuiCol_NavHighlight] = 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.80f, 0.80f, 0.80f, 0.56f); |
| 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_Tab] = ImLerp(colors[ImGuiCol_Header], colors[ImGuiCol_TitleBgActive], 0.90f); |
| colors[ImGuiCol_TabHovered] = colors[ImGuiCol_HeaderHovered]; |
| colors[ImGuiCol_TabActive] = ImLerp(colors[ImGuiCol_HeaderActive], colors[ImGuiCol_TitleBgActive], 0.60f); |
| colors[ImGuiCol_TabUnfocused] = ImLerp(colors[ImGuiCol_Tab], colors[ImGuiCol_TitleBg], 0.80f); |
| colors[ImGuiCol_TabUnfocusedActive] = ImLerp(colors[ImGuiCol_TabActive], colors[ImGuiCol_TitleBg], 0.40f); |
| 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_TextSelectedBg] = ImVec4(0.26f, 0.59f, 0.98f, 0.35f); |
| colors[ImGuiCol_DragDropTarget] = ImVec4(0.26f, 0.59f, 0.98f, 0.95f); |
| colors[ImGuiCol_NavHighlight] = 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); |
| } |
| |
| //----------------------------------------------------------------------------- |
| // ImDrawList |
| //----------------------------------------------------------------------------- |
| |
| ImDrawListSharedData::ImDrawListSharedData() |
| { |
| Font = NULL; |
| FontSize = 0.0f; |
| CurveTessellationTol = 0.0f; |
| CircleSegmentMaxError = 0.0f; |
| ClipRectFullscreen = ImVec4(-8192.0f, -8192.0f, +8192.0f, +8192.0f); |
| InitialFlags = ImDrawListFlags_None; |
| |
| // Lookup tables |
| for (int i = 0; i < IM_ARRAYSIZE(CircleVtx12); i++) |
| { |
| const float a = ((float)i * 2 * IM_PI) / (float)IM_ARRAYSIZE(CircleVtx12); |
| CircleVtx12[i] = ImVec2(ImCos(a), ImSin(a)); |
| } |
| memset(CircleSegmentCounts, 0, sizeof(CircleSegmentCounts)); // This will be set by SetCircleSegmentMaxError() |
| } |
| |
| void ImDrawListSharedData::SetCircleSegmentMaxError(float max_error) |
| { |
| if (CircleSegmentMaxError == max_error) |
| return; |
| CircleSegmentMaxError = max_error; |
| for (int i = 0; i < IM_ARRAYSIZE(CircleSegmentCounts); i++) |
| { |
| const float radius = i + 1.0f; |
| const int segment_count = IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC(radius, CircleSegmentMaxError); |
| CircleSegmentCounts[i] = (ImU8)ImMin(segment_count, 255); |
| } |
| } |
| |
| void ImDrawList::Clear() |
| { |
| CmdBuffer.resize(0); |
| IdxBuffer.resize(0); |
| VtxBuffer.resize(0); |
| Flags = _Data ? _Data->InitialFlags : ImDrawListFlags_None; |
| _VtxCurrentOffset = 0; |
| _VtxCurrentIdx = 0; |
| _VtxWritePtr = NULL; |
| _IdxWritePtr = NULL; |
| _ClipRectStack.resize(0); |
| _TextureIdStack.resize(0); |
| _Path.resize(0); |
| _Splitter.Clear(); |
| } |
| |
| void ImDrawList::ClearFreeMemory() |
| { |
| CmdBuffer.clear(); |
| IdxBuffer.clear(); |
| VtxBuffer.clear(); |
| _VtxCurrentIdx = 0; |
| _VtxWritePtr = NULL; |
| _IdxWritePtr = NULL; |
| _ClipRectStack.clear(); |
| _TextureIdStack.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; |
| } |
| |
| // Using macros because C++ is a terrible language, we want guaranteed inline, no code in header, and no overhead in Debug builds |
| #define GetCurrentClipRect() (_ClipRectStack.Size ? _ClipRectStack.Data[_ClipRectStack.Size-1] : _Data->ClipRectFullscreen) |
| #define GetCurrentTextureId() (_TextureIdStack.Size ? _TextureIdStack.Data[_TextureIdStack.Size-1] : (ImTextureID)NULL) |
| |
| void ImDrawList::AddDrawCmd() |
| { |
| ImDrawCmd draw_cmd; |
| draw_cmd.ClipRect = GetCurrentClipRect(); |
| draw_cmd.TextureId = GetCurrentTextureId(); |
| draw_cmd.VtxOffset = _VtxCurrentOffset; |
| draw_cmd.IdxOffset = IdxBuffer.Size; |
| |
| IM_ASSERT(draw_cmd.ClipRect.x <= draw_cmd.ClipRect.z && draw_cmd.ClipRect.y <= draw_cmd.ClipRect.w); |
| CmdBuffer.push_back(draw_cmd); |
| } |
| |
| void ImDrawList::AddCallback(ImDrawCallback callback, void* callback_data) |
| { |
| ImDrawCmd* current_cmd = CmdBuffer.Size ? &CmdBuffer.back() : NULL; |
| if (!current_cmd || current_cmd->ElemCount != 0 || current_cmd->UserCallback != NULL) |
| { |
| AddDrawCmd(); |
| current_cmd = &CmdBuffer.back(); |
| } |
| current_cmd->UserCallback = callback; |
| current_cmd->UserCallbackData = callback_data; |
| |
| AddDrawCmd(); // Force a new command after us (see comment below) |
| } |
| |
| // 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::UpdateClipRect() |
| { |
| // If current command is used with different settings we need to add a new command |
| const ImVec4 curr_clip_rect = GetCurrentClipRect(); |
| ImDrawCmd* curr_cmd = CmdBuffer.Size > 0 ? &CmdBuffer.Data[CmdBuffer.Size-1] : NULL; |
| if (!curr_cmd || (curr_cmd->ElemCount != 0 && memcmp(&curr_cmd->ClipRect, &curr_clip_rect, sizeof(ImVec4)) != 0) || curr_cmd->UserCallback != NULL) |
| { |
| AddDrawCmd(); |
| return; |
| } |
| |
| // Try to merge with previous command if it matches, else use current command |
| ImDrawCmd* prev_cmd = CmdBuffer.Size > 1 ? curr_cmd - 1 : NULL; |
| if (curr_cmd->ElemCount == 0 && prev_cmd && memcmp(&prev_cmd->ClipRect, &curr_clip_rect, sizeof(ImVec4)) == 0 && prev_cmd->TextureId == GetCurrentTextureId() && prev_cmd->UserCallback == NULL) |
| CmdBuffer.pop_back(); |
| else |
| curr_cmd->ClipRect = curr_clip_rect; |
| } |
| |
| void ImDrawList::UpdateTextureID() |
| { |
| // If current command is used with different settings we need to add a new command |
| const ImTextureID curr_texture_id = GetCurrentTextureId(); |
| ImDrawCmd* curr_cmd = CmdBuffer.Size ? &CmdBuffer.back() : NULL; |
| if (!curr_cmd || (curr_cmd->ElemCount != 0 && curr_cmd->TextureId != curr_texture_id) || curr_cmd->UserCallback != NULL) |
| { |
| AddDrawCmd(); |
| return; |
| } |
| |
| // Try to merge with previous command if it matches, else use current command |
| ImDrawCmd* prev_cmd = CmdBuffer.Size > 1 ? curr_cmd - 1 : NULL; |
| if (curr_cmd->ElemCount == 0 && prev_cmd && prev_cmd->TextureId == curr_texture_id && memcmp(&prev_cmd->ClipRect, &GetCurrentClipRect(), sizeof(ImVec4)) == 0 && prev_cmd->UserCallback == NULL) |
| CmdBuffer.pop_back(); |
| else |
| curr_cmd->TextureId = curr_texture_id; |
| } |
| |
| #undef GetCurrentClipRect |
| #undef GetCurrentTextureId |
| |
| // 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(ImVec2 cr_min, 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 && _ClipRectStack.Size) |
| { |
| ImVec4 current = _ClipRectStack.Data[_ClipRectStack.Size-1]; |
| 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); |
| UpdateClipRect(); |
| } |
| |
| void ImDrawList::PushClipRectFullScreen() |
| { |
| PushClipRect(ImVec2(_Data->ClipRectFullscreen.x, _Data->ClipRectFullscreen.y), ImVec2(_Data->ClipRectFullscreen.z, _Data->ClipRectFullscreen.w)); |
| } |
| |
| void ImDrawList::PopClipRect() |
| { |
| IM_ASSERT(_ClipRectStack.Size > 0); |
| _ClipRectStack.pop_back(); |
| UpdateClipRect(); |
| } |
| |
| void ImDrawList::PushTextureID(ImTextureID texture_id) |
| { |
| _TextureIdStack.push_back(texture_id); |
| UpdateTextureID(); |
| } |
| |
| void ImDrawList::PopTextureID() |
| { |
| IM_ASSERT(_TextureIdStack.Size > 0); |
| _TextureIdStack.pop_back(); |
| UpdateTextureID(); |
| } |
| |
| // 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)) |
| { |
| _VtxCurrentOffset = VtxBuffer.Size; |
| _VtxCurrentIdx = 0; |
| AddDrawCmd(); |
| } |
| |
| 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 a 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 superflous function calls to optimize debug/non-inlined builds. |
| // Those macros expects l-values. |
| #define IM_NORMALIZE2F_OVER_ZERO(VX,VY) { float d2 = VX*VX + VY*VY; if (d2 > 0.0f) { float inv_len = 1.0f / ImSqrt(d2); VX *= inv_len; VY *= inv_len; } } |
| #define IM_FIXNORMAL2F(VX,VY) { float d2 = VX*VX + VY*VY; if (d2 < 0.5f) d2 = 0.5f; float inv_lensq = 1.0f / d2; VX *= inv_lensq; VY *= inv_lensq; } |
| |
| // 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, bool closed, float thickness) |
| { |
| if (points_count < 2) |
| return; |
| |
| const ImVec2 uv = _Data->TexUvWhitePixel; |
| |
| int count = points_count; |
| if (!closed) |
| count = points_count-1; |
| |
| const bool thick_line = thickness > 1.0f; |
| if (Flags & ImDrawListFlags_AntiAliasedLines) |
| { |
| // Anti-aliased stroke |
| const float AA_SIZE = 1.0f; |
| const ImU32 col_trans = col & ~IM_COL32_A_MASK; |
| |
| const int idx_count = thick_line ? count*18 : count*12; |
| const int vtx_count = thick_line ? points_count*4 : points_count*3; |
| PrimReserve(idx_count, vtx_count); |
| |
| // Temporary buffer |
| ImVec2* temp_normals = (ImVec2*)alloca(points_count * (thick_line ? 5 : 3) * sizeof(ImVec2)); //-V630 |
| ImVec2* temp_points = temp_normals + points_count; |
| |
| 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 (!thick_line) |
| { |
| if (!closed) |
| { |
| temp_points[0] = points[0] + temp_normals[0] * AA_SIZE; |
| temp_points[1] = points[0] - temp_normals[0] * AA_SIZE; |
| temp_points[(points_count-1)*2+0] = points[points_count-1] + temp_normals[points_count-1] * AA_SIZE; |
| temp_points[(points_count-1)*2+1] = points[points_count-1] - temp_normals[points_count-1] * AA_SIZE; |
| } |
| |
| // FIXME-OPT: Merge the different loops, possibly remove the temporary buffer. |
| unsigned int idx1 = _VtxCurrentIdx; |
| for (int i1 = 0; i1 < count; i1++) |
| { |
| const int i2 = (i1+1) == points_count ? 0 : i1+1; |
| unsigned int idx2 = (i1+1) == points_count ? _VtxCurrentIdx : idx1+3; |
| |
| // 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 *= AA_SIZE; |
| dm_y *= AA_SIZE; |
| |
| // Add temporary vertexes |
| 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; |
| |
| // Add indexes |
| _IdxWritePtr[0] = (ImDrawIdx)(idx2+0); _IdxWritePtr[1] = (ImDrawIdx)(idx1+0); _IdxWritePtr[2] = (ImDrawIdx)(idx1+2); |
| _IdxWritePtr[3] = (ImDrawIdx)(idx1+2); _IdxWritePtr[4] = (ImDrawIdx)(idx2+2); _IdxWritePtr[5] = (ImDrawIdx)(idx2+0); |
| _IdxWritePtr[6] = (ImDrawIdx)(idx2+1); _IdxWritePtr[7] = (ImDrawIdx)(idx1+1); _IdxWritePtr[8] = (ImDrawIdx)(idx1+0); |
| _IdxWritePtr[9] = (ImDrawIdx)(idx1+0); _IdxWritePtr[10]= (ImDrawIdx)(idx2+0); _IdxWritePtr[11]= (ImDrawIdx)(idx2+1); |
| _IdxWritePtr += 12; |
| |
| idx1 = idx2; |
| } |
| |
| // Add vertexes |
| for (int i = 0; i < points_count; i++) |
| { |
| _VtxWritePtr[0].pos = points[i]; _VtxWritePtr[0].uv = uv; _VtxWritePtr[0].col = col; |
| _VtxWritePtr[1].pos = temp_points[i*2+0]; _VtxWritePtr[1].uv = uv; _VtxWritePtr[1].col = col_trans; |
| _VtxWritePtr[2].pos = temp_points[i*2+1]; _VtxWritePtr[2].uv = uv; _VtxWritePtr[2].col = col_trans; |
| _VtxWritePtr += 3; |
| } |
| } |
| else |
| { |
| const float half_inner_thickness = (thickness - AA_SIZE) * 0.5f; |
| if (!closed) |
| { |
| temp_points[0] = points[0] + temp_normals[0] * (half_inner_thickness + AA_SIZE); |
| temp_points[1] = points[0] + temp_normals[0] * (half_inner_thickness); |
| temp_points[2] = points[0] - temp_normals[0] * (half_inner_thickness); |
| temp_points[3] = points[0] - temp_normals[0] * (half_inner_thickness + AA_SIZE); |
| temp_points[(points_count-1)*4+0] = points[points_count-1] + temp_normals[points_count-1] * (half_inner_thickness + AA_SIZE); |
| temp_points[(points_count-1)*4+1] = points[points_count-1] + temp_normals[points_count-1] * (half_inner_thickness); |
| temp_points[(points_count-1)*4+2] = points[points_count-1] - temp_normals[points_count-1] * (half_inner_thickness); |
| temp_points[(points_count-1)*4+3] = points[points_count-1] - temp_normals[points_count-1] * (half_inner_thickness + AA_SIZE); |
| } |
| |
| // FIXME-OPT: Merge the different loops, possibly remove the temporary buffer. |
| unsigned int idx1 = _VtxCurrentIdx; |
| for (int i1 = 0; i1 < count; i1++) |
| { |
| const int i2 = (i1+1) == points_count ? 0 : i1+1; |
| unsigned int idx2 = (i1+1) == points_count ? _VtxCurrentIdx : idx1+4; |
| |
| // 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); |
| float dm_out_x = dm_x * (half_inner_thickness + AA_SIZE); |
| float dm_out_y = dm_y * (half_inner_thickness + AA_SIZE); |
| float dm_in_x = dm_x * half_inner_thickness; |
| float dm_in_y = dm_y * half_inner_thickness; |
| |
| // Add temporary vertexes |
| ImVec2* out_vtx = &temp_points[i2*4]; |
| out_vtx[0].x = points[i2].x + dm_out_x; |
| out_vtx[0].y = points[i2].y + dm_out_y; |
| out_vtx[1].x = points[i2].x + dm_in_x; |
| out_vtx[1].y = points[i2].y + dm_in_y; |
| out_vtx[2].x = points[i2].x - dm_in_x; |
| out_vtx[2].y = points[i2].y - dm_in_y; |
| out_vtx[3].x = points[i2].x - dm_out_x; |
| out_vtx[3].y = points[i2].y - dm_out_y; |
| |
| // Add indexes |
| _IdxWritePtr[0] = (ImDrawIdx)(idx2+1); _IdxWritePtr[1] = (ImDrawIdx)(idx1+1); _IdxWritePtr[2] = (ImDrawIdx)(idx1+2); |
| _IdxWritePtr[3] = (ImDrawIdx)(idx1+2); _IdxWritePtr[4] = (ImDrawIdx)(idx2+2); _IdxWritePtr[5] = (ImDrawIdx)(idx2+1); |
| _IdxWritePtr[6] = (ImDrawIdx)(idx2+1); _IdxWritePtr[7] = (ImDrawIdx)(idx1+1); _IdxWritePtr[8] = (ImDrawIdx)(idx1+0); |
| _IdxWritePtr[9] = (ImDrawIdx)(idx1+0); _IdxWritePtr[10] = (ImDrawIdx)(idx2+0); _IdxWritePtr[11] = (ImDrawIdx)(idx2+1); |
| _IdxWritePtr[12] = (ImDrawIdx)(idx2+2); _IdxWritePtr[13] = (ImDrawIdx)(idx1+2); _IdxWritePtr[14] = (ImDrawIdx)(idx1+3); |
| _IdxWritePtr[15] = (ImDrawIdx)(idx1+3); _IdxWritePtr[16] = (ImDrawIdx)(idx2+3); _IdxWritePtr[17] = (ImDrawIdx)(idx2+2); |
| _IdxWritePtr += 18; |
| |
| idx1 = idx2; |
| } |
| |
| // Add vertexes |
| for (int i = 0; i < points_count; i++) |
| { |
| _VtxWritePtr[0].pos = temp_points[i*4+0]; _VtxWritePtr[0].uv = uv; _VtxWritePtr[0].col = col_trans; |
| _VtxWritePtr[1].pos = temp_points[i*4+1]; _VtxWritePtr[1].uv = uv; _VtxWritePtr[1].col = col; |
| _VtxWritePtr[2].pos = temp_points[i*4+2]; _VtxWritePtr[2].uv = uv; _VtxWritePtr[2].col = col; |
| _VtxWritePtr[3].pos = temp_points[i*4+3]; _VtxWritePtr[3].uv = uv; _VtxWritePtr[3].col = col_trans; |
| _VtxWritePtr += 4; |
| } |
| } |
| _VtxCurrentIdx += (ImDrawIdx)vtx_count; |
| } |
| else |
| { |
| // Non Anti-aliased Stroke |
| const int idx_count = count*6; |
| const int vtx_count = count*4; // FIXME-OPT: Not sharing edges |
| PrimReserve(idx_count, vtx_count); |
| |
| for (int i1 = 0; i1 < count; i1++) |
| { |
| const int i2 = (i1+1) == points_count ? 0 : i1+1; |
| const ImVec2& p1 = points[i1]; |
| const ImVec2& p2 = points[i2]; |
| |
| float dx = p2.x - p1.x; |
| float dy = p2.y - p1.y; |
| IM_NORMALIZE2F_OVER_ZERO(dx, dy); |
| dx *= (thickness * 0.5f); |
| dy *= (thickness * 0.5f); |
| |
| _VtxWritePtr[0].pos.x = p1.x + dy; _VtxWritePtr[0].pos.y = p1.y - dx; _VtxWritePtr[0].uv = uv; _VtxWritePtr[0].col = col; |
| _VtxWritePtr[1].pos.x = p2.x + dy; _VtxWritePtr[1].pos.y = p2.y - dx; _VtxWritePtr[1].uv = uv; _VtxWritePtr[1].col = col; |
| _VtxWritePtr[2].pos.x = p2.x - dy; _VtxWritePtr[2].pos.y = p2.y + dx; _VtxWritePtr[2].uv = uv; _VtxWritePtr[2].col = col; |
| _VtxWritePtr[3].pos.x = p1.x - dy; _VtxWritePtr[3].pos.y = p1.y + dx; _VtxWritePtr[3].uv = uv; _VtxWritePtr[3].col = col; |
| _VtxWritePtr += 4; |
| |
| _IdxWritePtr[0] = (ImDrawIdx)(_VtxCurrentIdx); _IdxWritePtr[1] = (ImDrawIdx)(_VtxCurrentIdx+1); _IdxWritePtr[2] = (ImDrawIdx)(_VtxCurrentIdx+2); |
| _IdxWritePtr[3] = (ImDrawIdx)(_VtxCurrentIdx); _IdxWritePtr[4] = (ImDrawIdx)(_VtxCurrentIdx+2); _IdxWritePtr[5] = (ImDrawIdx)(_VtxCurrentIdx+3); |
| _IdxWritePtr += 6; |
| _VtxCurrentIdx += 4; |
| } |
| } |
| } |
| |
| // We intentionally avoid using ImVec2 and its math operators here to reduce cost to a minimum for debug/non-inlined builds. |
| void ImDrawList::AddConvexPolyFilled(const ImVec2* points, const int points_count, ImU32 col) |
| { |
| if (points_count < 3) |
| return; |
| |
| const ImVec2 uv = _Data->TexUvWhitePixel; |
| |
| if (Flags & ImDrawListFlags_AntiAliasedFill) |
| { |
| // Anti-aliased Fill |
| const float AA_SIZE = 1.0f; |
| const ImU32 col_trans = col & ~IM_COL32_A_MASK; |
| const int idx_count = (points_count-2)*3 + points_count*6; |
| const int vtx_count = (points_count*2); |
| PrimReserve(idx_count, vtx_count); |
| |
| // Add indexes for fill |
| unsigned int vtx_inner_idx = _VtxCurrentIdx; |
| unsigned int vtx_outer_idx = _VtxCurrentIdx+1; |
| for (int i = 2; i < points_count; i++) |
| { |
| _IdxWritePtr[0] = (ImDrawIdx)(vtx_inner_idx); _IdxWritePtr[1] = (ImDrawIdx)(vtx_inner_idx+((i-1)<<1)); _IdxWritePtr[2] = (ImDrawIdx)(vtx_inner_idx+(i<<1)); |
| _IdxWritePtr += 3; |
| } |
| |
| // Compute normals |
| ImVec2* temp_normals = (ImVec2*)alloca(points_count * sizeof(ImVec2)); //-V630 |
| for (int i0 = points_count-1, i1 = 0; i1 < points_count; i0 = i1++) |
| { |
| const ImVec2& p0 = points[i0]; |
| const ImVec2& p1 = points[i1]; |
| float dx = p1.x - p0.x; |
| float dy = p1.y - p0.y; |
| IM_NORMALIZE2F_OVER_ZERO(dx, dy); |
| temp_normals[i0].x = dy; |
| temp_normals[i0].y = -dx; |
| } |
| |
| for (int i0 = points_count-1, i1 = 0; i1 < points_count; i0 = i1++) |
| { |
| // Average normals |
| const ImVec2& n0 = temp_normals[i0]; |
| const ImVec2& n1 = temp_normals[i1]; |
| float dm_x = (n0.x + n1.x) * 0.5f; |
| float dm_y = (n0.y + n1.y) * 0.5f; |
| IM_FIXNORMAL2F(dm_x, dm_y); |
| dm_x *= AA_SIZE * 0.5f; |
| dm_y *= AA_SIZE * 0.5f; |
| |
| // Add vertices |
| _VtxWritePtr[0].pos.x = (points[i1].x - dm_x); _VtxWritePtr[0].pos.y = (points[i1].y - dm_y); _VtxWritePtr[0].uv = uv; _VtxWritePtr[0].col = col; // Inner |
| _VtxWritePtr[1].pos.x = (points[i1].x + dm_x); _VtxWritePtr[1].pos.y = (points[i1].y + dm_y); _VtxWritePtr[1].uv = uv; _VtxWritePtr[1].col = col_trans; // Outer |
| _VtxWritePtr += 2; |
| |
| // Add indexes for fringes |
| _IdxWritePtr[0] = (ImDrawIdx)(vtx_inner_idx+(i1<<1)); _IdxWritePtr[1] = (ImDrawIdx)(vtx_inner_idx+(i0<<1)); _IdxWritePtr[2] = (ImDrawIdx)(vtx_outer_idx+(i0<<1)); |
| _IdxWritePtr[3] = (ImDrawIdx)(vtx_outer_idx+(i0<<1)); _IdxWritePtr[4] = (ImDrawIdx)(vtx_outer_idx+(i1<<1)); _IdxWritePtr[5] = (ImDrawIdx)(vtx_inner_idx+(i1<<1)); |
| _IdxWritePtr += 6; |
| } |
| _VtxCurrentIdx += (ImDrawIdx)vtx_count; |
| } |
| else |
| { |
| // Non Anti-aliased Fill |
| const int idx_count = (points_count-2)*3; |
| const int vtx_count = points_count; |
| PrimReserve(idx_count, vtx_count); |
| for (int i = 0; i < vtx_count; i++) |
| { |
| _VtxWritePtr[0].pos = points[i]; _VtxWritePtr[0].uv = uv; _VtxWritePtr[0].col = col; |
| _VtxWritePtr++; |
| } |
| for (int i = 2; i < points_count; i++) |
| { |
| _IdxWritePtr[0] = (ImDrawIdx)(_VtxCurrentIdx); _IdxWritePtr[1] = (ImDrawIdx)(_VtxCurrentIdx+i-1); _IdxWritePtr[2] = (ImDrawIdx)(_VtxCurrentIdx+i); |
| _IdxWritePtr += 3; |
| } |
| _VtxCurrentIdx += (ImDrawIdx)vtx_count; |
| } |
| } |
| |
| void ImDrawList::PathArcToFast(const ImVec2& center, float radius, int a_min_of_12, int a_max_of_12) |
| { |
| if (radius == 0.0f || a_min_of_12 > a_max_of_12) |
| { |
| _Path.push_back(center); |
| return; |
| } |
| _Path.reserve(_Path.Size + (a_max_of_12 - a_min_of_12 + 1)); |
| for (int a = a_min_of_12; a <= a_max_of_12; a++) |
| { |
| const ImVec2& c = _Data->CircleVtx12[a % IM_ARRAYSIZE(_Data->CircleVtx12)]; |
| _Path.push_back(ImVec2(center.x + c.x * radius, center.y + c.y * radius)); |
| } |
| } |
| |
| void ImDrawList::PathArcTo(const ImVec2& center, float radius, float a_min, float a_max, int num_segments) |
| { |
| if (radius == 0.0f) |
| { |
| _Path.push_back(center); |
| return; |
| } |
| |
| // Note that we are adding a point at both a_min and a_max. |
| // If you are trying to draw a full closed circle you don't want the overlapping points! |
| _Path.reserve(_Path.Size + (num_segments + 1)); |
| for (int i = 0; i <= num_segments; i++) |
| { |
| const float a = a_min + ((float)i / (float)num_segments) * (a_max - a_min); |
| _Path.push_back(ImVec2(center.x + ImCos(a) * radius, center.y + ImSin(a) * radius)); |
| } |
| } |
| |
| ImVec2 ImBezierCalc(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, float t) |
| { |
| float u = 1.0f - t; |
| float w1 = u*u*u; |
| float w2 = 3*u*u*t; |
| float w3 = 3*u*t*t; |
| float w4 = t*t*t; |
| return ImVec2(w1*p1.x + w2*p2.x + w3*p3.x + w4*p4.x, w1*p1.y + w2*p2.y + w3*p3.y + w4*p4.y); |
| } |
| |
| // Closely mimics BezierClosestPointCasteljauStep() in imgui.cpp |
| static void PathBezierToCasteljau(ImVector<ImVec2>* path, float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4, float tess_tol, int level) |
| { |
| float dx = x4 - x1; |
| float dy = y4 - y1; |
| float d2 = ((x2 - x4) * dy - (y2 - y4) * dx); |
| float d3 = ((x3 - x4) * dy - (y3 - y4) * dx); |
| d2 = (d2 >= 0) ? d2 : -d2; |
| d3 = (d3 >= 0) ? d3 : -d3; |
| if ((d2+d3) * (d2+d3) < tess_tol * (dx*dx + dy*dy)) |
| { |
| path->push_back(ImVec2(x4, y4)); |
| } |
| else if (level < 10) |
| { |
| float x12 = (x1+x2)*0.5f, y12 = (y1+y2)*0.5f; |
| float x23 = (x2+x3)*0.5f, y23 = (y2+y3)*0.5f; |
| float x34 = (x3+x4)*0.5f, y34 = (y3+y4)*0.5f; |
| float x123 = (x12+x23)*0.5f, y123 = (y12+y23)*0.5f; |
| float x234 = (x23+x34)*0.5f, y234 = (y23+y34)*0.5f; |
| float x1234 = (x123+x234)*0.5f, y1234 = (y123+y234)*0.5f; |
| PathBezierToCasteljau(path, x1,y1, x12,y12, x123,y123, x1234,y1234, tess_tol, level+1); |
| PathBezierToCasteljau(path, x1234,y1234, x234,y234, x34,y34, x4,y4, tess_tol, level+1); |
| } |
| } |
| |
| void ImDrawList::PathBezierCurveTo(const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, int num_segments) |
| { |
| ImVec2 p1 = _Path.back(); |
| if (num_segments == 0) |
| { |
| PathBezierToCasteljau(&_Path, p1.x, p1.y, p2.x, p2.y, p3.x, p3.y, p4.x, p4.y, _Data->CurveTessellationTol, 0); // Auto-tessellated |
| } |
| else |
| { |
| float t_step = 1.0f / (float)num_segments; |
| for (int i_step = 1; i_step <= num_segments; i_step++) |
| _Path.push_back(ImBezierCalc(p1, p2, p3, p4, t_step * i_step)); |
| } |
| } |
| |
| void ImDrawList::PathRect(const ImVec2& a, const ImVec2& b, float rounding, ImDrawCornerFlags rounding_corners) |
| { |
| rounding = ImMin(rounding, ImFabs(b.x - a.x) * ( ((rounding_corners & ImDrawCornerFlags_Top) == ImDrawCornerFlags_Top) || ((rounding_corners & ImDrawCornerFlags_Bot) == ImDrawCornerFlags_Bot) ? 0.5f : 1.0f ) - 1.0f); |
| rounding = ImMin(rounding, ImFabs(b.y - a.y) * ( ((rounding_corners & ImDrawCornerFlags_Left) == ImDrawCornerFlags_Left) || ((rounding_corners & ImDrawCornerFlags_Right) == ImDrawCornerFlags_Right) ? 0.5f : 1.0f ) - 1.0f); |
| |
| if (rounding <= 0.0f || rounding_corners == 0) |
| { |
| PathLineTo(a); |
| PathLineTo(ImVec2(b.x, a.y)); |
| PathLineTo(b); |
| PathLineTo(ImVec2(a.x, b.y)); |
| } |
| else |
| { |
| const float rounding_tl = (rounding_corners & ImDrawCornerFlags_TopLeft) ? rounding : 0.0f; |
| const float rounding_tr = (rounding_corners & ImDrawCornerFlags_TopRight) ? rounding : 0.0f; |
| const float rounding_br = (rounding_corners & ImDrawCornerFlags_BotRight) ? rounding : 0.0f; |
| const float rounding_bl = (rounding_corners & ImDrawCornerFlags_BotLeft) ? rounding : 0.0f; |
| PathArcToFast(ImVec2(a.x + rounding_tl, a.y + rounding_tl), rounding_tl, 6, 9); |
| PathArcToFast(ImVec2(b.x - rounding_tr, a.y + rounding_tr), rounding_tr, 9, 12); |
| PathArcToFast(ImVec2(b.x - rounding_br, b.y - rounding_br), rounding_br, 0, 3); |
| PathArcToFast(ImVec2(a.x + rounding_bl, b.y - rounding_bl), rounding_bl, 3, 6); |
| } |
| } |
| |
| void ImDrawList::AddLine(const ImVec2& p1, const ImVec2& p2, ImU32 col, float thickness) |
| { |
| if ((col & IM_COL32_A_MASK) == 0) |
| return; |
| PathLineTo(p1 + ImVec2(0.5f, 0.5f)); |
| PathLineTo(p2 + ImVec2(0.5f, 0.5f)); |
| PathStroke(col, false, thickness); |
| } |
| |
| // p_min = upper-left, p_max = lower-right |
| // Note we don't render 1 pixels sized rectangles properly. |
| void ImDrawList::AddRect(const ImVec2& p_min, const ImVec2& p_max, ImU32 col, float rounding, ImDrawCornerFlags rounding_corners, float thickness) |
| { |
| if ((col & IM_COL32_A_MASK) == 0) |
| return; |
| if (Flags & ImDrawListFlags_AntiAliasedLines) |
| PathRect(p_min + ImVec2(0.50f,0.50f), p_max - ImVec2(0.50f,0.50f), rounding, rounding_corners); |
| else |
| PathRect(p_min + ImVec2(0.50f,0.50f), p_max - ImVec2(0.49f,0.49f), rounding, rounding_corners); // Better looking lower-right corner and rounded non-AA shapes. |
| PathStroke(col, true, thickness); |
| } |
| |
| void ImDrawList::AddRectFilled(const ImVec2& p_min, const ImVec2& p_max, ImU32 col, float rounding, ImDrawCornerFlags rounding_corners) |
| { |
| if ((col & IM_COL32_A_MASK) == 0) |
| return; |
| if (rounding > 0.0f) |
| { |
| PathRect(p_min, p_max, rounding, rounding_corners); |
| PathFillConvex(col); |
| } |
| else |
| { |
| PrimReserve(6, 4); |
| PrimRect(p_min, p_max, col); |
| } |
| } |
| |
| // p_min = upper-left, p_max = lower-right |
| void ImDrawList::AddRectFilledMultiColor(const ImVec2& p_min, const ImVec2& p_max, ImU32 col_upr_left, ImU32 col_upr_right, ImU32 col_bot_right, ImU32 col_bot_left) |
| { |
| if (((col_upr_left | col_upr_right | col_bot_right | col_bot_left) & IM_COL32_A_MASK) == 0) |
| return; |
| |
| const ImVec2 uv = _Data->TexUvWhitePixel; |
| PrimReserve(6, 4); |
| PrimWriteIdx((ImDrawIdx)(_VtxCurrentIdx)); PrimWriteIdx((ImDrawIdx)(_VtxCurrentIdx+1)); PrimWriteIdx((ImDrawIdx)(_VtxCurrentIdx+2)); |
| PrimWriteIdx((ImDrawIdx)(_VtxCurrentIdx)); PrimWriteIdx((ImDrawIdx)(_VtxCurrentIdx+2)); PrimWriteIdx((ImDrawIdx)(_VtxCurrentIdx+3)); |
| PrimWriteVtx(p_min, uv, col_upr_left); |
| PrimWriteVtx(ImVec2(p_max.x, p_min.y), uv, col_upr_right); |
| PrimWriteVtx(p_max, uv, col_bot_right); |
| PrimWriteVtx(ImVec2(p_min.x, p_max.y), uv, col_bot_left); |
| } |
| |
| void ImDrawList::AddQuad(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, ImU32 col, float thickness) |
| { |
| if ((col & IM_COL32_A_MASK) == 0) |
| return; |
| |
| PathLineTo(p1); |
| PathLineTo(p2); |
| PathLineTo(p3); |
| PathLineTo(p4); |
| PathStroke(col, true, thickness); |
| } |
| |
| void ImDrawList::AddQuadFilled(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, ImU32 col) |
| { |
| if ((col & IM_COL32_A_MASK) == 0) |
| return; |
| |
| PathLineTo(p1); |
| PathLineTo(p2); |
| PathLineTo(p3); |
| PathLineTo(p4); |
| PathFillConvex(col); |
| } |
| |
| void ImDrawList::AddTriangle(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, ImU32 col, float thickness) |
| { |
| if ((col & IM_COL32_A_MASK) == 0) |
| return; |
| |
| PathLineTo(p1); |
| PathLineTo(p2); |
| PathLineTo(p3); |
| PathStroke(col, true, thickness); |
| } |
| |
| void ImDrawList::AddTriangleFilled(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, ImU32 col) |
| { |
| if ((col & IM_COL32_A_MASK) == 0) |
| return; |
| |
| PathLineTo(p1); |
| PathLineTo(p2); |
| PathLineTo(p3); |
| PathFillConvex(col); |
| } |
| |
| void ImDrawList::AddCircle(const ImVec2& center, float radius, ImU32 col, int num_segments, float thickness) |
| { |
| if ((col & IM_COL32_A_MASK) == 0 || radius <= 0.0f) |
| return; |
| |
| // Obtain segment count |
| if (num_segments <= 0) |
| { |
| // Automatic segment count |
| const int radius_idx = (int)radius - 1; |
| if (radius_idx < IM_ARRAYSIZE(_Data->CircleSegmentCounts)) |
| num_segments = _Data->CircleSegmentCounts[radius_idx]; // Use cached value |
| else |
| num_segments = IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC(radius, _Data->CircleSegmentMaxError); |
| } |
| else |
| { |
| // Explicit segment count (still clamp to avoid drawing insanely tessellated shapes) |
| num_segments = ImClamp(num_segments, 3, IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MAX); |
| } |
| |
| // Because we are filling a closed shape we remove 1 from the count of segments/points |
| const float a_max = (IM_PI * 2.0f) * ((float)num_segments - 1.0f) / (float)num_segments; |
| if (num_segments == 12) |
| PathArcToFast(center, radius - 0.5f, 0, 12); |
| else |
| PathArcTo(center, radius - 0.5f, 0.0f, a_max, num_segments - 1); |
| PathStroke(col, true, thickness); |
| } |
| |
| void ImDrawList::AddCircleFilled(const ImVec2& center, float radius, ImU32 col, int num_segments) |
| { |
| if ((col & IM_COL32_A_MASK) == 0 || radius <= 0.0f) |
| return; |
| |
| // Obtain segment count |
| if (num_segments <= 0) |
| { |
| // Automatic segment count |
| const int radius_idx = (int)radius - 1; |
| if (radius_idx < IM_ARRAYSIZE(_Data->CircleSegmentCounts)) |
| num_segments = _Data->CircleSegmentCounts[radius_idx]; // Use cached value |
| else |
| num_segments = IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC(radius, _Data->CircleSegmentMaxError); |
| } |
| else |
| { |
| // Explicit segment count (still clamp to avoid drawing insanely tessellated shapes) |
| num_segments = ImClamp(num_segments, 3, IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MAX); |
| } |
| |
| // Because we are filling a closed shape we remove 1 from the count of segments/points |
| const float a_max = (IM_PI * 2.0f) * ((float)num_segments - 1.0f) / (float)num_segments; |
| if (num_segments == 12) |
| PathArcToFast(center, radius, 0, 12); |
| else |
| PathArcTo(center, radius, 0.0f, a_max, num_segments - 1); |
| PathFillConvex(col); |
| } |
| |
| // Guaranteed to honor 'num_segments' |
| void ImDrawList::AddNgon(const ImVec2& center, float radius, ImU32 col, int num_segments, float thickness) |
| { |
| if ((col & IM_COL32_A_MASK) == 0 || num_segments <= 2) |
| return; |
| |
| // Because we are filling a closed shape we remove 1 from the count of segments/points |
| const float a_max = (IM_PI * 2.0f) * ((float)num_segments - 1.0f) / (float)num_segments; |
| PathArcTo(center, radius - 0.5f, 0.0f, a_max, num_segments - 1); |
| PathStroke(col, true, thickness); |
| } |
| |
| // Guaranteed to honor 'num_segments' |
| void ImDrawList::AddNgonFilled(const ImVec2& center, float radius, ImU32 col, int num_segments) |
| { |
| if ((col & IM_COL32_A_MASK) == 0 || num_segments <= 2) |
| return; |
| |
| // Because we are filling a closed shape we remove 1 from the count of segments/points |
| const float a_max = (IM_PI * 2.0f) * ((float)num_segments - 1.0f) / (float)num_segments; |
| PathArcTo(center, radius, 0.0f, a_max, num_segments - 1); |
| PathFillConvex(col); |
| } |
| |
| // Cubic Bezier takes 4 controls points |
| void ImDrawList::AddBezierCurve(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, ImU32 col, float thickness, int num_segments) |
| { |
| if ((col & IM_COL32_A_MASK) == 0) |
| return; |
| |
| PathLineTo(p1); |
| PathBezierCurveTo(p2, p3, p4, num_segments); |
| PathStroke(col, false, thickness); |
| } |
| |
| void ImDrawList::AddText(const ImFont* font, float font_size, const ImVec2& pos, ImU32 col, const char* text_begin, const char* text_end, float wrap_width, const ImVec4* cpu_fine_clip_rect) |
| { |
| if ((col & IM_COL32_A_MASK) == 0) |
| return; |
| |
| if (text_end == NULL) |
| text_end = text_begin + strlen(text_begin); |
| if (text_begin == text_end) |
| return; |
| |
| // Pull default font/size from the shared ImDrawListSharedData instance |
| if (font == NULL) |
| font = _Data->Font; |
| if (font_size == 0.0f) |
| font_size = _Data->FontSize; |
| |
| IM_ASSERT(font->ContainerAtlas->TexID == _TextureIdStack.back()); // Use high-level ImGui::PushFont() or low-level ImDrawList::PushTextureId() to change font. |
| |
| ImVec4 clip_rect = _ClipRectStack.back(); |
| if (cpu_fine_clip_rect) |
| { |
| clip_rect.x = ImMax(clip_rect.x, cpu_fine_clip_rect->x); |
| clip_rect.y = ImMax(clip_rect.y, cpu_fine_clip_rect->y); |
| clip_rect.z = ImMin(clip_rect.z, cpu_fine_clip_rect->z); |
| clip_rect.w = ImMin(clip_rect.w, cpu_fine_clip_rect->w); |
| } |
| font->RenderText(this, font_size, pos, col, clip_rect, text_begin, text_end, wrap_width, cpu_fine_clip_rect != NULL); |
| } |
| |
| void ImDrawList::AddText(const ImVec2& pos, ImU32 col, const char* text_begin, const char* text_end) |
| { |
| AddText(NULL, 0.0f, pos, col, text_begin, text_end); |
| } |
| |
| void ImDrawList::AddImage(ImTextureID user_texture_id, const ImVec2& p_min, const ImVec2& p_max, const ImVec2& uv_min, const ImVec2& uv_max, ImU32 col) |
| { |
| if ((col & IM_COL32_A_MASK) == 0) |
| return; |
| |
| const bool push_texture_id = _TextureIdStack.empty() || user_texture_id != _TextureIdStack.back(); |
| if (push_texture_id) |
| PushTextureID(user_texture_id); |
| |
| PrimReserve(6, 4); |
| PrimRectUV(p_min, p_max, uv_min, uv_max, col); |
| |
| if (push_texture_id) |
| PopTextureID(); |
| } |
| |
| void ImDrawList::AddImageQuad(ImTextureID user_texture_id, const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, const ImVec2& uv1, const ImVec2& uv2, const ImVec2& uv3, const ImVec2& uv4, ImU32 col) |
| { |
| if ((col & IM_COL32_A_MASK) == 0) |
| return; |
| |
| const bool push_texture_id = _TextureIdStack.empty() || user_texture_id != _TextureIdStack.back(); |
| if (push_texture_id) |
| PushTextureID(user_texture_id); |
| |
| PrimReserve(6, 4); |
| PrimQuadUV(p1, p2, p3, p4, uv1, uv2, uv3, uv4, col); |
| |
| if (push_texture_id) |
| PopTextureID(); |
| } |
| |
| void ImDrawList::AddImageRounded(ImTextureID user_texture_id, const ImVec2& p_min, const ImVec2& p_max, const ImVec2& uv_min, const ImVec2& uv_max, ImU32 col, float rounding, ImDrawCornerFlags rounding_corners) |
| { |
| if ((col & IM_COL32_A_MASK) == 0) |
| return; |
| |
| if (rounding <= 0.0f || (rounding_corners & ImDrawCornerFlags_All) == 0) |
| { |
| AddImage(user_texture_id, p_min, p_max, uv_min, uv_max, col); |
| return; |
| } |
| |
| const bool push_texture_id = _TextureIdStack.empty() || user_texture_id != _TextureIdStack.back(); |
| if (push_texture_id) |
| PushTextureID(user_texture_id); |
| |
| int vert_start_idx = VtxBuffer.Size; |
| PathRect(p_min, p_max, rounding, rounding_corners); |
| PathFillConvex(col); |
| int vert_end_idx = VtxBuffer.Size; |
| ImGui::ShadeVertsLinearUV(this, vert_start_idx, vert_end_idx, p_min, p_max, uv_min, uv_max, true); |
| |
| if (push_texture_id) |
| PopTextureID(); |
| } |
| |
| |
| //----------------------------------------------------------------------------- |
| // ImDrawListSplitter |
| //----------------------------------------------------------------------------- |
| // FIXME: This may be a little confusing, trying to be a little too low-level/optimal instead of just doing vector swap.. |
| //----------------------------------------------------------------------------- |
| |
| void ImDrawListSplitter::ClearFreeMemory() |
| { |
| for (int i = 0; i < _Channels.Size; i++) |
| { |
| if (i == _Current) |
| memset(&_Channels[i], 0, sizeof(_Channels[i])); // Current channel is a copy of CmdBuffer/IdxBuffer, don't destruct again |
| _Channels[i]._CmdBuffer.clear(); |
| _Channels[i]._IdxBuffer.clear(); |
| } |
| _Current = 0; |
| _Count = 1; |
| _Channels.clear(); |
| } |
| |
| void ImDrawListSplitter::Split(ImDrawList* draw_list, int channels_count) |
| { |
| IM_ASSERT(_Current == 0 && _Count <= 1 && "Nested channel splitting is not supported. Please use separate instances of ImDrawListSplitter."); |
| int old_channels_count = _Channels.Size; |
| if (old_channels_count < channels_count) |
| _Channels.resize(channels_count); |
| _Count = channels_count; |
| |
| // Channels[] (24/32 bytes each) hold storage that we'll swap with draw_list->_CmdBuffer/_IdxBuffer |
| // The content of Channels[0] at this point doesn't matter. We clear it to make state tidy in a debugger but we don't strictly need to. |
| // When we switch to the next channel, we'll copy draw_list->_CmdBuffer/_IdxBuffer into Channels[0] and then Channels[1] into draw_list->CmdBuffer/_IdxBuffer |
| memset(&_Channels[0], 0, sizeof(ImDrawChannel)); |
| for (int i = 1; i < channels_count; i++) |
| { |
| if (i >= old_channels_count) |
| { |
| IM_PLACEMENT_NEW(&_Channels[i]) ImDrawChannel(); |
| } |
| else |
| { |
| _Channels[i]._CmdBuffer.resize(0); |
| _Channels[i]._IdxBuffer.resize(0); |
| } |
| if (_Channels[i]._CmdBuffer.Size == 0) |
| { |
| ImDrawCmd draw_cmd; |
| draw_cmd.ClipRect = draw_list->_ClipRectStack.back(); |
| draw_cmd.TextureId = draw_list->_TextureIdStack.back(); |
| _Channels[i]._CmdBuffer.push_back(draw_cmd); |
| } |
| } |
| } |
| |
| static inline bool CanMergeDrawCommands(ImDrawCmd* a, ImDrawCmd* b) |
| { |
| return memcmp(&a->ClipRect, &b->ClipRect, sizeof(a->ClipRect)) == 0 && a->TextureId == b->TextureId && a->VtxOffset == b->VtxOffset && !a->UserCallback && !b->UserCallback; |
| } |
| |
| void ImDrawListSplitter::Merge(ImDrawList* draw_list) |
| { |
| // Note that we never use or rely on channels.Size because it is merely a buffer that we never shrink back to 0 to keep all sub-buffers ready for use. |
| if (_Count <= 1) |
| return; |
| |
| SetCurrentChannel(draw_list, 0); |
| if (draw_list->CmdBuffer.Size != 0 && draw_list->CmdBuffer.back().ElemCount == 0) |
| draw_list->CmdBuffer.pop_back(); |
| |
| // Calculate our final buffer sizes. Also fix the incorrect IdxOffset values in each command. |
| int new_cmd_buffer_count = 0; |
| int new_idx_buffer_count = 0; |
| ImDrawCmd* last_cmd = (_Count > 0 && draw_list->CmdBuffer.Size > 0) ? &draw_list->CmdBuffer.back() : NULL; |
| int idx_offset = last_cmd ? last_cmd->IdxOffset + last_cmd->ElemCount : 0; |
| for (int i = 1; i < _Count; i++) |
| { |
| ImDrawChannel& ch = _Channels[i]; |
| if (ch._CmdBuffer.Size > 0 && ch._CmdBuffer.back().ElemCount == 0) |
| ch._CmdBuffer.pop_back(); |
| if (ch._CmdBuffer.Size > 0 && last_cmd != NULL && CanMergeDrawCommands(last_cmd, &ch._CmdBuffer[0])) |
| { |
| // Merge previous channel last draw command with current channel first draw command if matching. |
| last_cmd->ElemCount += ch._CmdBuffer[0].ElemCount; |
| idx_offset += ch._CmdBuffer[0].ElemCount; |
| ch._CmdBuffer.erase(ch._CmdBuffer.Data); // FIXME-OPT: Improve for multiple merges. |
| } |
| if (ch._CmdBuffer.Size > 0) |
| last_cmd = &ch._CmdBuffer.back(); |
| new_cmd_buffer_count += ch._CmdBuffer.Size; |
| new_idx_buffer_count += ch._IdxBuffer.Size; |
| for (int cmd_n = 0; cmd_n < ch._CmdBuffer.Size; cmd_n++) |
| { |
| ch._CmdBuffer.Data[cmd_n].IdxOffset = idx_offset; |
| idx_offset += ch._CmdBuffer.Data[cmd_n].ElemCount; |
| } |
| } |
| draw_list->CmdBuffer.resize(draw_list->CmdBuffer.Size + new_cmd_buffer_count); |
| draw_list->IdxBuffer.resize(draw_list->IdxBuffer.Size + new_idx_buffer_count); |
| |
| // Write commands and indices in order (they are fairly small structures, we don't copy vertices only indices) |
| ImDrawCmd* cmd_write = draw_list->CmdBuffer.Data + draw_list->CmdBuffer.Size - new_cmd_buffer_count; |
| ImDrawIdx* idx_write = draw_list->IdxBuffer.Data + draw_list->IdxBuffer.Size - new_idx_buffer_count; |
| for (int i = 1; i < _Count; i++) |
| { |
| ImDrawChannel& ch = _Channels[i]; |
| if (int sz = ch._CmdBuffer.Size) { memcpy(cmd_write, ch._CmdBuffer.Data, sz * sizeof(ImDrawCmd)); cmd_write += sz; } |
| if (int sz = ch._IdxBuffer.Size) { memcpy(idx_write, ch._IdxBuffer.Data, sz * sizeof(ImDrawIdx)); idx_write += sz; } |
| } |
| draw_list->_IdxWritePtr = idx_write; |
| draw_list->UpdateClipRect(); // We call this instead of AddDrawCmd(), so that empty channels won't produce an extra draw call. |
| draw_list->UpdateTextureID(); |
| _Count = 1; |
| } |
| |
| void ImDrawListSplitter::SetCurrentChannel(ImDrawList* draw_list, int idx) |
| { |
| IM_ASSERT(idx >= 0 && idx < _Count); |
| if (_Current == idx) |
| return; |
| // Overwrite ImVector (12/16 bytes), four times. This is merely a silly optimization instead of doing .swap() |
| memcpy(&_Channels.Data[_Current]._CmdBuffer, &draw_list->CmdBuffer, sizeof(draw_list->CmdBuffer)); |
| memcpy(&_Channels.Data[_Current]._IdxBuffer, &draw_list->IdxBuffer, sizeof(draw_list->IdxBuffer)); |
| _Current = idx; |
| memcpy(&draw_list->CmdBuffer, &_Channels.Data[idx]._CmdBuffer, sizeof(draw_list->CmdBuffer)); |
| memcpy(&draw_list->IdxBuffer, &_Channels.Data[idx]._IdxBuffer, sizeof(draw_list->IdxBuffer)); |
| draw_list->_IdxWritePtr = draw_list->IdxBuffer.Data + draw_list->IdxBuffer.Size; |
| } |
| |
| //----------------------------------------------------------------------------- |
| // [SECTION] ImDrawData |
| //----------------------------------------------------------------------------- |
| |
| // For backward compatibility: convert all buffers from indexed to de-indexed, in case you cannot render indexed. Note: this is slow and most likely a waste of resources. Always prefer indexed rendering! |
| void ImDrawData::DeIndexAllBuffers() |
| { |
| ImVector<ImDrawVert> new_vtx_buffer; |
| TotalVtxCount = TotalIdxCount = 0; |
| for (int i = 0; i < CmdListsCount; i++) |
| { |
| ImDrawList* cmd_list = CmdLists[i]; |
| if (cmd_list->IdxBuffer.empty()) |
| continue; |
| new_vtx_buffer.resize(cmd_list->IdxBuffer.Size); |
| for (int j = 0; j < cmd_list->IdxBuffer.Size; j++) |
| new_vtx_buffer[j] = cmd_list->VtxBuffer[cmd_list->IdxBuffer[j]]; |
| cmd_list->VtxBuffer.swap(new_vtx_buffer); |
| cmd_list->IdxBuffer.resize(0); |
| TotalVtxCount += cmd_list->VtxBuffer.Size; |
| } |
| } |
| |
| // Helper to scale the ClipRect field of each ImDrawCmd. |
| // Use if your final output buffer is at a different scale than draw_data->DisplaySize, |
| // or if there is a difference between your window resolution and framebuffer resolution. |
| void ImDrawData::ScaleClipRects(const ImVec2& fb_scale) |
| { |
| for (int i = 0; i < CmdListsCount; i++) |
| { |
| ImDrawList* cmd_list = CmdLists[i]; |
| for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++) |
| { |
| ImDrawCmd* cmd = &cmd_list->CmdBuffer[cmd_i]; |
| cmd->ClipRect = ImVec4(cmd->ClipRect.x * fb_scale.x, cmd->ClipRect.y * fb_scale.y, cmd->ClipRect.z * fb_scale.x, cmd->ClipRect.w * fb_scale.y); |
| } |
| } |
| } |
| |
| //----------------------------------------------------------------------------- |
| // [SECTION] Helpers ShadeVertsXXX functions |
| //----------------------------------------------------------------------------- |
| |
| // Generic linear color gradient, write to RGB fields, leave A untouched. |
| void ImGui::ShadeVertsLinearColorGradientKeepAlpha(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, ImVec2 gradient_p0, ImVec2 gradient_p1, ImU32 col0, ImU32 col1) |
| { |
| ImVec2 gradient_extent = gradient_p1 - gradient_p0; |
| float gradient_inv_length2 = 1.0f / ImLengthSqr(gradient_extent); |
| ImDrawVert* vert_start = draw_list->VtxBuffer.Data + vert_start_idx; |
| ImDrawVert* vert_end = draw_list->VtxBuffer.Data + vert_end_idx; |
| for (ImDrawVert* vert = vert_start; vert < vert_end; vert++) |
| { |
| float d = ImDot(vert->pos - gradient_p0, gradient_extent); |
| float t = ImClamp(d * gradient_inv_length2, 0.0f, 1.0f); |
| int r = ImLerp((int)(col0 >> IM_COL32_R_SHIFT) & 0xFF, (int)(col1 >> IM_COL32_R_SHIFT) & 0xFF, t); |
| int g = ImLerp((int)(col0 >> IM_COL32_G_SHIFT) & 0xFF, (int)(col1 >> IM_COL32_G_SHIFT) & 0xFF, t); |
| int b = ImLerp((int)(col0 >> IM_COL32_B_SHIFT) & 0xFF, (int)(col1 >> IM_COL32_B_SHIFT) & 0xFF, t); |
| vert->col = (r << IM_COL32_R_SHIFT) | (g << IM_COL32_G_SHIFT) | (b << IM_COL32_B_SHIFT) | (vert->col & IM_COL32_A_MASK); |
| } |
| } |
| |
| // Distribute UV over (a, b) rectangle |
| void ImGui::ShadeVertsLinearUV(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, const ImVec2& a, const ImVec2& b, const ImVec2& uv_a, const ImVec2& uv_b, bool clamp) |
| { |
| const ImVec2 size = b - a; |
| const ImVec2 uv_size = uv_b - uv_a; |
| const ImVec2 scale = ImVec2( |
| size.x != 0.0f ? (uv_size.x / size.x) : 0.0f, |
| size.y != 0.0f ? (uv_size.y / size.y) : 0.0f); |
| |
| ImDrawVert* vert_start = draw_list->VtxBuffer.Data + vert_start_idx; |
| ImDrawVert* vert_end = draw_list->VtxBuffer.Data + vert_end_idx; |
| if (clamp) |
| { |
| const ImVec2 min = ImMin(uv_a, uv_b); |
| const ImVec2 max = ImMax(uv_a, uv_b); |
| for (ImDrawVert* vertex = vert_start; vertex < vert_end; ++vertex) |
| vertex->uv = ImClamp(uv_a + ImMul(ImVec2(vertex->pos.x, vertex->pos.y) - a, scale), min, max); |
| } |
| else |
| { |
| for (ImDrawVert* vertex = vert_start; vertex < vert_end; ++vertex) |
| vertex->uv = uv_a + ImMul(ImVec2(vertex->pos.x, vertex->pos.y) - a, scale); |
| } |
| } |
| |
| //----------------------------------------------------------------------------- |
| // [SECTION] ImFontConfig |
| //----------------------------------------------------------------------------- |
| |
| ImFontConfig::ImFontConfig() |
| { |
| FontData = NULL; |
| FontDataSize = 0; |
| FontDataOwnedByAtlas = true; |
| FontNo = 0; |
| SizePixels = 0.0f; |
| OversampleH = 3; // FIXME: 2 may be a better default? |
| OversampleV = 1; |
| PixelSnapH = false; |
| GlyphExtraSpacing = ImVec2(0.0f, 0.0f); |
| GlyphOffset = ImVec2(0.0f, 0.0f); |
| GlyphRanges = NULL; |
| GlyphMinAdvanceX = 0.0f; |
| GlyphMaxAdvanceX = FLT_MAX; |
| MergeMode = false; |
| RasterizerFlags = 0x00; |
| RasterizerMultiply = 1.0f; |
| EllipsisChar = (ImWchar)-1; |
| memset(Name, 0, sizeof(Name)); |
| DstFont = NULL; |
| } |
| |
| //----------------------------------------------------------------------------- |
| // [SECTION] ImFontAtlas |
| //----------------------------------------------------------------------------- |
| |
| // A work of art lies ahead! (. = white layer, X = black layer, others are blank) |
| // The white texels on the top left are the ones we'll use everywhere in Dear ImGui to render filled shapes. |
| const int FONT_ATLAS_DEFAULT_TEX_DATA_W_HALF = 108; |
| const int FONT_ATLAS_DEFAULT_TEX_DATA_H = 27; |
| const unsigned int FONT_ATLAS_DEFAULT_TEX_DATA_ID = 0x80000000; |
| static const char FONT_ATLAS_DEFAULT_TEX_DATA_PIXELS[FONT_ATLAS_DEFAULT_TEX_DATA_W_HALF * FONT_ATLAS_DEFAULT_TEX_DATA_H + 1] = |
| { |
| "..- -XXXXXXX- X - X -XXXXXXX - XXXXXXX- XX " |
| "..- -X.....X- X.X - X.X -X.....X - X.....X- X..X " |
| "--- -XXX.XXX- X...X - X...X -X....X - X....X- X..X " |
| "X - X.X - X.....X - X.....X -X...X - X...X- X..X " |
| "XX - X.X -X.......X- X.......X -X..X.X - X.X..X- X..X " |
| "X.X - X.X -XXXX.XXXX- XXXX.XXXX -X.X X.X - X.X X.X- X..XXX " |
| "X..X - X.X - X.X - X.X -XX X.X - X.X XX- X..X..XXX " |
| "X...X - X.X - X.X - XX X.X XX - X.X - X.X - X..X..X..XX " |
| "X....X - X.X - X.X - X.X X.X X.X - X.X - X.X - X..X..X..X.X " |
| "X.....X - X.X - X.X - X..X X.X X..X - X.X - X.X -XXX X..X..X..X..X" |
| "X......X - X.X - X.X - X...XXXXXX.XXXXXX...X - X.X XX-XX X.X -X..XX........X..X" |
| "X.......X - X.X - X.X -X.....................X- X.X X.X-X.X X.X -X...X...........X" |
| "X........X - X.X - X.X - X...XXXXXX.XXXXXX...X - X.X..X-X..X.X - X..............X" |
| "X.........X -XXX.XXX- X.X - X..X X.X X..X - X...X-X...X - X.............X" |
| "X..........X-X.....X- X.X - X.X X.X X.X - X....X-X....X - X.............X" |
| "X......XXXXX-XXXXXXX- X.X - XX X.X XX - X.....X-X.....X - X............X" |
| "X...X..X --------- X.X - X.X - XXXXXXX-XXXXXXX - X...........X " |
| "X..X X..X - -XXXX.XXXX- XXXX.XXXX ------------------------------------- X..........X " |
| "X.X X..X - -X.......X- X.......X - XX XX - - X..........X " |
| "XX X..X - - X.....X - X.....X - X.X X.X - - X........X " |
| " X..X - X...X - X...X - X..X X..X - - X........X " |
| " XX - X.X - X.X - X...XXXXXXXXXXXXX...X - - XXXXXXXXXX " |
| "------------ - X - X -X.....................X- ------------------" |
| " ----------------------------------- X...XXXXXXXXXXXXX...X - " |
| " - X..X X..X - " |
| " - X.X X.X - " |
| " - XX XX - " |
| }; |
| |
| static const ImVec2 FONT_ATLAS_DEFAULT_TEX_CURSOR_DATA[ImGuiMouseCursor_COUNT][3] = |
| { |
| // Pos ........ Size ......... Offset ...... |
| { ImVec2( 0,3), ImVec2(12,19), ImVec2( 0, 0) }, // ImGuiMouseCursor_Arrow |
| { ImVec2(13,0), ImVec2( 7,16), ImVec2( 1, 8) }, // ImGuiMouseCursor_TextInput |
| { ImVec2(31,0), ImVec2(23,23), ImVec2(11,11) }, // ImGuiMouseCursor_ResizeAll |
| { ImVec2(21,0), ImVec2( 9,23), ImVec2( 4,11) }, // ImGuiMouseCursor_ResizeNS |
| { ImVec2(55,18),ImVec2(23, 9), ImVec2(11, 4) }, // ImGuiMouseCursor_ResizeEW |
| { ImVec2(73,0), ImVec2(17,17), ImVec2( 8, 8) }, // ImGuiMouseCursor_ResizeNESW |
| { ImVec2(55,0), ImVec2(17,17), ImVec2( 8, 8) }, // ImGuiMouseCursor_ResizeNWSE |
| { ImVec2(91,0), ImVec2(17,22), ImVec2( 5, 0) }, // ImGuiMouseCursor_Hand |
| }; |
| |
| ImFontAtlas::ImFontAtlas() |
| { |
| Locked = false; |
| Flags = ImFontAtlasFlags_None; |
| TexID = (ImTextureID)NULL; |
| TexDesiredWidth = 0; |
| TexGlyphPadding = 1; |
| |
| TexPixelsAlpha8 = NULL; |
| TexPixelsRGBA32 = NULL; |
| TexWidth = TexHeight = 0; |
| TexUvScale = ImVec2(0.0f, 0.0f); |
| TexUvWhitePixel = ImVec2(0.0f, 0.0f); |
| for (int n = 0; n < IM_ARRAYSIZE(CustomRectIds); n++) |
| CustomRectIds[n] = -1; |
| } |
| |
| ImFontAtlas::~ImFontAtlas() |
| { |
| IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!"); |
| Clear(); |
| } |
| |
| void ImFontAtlas::ClearInputData() |
| { |
| IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!"); |
| for (int i = 0; i < ConfigData.Size; i++) |
| if (ConfigData[i].FontData && ConfigData[i].FontDataOwnedByAtlas) |
| { |
| IM_FREE(ConfigData[i].FontData); |
| ConfigData[i].FontData = NULL; |
| } |
| |
| // When clearing this we lose access to the font name and other information used to build the font. |
| for (int i = 0; i < Fonts.Size; i++) |
| if (Fonts[i]->ConfigData >= ConfigData.Data && Fonts[i]->ConfigData < ConfigData.Data + ConfigData.Size) |
| { |
| Fonts[i]->ConfigData = NULL; |
| Fonts[i]->ConfigDataCount = 0; |
| } |
| ConfigData.clear(); |
| CustomRects.clear(); |
| for (int n = 0; n < IM_ARRAYSIZE(CustomRectIds); n++) |
| CustomRectIds[n] = -1; |
| } |
| |
| void ImFontAtlas::ClearTexData() |
| { |
| IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!"); |
| if (TexPixelsAlpha8) |
| IM_FREE(TexPixelsAlpha8); |
| if (TexPixelsRGBA32) |
| IM_FREE(TexPixelsRGBA32); |
| TexPixelsAlpha8 = NULL; |
| TexPixelsRGBA32 = NULL; |
| } |
| |
| void ImFontAtlas::ClearFonts() |
| { |
| IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!"); |
| for (int i = 0; i < Fonts.Size; i++) |
| IM_DELETE(Fonts[i]); |
| Fonts.clear(); |
| } |
| |
| void ImFontAtlas::Clear() |
| { |
| ClearInputData(); |
| ClearTexData(); |
| ClearFonts(); |
| } |
| |
| void ImFontAtlas::GetTexDataAsAlpha8(unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel) |
| { |
| // Build atlas on demand |
| if (TexPixelsAlpha8 == NULL) |
| { |
| if (ConfigData.empty()) |
| AddFontDefault(); |
| Build(); |
| } |
| |
| *out_pixels = TexPixelsAlpha8; |
| if (out_width) *out_width = TexWidth; |
| if (out_height) *out_height = TexHeight; |
| if (out_bytes_per_pixel) *out_bytes_per_pixel = 1; |
| } |
| |
| void ImFontAtlas::GetTexDataAsRGBA32(unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel) |
| { |
| // Convert to RGBA32 format on demand |
| // Although it is likely to be the most commonly used format, our font rendering is 1 channel / 8 bpp |
| if (!TexPixelsRGBA32) |
| { |
| unsigned char* pixels = NULL; |
| GetTexDataAsAlpha8(&pixels, NULL, NULL); |
| if (pixels) |
| { |
| TexPixelsRGBA32 = (unsigned int*)IM_ALLOC((size_t)TexWidth * (size_t)TexHeight * 4); |
| const unsigned char* src = pixels; |
| unsigned int* dst = TexPixelsRGBA32; |
| for (int n = TexWidth * TexHeight; n > 0; n--) |
| *dst++ = IM_COL32(255, 255, 255, (unsigned int)(*src++)); |
| } |
| } |
| |
| *out_pixels = (unsigned char*)TexPixelsRGBA32; |
| if (out_width) *out_width = TexWidth; |
| if (out_height) *out_height = TexHeight; |
| if (out_bytes_per_pixel) *out_bytes_per_pixel = 4; |
| } |
| |
| ImFont* ImFontAtlas::AddFont(const ImFontConfig* font_cfg) |
| { |
| IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!"); |
| IM_ASSERT(font_cfg->FontData != NULL && font_cfg->FontDataSize > 0); |
| IM_ASSERT(font_cfg->SizePixels > 0.0f); |
| |
| // Create new font |
| if (!font_cfg->MergeMode) |
| Fonts.push_back(IM_NEW(ImFont)); |
| else |
| IM_ASSERT(!Fonts.empty() && "Cannot use MergeMode for the first font"); // When using MergeMode make sure that a font has already been added before. You can use ImGui::GetIO().Fonts->AddFontDefault() to add the default imgui font. |
| |
| ConfigData.push_back(*font_cfg); |
| ImFontConfig& new_font_cfg = ConfigData.back(); |
| if (new_font_cfg.DstFont == NULL) |
| new_font_cfg.DstFont = Fonts.back(); |
| if (!new_font_cfg.FontDataOwnedByAtlas) |
| { |
| new_font_cfg.FontData = IM_ALLOC(new_font_cfg.FontDataSize); |
| new_font_cfg.FontDataOwnedByAtlas = true; |
| memcpy(new_font_cfg.FontData, font_cfg->FontData, (size_t)new_font_cfg.FontDataSize); |
| } |
| |
| if (new_font_cfg.DstFont->EllipsisChar == (ImWchar)-1) |
| new_font_cfg.DstFont->EllipsisChar = font_cfg->EllipsisChar; |
| |
| // Invalidate texture |
| ClearTexData(); |
| return new_font_cfg.DstFont; |
| } |
| |
| // Default font TTF is compressed with stb_compress then base85 encoded (see misc/fonts/binary_to_compressed_c.cpp for encoder) |
| static unsigned int stb_decompress_length(const unsigned char *input); |
| static unsigned int stb_decompress(unsigned char *output, const unsigned char *input, unsigned int length); |
| static const char* GetDefaultCompressedFontDataTTFBase85(); |
| static unsigned int Decode85Byte(char c) { return c >= '\\' ? c-36 : c-35; } |
| static void Decode85(const unsigned char* src, unsigned char* dst) |
| { |
| while (*src) |
| { |
| unsigned int tmp = Decode85Byte(src[0]) + 85*(Decode85Byte(src[1]) + 85*(Decode85Byte(src[2]) + 85*(Decode85Byte(src[3]) + 85*Decode85Byte(src[4])))); |
| dst[0] = ((tmp >> 0) & 0xFF); dst[1] = ((tmp >> 8) & 0xFF); dst[2] = ((tmp >> 16) & 0xFF); dst[3] = ((tmp >> 24) & 0xFF); // We can't assume little-endianness. |
| src += 5; |
| dst += 4; |
| } |
| } |
| |
| // Load embedded ProggyClean.ttf at size 13, disable oversampling |
| ImFont* ImFontAtlas::AddFontDefault(const ImFontConfig* font_cfg_template) |
| { |
| ImFontConfig font_cfg = font_cfg_template ? *font_cfg_template : ImFontConfig(); |
| if (!font_cfg_template) |
| { |
| font_cfg.OversampleH = font_cfg.OversampleV = 1; |
| font_cfg.PixelSnapH = true; |
| } |
| if (font_cfg.SizePixels <= 0.0f) |
| font_cfg.SizePixels = 13.0f * 1.0f; |
| if (font_cfg.Name[0] == '\0') |
| ImFormatString(font_cfg.Name, IM_ARRAYSIZE(font_cfg.Name), "ProggyClean.ttf, %dpx", (int)font_cfg.SizePixels); |
| font_cfg.EllipsisChar = (ImWchar)0x0085; |
| |
| const char* ttf_compressed_base85 = GetDefaultCompressedFontDataTTFBase85(); |
| const ImWchar* glyph_ranges = font_cfg.GlyphRanges != NULL ? font_cfg.GlyphRanges : GetGlyphRangesDefault(); |
| ImFont* font = AddFontFromMemoryCompressedBase85TTF(ttf_compressed_base85, font_cfg.SizePixels, &font_cfg, glyph_ranges); |
| font->DisplayOffset.y = 1.0f; |
| return font; |
| } |
| |
| ImFont* ImFontAtlas::AddFontFromFileTTF(const char* filename, float size_pixels, const ImFontConfig* font_cfg_template, const ImWchar* glyph_ranges) |
| { |
| IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!"); |
| size_t data_size = 0; |
| void* data = ImFileLoadToMemory(filename, "rb", &data_size, 0); |
| if (!data) |
| { |
| IM_ASSERT_USER_ERROR(0, "Could not load font file!"); |
| return NULL; |
| } |
| ImFontConfig font_cfg = font_cfg_template ? *font_cfg_template : ImFontConfig(); |
| if (font_cfg.Name[0] == '\0') |
| { |
| // Store a short copy of filename into into the font name for convenience |
| const char* p; |
| for (p = filename + strlen(filename); p > filename && p[-1] != '/' && p[-1] != '\\'; p--) {} |
| ImFormatString(font_cfg.Name, IM_ARRAYSIZE(font_cfg.Name), "%s, %.0fpx", p, size_pixels); |
| } |
| return AddFontFromMemoryTTF(data, (int)data_size, size_pixels, &font_cfg, glyph_ranges); |
| } |
| |
| // NB: Transfer ownership of 'ttf_data' to ImFontAtlas, unless font_cfg_template->FontDataOwnedByAtlas == false. Owned TTF buffer will be deleted after Build(). |
| ImFont* ImFontAtlas::AddFontFromMemoryTTF(void* ttf_data, int ttf_size, float size_pixels, const ImFontConfig* font_cfg_template, const ImWchar* glyph_ranges) |
| { |
| IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!"); |
| ImFontConfig font_cfg = font_cfg_template ? *font_cfg_template : ImFontConfig(); |
| IM_ASSERT(font_cfg.FontData == NULL); |
| font_cfg.FontData = ttf_data; |
| font_cfg.FontDataSize = ttf_size; |
| font_cfg.SizePixels = size_pixels; |
| if (glyph_ranges) |
| font_cfg.GlyphRanges = glyph_ranges; |
| return AddFont(&font_cfg); |
| } |
| |
| ImFont* ImFontAtlas::AddFontFromMemoryCompressedTTF(const void* compressed_ttf_data, int compressed_ttf_size, float size_pixels, const ImFontConfig* font_cfg_template, const ImWchar* glyph_ranges) |
| { |
| const unsigned int buf_decompressed_size = stb_decompress_length((const unsigned char*)compressed_ttf_data); |
| unsigned char* buf_decompressed_data = (unsigned char *)IM_ALLOC(buf_decompressed_size); |
| stb_decompress(buf_decompressed_data, (const unsigned char*)compressed_ttf_data, (unsigned int)compressed_ttf_size); |
| |
| ImFontConfig font_cfg = font_cfg_template ? *font_cfg_template : ImFontConfig(); |
| IM_ASSERT(font_cfg.FontData == NULL); |
| font_cfg.FontDataOwnedByAtlas = true; |
| return AddFontFromMemoryTTF(buf_decompressed_data, (int)buf_decompressed_size, size_pixels, &font_cfg, glyph_ranges); |
| } |
| |
| ImFont* ImFontAtlas::AddFontFromMemoryCompressedBase85TTF(const char* compressed_ttf_data_base85, float size_pixels, const ImFontConfig* font_cfg, const ImWchar* glyph_ranges) |
| { |
| int compressed_ttf_size = (((int)strlen(compressed_ttf_data_base85) + 4) / 5) * 4; |
| void* compressed_ttf = IM_ALLOC((size_t)compressed_ttf_size); |
| Decode85((const unsigned char*)compressed_ttf_data_base85, (unsigned char*)compressed_ttf); |
| ImFont* font = AddFontFromMemoryCompressedTTF(compressed_ttf, compressed_ttf_size, size_pixels, font_cfg, glyph_ranges); |
| IM_FREE(compressed_ttf); |
| return font; |
| } |
| |
| int ImFontAtlas::AddCustomRectRegular(unsigned int id, int width, int height) |
| { |
| // Breaking change on 2019/11/21 (1.74): ImFontAtlas::AddCustomRectRegular() now requires an ID >= 0x110000 (instead of >= 0x10000) |
| IM_ASSERT(id >= 0x110000); |
| IM_ASSERT(width > 0 && width <= 0xFFFF); |
| IM_ASSERT(height > 0 && height <= 0xFFFF); |
| ImFontAtlasCustomRect r; |
| r.ID = id; |
| r.Width = (unsigned short)width; |
| r.Height = (unsigned short)height; |
| CustomRects.push_back(r); |
| return CustomRects.Size - 1; // Return index |
| } |
| |
| int ImFontAtlas::AddCustomRectFontGlyph(ImFont* font, ImWchar id, int width, int height, float advance_x, const ImVec2& offset) |
| { |
| IM_ASSERT(font != NULL); |
| IM_ASSERT(width > 0 && width <= 0xFFFF); |
| IM_ASSERT(height > 0 && height <= 0xFFFF); |
| ImFontAtlasCustomRect r; |
| r.ID = id; |
| r.Width = (unsigned short)width; |
| r.Height = (unsigned short)height; |
| r.GlyphAdvanceX = advance_x; |
| r.GlyphOffset = offset; |
| r.Font = font; |
| CustomRects.push_back(r); |
| return CustomRects.Size - 1; // Return index |
| } |
| |
| void ImFontAtlas::CalcCustomRectUV(const ImFontAtlasCustomRect* rect, ImVec2* out_uv_min, ImVec2* out_uv_max) const |
| { |
| IM_ASSERT(TexWidth > 0 && TexHeight > 0); // Font atlas needs to be built before we can calculate UV coordinates |
| IM_ASSERT(rect->IsPacked()); // Make sure the rectangle has been packed |
| *out_uv_min = ImVec2((float)rect->X * TexUvScale.x, (float)rect->Y * TexUvScale.y); |
| *out_uv_max = ImVec2((float)(rect->X + rect->Width) * TexUvScale.x, (float)(rect->Y + rect->Height) * TexUvScale.y); |
| } |
| |
| bool ImFontAtlas::GetMouseCursorTexData(ImGuiMouseCursor cursor_type, ImVec2* out_offset, ImVec2* out_size, ImVec2 out_uv_border[2], ImVec2 out_uv_fill[2]) |
| { |
| if (cursor_type <= ImGuiMouseCursor_None || cursor_type >= ImGuiMouseCursor_COUNT) |
| return false; |
| if (Flags & ImFontAtlasFlags_NoMouseCursors) |
| return false; |
| |
| IM_ASSERT(CustomRectIds[0] != -1); |
| ImFontAtlasCustomRect& r = CustomRects[CustomRectIds[0]]; |
| IM_ASSERT(r.ID == FONT_ATLAS_DEFAULT_TEX_DATA_ID); |
| ImVec2 pos = FONT_ATLAS_DEFAULT_TEX_CURSOR_DATA[cursor_type][0] + ImVec2((float)r.X, (float)r.Y); |
| ImVec2 size = FONT_ATLAS_DEFAULT_TEX_CURSOR_DATA[cursor_type][1]; |
| *out_size = size; |
| *out_offset = FONT_ATLAS_DEFAULT_TEX_CURSOR_DATA[cursor_type][2]; |
| out_uv_border[0] = (pos) * TexUvScale; |
| out_uv_border[1] = (pos + size) * TexUvScale; |
| pos.x += FONT_ATLAS_DEFAULT_TEX_DATA_W_HALF + 1; |
| out_uv_fill[0] = (pos) * TexUvScale; |
| out_uv_fill[1] = (pos + size) * TexUvScale; |
| return true; |
| } |
| |
| bool ImFontAtlas::Build() |
| { |
| IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!"); |
| return ImFontAtlasBuildWithStbTruetype(this); |
| } |
| |
| void ImFontAtlasBuildMultiplyCalcLookupTable(unsigned char out_table[256], float in_brighten_factor) |
| { |
| for (unsigned int i = 0; i < 256; i++) |
| { |
| unsigned int value = (unsigned int)(i * in_brighten_factor); |
| out_table[i] = value > 255 ? 255 : (value & 0xFF); |
| } |
| } |
| |
| void ImFontAtlasBuildMultiplyRectAlpha8(const unsigned char table[256], unsigned char* pixels, int x, int y, int w, int h, int stride) |
| { |
| unsigned char* data = pixels + x + y * stride; |
| for (int j = h; j > 0; j--, data += stride) |
| for (int i = 0; i < w; i++) |
| data[i] = table[data[i]]; |
| } |
| |
| // Temporary data for one source font (multiple source fonts can be merged into one destination ImFont) |
| // (C++03 doesn't allow instancing ImVector<> with function-local types so we declare the type here.) |
| struct ImFontBuildSrcData |
| { |
| stbtt_fontinfo FontInfo; |
| stbtt_pack_range PackRange; // Hold the list of codepoints to pack (essentially points to Codepoints.Data) |
| stbrp_rect* Rects; // Rectangle to pack. We first fill in their size and the packer will give us their position. |
| stbtt_packedchar* PackedChars; // Output glyphs |
| const ImWchar* SrcRanges; // Ranges as requested by user (user is allowed to request too much, e.g. 0x0020..0xFFFF) |
| int DstIndex; // Index into atlas->Fonts[] and dst_tmp_array[] |
| int GlyphsHighest; // Highest requested codepoint |
| int GlyphsCount; // Glyph count (excluding missing glyphs and glyphs already set by an earlier source font) |
| ImBoolVector GlyphsSet; // Glyph bit map (random access, 1-bit per codepoint. This will be a maximum of 8KB) |
| ImVector<int> GlyphsList; // Glyph codepoints list (flattened version of GlyphsMap) |
| }; |
| |
| // Temporary data for one destination ImFont* (multiple source fonts can be merged into one destination ImFont) |
| struct ImFontBuildDstData |
| { |
| int SrcCount; // Number of source fonts targeting this destination font. |
| int GlyphsHighest; |
| int GlyphsCount; |
| ImBoolVector GlyphsSet; // This is used to resolve collision when multiple sources are merged into a same destination font. |
| }; |
| |
| static void UnpackBoolVectorToFlatIndexList(const ImBoolVector* in, ImVector<int>* out) |
| { |
| IM_ASSERT(sizeof(in->Storage.Data[0]) == sizeof(int)); |
| const int* it_begin = in->Storage.begin(); |
| const int* it_end = in->Storage.end(); |
| for (const int* it = it_begin; it < it_end; it++) |
| if (int entries_32 = *it) |
| for (int bit_n = 0; bit_n < 32; bit_n++) |
| if (entries_32 & (1u << bit_n)) |
| out->push_back((int)((it - it_begin) << 5) + bit_n); |
| } |
| |
| bool ImFontAtlasBuildWithStbTruetype(ImFontAtlas* atlas) |
| { |
| IM_ASSERT(atlas->ConfigData.Size > 0); |
| |
| ImFontAtlasBuildRegisterDefaultCustomRects(atlas); |
| |
| // Clear atlas |
| atlas->TexID = (ImTextureID)NULL; |
| atlas->TexWidth = atlas->TexHeight = 0; |
| atlas->TexUvScale = ImVec2(0.0f, 0.0f); |
| atlas->TexUvWhitePixel = ImVec2(0.0f, 0.0f); |
| atlas->ClearTexData(); |
| |
| // Temporary storage for building |
| ImVector<ImFontBuildSrcData> src_tmp_array; |
| ImVector<ImFontBuildDstData> dst_tmp_array; |
| src_tmp_array.resize(atlas->ConfigData.Size); |
| dst_tmp_array.resize(atlas->Fonts.Size); |
| memset(src_tmp_array.Data, 0, (size_t)src_tmp_array.size_in_bytes()); |
| memset(dst_tmp_array.Data, 0, (size_t)dst_tmp_array.size_in_bytes()); |
| |
| // 1. Initialize font loading structure, check font data validity |
| for (int src_i = 0; src_i < atlas->ConfigData.Size; src_i++) |
| { |
| ImFontBuildSrcData& src_tmp = src_tmp_array[src_i]; |
| ImFontConfig& cfg = atlas->ConfigData[src_i]; |
| IM_ASSERT(cfg.DstFont && (!cfg.DstFont->IsLoaded() || cfg.DstFont->ContainerAtlas == atlas)); |
| |
| // Find index from cfg.DstFont (we allow the user to set cfg.DstFont. Also it makes casual debugging nicer than when storing indices) |
| src_tmp.DstIndex = -1; |
| for (int output_i = 0; output_i < atlas->Fonts.Size && src_tmp.DstIndex == -1; output_i++) |
| if (cfg.DstFont == atlas->Fonts[output_i]) |
| src_tmp.DstIndex = output_i; |
| IM_ASSERT(src_tmp.DstIndex != -1); // cfg.DstFont not pointing within atlas->Fonts[] array? |
| if (src_tmp.DstIndex == -1) |
| return false; |
| |
| // Initialize helper structure for font loading and verify that the TTF/OTF data is correct |
| const int font_offset = stbtt_GetFontOffsetForIndex((unsigned char*)cfg.FontData, cfg.FontNo); |
| IM_ASSERT(font_offset >= 0 && "FontData is incorrect, or FontNo cannot be found."); |
| if (!stbtt_InitFont(&src_tmp.FontInfo, (unsigned char*)cfg.FontData, font_offset)) |
| return false; |
| |
| // Measure highest codepoints |
| ImFontBuildDstData& dst_tmp = dst_tmp_array[src_tmp.DstIndex]; |
| src_tmp.SrcRanges = cfg.GlyphRanges ? cfg.GlyphRanges : atlas->GetGlyphRangesDefault(); |
| for (const ImWchar* src_range = src_tmp.SrcRanges; src_range[0] && src_range[1]; src_range += 2) |
| src_tmp.GlyphsHighest = ImMax(src_tmp.GlyphsHighest, (int)src_range[1]); |
| dst_tmp.SrcCount++; |
| dst_tmp.GlyphsHighest = ImMax(dst_tmp.GlyphsHighest, src_tmp.GlyphsHighest); |
| } |
| |
| // 2. For every requested codepoint, check for their presence in the font data, and handle redundancy or overlaps between source fonts to avoid unused glyphs. |
| int total_glyphs_count = 0; |
| for (int src_i = 0; src_i < src_tmp_array.Size; src_i++) |
| { |
| ImFontBuildSrcData& src_tmp = src_tmp_array[src_i]; |
| ImFontBuildDstData& dst_tmp = dst_tmp_array[src_tmp.DstIndex]; |
| src_tmp.GlyphsSet.Resize(src_tmp.GlyphsHighest + 1); |
| if (dst_tmp.GlyphsSet.Storage.empty()) |
| dst_tmp.GlyphsSet.Resize(dst_tmp.GlyphsHighest + 1); |
| |
| for (const ImWchar* src_range = src_tmp.SrcRanges; src_range[0] && src_range[1]; src_range += 2) |
| for (unsigned int codepoint = src_range[0]; codepoint <= src_range[1]; codepoint++) |
| { |
| if (dst_tmp.GlyphsSet.GetBit(codepoint)) // Don't overwrite existing glyphs. We could make this an option for MergeMode (e.g. MergeOverwrite==true) |
| continue; |
| if (!stbtt_FindGlyphIndex(&src_tmp.FontInfo, codepoint)) // It is actually in the font? |
| continue; |
| |
| // Add to avail set/counters |
| src_tmp.GlyphsCount++; |
| dst_tmp.GlyphsCount++; |
| src_tmp.GlyphsSet.SetBit(codepoint, true); |
| dst_tmp.GlyphsSet.SetBit(codepoint, true); |
| total_glyphs_count++; |
| } |
| } |
| |
| // 3. Unpack our bit map into a flat list (we now have all the Unicode points that we know are requested _and_ available _and_ not overlapping another) |
| for (int src_i = 0; src_i < src_tmp_array.Size; src_i++) |
| { |
| ImFontBuildSrcData& src_tmp = src_tmp_array[src_i]; |
| src_tmp.GlyphsList.reserve(src_tmp.GlyphsCount); |
| UnpackBoolVectorToFlatIndexList(&src_tmp.GlyphsSet, &src_tmp.GlyphsList); |
| src_tmp.GlyphsSet.Clear(); |
| IM_ASSERT(src_tmp.GlyphsList.Size == src_tmp.GlyphsCount); |
| } |
| for (int dst_i = 0; dst_i < dst_tmp_array.Size; dst_i++) |
| dst_tmp_array[dst_i].GlyphsSet.Clear(); |
| dst_tmp_array.clear(); |
| |
| // Allocate packing character data and flag packed characters buffer as non-packed (x0=y0=x1=y1=0) |
| // (We technically don't need to zero-clear buf_rects, but let's do it for the sake of sanity) |
| ImVector<stbrp_rect> buf_rects; |
| ImVector<stbtt_packedchar> buf_packedchars; |
| buf_rects.resize(total_glyphs_count); |
| buf_packedchars.resize(total_glyphs_count); |
| memset(buf_rects.Data, 0, (size_t)buf_rects.size_in_bytes()); |
| memset(buf_packedchars.Data, 0, (size_t)buf_packedchars.size_in_bytes()); |
| |
| // 4. Gather glyphs sizes so we can pack them in our virtual canvas. |
| int total_surface = 0; |
| int buf_rects_out_n = 0; |
| int buf_packedchars_out_n = 0; |
| for (int src_i = 0; src_i < src_tmp_array.Size; src_i++) |
| { |
| ImFontBuildSrcData& src_tmp = src_tmp_array[src_i]; |
| if (src_tmp.GlyphsCount == 0) |
| continue; |
| |
| src_tmp.Rects = &buf_rects[buf_rects_out_n]; |
| src_tmp.PackedChars = &buf_packedchars[buf_packedchars_out_n]; |
| buf_rects_out_n += src_tmp.GlyphsCount; |
| buf_packedchars_out_n += src_tmp.GlyphsCount; |
| |
| // Convert our ranges in the format stb_truetype wants |
| ImFontConfig& cfg = atlas->ConfigData[src_i]; |
| src_tmp.PackRange.font_size = cfg.SizePixels; |
| src_tmp.PackRange.first_unicode_codepoint_in_range = 0; |
| src_tmp.PackRange.array_of_unicode_codepoints = src_tmp.GlyphsList.Data; |
| src_tmp.PackRange.num_chars = src_tmp.GlyphsList.Size; |
| src_tmp.PackRange.chardata_for_range = src_tmp.PackedChars; |
| src_tmp.PackRange.h_oversample = (unsigned char)cfg.OversampleH; |
| src_tmp.PackRange.v_oversample = (unsigned char)cfg.OversampleV; |
| |
| // Gather the sizes of all rectangles we will need to pack (this loop is based on stbtt_PackFontRangesGatherRects) |
| const float scale = (cfg.SizePixels > 0) ? stbtt_ScaleForPixelHeight(&src_tmp.FontInfo, cfg.SizePixels) : stbtt_ScaleForMappingEmToPixels(&src_tmp.FontInfo, -cfg.SizePixels); |
| const int padding = atlas->TexGlyphPadding; |
| for (int glyph_i = 0; glyph_i < src_tmp.GlyphsList.Size; glyph_i++) |
| { |
| int x0, y0, x1, y1; |
| const int glyph_index_in_font = stbtt_FindGlyphIndex(&src_tmp.FontInfo, src_tmp.GlyphsList[glyph_i]); |
| IM_ASSERT(glyph_index_in_font != 0); |
| stbtt_GetGlyphBitmapBoxSubpixel(&src_tmp.FontInfo, glyph_index_in_font, scale * cfg.OversampleH, scale * cfg.OversampleV, 0, 0, &x0, &y0, &x1, &y1); |
| src_tmp.Rects[glyph_i].w = (stbrp_coord)(x1 - x0 + padding + cfg.OversampleH - 1); |
| src_tmp.Rects[glyph_i].h = (stbrp_coord)(y1 - y0 + padding + cfg.OversampleV - 1); |
| total_surface += src_tmp.Rects[glyph_i].w * src_tmp.Rects[glyph_i].h; |
| } |
| } |
| |
| // We need a width for the skyline algorithm, any width! |
| // The exact width doesn't really matter much, but some API/GPU have texture size limitations and increasing width can decrease height. |
| // User can override TexDesiredWidth and TexGlyphPadding if they wish, otherwise we use a simple heuristic to select the width based on expected surface. |
| const int surface_sqrt = (int)ImSqrt((float)total_surface) + 1; |
| atlas->TexHeight = 0; |
| if (atlas->TexDesiredWidth > 0) |
| atlas->TexWidth = atlas->TexDesiredWidth; |
| else |
| atlas->TexWidth = (surface_sqrt >= 4096*0.7f) ? 4096 : (surface_sqrt >= 2048*0.7f) ? 2048 : (surface_sqrt >= 1024*0.7f) ? 1024 : 512; |
| |
| // 5. Start packing |
| // Pack our extra data rectangles first, so it will be on the upper-left corner of our texture (UV will have small values). |
| const int TEX_HEIGHT_MAX = 1024 * 32; |
| stbtt_pack_context spc = {}; |
| stbtt_PackBegin(&spc, NULL, atlas->TexWidth, TEX_HEIGHT_MAX, 0, atlas->TexGlyphPadding, NULL); |
| ImFontAtlasBuildPackCustomRects(atlas, spc.pack_info); |
| |
| // 6. Pack each source font. No rendering yet, we are working with rectangles in an infinitely tall texture at this point. |
| for (int src_i = 0; src_i < src_tmp_array.Size; src_i++) |
| { |
| ImFontBuildSrcData& src_tmp = src_tmp_array[src_i]; |
| if (src_tmp.GlyphsCount == 0) |
| continue; |
| |
| stbrp_pack_rects((stbrp_context*)spc.pack_info, src_tmp.Rects, src_tmp.GlyphsCount); |
| |
| // Extend texture height and mark missing glyphs as non-packed so we won't render them. |
| // FIXME: We are not handling packing failure here (would happen if we got off TEX_HEIGHT_MAX or if a single if larger than TexWidth?) |
| for (int glyph_i = 0; glyph_i < src_tmp.GlyphsCount; glyph_i++) |
| if (src_tmp.Rects[glyph_i].was_packed) |
| atlas->TexHeight = ImMax(atlas->TexHeight, src_tmp.Rects[glyph_i].y + src_tmp.Rects[glyph_i].h); |
| } |
| |
| // 7. Allocate texture |
| atlas->TexHeight = (atlas->Flags & ImFontAtlasFlags_NoPowerOfTwoHeight) ? (atlas->TexHeight + 1) : ImUpperPowerOfTwo(atlas->TexHeight); |
| atlas->TexUvScale = ImVec2(1.0f / atlas->TexWidth, 1.0f / atlas->TexHeight); |
| atlas->TexPixelsAlpha8 = (unsigned char*)IM_ALLOC(atlas->TexWidth * atlas->TexHeight); |
| memset(atlas->TexPixelsAlpha8, 0, atlas->TexWidth * atlas->TexHeight); |
| spc.pixels = atlas->TexPixelsAlpha8; |
| spc.height = atlas->TexHeight; |
| |
| // 8. Render/rasterize font characters into the texture |
| for (int src_i = 0; src_i < src_tmp_array.Size; src_i++) |
| { |
| ImFontConfig& cfg = atlas->ConfigData[src_i]; |
| ImFontBuildSrcData& src_tmp = src_tmp_array[src_i]; |
| if (src_tmp.GlyphsCount == 0) |
| continue; |
| |
| stbtt_PackFontRangesRenderIntoRects(&spc, &src_tmp.FontInfo, &src_tmp.PackRange, 1, src_tmp.Rects); |
| |
| // Apply multiply operator |
| if (cfg.RasterizerMultiply != 1.0f) |
| { |
| unsigned char multiply_table[256]; |
| ImFontAtlasBuildMultiplyCalcLookupTable(multiply_table, cfg.RasterizerMultiply); |
| stbrp_rect* r = &src_tmp.Rects[0]; |
| for (int glyph_i = 0; glyph_i < src_tmp.GlyphsCount; glyph_i++, r++) |
| if (r->was_packed) |
| ImFontAtlasBuildMultiplyRectAlpha8(multiply_table, atlas->TexPixelsAlpha8, r->x, r->y, r->w, r->h, atlas->TexWidth * 1); |
| } |
| src_tmp.Rects = NULL; |
| } |
| |
| // End packing |
| stbtt_PackEnd(&spc); |
| buf_rects.clear(); |
| |
| // 9. Setup ImFont and glyphs for runtime |
| for (int src_i = 0; src_i < src_tmp_array.Size; src_i++) |
| { |
| ImFontBuildSrcData& src_tmp = src_tmp_array[src_i]; |
| if (src_tmp.GlyphsCount == 0) |
| continue; |
| |
| ImFontConfig& cfg = atlas->ConfigData[src_i]; |
| ImFont* dst_font = cfg.DstFont; // We can have multiple input fonts writing into a same destination font (when using MergeMode=true) |
| |
| const float font_scale = stbtt_ScaleForPixelHeight(&src_tmp.FontInfo, cfg.SizePixels); |
| int unscaled_ascent, unscaled_descent, unscaled_line_gap; |
| stbtt_GetFontVMetrics(&src_tmp.FontInfo, &unscaled_ascent, &unscaled_descent, &unscaled_line_gap); |
| |
| const float ascent = ImFloor(unscaled_ascent * font_scale + ((unscaled_ascent > 0.0f) ? +1 : -1)); |
| const float descent = ImFloor(unscaled_descent * font_scale + ((unscaled_descent > 0.0f) ? +1 : -1)); |
| ImFontAtlasBuildSetupFont(atlas, dst_font, &cfg, ascent, descent); |
| const float font_off_x = cfg.GlyphOffset.x; |
| const float font_off_y = cfg.GlyphOffset.y + IM_ROUND(dst_font->Ascent); |
| |
| for (int glyph_i = 0; glyph_i < src_tmp.GlyphsCount; glyph_i++) |
| { |
| const int codepoint = src_tmp.GlyphsList[glyph_i]; |
| const stbtt_packedchar& pc = src_tmp.PackedChars[glyph_i]; |
| |
| const float char_advance_x_org = pc.xadvance; |
| const float char_advance_x_mod = ImClamp(char_advance_x_org, cfg.GlyphMinAdvanceX, cfg.GlyphMaxAdvanceX); |
| float char_off_x = font_off_x; |
| if (char_advance_x_org != char_advance_x_mod) |
| char_off_x += cfg.PixelSnapH ? ImFloor((char_advance_x_mod - char_advance_x_org) * 0.5f) : (char_advance_x_mod - char_advance_x_org) * 0.5f; |
| |
| // Register glyph |
| stbtt_aligned_quad q; |
| float dummy_x = 0.0f, dummy_y = 0.0f; |
| stbtt_GetPackedQuad(src_tmp.PackedChars, atlas->TexWidth, atlas->TexHeight, glyph_i, &dummy_x, &dummy_y, &q, 0); |
| dst_font->AddGlyph((ImWchar)codepoint, q.x0 + char_off_x, q.y0 + font_off_y, q.x1 + char_off_x, q.y1 + font_off_y, q.s0, q.t0, q.s1, q.t1, char_advance_x_mod); |
| } |
| } |
| |
| // Cleanup temporary (ImVector doesn't honor destructor) |
| for (int src_i = 0; src_i < src_tmp_array.Size; src_i++) |
| src_tmp_array[src_i].~ImFontBuildSrcData(); |
| |
| ImFontAtlasBuildFinish(atlas); |
| return true; |
| } |
| |
| void ImFontAtlasBuildRegisterDefaultCustomRects(ImFontAtlas* atlas) |
| { |
| if (atlas->CustomRectIds[0] >= 0) |
| return; |
| if (!(atlas->Flags & ImFontAtlasFlags_NoMouseCursors)) |
| atlas->CustomRectIds[0] = atlas->AddCustomRectRegular(FONT_ATLAS_DEFAULT_TEX_DATA_ID, FONT_ATLAS_DEFAULT_TEX_DATA_W_HALF*2+1, FONT_ATLAS_DEFAULT_TEX_DATA_H); |
| else |
| |