Merge branch 'master' into navigation
# Conflicts: # imgui_internal.h
This commit is contained in:
omar
commit
2ee1b70652
17
README.md
17
README.md
@ -55,14 +55,15 @@ _NB: those third-party bindings may be more or less maintained, more or less clo
|
||||
_Integrating Dear ImGui within your custom engine is a matter of wiring mouse/keyboard inputs and providing a render function that can bind a texture and render simple textured triangles. The examples/ folder is populated with applications doing just that. If you are an experienced programmer it should take you less than an hour to integrate Dear ImGui in your custom engine, but make sure to spend time reading the FAQ, the comments and other documentation!_
|
||||
|
||||
Languages:
|
||||
- cimgui: thin c-api wrapper for ImGui https://github.com/Extrawurst/cimgui
|
||||
- ImGui.NET: An ImGui wrapper for .NET Core https://github.com/mellinoe/ImGui.NET
|
||||
- imgui-rs: Rust bindings for dear imgui https://github.com/Gekkio/imgui-rs
|
||||
- DerelictImgui: Dynamic bindings for the D programming language: https://github.com/Extrawurst/DerelictImgui
|
||||
- CyImGui: Python bindings for dear imgui using Cython: https://github.com/chromy/cyimgui
|
||||
- pyimgui: Another Python bindings for dear imgui: https://github.com/swistakm/pyimgui
|
||||
- LUA: https://github.com/patrickriordan/imgui_lua_bindings
|
||||
- imgui-pas: P ascal bindings for imgui https://github.com/dpethes/imgui-pas
|
||||
- C - cimgui: thin c-api wrapper for ImGui https://github.com/Extrawurst/cimgui
|
||||
- C#/.Net - ImGui.NET: An ImGui wrapper for .NET Core https://github.com/mellinoe/ImGui.NET
|
||||
- D - DerelictImgui: Dynamic bindings for the D programming language: https://github.com/Extrawurst/DerelictImgui
|
||||
- Go - go-imgui https://github.com/Armored-Dragon/go-imgui
|
||||
- Lua - https://github.com/patrickriordan/imgui_lua_bindings
|
||||
- Pascal - imgui-pas https://github.com/dpethes/imgui-pas
|
||||
- Python - CyImGui: Python bindings for dear imgui using Cython: https://github.com/chromy/cyimgui
|
||||
- Python - pyimgui: Another Python bindings for dear imgui: https://github.com/swistakm/pyimgui
|
||||
- Rust - imgui-rs: Rust bindings for dear imgui https://github.com/Gekkio/imgui-rs
|
||||
|
||||
Frameworks:
|
||||
- Main ImGui repository include examples for DirectX9, DirectX10, DirectX11, OpenGL2/3, Vulkan, Allegro 5, SDL+GL2/3, iOS and Marmalade: https://github.com/ocornut/imgui/tree/master/examples
|
||||
|
||||
38
imgui.cpp
38
imgui.cpp
@ -983,6 +983,18 @@ const char* ImStristr(const char* haystack, const char* haystack_end, const char
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static const char* ImAtoi(const char* src, int* output)
|
||||
{
|
||||
int negative = 0;
|
||||
if (*src == '-') { negative = 1; src++; }
|
||||
if (*src == '+') { src++; }
|
||||
int v = 0;
|
||||
while (*src >= '0' && *src <= '9')
|
||||
v = (v * 10) + (*src++ - '0');
|
||||
*output = negative ? -v : v;
|
||||
return src;
|
||||
}
|
||||
|
||||
// MSVC version appears to return -1 on overflow, whereas glibc appears to return total count (which may be >= buf_size).
|
||||
// Ideally we would test for only one of those limits at runtime depending on the behavior the vsnprintf(), but trying to deduct it at compile time sounds like a pandora can of worm.
|
||||
int ImFormatString(char* buf, int buf_size, const char* fmt, ...)
|
||||
@ -1287,12 +1299,12 @@ void ImGui::ColorConvertRGBtoHSV(float r, float g, float b, float& out_h, float&
|
||||
float K = 0.f;
|
||||
if (g < b)
|
||||
{
|
||||
const float tmp = g; g = b; b = tmp;
|
||||
ImSwap(g, b);
|
||||
K = -1.f;
|
||||
}
|
||||
if (r < g)
|
||||
{
|
||||
const float tmp = r; r = g; g = tmp;
|
||||
ImSwap(r, g);
|
||||
K = -2.f / 6.f - K;
|
||||
}
|
||||
|
||||
@ -5064,7 +5076,7 @@ bool ImGui::Begin(const char* name, bool* p_open, const ImVec2& size_on_first_us
|
||||
bg_color.w = bg_alpha;
|
||||
bg_color.w *= style.Alpha;
|
||||
if (bg_color.w > 0.0f)
|
||||
window->DrawList->AddRectFilled(window->Pos+ImVec2(0,window->TitleBarHeight()), window->Pos+window->Size, ColorConvertFloat4ToU32(bg_color), window_rounding, (flags & ImGuiWindowFlags_NoTitleBar) ? ImGuiCorner_All : ImGuiCorner_BottomLeft|ImGuiCorner_BottomRight);
|
||||
window->DrawList->AddRectFilled(window->Pos+ImVec2(0,window->TitleBarHeight()), window->Pos+window->Size, ColorConvertFloat4ToU32(bg_color), window_rounding, (flags & ImGuiWindowFlags_NoTitleBar) ? ImGuiCorner_All : ImGuiCorner_BotLeft|ImGuiCorner_BotRight);
|
||||
|
||||
// Title bar
|
||||
const bool is_focused = g.NavWindow && window->RootNonPopupWindow == g.NavWindow->RootNonPopupWindow;
|
||||
@ -5324,9 +5336,9 @@ static void Scrollbar(ImGuiWindow* window, bool horizontal)
|
||||
float window_rounding = (window->Flags & ImGuiWindowFlags_ChildWindow) ? style.ChildWindowRounding : style.WindowRounding;
|
||||
int window_rounding_corners;
|
||||
if (horizontal)
|
||||
window_rounding_corners = ImGuiCorner_BottomLeft | (other_scrollbar ? 0 : ImGuiCorner_BottomRight);
|
||||
window_rounding_corners = ImGuiCorner_BotLeft | (other_scrollbar ? 0 : ImGuiCorner_BotRight);
|
||||
else
|
||||
window_rounding_corners = (((window->Flags & ImGuiWindowFlags_NoTitleBar) && !(window->Flags & ImGuiWindowFlags_MenuBar)) ? ImGuiCorner_TopRight : 0) | (other_scrollbar ? 0 : ImGuiCorner_BottomRight);
|
||||
window_rounding_corners = (((window->Flags & ImGuiWindowFlags_NoTitleBar) && !(window->Flags & ImGuiWindowFlags_MenuBar)) ? ImGuiCorner_TopRight : 0) | (other_scrollbar ? 0 : ImGuiCorner_BotRight);
|
||||
window->DrawList->AddRectFilled(bb.Min, bb.Max, ImGui::GetColorU32(ImGuiCol_ScrollbarBg), window_rounding, window_rounding_corners);
|
||||
bb.Expand(ImVec2(-ImClamp((float)(int)((bb.Max.x - bb.Min.x - 2.0f) * 0.5f), 0.0f, 3.0f), -ImClamp((float)(int)((bb.Max.y - bb.Min.y - 2.0f) * 0.5f), 0.0f, 3.0f)));
|
||||
|
||||
@ -7352,10 +7364,12 @@ int ImGui::ParseFormatPrecision(const char* fmt, int default_precision)
|
||||
fmt++;
|
||||
if (*fmt == '.')
|
||||
{
|
||||
precision = atoi(fmt + 1);
|
||||
fmt = ImAtoi(fmt + 1, &precision);
|
||||
if (precision < 0 || precision > 10)
|
||||
precision = default_precision;
|
||||
}
|
||||
if (*fmt == 'e' || *fmt == 'E') // Maximum precision with scientific notation
|
||||
precision = -1;
|
||||
break;
|
||||
}
|
||||
return precision;
|
||||
@ -7372,6 +7386,8 @@ float ImGui::RoundScalar(float value, int decimal_precision)
|
||||
// Round past decimal precision
|
||||
// So when our value is 1.99999 with a precision of 0.001 we'll end up rounding to 2.0
|
||||
// FIXME: Investigate better rounding methods
|
||||
if (decimal_precision < 0)
|
||||
return value;
|
||||
const float min_step = GetMinimumStepAtDecimalPrecision(decimal_precision);
|
||||
bool negative = value < 0.0f;
|
||||
value = fabsf(value);
|
||||
@ -7425,7 +7441,7 @@ bool ImGui::SliderBehavior(const ImRect& frame_bb, ImGuiID id, float* v, float v
|
||||
const float grab_padding = 2.0f;
|
||||
const float slider_sz = is_horizontal ? (frame_bb.GetWidth() - grab_padding * 2.0f) : (frame_bb.GetHeight() - grab_padding * 2.0f);
|
||||
float grab_sz;
|
||||
if (decimal_precision > 0)
|
||||
if (decimal_precision != 0)
|
||||
grab_sz = ImMin(style.GrabMinSize, slider_sz);
|
||||
else
|
||||
grab_sz = ImMin(ImMax(1.0f * (slider_sz / ((v_min < v_max ? v_max - v_min : v_min - v_max) + 1.0f)), style.GrabMinSize), slider_sz); // Integer sliders, if possible have the grab size represent 1 unit
|
||||
@ -8235,7 +8251,7 @@ void ImGui::ProgressBar(float fraction, const ImVec2& size_arg, const char* over
|
||||
RenderFrame(bb.Min, bb.Max, GetColorU32(ImGuiCol_FrameBg), true, style.FrameRounding);
|
||||
bb.Expand(ImVec2(-window->BorderSize, -window->BorderSize));
|
||||
const ImVec2 fill_br = ImVec2(ImLerp(bb.Min.x, bb.Max.x, fraction), bb.Max.y);
|
||||
RenderFrame(bb.Min, fill_br, GetColorU32(ImGuiCol_PlotHistogram), false, style.FrameRounding);
|
||||
RenderRectFilledRangeH(window->DrawList, bb, GetColorU32(ImGuiCol_PlotHistogram), 0.0f, fraction, style.FrameRounding);
|
||||
|
||||
// Default displaying the fraction as percentage string, but user can override it
|
||||
char overlay_buf[32];
|
||||
@ -10056,7 +10072,7 @@ void ImGui::RenderColorRectWithAlphaCheckerboard(ImVec2 p_min, ImVec2 p_max, ImU
|
||||
continue;
|
||||
int rounding_corners_flags_cell = 0;
|
||||
if (y1 <= p_min.y) { if (x1 <= p_min.x) rounding_corners_flags_cell |= ImGuiCorner_TopLeft; if (x2 >= p_max.x) rounding_corners_flags_cell |= ImGuiCorner_TopRight; }
|
||||
if (y2 >= p_max.y) { if (x1 <= p_min.x) rounding_corners_flags_cell |= ImGuiCorner_BottomLeft; if (x2 >= p_max.x) rounding_corners_flags_cell |= ImGuiCorner_BottomRight; }
|
||||
if (y2 >= p_max.y) { if (x1 <= p_min.x) rounding_corners_flags_cell |= ImGuiCorner_BotLeft; if (x2 >= p_max.x) rounding_corners_flags_cell |= ImGuiCorner_BotRight; }
|
||||
rounding_corners_flags_cell &= rounding_corners_flags;
|
||||
window->DrawList->AddRectFilled(ImVec2(x1,y1), ImVec2(x2,y2), col_bg2, rounding_corners_flags_cell ? rounding : 0.0f, rounding_corners_flags_cell);
|
||||
}
|
||||
@ -10116,8 +10132,8 @@ bool ImGui::ColorButton(const char* desc_id, const ImVec4& col, ImGuiColorEditFl
|
||||
if ((flags & ImGuiColorEditFlags_AlphaPreviewHalf) && col.w < 1.0f)
|
||||
{
|
||||
float mid_x = (float)(int)((bb.Min.x + bb.Max.x) * 0.5f + 0.5f);
|
||||
RenderColorRectWithAlphaCheckerboard(ImVec2(bb.Min.x + grid_step, bb.Min.y), bb.Max, GetColorU32(col), grid_step, ImVec2(-grid_step, 0.0f), rounding, ImGuiCorner_TopRight|ImGuiCorner_BottomRight);
|
||||
window->DrawList->AddRectFilled(bb.Min, ImVec2(mid_x, bb.Max.y), GetColorU32(col_without_alpha), rounding, ImGuiCorner_TopLeft|ImGuiCorner_BottomLeft);
|
||||
RenderColorRectWithAlphaCheckerboard(ImVec2(bb.Min.x + grid_step, bb.Min.y), bb.Max, GetColorU32(col), grid_step, ImVec2(-grid_step, 0.0f), rounding, ImGuiCorner_TopRight|ImGuiCorner_BotRight);
|
||||
window->DrawList->AddRectFilled(bb.Min, ImVec2(mid_x, bb.Max.y), GetColorU32(col_without_alpha), rounding, ImGuiCorner_TopLeft|ImGuiCorner_BotLeft);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
115
imgui_draw.cpp
115
imgui_draw.cpp
@ -694,13 +694,11 @@ void ImDrawList::PathArcToFast(const ImVec2& centre, float radius, int a_min_of_
|
||||
circle_vtx_builds = true;
|
||||
}
|
||||
|
||||
if (a_min_of_12 > a_max_of_12) return;
|
||||
if (radius == 0.0f)
|
||||
if (radius == 0.0f || a_min_of_12 > a_max_of_12)
|
||||
{
|
||||
_Path.push_back(centre);
|
||||
return;
|
||||
}
|
||||
else
|
||||
{
|
||||
_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++)
|
||||
{
|
||||
@ -708,16 +706,18 @@ void ImDrawList::PathArcToFast(const ImVec2& centre, float radius, int a_min_of_
|
||||
_Path.push_back(ImVec2(centre.x + c.x * radius, centre.y + c.y * radius));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ImDrawList::PathArcTo(const ImVec2& centre, float radius, float amin, float amax, int num_segments)
|
||||
void ImDrawList::PathArcTo(const ImVec2& centre, float radius, float a_min, float a_max, int num_segments)
|
||||
{
|
||||
if (radius == 0.0f)
|
||||
{
|
||||
_Path.push_back(centre);
|
||||
return;
|
||||
}
|
||||
_Path.reserve(_Path.Size + (num_segments + 1));
|
||||
for (int i = 0; i <= num_segments; i++)
|
||||
{
|
||||
const float a = amin + ((float)i / (float)num_segments) * (amax - amin);
|
||||
const float a = a_min + ((float)i / (float)num_segments) * (a_max - a_min);
|
||||
_Path.push_back(ImVec2(centre.x + cosf(a) * radius, centre.y + sinf(a) * radius));
|
||||
}
|
||||
}
|
||||
@ -775,15 +775,14 @@ void ImDrawList::PathBezierCurveTo(const ImVec2& p2, const ImVec2& p3, const ImV
|
||||
void ImDrawList::PathRect(const ImVec2& a, const ImVec2& b, float rounding, int rounding_corners)
|
||||
{
|
||||
const int corners_top = ImGuiCorner_TopLeft | ImGuiCorner_TopRight;
|
||||
const int corners_bottom = ImGuiCorner_BottomLeft | ImGuiCorner_BottomRight;
|
||||
const int corners_left = ImGuiCorner_TopLeft | ImGuiCorner_BottomLeft;
|
||||
const int corners_right = ImGuiCorner_TopRight | ImGuiCorner_BottomRight;
|
||||
const int corners_bottom = ImGuiCorner_BotLeft | ImGuiCorner_BotRight;
|
||||
const int corners_left = ImGuiCorner_TopLeft | ImGuiCorner_BotLeft;
|
||||
const int corners_right = ImGuiCorner_TopRight | ImGuiCorner_BotRight;
|
||||
|
||||
float r = rounding;
|
||||
r = ImMin(r, fabsf(b.x-a.x) * ( ((rounding_corners & corners_top) == corners_top) || ((rounding_corners & corners_bottom) == corners_bottom) ? 0.5f : 1.0f ) - 1.0f);
|
||||
r = ImMin(r, fabsf(b.y-a.y) * ( ((rounding_corners & corners_left) == corners_left) || ((rounding_corners & corners_right) == corners_right) ? 0.5f : 1.0f ) - 1.0f);
|
||||
rounding = ImMin(rounding, fabsf(b.x - a.x) * ( ((rounding_corners & corners_top) == corners_top) || ((rounding_corners & corners_bottom) == corners_bottom) ? 0.5f : 1.0f ) - 1.0f);
|
||||
rounding = ImMin(rounding, fabsf(b.y - a.y) * ( ((rounding_corners & corners_left) == corners_left) || ((rounding_corners & corners_right) == corners_right) ? 0.5f : 1.0f ) - 1.0f);
|
||||
|
||||
if (r <= 0.0f || rounding_corners == 0)
|
||||
if (rounding <= 0.0f || rounding_corners == 0)
|
||||
{
|
||||
PathLineTo(a);
|
||||
PathLineTo(ImVec2(b.x, a.y));
|
||||
@ -792,14 +791,14 @@ void ImDrawList::PathRect(const ImVec2& a, const ImVec2& b, float rounding, int
|
||||
}
|
||||
else
|
||||
{
|
||||
const float r0 = (rounding_corners & ImGuiCorner_TopLeft) ? r : 0.0f;
|
||||
const float r1 = (rounding_corners & ImGuiCorner_TopRight) ? r : 0.0f;
|
||||
const float r2 = (rounding_corners & ImGuiCorner_BottomRight) ? r : 0.0f;
|
||||
const float r3 = (rounding_corners & ImGuiCorner_BottomLeft) ? r : 0.0f;
|
||||
PathArcToFast(ImVec2(a.x+r0,a.y+r0), r0, 6, 9);
|
||||
PathArcToFast(ImVec2(b.x-r1,a.y+r1), r1, 9, 12);
|
||||
PathArcToFast(ImVec2(b.x-r2,b.y-r2), r2, 0, 3);
|
||||
PathArcToFast(ImVec2(a.x+r3,b.y-r3), r3, 3, 6);
|
||||
const float rounding_tl = (rounding_corners & ImGuiCorner_TopLeft) ? rounding : 0.0f;
|
||||
const float rounding_tr = (rounding_corners & ImGuiCorner_TopRight) ? rounding : 0.0f;
|
||||
const float rounding_br = (rounding_corners & ImGuiCorner_BotRight) ? rounding : 0.0f;
|
||||
const float rounding_bl = (rounding_corners & ImGuiCorner_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);
|
||||
}
|
||||
}
|
||||
|
||||
@ -2330,6 +2329,78 @@ void ImFont::RenderText(ImDrawList* draw_list, float size, ImVec2 pos, ImU32 col
|
||||
draw_list->_VtxCurrentIdx = (unsigned int)draw_list->VtxBuffer.Size;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Internals Drawing Helpers
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static inline float ImAcos01(float x)
|
||||
{
|
||||
if (x <= 0.0f) return IM_PI * 0.5f;
|
||||
if (x >= 1.0f) return 0.0f;
|
||||
return acosf(x);
|
||||
//return (-0.69813170079773212f * x * x - 0.87266462599716477f) * x + 1.5707963267948966f; // Cheap approximation, may be enough for what we do.
|
||||
}
|
||||
|
||||
// FIXME: Cleanup and move code to ImDrawList.
|
||||
void ImGui::RenderRectFilledRangeH(ImDrawList* draw_list, const ImRect& rect, ImU32 col, float x_start_norm, float x_end_norm, float rounding)
|
||||
{
|
||||
if (x_end_norm == x_start_norm)
|
||||
return;
|
||||
if (x_start_norm > x_end_norm)
|
||||
ImSwap(x_start_norm, x_end_norm);
|
||||
|
||||
ImVec2 p0 = ImVec2(ImLerp(rect.Min.x, rect.Max.x, x_start_norm), rect.Min.y);
|
||||
ImVec2 p1 = ImVec2(ImLerp(rect.Min.x, rect.Max.x, x_end_norm), rect.Max.y);
|
||||
if (rounding == 0.0f)
|
||||
{
|
||||
draw_list->AddRectFilled(p0, p1, col, 0.0f);
|
||||
return;
|
||||
}
|
||||
|
||||
rounding = ImClamp(ImMin((rect.Max.x - rect.Min.x) * 0.5f, (rect.Max.y - rect.Min.y) * 0.5f) - 1.0f, 0.0f, rounding);
|
||||
const float inv_rounding = 1.0f / rounding;
|
||||
const float arc0_b = ImAcos01(1.0f - (p0.x - rect.Min.x) * inv_rounding);
|
||||
const float arc0_e = ImAcos01(1.0f - (p1.x - rect.Min.x) * inv_rounding);
|
||||
const float x0 = ImMax(p0.x, rect.Min.x + rounding);
|
||||
if (arc0_b == arc0_e)
|
||||
{
|
||||
draw_list->PathLineTo(ImVec2(x0, p1.y));
|
||||
draw_list->PathLineTo(ImVec2(x0, p0.y));
|
||||
}
|
||||
else if (arc0_b == 0.0f && arc0_e == IM_PI*0.5f)
|
||||
{
|
||||
draw_list->PathArcToFast(ImVec2(x0, p1.y - rounding), rounding, 3, 6); // BL
|
||||
draw_list->PathArcToFast(ImVec2(x0, p0.y + rounding), rounding, 6, 9); // TR
|
||||
}
|
||||
else
|
||||
{
|
||||
draw_list->PathArcTo(ImVec2(x0, p1.y - rounding), rounding, IM_PI - arc0_e, IM_PI - arc0_b, 3); // BL
|
||||
draw_list->PathArcTo(ImVec2(x0, p0.y + rounding), rounding, IM_PI + arc0_b, IM_PI + arc0_e, 3); // TR
|
||||
}
|
||||
if (p1.x > rect.Min.x + rounding)
|
||||
{
|
||||
const float arc1_b = ImAcos01(1.0f - (rect.Max.x - p1.x) * inv_rounding);
|
||||
const float arc1_e = ImAcos01(1.0f - (rect.Max.x - p0.x) * inv_rounding);
|
||||
const float x1 = ImMin(p1.x, rect.Max.x - rounding);
|
||||
if (arc1_b == arc1_e)
|
||||
{
|
||||
draw_list->PathLineTo(ImVec2(x1, p0.y));
|
||||
draw_list->PathLineTo(ImVec2(x1, p1.y));
|
||||
}
|
||||
else if (arc1_b == 0.0f && arc1_e == IM_PI*0.5f)
|
||||
{
|
||||
draw_list->PathArcToFast(ImVec2(x1, p0.y + rounding), rounding, 9, 12); // TR
|
||||
draw_list->PathArcToFast(ImVec2(x1, p1.y - rounding), rounding, 0, 3); // BR
|
||||
}
|
||||
else
|
||||
{
|
||||
draw_list->PathArcTo(ImVec2(x1, p0.y + rounding), rounding, -arc1_e, -arc1_b, 3); // TR
|
||||
draw_list->PathArcTo(ImVec2(x1, p1.y - rounding), rounding, +arc1_b, +arc1_e, 3); // BR
|
||||
}
|
||||
}
|
||||
draw_list->PathFillConvex(col);
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// DEFAULT FONT DATA
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
@ -140,6 +140,7 @@ static inline int ImClamp(int v, int mn, int mx)
|
||||
static inline float ImClamp(float v, float mn, float mx) { return (v < mn) ? mn : (v > mx) ? mx : v; }
|
||||
static inline ImVec2 ImClamp(const ImVec2& f, const ImVec2& mn, ImVec2 mx) { return ImVec2(ImClamp(f.x,mn.x,mx.x), ImClamp(f.y,mn.y,mx.y)); }
|
||||
static inline float ImSaturate(float f) { return (f < 0.0f) ? 0.0f : (f > 1.0f) ? 1.0f : f; }
|
||||
static inline void ImSwap(float& a, float& b) { float tmp = a; a = b; b = tmp; }
|
||||
static inline int ImLerp(int a, int b, float t) { return (int)(a + (b - a) * t); }
|
||||
static inline float ImLerp(float a, float b, float t) { return a + (b - a) * t; }
|
||||
static inline ImVec2 ImLerp(const ImVec2& a, const ImVec2& b, float t) { return ImVec2(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t); }
|
||||
@ -245,8 +246,8 @@ enum ImGuiCorner
|
||||
{
|
||||
ImGuiCorner_TopLeft = 1 << 0, // 1
|
||||
ImGuiCorner_TopRight = 1 << 1, // 2
|
||||
ImGuiCorner_BottomRight = 1 << 2, // 4
|
||||
ImGuiCorner_BottomLeft = 1 << 3, // 8
|
||||
ImGuiCorner_BotRight = 1 << 2, // 4
|
||||
ImGuiCorner_BotLeft = 1 << 3, // 8
|
||||
ImGuiCorner_All = 0x0F
|
||||
};
|
||||
|
||||
@ -862,6 +863,7 @@ namespace ImGui
|
||||
IMGUI_API void RenderBullet(ImVec2 pos);
|
||||
IMGUI_API void RenderCheckMark(ImVec2 pos, ImU32 col);
|
||||
IMGUI_API void RenderNavHighlight(const ImRect& bb, ImGuiID id); // Navigation highlight
|
||||
IMGUI_API void RenderRectFilledRangeH(ImDrawList* draw_list, const ImRect& rect, ImU32 col, float x_start_norm, float x_end_norm, float rounding);
|
||||
IMGUI_API const char* FindRenderedTextEnd(const char* text, const char* text_end = NULL); // Find the optional ## from which we stop displaying text.
|
||||
|
||||
IMGUI_API bool ButtonBehavior(const ImRect& bb, ImGuiID id, bool* out_hovered, bool* out_held, ImGuiButtonFlags flags = 0);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user