Skip to content

Commit 51d7012

Browse files
thedmdthedmd
committed
ImDrawList: DIrect implementation of AddRect() (WIP) (fixup)
1 parent 66a053c commit 51d7012

File tree

1 file changed

+293
-2
lines changed

1 file changed

+293
-2
lines changed

‎imgui_draw.cpp

+293-2
Original file line numberDiff line numberDiff line change
@@ -3429,7 +3429,299 @@ void ImDrawList::AddRect(const ImVec2& p_min, const ImVec2& p_max, ImU32 col, fl
34293429
if ((col & IM_COL32_A_MASK) == 0 || thickness <= 0.0f) IM_UNLIKELY
34303430
return;
34313431

3432-
if (GImGui->IO.KeyCtrl || (flags & 0x80000000u))
3432+
if (flags & 0x40000000u)
3433+
{
3434+
const ImVec2 uv = this->_Data->TexUvWhitePixel;
3435+
const ImVec2 a = ImVec2(p_min.x + 0.50f, p_min.y + 0.50f);
3436+
const ImVec2 b = ImVec2(p_max.x - 0.50f, p_max.y - 0.50f);
3437+
3438+
if (flags & ImDrawFlags_RoundCornersNone) IM_UNLIKELY
3439+
rounding = 0.0f;
3440+
3441+
if (rounding > 0.0f) IM_UNLIKELY // with any rounded corner
3442+
{
3443+
const float min_inner_offset_x = ImFabs(b.x - a.x) * (((flags & ImDrawFlags_RoundCornersTop) == ImDrawFlags_RoundCornersTop) || ((flags & ImDrawFlags_RoundCornersBottom) == ImDrawFlags_RoundCornersBottom) ? 0.5f : 1.0f) - 1.0f;
3444+
const float min_inner_offset_y = ImFabs(b.y - a.y) * (((flags & ImDrawFlags_RoundCornersLeft) == ImDrawFlags_RoundCornersLeft) || ((flags & ImDrawFlags_RoundCornersRight) == ImDrawFlags_RoundCornersRight) ? 0.5f : 1.0f) - 1.0f;
3445+
3446+
int path_count = 0;
3447+
ImVec2 path_offsets[4];
3448+
ImU32 path_colors[4];
3449+
if (this->Flags & ImDrawListFlags_AntiAliasedLines) IM_LIKELY
3450+
{
3451+
const float screen_thickness = thickness / this->_FringeScale;
3452+
3453+
if (screen_thickness < 1.0f) IM_UNLIKELY
3454+
{
3455+
// Blend color alpha using fringe
3456+
const ImU32 alpha = (ImU32)(((col >> IM_COL32_A_SHIFT) & 0xFF) * screen_thickness);
3457+
if (alpha == 0) IM_UNLIKELY
3458+
return;
3459+
3460+
col = (col & ~IM_COL32_A_MASK) | (alpha << IM_COL32_A_SHIFT);
3461+
}
3462+
3463+
if (screen_thickness <= 1.0f) IM_LIKELY // thin
3464+
{
3465+
path_offsets[0].x = thickness;
3466+
path_offsets[0].y = thickness;
3467+
path_offsets[1].x = 0.0f;
3468+
path_offsets[1].y = 0.0f;
3469+
path_offsets[2].x = -ImMin(thickness, min_inner_offset_x);
3470+
path_offsets[2].y = -ImMin(thickness, min_inner_offset_y);
3471+
path_colors[0] = col & ~IM_COL32_A_MASK;
3472+
path_colors[1] = col;
3473+
path_colors[2] = col & ~IM_COL32_A_MASK;
3474+
path_count = 3;
3475+
}
3476+
else IM_UNLIKELY // thick
3477+
{
3478+
path_offsets[0].x = (thickness + this->_FringeScale) * 0.5f;
3479+
path_offsets[0].y = (thickness + this->_FringeScale) * 0.5f;
3480+
path_offsets[1].x = (thickness - this->_FringeScale) * 0.5f;
3481+
path_offsets[1].y = (thickness - this->_FringeScale) * 0.5f;
3482+
path_offsets[2].x = -ImMin(path_offsets[1].x, min_inner_offset_x);
3483+
path_offsets[2].y = -ImMin(path_offsets[1].y, min_inner_offset_y);
3484+
path_offsets[3].x = -ImMin(path_offsets[0].x, min_inner_offset_x);
3485+
path_offsets[3].y = -ImMin(path_offsets[0].y, min_inner_offset_y);
3486+
path_colors[0] = col & ~IM_COL32_A_MASK;
3487+
path_colors[1] = col;
3488+
path_colors[2] = col;
3489+
path_colors[3] = col & ~IM_COL32_A_MASK;
3490+
path_count = 4;
3491+
}
3492+
}
3493+
else IM_UNLIKELY
3494+
{
3495+
path_offsets[0].x = thickness * 0.5f;
3496+
path_offsets[0].y = thickness * 0.5f;
3497+
path_offsets[1].x = -ImMin(path_offsets[0].x, min_inner_offset_x);
3498+
path_offsets[1].y = -ImMin(path_offsets[0].y, min_inner_offset_y);
3499+
path_colors[0] = col;
3500+
path_colors[1] = col;
3501+
path_count = 2;
3502+
}
3503+
3504+
flags = FixRectCornerFlags(flags);
3505+
3506+
this->_PathArcToFastEx(ImVec2(0.0f, 0.0f), 1.0f, 0, IM_DRAWLIST_ARCFAST_SAMPLE_MAX / 4, IM_DRAWLIST_ARCFAST_SAMPLE_MAX / ImMax(this->_CalcCircleAutoSegmentCount(rounding), 1));
3507+
const int segment_count = this->_Path.Size - 1;
3508+
3509+
const int max_vtx_count = 4 * (segment_count + 1) * path_count;
3510+
const int max_idx_count = 4 * segment_count * path_count * 2 * 3;
3511+
IM_POLYLINE_PRIM_RESERVE(max_idx_count, max_vtx_count);
3512+
3513+
int path_size = 0;
3514+
3515+
//if (flags & ImDrawFlags_RoundCornersTopLeft) IM_LIKELY
3516+
//{
3517+
// for (int i = 0; i < this->_Path.Size; i++)
3518+
// {
3519+
// for (int j = 0; j < path_count; j++)
3520+
// {
3521+
// //IM_POLYLINE_VERTEX(j, a.x + path_offsets[j].x * this->_Path[i].x * 2.0f, a.y + rounding - path_offsets[j].y * this->_Path[i].y * 2.0f, uv, path_colors[j]);
3522+
// IM_POLYLINE_VERTEX(j, a.x + path_offsets[j].x * rounding * this->_Path[i].x, a.y + path_offsets[j].y * rounding * this->_Path[i].y, uv, path_colors[j]);
3523+
// }
3524+
3525+
// IM_POLYLINE_PRIM_VTX_WRITE += path_count;
3526+
// ++path_size;
3527+
// }
3528+
//}
3529+
//else
3530+
{
3531+
for (int j = 0; j < path_count; j++)
3532+
{
3533+
IM_POLYLINE_VERTEX(j, a.x + path_offsets[j].x, a.y + path_offsets[j].y, uv, path_colors[j]);
3534+
}
3535+
3536+
IM_POLYLINE_PRIM_VTX_WRITE += path_count;
3537+
++path_size;
3538+
}
3539+
3540+
3541+
{
3542+
for (int j = 0; j < path_count; j++)
3543+
{
3544+
IM_POLYLINE_VERTEX(j, b.x - path_offsets[j].x, a.y + path_offsets[j].y, uv, path_colors[j]);
3545+
}
3546+
3547+
IM_POLYLINE_PRIM_VTX_WRITE += path_count;
3548+
++path_size;
3549+
}
3550+
3551+
{
3552+
for (int j = 0; j < path_count; j++)
3553+
{
3554+
IM_POLYLINE_VERTEX(j, b.x - path_offsets[j].x, b.y - path_offsets[j].y, uv, path_colors[j]);
3555+
}
3556+
3557+
IM_POLYLINE_PRIM_VTX_WRITE += path_count;
3558+
++path_size;
3559+
}
3560+
3561+
{
3562+
for (int j = 0; j < path_count; j++)
3563+
{
3564+
IM_POLYLINE_VERTEX(j, a.x + path_offsets[j].x, b.y - path_offsets[j].y, uv, path_colors[j]);
3565+
}
3566+
3567+
IM_POLYLINE_PRIM_VTX_WRITE += path_count;
3568+
++path_size;
3569+
}
3570+
3571+
const int strip_count = path_count - 1;
3572+
const int vtx_count = path_size * path_count;
3573+
3574+
IM_POLYLINE_TRIANGLE_BEGIN(path_size * strip_count * 2 * 3);
3575+
for (int i = 0; i < path_size; ++i)
3576+
{
3577+
for (int j = 0; j < strip_count; j++)
3578+
{
3579+
IM_POLYLINE_TRIANGLE(i * j * 2 + 0, i * path_count + j + 0, i * path_count + j + 1, i * path_count + j + path_count + 1);
3580+
IM_POLYLINE_TRIANGLE(i * j * 2 + 1, i * path_count + j + 0, i * path_count + j + path_count + 1, i * path_count + j + path_count + 0);
3581+
}
3582+
}
3583+
IM_POLYLINE_TRIANGLE_END(path_size * strip_count * 2 * 3);
3584+
3585+
IM_POLYLINE_PRIM_IDX_BASE += vtx_count;
3586+
3587+
for (int j = 0; j < (path_count - 1) * 6; j++)
3588+
{
3589+
if (IM_POLYLINE_PRIM_IDX_WRITE[-j - 1] >= IM_POLYLINE_PRIM_IDX_BASE)
3590+
IM_POLYLINE_PRIM_IDX_WRITE[-j - 1] -= vtx_count;
3591+
}
3592+
3593+
IM_POLYLINE_PRIM_COMMIT();
3594+
3595+
this->_Path.Size = 0;
3596+
}
3597+
else IM_LIKELY
3598+
{
3599+
if (this->Flags & ImDrawListFlags_AntiAliasedLines) IM_LIKELY
3600+
{
3601+
const float screen_thickness = thickness / this->_FringeScale;
3602+
const int integer_thickness = (int)screen_thickness;
3603+
const float fractional_thickness = screen_thickness - integer_thickness;
3604+
3605+
const bool use_texture = (Flags & ImDrawListFlags_AntiAliasedLinesUseTex) && (integer_thickness < IM_DRAWLIST_TEX_LINES_WIDTH_MAX) && (fractional_thickness <= 0.00001f);
3606+
3607+
if (screen_thickness < 1.0f) IM_UNLIKELY
3608+
{
3609+
// Blend color alpha using fringe
3610+
const ImU32 alpha = (ImU32)(((col >> IM_COL32_A_SHIFT) & 0xFF) * screen_thickness);
3611+
if (alpha == 0) IM_UNLIKELY
3612+
return;
3613+
3614+
col = (col & ~IM_COL32_A_MASK) | (alpha << IM_COL32_A_SHIFT);
3615+
}
3616+
3617+
if (use_texture) IM_LIKELY
3618+
{
3619+
const float outer_offset = thickness * 0.5f + this->_FringeScale;
3620+
const float inner_offset_x = ImMin(outer_offset, ImFabs(b.x - a.x) * 0.5f - 1.0f);
3621+
const float inner_offset_y = ImMin(outer_offset, ImFabs(b.y - a.y) * 0.5f - 1.0f);
3622+
const ImVec4 tex_uvs = _Data->TexUvLines[integer_thickness];
3623+
const ImVec2 uv_outer = ImVec2(tex_uvs.x, tex_uvs.y);
3624+
const ImVec2 uv_inner = ImVec2(tex_uvs.z, tex_uvs.w);
3625+
3626+
IM_POLYLINE_PRIM_RESERVE(24, 8);
3627+
3628+
IM_POLYLINE_VERTEX(0, a.x - outer_offset, a.y - outer_offset, uv_outer, col); IM_POLYLINE_VERTEX(1, a.x + inner_offset_x, a.y + inner_offset_y, uv_inner, col);
3629+
IM_POLYLINE_VERTEX(2, b.x + outer_offset, a.y - outer_offset, uv_outer, col); IM_POLYLINE_VERTEX(3, b.x - inner_offset_x, a.y + inner_offset_y, uv_inner, col);
3630+
IM_POLYLINE_VERTEX(4, b.x + outer_offset, b.y + outer_offset, uv_outer, col); IM_POLYLINE_VERTEX(5, b.x - inner_offset_x, b.y - inner_offset_y, uv_inner, col);
3631+
IM_POLYLINE_VERTEX(6, a.x - outer_offset, b.y + outer_offset, uv_outer, col); IM_POLYLINE_VERTEX(7, a.x + inner_offset_x, b.y - inner_offset_y, uv_inner, col);
3632+
3633+
IM_POLYLINE_TRIANGLE_BEGIN(24);
3634+
IM_POLYLINE_TRIANGLE(0, 0, 1, 3); IM_POLYLINE_TRIANGLE(1, 0, 3, 2);
3635+
IM_POLYLINE_TRIANGLE(2, 2, 3, 5); IM_POLYLINE_TRIANGLE(3, 2, 5, 4);
3636+
IM_POLYLINE_TRIANGLE(4, 4, 5, 7); IM_POLYLINE_TRIANGLE(5, 4, 7, 6);
3637+
IM_POLYLINE_TRIANGLE(6, 6, 7, 1); IM_POLYLINE_TRIANGLE(7, 6, 1, 0);
3638+
IM_POLYLINE_TRIANGLE_END(24);
3639+
3640+
IM_POLYLINE_VTX_COMMIT(8);
3641+
3642+
IM_POLYLINE_PRIM_COMMIT();
3643+
}
3644+
else if (screen_thickness > 1.0f) IM_UNLIKELY
3645+
{
3646+
const float outer_edge_offset = (thickness + this->_FringeScale) * 0.5f;
3647+
const float outer_core_offset = (thickness - this->_FringeScale) * 0.5f;
3648+
const float inner_core_offset_x = ImMin(outer_core_offset, ImFabs(b.x - a.x) * 0.5f - 1.0f);
3649+
const float inner_core_offset_y = ImMin(outer_core_offset, ImFabs(b.y - a.y) * 0.5f - 1.0f);
3650+
const float inner_edge_offset_x = ImMin(outer_edge_offset, ImFabs(b.x - a.x) * 0.5f - 1.0f);
3651+
const float inner_edge_offset_y = ImMin(outer_edge_offset, ImFabs(b.y - a.y) * 0.5f - 1.0f);
3652+
const ImU32 outer_color = col & ~IM_COL32_A_MASK;
3653+
3654+
IM_POLYLINE_PRIM_RESERVE(72, 16);
3655+
3656+
IM_POLYLINE_VERTEX( 0, a.x - outer_edge_offset, a.y - outer_edge_offset, uv, outer_color); IM_POLYLINE_VERTEX( 1, a.x - outer_core_offset, a.y - outer_core_offset, uv, col); IM_POLYLINE_VERTEX( 2, a.x + inner_core_offset_x, a.y + inner_core_offset_y, uv, col); IM_POLYLINE_VERTEX( 3, a.x + inner_edge_offset_x, a.y + inner_edge_offset_y, uv, outer_color);
3657+
IM_POLYLINE_VERTEX( 4, b.x + outer_edge_offset, a.y - outer_edge_offset, uv, outer_color); IM_POLYLINE_VERTEX( 5, b.x + outer_core_offset, a.y - outer_core_offset, uv, col); IM_POLYLINE_VERTEX( 6, b.x - inner_core_offset_x, a.y + inner_core_offset_y, uv, col); IM_POLYLINE_VERTEX( 7, b.x - inner_edge_offset_x, a.y + inner_edge_offset_y, uv, outer_color);
3658+
IM_POLYLINE_VERTEX( 8, b.x + outer_edge_offset, b.y + outer_edge_offset, uv, outer_color); IM_POLYLINE_VERTEX( 9, b.x + outer_core_offset, b.y + outer_core_offset, uv, col); IM_POLYLINE_VERTEX(10, b.x - inner_core_offset_x, b.y - inner_core_offset_y, uv, col); IM_POLYLINE_VERTEX(11, b.x - inner_edge_offset_x, b.y - inner_edge_offset_y, uv, outer_color);
3659+
IM_POLYLINE_VERTEX(12, a.x - outer_edge_offset, b.y + outer_edge_offset, uv, outer_color); IM_POLYLINE_VERTEX(13, a.x - outer_core_offset, b.y + outer_core_offset, uv, col); IM_POLYLINE_VERTEX(14, a.x + inner_core_offset_x, b.y - inner_core_offset_y, uv, col); IM_POLYLINE_VERTEX(15, a.x + inner_edge_offset_x, b.y - inner_edge_offset_y, uv, outer_color);
3660+
3661+
IM_POLYLINE_TRIANGLE_BEGIN(72);
3662+
IM_POLYLINE_TRIANGLE( 0, 0, 5, 4); IM_POLYLINE_TRIANGLE( 1, 0, 1, 5); IM_POLYLINE_TRIANGLE( 2, 1, 6, 5); IM_POLYLINE_TRIANGLE( 3, 1, 2, 6); IM_POLYLINE_TRIANGLE( 4, 2, 7, 6); IM_POLYLINE_TRIANGLE( 5, 2, 3, 7);
3663+
IM_POLYLINE_TRIANGLE( 6, 4, 9, 8); IM_POLYLINE_TRIANGLE( 7, 4, 5, 9); IM_POLYLINE_TRIANGLE( 8, 5, 10, 9); IM_POLYLINE_TRIANGLE( 9, 5, 6, 10); IM_POLYLINE_TRIANGLE(10, 6, 11, 10); IM_POLYLINE_TRIANGLE(11, 6, 7, 11);
3664+
IM_POLYLINE_TRIANGLE(12, 8, 13, 12); IM_POLYLINE_TRIANGLE(13, 8, 9, 13); IM_POLYLINE_TRIANGLE(14, 9, 14, 13); IM_POLYLINE_TRIANGLE(15, 9, 10, 14); IM_POLYLINE_TRIANGLE(16, 10, 15, 14); IM_POLYLINE_TRIANGLE(17, 10, 11, 15);
3665+
IM_POLYLINE_TRIANGLE(18, 12, 1, 0); IM_POLYLINE_TRIANGLE(19, 12, 13, 1); IM_POLYLINE_TRIANGLE(20, 13, 2, 1); IM_POLYLINE_TRIANGLE(21, 13, 14, 2); IM_POLYLINE_TRIANGLE(22, 14, 3, 2); IM_POLYLINE_TRIANGLE(23, 14, 15, 3);
3666+
IM_POLYLINE_TRIANGLE_END(72);
3667+
3668+
IM_POLYLINE_VTX_COMMIT(16);
3669+
3670+
IM_POLYLINE_PRIM_COMMIT();
3671+
}
3672+
else IM_LIKELY
3673+
{
3674+
const float outer_offset = thickness;
3675+
const float inner_offset_x = ImMin(outer_offset, ImFabs(b.x - a.x) * 0.5f - 1.0f);
3676+
const float inner_offset_y = ImMin(outer_offset, ImFabs(b.y - a.y) * 0.5f - 1.0f);
3677+
const ImU32 outer_color = col & ~IM_COL32_A_MASK;
3678+
3679+
IM_POLYLINE_PRIM_RESERVE(48, 12);
3680+
3681+
IM_POLYLINE_VERTEX(0, a.x - outer_offset, a.y - outer_offset, uv, outer_color); IM_POLYLINE_VERTEX( 1, a.x, a.y, uv, col); IM_POLYLINE_VERTEX( 2, a.x + inner_offset_x, a.y + inner_offset_y, uv, outer_color);
3682+
IM_POLYLINE_VERTEX(3, b.x + outer_offset, a.y - outer_offset, uv, outer_color); IM_POLYLINE_VERTEX( 4, b.x, a.y, uv, col); IM_POLYLINE_VERTEX( 5, b.x - inner_offset_x, a.y + inner_offset_y, uv, outer_color);
3683+
IM_POLYLINE_VERTEX(6, b.x + outer_offset, b.y + outer_offset, uv, outer_color); IM_POLYLINE_VERTEX( 7, b.x, b.y, uv, col); IM_POLYLINE_VERTEX( 8, b.x - inner_offset_x, b.y - inner_offset_y, uv, outer_color);
3684+
IM_POLYLINE_VERTEX(9, a.x - outer_offset, b.y + outer_offset, uv, outer_color); IM_POLYLINE_VERTEX(10, a.x, b.y, uv, col); IM_POLYLINE_VERTEX(11, a.x + inner_offset_x, b.y - inner_offset_y, uv, outer_color);
3685+
3686+
IM_POLYLINE_TRIANGLE_BEGIN(48);
3687+
IM_POLYLINE_TRIANGLE( 0, 0, 4, 3); IM_POLYLINE_TRIANGLE( 1, 0, 1, 4); IM_POLYLINE_TRIANGLE( 2, 1, 5, 4); IM_POLYLINE_TRIANGLE( 3, 1, 2, 5);
3688+
IM_POLYLINE_TRIANGLE( 4, 3, 7, 6); IM_POLYLINE_TRIANGLE( 5, 3, 4, 7); IM_POLYLINE_TRIANGLE( 6, 4, 8, 7); IM_POLYLINE_TRIANGLE( 7, 4, 5, 8);
3689+
IM_POLYLINE_TRIANGLE( 8, 6, 10, 9); IM_POLYLINE_TRIANGLE( 9, 6, 7, 10); IM_POLYLINE_TRIANGLE(10, 7, 11, 10); IM_POLYLINE_TRIANGLE(11, 7, 8, 11);
3690+
IM_POLYLINE_TRIANGLE(12, 9, 1, 0); IM_POLYLINE_TRIANGLE(13, 9, 10, 1); IM_POLYLINE_TRIANGLE(14, 10, 2, 1); IM_POLYLINE_TRIANGLE(15, 10, 11, 2);
3691+
IM_POLYLINE_TRIANGLE_END(48);
3692+
3693+
IM_POLYLINE_VTX_COMMIT(12);
3694+
3695+
IM_POLYLINE_PRIM_COMMIT();
3696+
}
3697+
}
3698+
else
3699+
{
3700+
const float outer_offset = thickness * 0.5f;
3701+
const float inner_offset_x = ImMin(outer_offset, ImFabs(b.x - a.x) * 0.5f - 1.0f);
3702+
const float inner_offset_y = ImMin(outer_offset, ImFabs(b.y - a.y) * 0.5f - 1.0f);
3703+
3704+
IM_POLYLINE_PRIM_RESERVE(24, 8);
3705+
3706+
IM_POLYLINE_VERTEX(0, a.x - outer_offset, a.y - outer_offset, uv, col); IM_POLYLINE_VERTEX(1, a.x + inner_offset_x, a.y + inner_offset_y, uv, col);
3707+
IM_POLYLINE_VERTEX(2, b.x + outer_offset, a.y - outer_offset, uv, col); IM_POLYLINE_VERTEX(3, b.x - inner_offset_x, a.y + inner_offset_y, uv, col);
3708+
IM_POLYLINE_VERTEX(4, b.x + outer_offset, b.y + outer_offset, uv, col); IM_POLYLINE_VERTEX(5, b.x - inner_offset_x, b.y - inner_offset_y, uv, col);
3709+
IM_POLYLINE_VERTEX(6, a.x - outer_offset, b.y + outer_offset, uv, col); IM_POLYLINE_VERTEX(7, a.x + inner_offset_x, b.y - inner_offset_y, uv, col);
3710+
3711+
IM_POLYLINE_TRIANGLE_BEGIN(24);
3712+
IM_POLYLINE_TRIANGLE(0, 0, 1, 3); IM_POLYLINE_TRIANGLE(1, 0, 3, 2);
3713+
IM_POLYLINE_TRIANGLE(2, 2, 3, 5); IM_POLYLINE_TRIANGLE(3, 2, 5, 4);
3714+
IM_POLYLINE_TRIANGLE(4, 4, 5, 7); IM_POLYLINE_TRIANGLE(5, 4, 7, 6);
3715+
IM_POLYLINE_TRIANGLE(6, 6, 7, 1); IM_POLYLINE_TRIANGLE(7, 6, 1, 0);
3716+
IM_POLYLINE_TRIANGLE_END(24);
3717+
3718+
IM_POLYLINE_VTX_COMMIT(8);
3719+
3720+
IM_POLYLINE_PRIM_COMMIT();
3721+
}
3722+
}
3723+
}
3724+
else if (GImGui->IO.KeyCtrl || (flags & 0x80000000u))
34333725
{
34343726
ImU32 inner_color = 0;
34353727
ImU32 outer_color = col;
@@ -3553,7 +3845,6 @@ if (GImGui->IO.KeyCtrl || (flags & 0x80000000u))
35533845
}
35543846
else
35553847
{
3556-
35573848
if (Flags & ImDrawListFlags_AntiAliasedLines)
35583849
PathRect(p_min + ImVec2(0.50f, 0.50f), p_max - ImVec2(0.50f, 0.50f), rounding, flags);
35593850
else

0 commit comments

Comments
 (0)