anulax
/
imgui-docking
1
0
Fork 0
Code Issues Pull Requests Packages project_board Releases Wiki Activity

Merge: First pass on AA rendered primitives from https://github.com/memononen/imgui

Browse Source
features/sdl_renderer3_multiviewports
ocornut ago%!(EXTRA string=11 years)
parent 1f272785f1 fdc8c0722f
commit 8ca3dc8e41
2 changed files with 246 additions and 140 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 369
      imgui.cpp
  2. 13
      imgui.h

369
imgui.cpp
Unescape View File

@ -3002,17 +3002,10 @@ bool ImGui::Begin(const char* name, bool* p_opened, const ImVec2& size, float bg
{ {
const float r = window_rounding; const float r = window_rounding;
const ImVec2 br = window->Aabb().GetBR(); const ImVec2 br = window->Aabb().GetBR();
if (r == 0.0f) window->DrawList->LineTo(br + ImVec2(-2*r,0));
{ window->DrawList->LineTo(br + ImVec2(0,-2*r));
window->DrawList->AddTriangleFilled(br, br-ImVec2(0,14), br-ImVec2(14,0), resize_col); window->DrawList->ArcToFast(ImVec2(br.x-r,br.y-r), r, 6, 9);
} window->DrawList->Fill(resize_col);
else
{
// FIXME: We should draw 4 triangles and decide on a size that's not dependent on the rounding size (previously used 18)
window->DrawList->AddArc(br - ImVec2(r,r), r, resize_col, 6, 9, true);
window->DrawList->AddTriangleFilled(br+ImVec2(0,-2*r),br+ImVec2(0,-r),br+ImVec2(-r,-r), resize_col);
window->DrawList->AddTriangleFilled(br+ImVec2(-r,-r), br+ImVec2(-r,0),br+ImVec2(-2*r,0), resize_col);
}
} }
} }
@ -6805,198 +6798,300 @@ void ImDrawList::AddVtxUV(const ImVec2& pos, ImU32 col, const ImVec2& uv)
vtx_write++; vtx_write++;
} }
// NB: memory should be reserved for 6 vertices by the caller. static ImVector<ImVec2> temp_inner;
void ImDrawList::AddVtxLine(const ImVec2& a, const ImVec2& b, ImU32 col) static ImVector<ImVec2> temp_outer;
static ImVector<ImVec2> temp_normals;
void ImDrawList::AddPolyline(const ImVec2* points, const int points_count, ImU32 col, bool closed)
{ {
const float length = sqrtf(ImLengthSqr(b - a)); if (points_count < 2)
const ImVec2 hn = (b - a) * (0.50f / length); // half normal return;
const ImVec2 hp0 = ImVec2(+hn.y, -hn.x); // half perpendiculars + user offset
const ImVec2 hp1 = ImVec2(-hn.y, +hn.x); const float aa_size = 1.0f;
temp_inner.resize(points_count);
temp_outer.resize(points_count);
temp_normals.resize(points_count);
int start = 0, count = points_count;
if (!closed)
{
start = 1;
count = points_count-1;
}
for (int i = 0; i < count; i++)
{
const int ni = (i+1) < points_count ? i+1 : 0;
const ImVec2& v0 = points[i];
const ImVec2& v1 = points[ni];
ImVec2 diff = v1 - v0;
float d = ImLengthSqr(diff);
if (d > 0)
diff *= 1.0f/sqrtf(d);
temp_normals[i].x = diff.y;
temp_normals[i].y = -diff.x;
}
if (!closed)
{
temp_normals[points_count-1] = temp_normals[points_count-2];
temp_outer[0] = points[0] + temp_normals[0]*aa_size;
temp_inner[0] = points[0] - temp_normals[0]*aa_size;
temp_outer[points_count-1] = points[points_count-1] + temp_normals[points_count-1]*aa_size;
temp_inner[points_count-1] = points[points_count-1] - temp_normals[points_count-1]*aa_size;
}
for (int i = start; i < count; i++)
{
const int ni = (i+1) < points_count ? i+1 : 0;
const ImVec2& dl0 = temp_normals[i];
const ImVec2& dl1 = temp_normals[ni];
ImVec2 dm = (dl0 + dl1) * 0.5f;
float dmr2 = dm.x*dm.x + dm.y*dm.y;
if (dmr2 > 0.000001f)
{
float scale = 1.0f / dmr2;
if (scale > 100.0f) scale = 100.0f;
dm *= scale;
}
dm *= aa_size;
temp_outer[ni] = points[ni] + dm;
temp_inner[ni] = points[ni] - dm;
}
const ImU32 col_trans = col & 0x00ffffff;
int vertex_count = count*12;
ReserveVertices(vertex_count);
// Stroke
for (int i = 0; i < count; i++)
{
const int ni = (i+1) < points_count ? i+1 : 0;
AddVtx(points[ni], col);
AddVtx(points[i], col);
AddVtx(temp_outer[i], col_trans);
AddVtx(temp_outer[i], col_trans);
AddVtx(temp_outer[ni], col_trans);
AddVtx(points[ni], col);
// Two triangles makes up one line. Using triangles allows us to reduce amount of draw calls. AddVtx(temp_inner[ni], col_trans);
AddVtx(a + hp0, col); AddVtx(temp_inner[i], col_trans);
AddVtx(b + hp0, col); AddVtx(points[i], col);
AddVtx(a + hp1, col);
AddVtx(b + hp0, col); AddVtx(points[i], col);
AddVtx(b + hp1, col); AddVtx(points[ni], col);
AddVtx(a + hp1, col); AddVtx(temp_inner[ni], col_trans);
}
} }
void ImDrawList::AddLine(const ImVec2& a, const ImVec2& b, ImU32 col) void ImDrawList::AddConvexPolyFilled(const ImVec2* points, const int points_count, ImU32 col)
{ {
if ((col >> 24) == 0) if (points_count < 3)
return; return;
ReserveVertices(6); const float aa_size = 1.0f;
AddVtxLine(a, b, col);
temp_inner.resize(points_count);
temp_outer.resize(points_count);
temp_normals.resize(points_count);
for (int i = 0, j = points_count-1; i < points_count; j=i++)
{
const ImVec2& v0 = points[j];
const ImVec2& v1 = points[i];
ImVec2 diff = v1 - v0;
float d = ImLengthSqr(diff);
if (d > 0)
diff *= 1.0f/sqrtf(d);
temp_normals[j].x = diff.y;
temp_normals[j].y = -diff.x;
}
for (int i = 0, j = points_count-1; i < points_count; j=i++)
{
const ImVec2& dl0 = temp_normals[j];
const ImVec2& dl1 = temp_normals[i];
ImVec2 dm = (dl0 + dl1) * 0.5f;
float dmr2 = dm.x*dm.x + dm.y*dm.y;
if (dmr2 > 0.000001f)
{
float scale = 1.0f / dmr2;
if (scale > 100.0f) scale = 100.0f;
dm *= scale;
}
dm *= aa_size*0.5f;
temp_outer[i] = points[i] + dm;
temp_inner[i] = points[i] - dm;
}
const ImU32 col_trans = col & 0x00ffffff;
int vertex_count = (points_count-2)*3 + points_count*6;
ReserveVertices(vertex_count);
// Fill
for (int i = 2; i < points_count; i++)
{
AddVtx(temp_inner[0], col);
AddVtx(temp_inner[i-1], col);
AddVtx(temp_inner[i], col);
}
// AA fringe
for (int i = 0, j = points_count-1; i < points_count; j=i++)
{
AddVtx(temp_inner[i], col);
AddVtx(temp_inner[j], col);
AddVtx(temp_outer[j], col_trans);
AddVtx(temp_outer[j], col_trans);
AddVtx(temp_outer[i], col_trans);
AddVtx(temp_inner[i], col);
}
} }
void ImDrawList::AddArc(const ImVec2& center, float rad, ImU32 col, int a_min, int a_max, bool tris, const ImVec2& third_point_offset) void ImDrawList::ClearPath()
{ {
if ((col >> 24) == 0) path.resize(0);
return; }
void ImDrawList::LineTo(const ImVec2& p)
{
path.push_back(p);
}
void ImDrawList::ArcToFast(const ImVec2& centre, float radius, int amin, int amax)
{
static ImVec2 circle_vtx[12]; static ImVec2 circle_vtx[12];
static bool circle_vtx_builds = false; static bool circle_vtx_builds = false;
static const int circle_vtx_count = IM_ARRAYSIZE(circle_vtx);
if (!circle_vtx_builds) if (!circle_vtx_builds)
{ {
for (int i = 0; i < IM_ARRAYSIZE(circle_vtx); i++) for (int i = 0; i < circle_vtx_count; i++)
{ {
const float a = ((float)i / (float)IM_ARRAYSIZE(circle_vtx)) * 2*PI; const float a = ((float)i / (float)circle_vtx_count) * 2*PI;
circle_vtx[i].x = cosf(a + PI); circle_vtx[i].x = cosf(a + PI);
circle_vtx[i].y = sinf(a + PI); circle_vtx[i].y = sinf(a + PI);
} }
circle_vtx_builds = true; circle_vtx_builds = true;
} }
if (amin > amax) return;
if (tris) if (radius == 0.0f)
{ {
ReserveVertices((unsigned int)(a_max-a_min) * 3); path.push_back(centre);
for (int a = a_min; a < a_max; a++)
{
AddVtx(center + circle_vtx[a % IM_ARRAYSIZE(circle_vtx)] * rad, col);
AddVtx(center + circle_vtx[(a+1) % IM_ARRAYSIZE(circle_vtx)] * rad, col);
AddVtx(center + third_point_offset, col);
}
} }
else else
{ {
ReserveVertices((unsigned int)(a_max-a_min) * 6); for (int a = amin; a <= amax; a++)
for (int a = a_min; a < a_max; a++) path.push_back(centre + circle_vtx[a % circle_vtx_count] * radius);
AddVtxLine(center + circle_vtx[a % IM_ARRAYSIZE(circle_vtx)] * rad, center + circle_vtx[(a+1) % IM_ARRAYSIZE(circle_vtx)] * rad, col);
} }
} }
void ImDrawList::AddRect(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding, int rounding_corners) void ImDrawList::ArcTo(const ImVec2& centre, float radius, float amin, float amax, int num_segments)
{ {
if ((col >> 24) == 0) if (radius == 0.0f)
return;
float r = rounding;
r = ImMin(r, fabsf(b.x-a.x) * ( ((rounding_corners&(1|2))==(1|2)) || ((rounding_corners&(4|8))==(4|8)) ? 0.5f : 1.0f ));
r = ImMin(r, fabsf(b.y-a.y) * ( ((rounding_corners&(1|8))==(1|8)) || ((rounding_corners&(2|4))==(2|4)) ? 0.5f : 1.0f ));
if (r == 0.0f || rounding_corners == 0)
{ {
ReserveVertices(4*6); path.push_back(centre);
AddVtxLine(ImVec2(a.x,a.y), ImVec2(b.x,a.y), col);
AddVtxLine(ImVec2(b.x,a.y), ImVec2(b.x,b.y), col);
AddVtxLine(ImVec2(b.x,b.y), ImVec2(a.x,b.y), col);
AddVtxLine(ImVec2(a.x,b.y), ImVec2(a.x,a.y), col);
} }
else for (int i = 0; i <= num_segments; i++)
{ {
ReserveVertices(4*6); const float a = amin + ((float)i / (float)num_segments) * (amax - amin);
AddVtxLine(ImVec2(a.x + ((rounding_corners & 1)?r:0), a.y), ImVec2(b.x - ((rounding_corners & 2)?r:0), a.y), col); path.push_back(centre + ImVec2(cosf(a + PI) * radius, sinf(a + PI) * radius));
AddVtxLine(ImVec2(b.x, a.y + ((rounding_corners & 2)?r:0)), ImVec2(b.x, b.y - ((rounding_corners & 4)?r:0)), col);
AddVtxLine(ImVec2(b.x - ((rounding_corners & 4)?r:0), b.y), ImVec2(a.x + ((rounding_corners & 8)?r:0), b.y), col);
AddVtxLine(ImVec2(a.x, b.y - ((rounding_corners & 8)?r:0)), ImVec2(a.x, a.y + ((rounding_corners & 1)?r:0)), col);
if (rounding_corners & 1) AddArc(ImVec2(a.x+r,a.y+r), r, col, 0, 3);
if (rounding_corners & 2) AddArc(ImVec2(b.x-r,a.y+r), r, col, 3, 6);
if (rounding_corners & 4) AddArc(ImVec2(b.x-r,b.y-r), r, col, 6, 9);
if (rounding_corners & 8) AddArc(ImVec2(a.x+r,b.y-r), r, col, 9, 12);
} }
} }
void ImDrawList::AddRectFilled(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding, int rounding_corners) void ImDrawList::Fill(ImU32 col)
{ {
if ((col >> 24) == 0) AddConvexPolyFilled(&path[0], path.size(), col);
return; ClearPath();
}
void ImDrawList::Stroke(ImU32 col, bool closed)
{
// Remove duplicates
AddPolyline(&path[0], path.size(), col, closed);
ClearPath();
}
void ImDrawList::Rect(const ImVec2& a, const ImVec2& b, float rounding, int rounding_corners)
{
float r = rounding; float r = rounding;
r = ImMin(r, fabsf(b.x-a.x) * ( ((rounding_corners&(1|2))==(1|2)) || ((rounding_corners&(4|8))==(4|8)) ? 0.5f : 1.0f )); r = ImMin(r, fabsf(b.x-a.x) * ( ((rounding_corners&(1|2))==(1|2)) || ((rounding_corners&(4|8))==(4|8)) ? 0.5f : 1.0f ));
r = ImMin(r, fabsf(b.y-a.y) * ( ((rounding_corners&(1|8))==(1|8)) || ((rounding_corners&(2|4))==(2|4)) ? 0.5f : 1.0f )); r = ImMin(r, fabsf(b.y-a.y) * ( ((rounding_corners&(1|8))==(1|8)) || ((rounding_corners&(2|4))==(2|4)) ? 0.5f : 1.0f ));
if (r == 0.0f || rounding_corners == 0) if (r == 0.0f || rounding_corners == 0)
{ {
// Use triangle so we can merge more draw calls together (at the cost of extra vertices) LineTo(ImVec2(a.x,a.y));
ReserveVertices(6); LineTo(ImVec2(b.x,a.y));
AddVtx(ImVec2(a.x,a.y), col); LineTo(ImVec2(b.x,b.y));
AddVtx(ImVec2(b.x,a.y), col); LineTo(ImVec2(a.x,b.y));
AddVtx(ImVec2(b.x,b.y), col);
AddVtx(ImVec2(a.x,a.y), col);
AddVtx(ImVec2(b.x,b.y), col);
AddVtx(ImVec2(a.x,b.y), col);
} }
else else
{ {
ReserveVertices(6+6*2); const float r0 = (rounding_corners & 1) ? r : 0.0f;
AddVtx(ImVec2(a.x+r,a.y), col); const float r1 = (rounding_corners & 2) ? r : 0.0f;
AddVtx(ImVec2(b.x-r,a.y), col); const float r2 = (rounding_corners & 4) ? r : 0.0f;
AddVtx(ImVec2(b.x-r,b.y), col); const float r3 = (rounding_corners & 8) ? r : 0.0f;
AddVtx(ImVec2(a.x+r,a.y), col); ArcToFast(ImVec2(a.x+r0,a.y+r0), r0, 0, 3);
AddVtx(ImVec2(b.x-r,b.y), col); ArcToFast(ImVec2(b.x-r1,a.y+r1), r1, 3, 6);
AddVtx(ImVec2(a.x+r,b.y), col); ArcToFast(ImVec2(b.x-r2,b.y-r2), r2, 6, 9);
ArcToFast(ImVec2(a.x+r3,b.y-r3), r3, 9, 12);
float top_y = (rounding_corners & 1) ? a.y+r : a.y;
float bot_y = (rounding_corners & 8) ? b.y-r : b.y;
AddVtx(ImVec2(a.x,top_y), col);
AddVtx(ImVec2(a.x+r,top_y), col);
AddVtx(ImVec2(a.x+r,bot_y), col);
AddVtx(ImVec2(a.x,top_y), col);
AddVtx(ImVec2(a.x+r,bot_y), col);
AddVtx(ImVec2(a.x,bot_y), col);
top_y = (rounding_corners & 2) ? a.y+r : a.y;
bot_y = (rounding_corners & 4) ? b.y-r : b.y;
AddVtx(ImVec2(b.x-r,top_y), col);
AddVtx(ImVec2(b.x,top_y), col);
AddVtx(ImVec2(b.x,bot_y), col);
AddVtx(ImVec2(b.x-r,top_y), col);
AddVtx(ImVec2(b.x,bot_y), col);
AddVtx(ImVec2(b.x-r,bot_y), col);
if (rounding_corners & 1) AddArc(ImVec2(a.x+r,a.y+r), r, col, 0, 3, true);
if (rounding_corners & 2) AddArc(ImVec2(b.x-r,a.y+r), r, col, 3, 6, true);
if (rounding_corners & 4) AddArc(ImVec2(b.x-r,b.y-r), r, col, 6, 9, true);
if (rounding_corners & 8) AddArc(ImVec2(a.x+r,b.y-r), r, col, 9, 12,true);
} }
} }
void ImDrawList::AddTriangleFilled(const ImVec2& a, const ImVec2& b, const ImVec2& c, ImU32 col) void ImDrawList::AddLine(const ImVec2& a, const ImVec2& b, ImU32 col)
{ {
if ((col >> 24) == 0) if ((col >> 24) == 0)
return; return;
LineTo(a);
LineTo(b);
Stroke(col);
}
ReserveVertices(3); void ImDrawList::AddRect(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding, int rounding_corners)
AddVtx(a, col); {
AddVtx(b, col); if ((col >> 24) == 0)
AddVtx(c, col); return;
Rect(a, b, rounding, rounding_corners);
Stroke(col, true);
} }
void ImDrawList::AddCircle(const ImVec2& centre, float radius, ImU32 col, int num_segments) void ImDrawList::AddRectFilled(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding, int rounding_corners)
{ {
if ((col >> 24) == 0) if ((col >> 24) == 0)
return; return;
Rect(a, b, rounding, rounding_corners);
Fill(col);
}
ReserveVertices((unsigned int)num_segments*6); void ImDrawList::AddTriangleFilled(const ImVec2& a, const ImVec2& b, const ImVec2& c, ImU32 col)
const float a_step = 2*PI/(float)num_segments; {
float a0 = 0.0f; if ((col >> 24) == 0)
for (int i = 0; i < num_segments; i++) return;
{ LineTo(a);
const float a1 = (i + 1) == num_segments ? 0.0f : a0 + a_step; LineTo(b);
AddVtxLine(centre + ImVec2(cosf(a0), sinf(a0))*radius, centre + ImVec2(cosf(a1), sinf(a1))*radius, col); LineTo(c);
a0 = a1; Fill(col);
}
} }
void ImDrawList::AddCircleFilled(const ImVec2& centre, float radius, ImU32 col, int num_segments) void ImDrawList::AddCircle(const ImVec2& centre, float radius, ImU32 col, int num_segments)
{ {
if ((col >> 24) == 0) if ((col >> 24) == 0)
return; return;
ArcTo(centre, radius, 0.0f, PI*2, num_segments);
Stroke(col, true);
}
ReserveVertices((unsigned int)num_segments*3); void ImDrawList::AddCircleFilled(const ImVec2& centre, float radius, ImU32 col, int num_segments)
const float a_step = 2*PI/(float)num_segments; {
float a0 = 0.0f; if ((col >> 24) == 0)
for (int i = 0; i < num_segments; i++) return;
{ ArcTo(centre, radius, 0.0f, PI*2, num_segments);
const float a1 = (i + 1) == num_segments ? 0.0f : a0 + a_step; Fill(col);
AddVtx(centre + ImVec2(cosf(a0), sinf(a0))*radius, col);
AddVtx(centre + ImVec2(cosf(a1), sinf(a1))*radius, col);
AddVtx(centre, col);
a0 = a1;
}
} }
void ImDrawList::AddText(ImFont* font, float font_size, const ImVec2& pos, ImU32 col, const char* text_begin, const char* text_end, float wrap_width, const ImVec2* cpu_clip_max) void ImDrawList::AddText(ImFont* font, float font_size, const ImVec2& pos, ImU32 col, const char* text_begin, const char* text_end, float wrap_width, const ImVec2* cpu_clip_max)

13
imgui.h
Unescape View File

@ -831,6 +831,7 @@ struct ImDrawList
ImVector<ImVec4> clip_rect_stack; // [Internal] ImVector<ImVec4> clip_rect_stack; // [Internal]
ImVector<ImTextureID> texture_id_stack; // [Internal] ImVector<ImTextureID> texture_id_stack; // [Internal]
ImDrawVert* vtx_write; // [Internal] point within vtx_buffer after each add command (to avoid using the ImVector<> operators too much) ImDrawVert* vtx_write; // [Internal] point within vtx_buffer after each add command (to avoid using the ImVector<> operators too much)
ImVector<ImVec2> path; // [Internal]
ImDrawList() { Clear(); } ImDrawList() { Clear(); }
IMGUI_API void Clear(); IMGUI_API void Clear();
@ -839,6 +840,15 @@ struct ImDrawList
IMGUI_API void PushTextureID(const ImTextureID& texture_id); IMGUI_API void PushTextureID(const ImTextureID& texture_id);
IMGUI_API void PopTextureID(); IMGUI_API void PopTextureID();
// Stateful path API (finish with Fill or Stroke)
IMGUI_API void ClearPath();
IMGUI_API void LineTo(const ImVec2& p);
IMGUI_API void ArcToFast(const ImVec2& centre, float radius, int a_min, int a_max);
IMGUI_API void ArcTo(const ImVec2& centre, float radius, float a_min, float a_max, int num_segments = 12);
IMGUI_API void Rect(const ImVec2& a, const ImVec2& b, float rounding = 0.0f, int rounding_corners = 0x0F);
IMGUI_API void Fill(ImU32 col);
IMGUI_API void Stroke(ImU32 col, bool closed = false);
// Primitives // Primitives
IMGUI_API void AddLine(const ImVec2& a, const ImVec2& b, ImU32 col); IMGUI_API void AddLine(const ImVec2& a, const ImVec2& b, ImU32 col);
IMGUI_API void AddRect(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding = 0.0f, int rounding_corners=0x0F); IMGUI_API void AddRect(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding = 0.0f, int rounding_corners=0x0F);
@ -846,9 +856,10 @@ struct ImDrawList
IMGUI_API void AddTriangleFilled(const ImVec2& a, const ImVec2& b, const ImVec2& c, ImU32 col); IMGUI_API void AddTriangleFilled(const ImVec2& a, const ImVec2& b, const ImVec2& c, ImU32 col);
IMGUI_API void AddCircle(const ImVec2& centre, float radius, ImU32 col, int num_segments = 12); IMGUI_API void AddCircle(const ImVec2& centre, float radius, ImU32 col, int num_segments = 12);
IMGUI_API void AddCircleFilled(const ImVec2& centre, float radius, ImU32 col, int num_segments = 12); IMGUI_API void AddCircleFilled(const ImVec2& centre, float radius, ImU32 col, int num_segments = 12);
IMGUI_API void AddArc(const ImVec2& center, float rad, ImU32 col, int a_min, int a_max, bool tris = false, const ImVec2& third_point_offset = ImVec2(0,0));
IMGUI_API void AddText(ImFont* font, float font_size, const ImVec2& pos, ImU32 col, const char* text_begin, const char* text_end = NULL, float wrap_width = 0.0f, const ImVec2* cpu_clip_max = NULL); IMGUI_API void AddText(ImFont* font, float font_size, const ImVec2& pos, ImU32 col, const char* text_begin, const char* text_end = NULL, float wrap_width = 0.0f, const ImVec2* cpu_clip_max = NULL);
IMGUI_API void AddImage(ImTextureID user_texture_id, const ImVec2& a, const ImVec2& b, const ImVec2& uv0, const ImVec2& uv1, ImU32 col = 0xFFFFFFFF); IMGUI_API void AddImage(ImTextureID user_texture_id, const ImVec2& a, const ImVec2& b, const ImVec2& uv0, const ImVec2& uv1, ImU32 col = 0xFFFFFFFF);
IMGUI_API void AddPolyline(const ImVec2* points, const int num_points, ImU32 col, bool closed);
IMGUI_API void AddConvexPolyFilled(const ImVec2* points, const int num_points, ImU32 col);
// Advanced // Advanced
IMGUI_API void AddCallback(ImDrawCallback callback, void* callback_data); // Your rendering function must check for 'user_callback' in ImDrawCmd and call the function instead of rendering triangles. IMGUI_API void AddCallback(ImDrawCallback callback, void* callback_data); // Your rendering function must check for 'user_callback' in ImDrawCmd and call the function instead of rendering triangles.

Write Preview
Loading…
Cancel
Save