ImDrawList Struct Reference

#include <src/imgui/imgui.h>

Collaboration diagram for ImDrawList:

Public Member Functions
	ImDrawList (const ImDrawListSharedData *shared_data)
	~ImDrawList ()
IMGUI_API void	PushClipRect (ImVec2 clip_rect_min, ImVec2 clip_rect_max, bool intersect_with_current_clip_rect=false)
IMGUI_API void	PushClipRectFullScreen ()
IMGUI_API void	PopClipRect ()
IMGUI_API void	PushTextureID (ImTextureID texture_id)
IMGUI_API void	PopTextureID ()
ImVec2	GetClipRectMin () const
ImVec2	GetClipRectMax () const
IMGUI_API void	AddLine (const ImVec2 &p1, const ImVec2 &p2, ImU32 col, float thickness=1.0f)
IMGUI_API void	AddRect (const ImVec2 &p_min, const ImVec2 &p_max, ImU32 col, float rounding=0.0f, ImDrawFlags flags=0, float thickness=1.0f)
IMGUI_API void	AddRectFilled (const ImVec2 &p_min, const ImVec2 &p_max, ImU32 col, float rounding=0.0f, ImDrawFlags flags=0)
IMGUI_API void	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)
IMGUI_API void	AddQuad (const ImVec2 &p1, const ImVec2 &p2, const ImVec2 &p3, const ImVec2 &p4, ImU32 col, float thickness=1.0f)
IMGUI_API void	AddQuadFilled (const ImVec2 &p1, const ImVec2 &p2, const ImVec2 &p3, const ImVec2 &p4, ImU32 col)
IMGUI_API void	AddTriangle (const ImVec2 &p1, const ImVec2 &p2, const ImVec2 &p3, ImU32 col, float thickness=1.0f)
IMGUI_API void	AddTriangleFilled (const ImVec2 &p1, const ImVec2 &p2, const ImVec2 &p3, ImU32 col)
IMGUI_API void	AddCircle (const ImVec2 &center, float radius, ImU32 col, int num_segments=0, float thickness=1.0f)
IMGUI_API void	AddCircleFilled (const ImVec2 &center, float radius, ImU32 col, int num_segments=0)
IMGUI_API void	AddNgon (const ImVec2 &center, float radius, ImU32 col, int num_segments, float thickness=1.0f)
IMGUI_API void	AddNgonFilled (const ImVec2 &center, float radius, ImU32 col, int num_segments)
IMGUI_API void	AddText (const ImVec2 &pos, ImU32 col, const char *text_begin, const char *text_end=NULL)
IMGUI_API void	AddText (const 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 ImVec4 *cpu_fine_clip_rect=NULL)
IMGUI_API void	AddPolyline (const ImVec2 *points, int num_points, ImU32 col, ImDrawFlags flags, float thickness)
IMGUI_API void	AddConvexPolyFilled (const ImVec2 *points, int num_points, ImU32 col)
IMGUI_API void	AddBezierCubic (const ImVec2 &p1, const ImVec2 &p2, const ImVec2 &p3, const ImVec2 &p4, ImU32 col, float thickness, int num_segments=0)
IMGUI_API void	AddBezierQuadratic (const ImVec2 &p1, const ImVec2 &p2, const ImVec2 &p3, ImU32 col, float thickness, int num_segments=0)
IMGUI_API void	AddImage (ImTextureID user_texture_id, const ImVec2 &p_min, const ImVec2 &p_max, const ImVec2 &uv_min=ImVec2(0, 0), const ImVec2 &uv_max=ImVec2(1, 1), ImU32 col=IM_COL32_WHITE)
IMGUI_API void	AddImageQuad (ImTextureID user_texture_id, const ImVec2 &p1, const ImVec2 &p2, const ImVec2 &p3, const ImVec2 &p4, const ImVec2 &uv1=ImVec2(0, 0), const ImVec2 &uv2=ImVec2(1, 0), const ImVec2 &uv3=ImVec2(1, 1), const ImVec2 &uv4=ImVec2(0, 1), ImU32 col=IM_COL32_WHITE)
IMGUI_API void	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, ImDrawFlags flags=0)
void	PathClear ()
void	PathLineTo (const ImVec2 &pos)
void	PathLineToMergeDuplicate (const ImVec2 &pos)
void	PathFillConvex (ImU32 col)
void	PathStroke (ImU32 col, ImDrawFlags flags=0, float thickness=1.0f)
IMGUI_API void	PathArcTo (const ImVec2 &center, float radius, float a_min, float a_max, int num_segments=0)
IMGUI_API void	PathArcToFast (const ImVec2 &center, float radius, int a_min_of_12, int a_max_of_12)
IMGUI_API void	PathBezierCubicCurveTo (const ImVec2 &p2, const ImVec2 &p3, const ImVec2 &p4, int num_segments=0)
IMGUI_API void	PathBezierQuadraticCurveTo (const ImVec2 &p2, const ImVec2 &p3, int num_segments=0)
IMGUI_API void	PathRect (const ImVec2 &rect_min, const ImVec2 &rect_max, float rounding=0.0f, ImDrawFlags flags=0)
IMGUI_API void	AddCallback (ImDrawCallback callback, void *callback_data)
IMGUI_API void	AddDrawCmd ()
IMGUI_API ImDrawList *	CloneOutput () const
void	ChannelsSplit (int count)
void	ChannelsMerge ()
void	ChannelsSetCurrent (int n)
IMGUI_API void	PrimReserve (int idx_count, int vtx_count)
IMGUI_API void	PrimUnreserve (int idx_count, int vtx_count)
IMGUI_API void	PrimRect (const ImVec2 &a, const ImVec2 &b, ImU32 col)
IMGUI_API void	PrimRectUV (const ImVec2 &a, const ImVec2 &b, const ImVec2 &uv_a, const ImVec2 &uv_b, ImU32 col)
IMGUI_API void	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)
void	PrimWriteVtx (const ImVec2 &pos, const ImVec2 &uv, ImU32 col)
void	PrimWriteIdx (ImDrawIdx idx)
void	PrimVtx (const ImVec2 &pos, const ImVec2 &uv, ImU32 col)
void	AddBezierCurve (const ImVec2 &p1, const ImVec2 &p2, const ImVec2 &p3, const ImVec2 &p4, ImU32 col, float thickness, int num_segments=0)
void	PathBezierCurveTo (const ImVec2 &p2, const ImVec2 &p3, const ImVec2 &p4, int num_segments=0)
IMGUI_API void	_ResetForNewFrame ()
IMGUI_API void	_ClearFreeMemory ()
IMGUI_API void	_PopUnusedDrawCmd ()
IMGUI_API void	_OnChangedClipRect ()
IMGUI_API void	_OnChangedTextureID ()
IMGUI_API void	_OnChangedVtxOffset ()
IMGUI_API int	_CalcCircleAutoSegmentCount (float radius) const
IMGUI_API void	_PathArcToFastEx (const ImVec2 &center, float radius, int a_min_sample, int a_max_sample, int a_step)
IMGUI_API void	_PathArcToN (const ImVec2 &center, float radius, float a_min, float a_max, int num_segments)

Public Attributes
ImVector< ImDrawCmd >	CmdBuffer
ImVector< ImDrawIdx >	IdxBuffer
ImVector< ImDrawVert >	VtxBuffer
ImDrawListFlags	Flags
unsigned int	_VtxCurrentIdx
const ImDrawListSharedData *	_Data
const char *	_OwnerName
ImDrawVert *	_VtxWritePtr
ImDrawIdx *	_IdxWritePtr
ImVector< ImVec4 >	_ClipRectStack
ImVector< ImTextureID >	_TextureIdStack
ImVector< ImVec2 >	_Path
ImDrawCmdHeader	_CmdHeader
ImDrawListSplitter	_Splitter
float	_FringeScale

Detailed Description

Constructor & Destructor Documentation

ImDrawList()

ImDrawList::ImDrawList ( const ImDrawListSharedData *  shared_data )

inline

{ memset(this, 0, sizeof(*this)); _Data = shared_data; }

~ImDrawList()

ImDrawList::~ImDrawList ( )

inline

{ _ClearFreeMemory(); }

Member Function Documentation

_CalcCircleAutoSegmentCount()

int ImDrawList::_CalcCircleAutoSegmentCount

(

float

radius

)

const

{
    // Automatic segment count
    const int radius_idx = (int)(radius + 0.999999f); // ceil to never reduce accuracy
    if (radius_idx < IM_ARRAYSIZE(_Data->CircleSegmentCounts))
        return _Data->CircleSegmentCounts[radius_idx]; // Use cached value
    else
        return IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC(radius, _Data->CircleSegmentMaxError);
}

References _Data, ImDrawListSharedData::CircleSegmentCounts, ImDrawListSharedData::CircleSegmentMaxError, IM_ARRAYSIZE, and IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC.

Referenced by _PathArcToFastEx(), AddCircle(), AddCircleFilled(), PathArcTo(), and ImGui::ShowStyleEditor().

Here is the caller graph for this function:

_ClearFreeMemory()

void ImDrawList::_ClearFreeMemory

(

)

{
    CmdBuffer.clear();
    IdxBuffer.clear();
    VtxBuffer.clear();
    Flags = ImDrawListFlags_None;
    _VtxCurrentIdx = 0;
    _VtxWritePtr = NULL;
    _IdxWritePtr = NULL;
    _ClipRectStack.clear();
    _TextureIdStack.clear();
    _Path.clear();
    _Splitter.ClearFreeMemory();
}

References _ClipRectStack, _IdxWritePtr, _Path, _Splitter, _TextureIdStack, _VtxCurrentIdx, _VtxWritePtr, ImVector< T >::clear(), ImDrawListSplitter::ClearFreeMemory(), CmdBuffer, Flags, IdxBuffer, ImDrawListFlags_None, and VtxBuffer.

Referenced by ImGui::GcCompactTransientWindowBuffers().

Here is the call graph for this function:

Here is the caller graph for this function:

_OnChangedClipRect()

void ImDrawList::_OnChangedClipRect

(

)

{
    // If current command is used with different settings we need to add a new command
    ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
    if (curr_cmd->ElemCount != 0 && memcmp(&curr_cmd->ClipRect, &_CmdHeader.ClipRect, sizeof(ImVec4)) != 0)
    {
        AddDrawCmd();
        return;
    }
    IM_ASSERT(curr_cmd->UserCallback == NULL);
 
    // Try to merge with previous command if it matches, else use current command
    ImDrawCmd* prev_cmd = curr_cmd - 1;
    if (curr_cmd->ElemCount == 0 && CmdBuffer.Size > 1 && ImDrawCmd_HeaderCompare(&_CmdHeader, prev_cmd) == 0 && prev_cmd->UserCallback == NULL)
    {
        CmdBuffer.pop_back();
        return;
    }
 
    curr_cmd->ClipRect = _CmdHeader.ClipRect;
}

References _CmdHeader, AddDrawCmd(), ImDrawCmd::ClipRect, ImDrawCmdHeader::ClipRect, CmdBuffer, ImVector< T >::Data, ImDrawCmd::ElemCount, IM_ASSERT, ImDrawCmd_HeaderCompare, ImVector< T >::pop_back(), ImVector< T >::Size, and ImDrawCmd::UserCallback.

Referenced by PopClipRect(), and PushClipRect().

Here is the call graph for this function:

Here is the caller graph for this function:

_OnChangedTextureID()

void ImDrawList::_OnChangedTextureID

(

)

{
    // If current command is used with different settings we need to add a new command
    ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
    if (curr_cmd->ElemCount != 0 && curr_cmd->TextureId != _CmdHeader.TextureId)
    {
        AddDrawCmd();
        return;
    }
    IM_ASSERT(curr_cmd->UserCallback == NULL);
 
    // Try to merge with previous command if it matches, else use current command
    ImDrawCmd* prev_cmd = curr_cmd - 1;
    if (curr_cmd->ElemCount == 0 && CmdBuffer.Size > 1 && ImDrawCmd_HeaderCompare(&_CmdHeader, prev_cmd) == 0 && prev_cmd->UserCallback == NULL)
    {
        CmdBuffer.pop_back();
        return;
    }
 
    curr_cmd->TextureId = _CmdHeader.TextureId;
}

References _CmdHeader, AddDrawCmd(), CmdBuffer, ImVector< T >::Data, ImDrawCmd::ElemCount, IM_ASSERT, ImDrawCmd_HeaderCompare, ImVector< T >::pop_back(), ImVector< T >::Size, ImDrawCmd::TextureId, ImDrawCmdHeader::TextureId, and ImDrawCmd::UserCallback.

Referenced by PopTextureID(), and PushTextureID().

Here is the call graph for this function:

Here is the caller graph for this function:

_OnChangedVtxOffset()

void ImDrawList::_OnChangedVtxOffset

(

)

{
    // We don't need to compare curr_cmd->VtxOffset != _CmdHeader.VtxOffset because we know it'll be different at the time we call this.
    _VtxCurrentIdx = 0;
    ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
    //IM_ASSERT(curr_cmd->VtxOffset != _CmdHeader.VtxOffset); // See #3349
    if (curr_cmd->ElemCount != 0)
    {
        AddDrawCmd();
        return;
    }
    IM_ASSERT(curr_cmd->UserCallback == NULL);
    curr_cmd->VtxOffset = _CmdHeader.VtxOffset;
}

References _CmdHeader, _VtxCurrentIdx, AddDrawCmd(), CmdBuffer, ImVector< T >::Data, ImDrawCmd::ElemCount, IM_ASSERT, ImVector< T >::Size, ImDrawCmd::UserCallback, ImDrawCmd::VtxOffset, and ImDrawCmdHeader::VtxOffset.

Referenced by PrimReserve().

Here is the call graph for this function:

Here is the caller graph for this function:

_PathArcToFastEx()

void ImDrawList::_PathArcToFastEx	(	const ImVec2 &	center,
		float	radius,
		int	a_min_sample,
		int	a_max_sample,
		int	a_step
	)

{
    if (radius <= 0.0f)
    {
        _Path.push_back(center);
        return;
    }
 
    // Calculate arc auto segment step size
    if (a_step <= 0)
        a_step = IM_DRAWLIST_ARCFAST_SAMPLE_MAX / _CalcCircleAutoSegmentCount(radius);
 
    // Make sure we never do steps larger than one quarter of the circle
    a_step = ImClamp(a_step, 1, IM_DRAWLIST_ARCFAST_TABLE_SIZE / 4);
 
    const int sample_range = ImAbs(a_max_sample - a_min_sample);
    const int a_next_step = a_step;
 
    int samples = sample_range + 1;
    bool extra_max_sample = false;
    if (a_step > 1)
    {
        samples            = sample_range / a_step + 1;
        const int overstep = sample_range % a_step;
 
        if (overstep > 0)
        {
            extra_max_sample = true;
            samples++;
 
            // When we have overstep to avoid awkwardly looking one long line and one tiny one at the end,
            // distribute first step range evenly between them by reducing first step size.
            if (sample_range > 0)
                a_step -= (a_step - overstep) / 2;
        }
    }
 
    _Path.resize(_Path.Size + samples);
    ImVec2* out_ptr = _Path.Data + (_Path.Size - samples);
 
    int sample_index = a_min_sample;
    if (sample_index < 0 || sample_index >= IM_DRAWLIST_ARCFAST_SAMPLE_MAX)
    {
        sample_index = sample_index % IM_DRAWLIST_ARCFAST_SAMPLE_MAX;
        if (sample_index < 0)
            sample_index += IM_DRAWLIST_ARCFAST_SAMPLE_MAX;
    }
 
    if (a_max_sample >= a_min_sample)
    {
        for (int a = a_min_sample; a <= a_max_sample; a += a_step, sample_index += a_step, a_step = a_next_step)
        {
            // a_step is clamped to IM_DRAWLIST_ARCFAST_SAMPLE_MAX, so we have guaranteed that it will not wrap over range twice or more
            if (sample_index >= IM_DRAWLIST_ARCFAST_SAMPLE_MAX)
                sample_index -= IM_DRAWLIST_ARCFAST_SAMPLE_MAX;
 
            const ImVec2 s = _Data->ArcFastVtx[sample_index];
            out_ptr->x = center.x + s.x * radius;
            out_ptr->y = center.y + s.y * radius;
            out_ptr++;
        }
    }
    else
    {
        for (int a = a_min_sample; a >= a_max_sample; a -= a_step, sample_index -= a_step, a_step = a_next_step)
        {
            // a_step is clamped to IM_DRAWLIST_ARCFAST_SAMPLE_MAX, so we have guaranteed that it will not wrap over range twice or more
            if (sample_index < 0)
                sample_index += IM_DRAWLIST_ARCFAST_SAMPLE_MAX;
 
            const ImVec2 s = _Data->ArcFastVtx[sample_index];
            out_ptr->x = center.x + s.x * radius;
            out_ptr->y = center.y + s.y * radius;
            out_ptr++;
        }
    }
 
    if (extra_max_sample)
    {
        int normalized_max_sample = a_max_sample % IM_DRAWLIST_ARCFAST_SAMPLE_MAX;
        if (normalized_max_sample < 0)
            normalized_max_sample += IM_DRAWLIST_ARCFAST_SAMPLE_MAX;
 
        const ImVec2 s = _Data->ArcFastVtx[normalized_max_sample];
        out_ptr->x = center.x + s.x * radius;
        out_ptr->y = center.y + s.y * radius;
        out_ptr++;
    }
 
    IM_ASSERT_PARANOID(_Path.Data + _Path.Size == out_ptr);
}

References _CalcCircleAutoSegmentCount(), _Data, _Path, ImDrawListSharedData::ArcFastVtx, ImVector< T >::Data, IM_ASSERT_PARANOID, IM_DRAWLIST_ARCFAST_SAMPLE_MAX, IM_DRAWLIST_ARCFAST_TABLE_SIZE, ImAbs(), ImClamp(), ImVector< T >::push_back(), ImVector< T >::resize(), ImVector< T >::Size, ImVec2::x, and ImVec2::y.

Referenced by PathArcTo(), and PathArcToFast().

Here is the call graph for this function:

Here is the caller graph for this function:

_PathArcToN()

void ImDrawList::_PathArcToN	(	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));
    }
}

References _Path, ImCos, ImSin, ImVector< T >::push_back(), ImVector< T >::reserve(), ImVector< T >::Size, ImVec2::x, and ImVec2::y.

Referenced by PathArcTo().

Here is the call graph for this function:

Here is the caller graph for this function:

_PopUnusedDrawCmd()

void ImDrawList::_PopUnusedDrawCmd

(

)

{
    if (CmdBuffer.Size == 0)
        return;
    ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
    if (curr_cmd->ElemCount == 0 && curr_cmd->UserCallback == NULL)
        CmdBuffer.pop_back();
}

References CmdBuffer, ImVector< T >::Data, ImDrawCmd::ElemCount, ImVector< T >::pop_back(), ImVector< T >::Size, and ImDrawCmd::UserCallback.

Referenced by AddDrawListToDrawData(), and ImDrawListSplitter::Merge().

Here is the call graph for this function:

Here is the caller graph for this function:

_ResetForNewFrame()

void ImDrawList::_ResetForNewFrame

(

)

{
    // Verify that the ImDrawCmd fields we want to memcmp() are contiguous in memory.
    // (those should be IM_STATIC_ASSERT() in theory but with our pre C++11 setup the whole check doesn't compile with GCC)
    IM_ASSERT(IM_OFFSETOF(ImDrawCmd, ClipRect) == 0);
    IM_ASSERT(IM_OFFSETOF(ImDrawCmd, TextureId) == sizeof(ImVec4));
    IM_ASSERT(IM_OFFSETOF(ImDrawCmd, VtxOffset) == sizeof(ImVec4) + sizeof(ImTextureID));
 
    CmdBuffer.resize(0);
    IdxBuffer.resize(0);
    VtxBuffer.resize(0);
    Flags = _Data->InitialFlags;
    memset(&_CmdHeader, 0, sizeof(_CmdHeader));
    _VtxCurrentIdx = 0;
    _VtxWritePtr = NULL;
    _IdxWritePtr = NULL;
    _ClipRectStack.resize(0);
    _TextureIdStack.resize(0);
    _Path.resize(0);
    _Splitter.Clear();
    CmdBuffer.push_back(ImDrawCmd());
    _FringeScale = 1.0f;
}

References _ClipRectStack, _CmdHeader, _Data, _FringeScale, _IdxWritePtr, _Path, _Splitter, _TextureIdStack, _VtxCurrentIdx, _VtxWritePtr, ImDrawListSplitter::Clear(), CmdBuffer, Flags, IdxBuffer, IM_ASSERT, IM_OFFSETOF, ImDrawListSharedData::InitialFlags, ImVector< T >::push_back(), ImVector< T >::resize(), and VtxBuffer.

Referenced by ImGui::Begin(), and GetViewportDrawList().

Here is the call graph for this function:

Here is the caller graph for this function:

AddBezierCubic()

void ImDrawList::AddBezierCubic	(	const ImVec2 &	p1,
		const ImVec2 &	p2,
		const ImVec2 &	p3,
		const ImVec2 &	p4,
		ImU32	col,
		float	thickness,
		int	num_segments = 0
	)

{
    if ((col & IM_COL32_A_MASK) == 0)
        return;
 
    PathLineTo(p1);
    PathBezierCubicCurveTo(p2, p3, p4, num_segments);
    PathStroke(col, 0, thickness);
}

References col(), IM_COL32_A_MASK, PathBezierCubicCurveTo(), PathLineTo(), and PathStroke().

Referenced by ShowExampleAppCustomRendering().

Here is the call graph for this function:

Here is the caller graph for this function:

AddBezierCurve()

void ImDrawList::AddBezierCurve ( const ImVec2 &  p1, const ImVec2 &  p2, const ImVec2 &  p3, const ImVec2 &  p4, ImU32  col, float  thickness, int  num_segments = 0  )

inline

{ AddBezierCubic(p1, p2, p3, p4, col, thickness, num_segments); }

References col().

Here is the call graph for this function:

AddBezierQuadratic()

void ImDrawList::AddBezierQuadratic	(	const ImVec2 &	p1,
		const ImVec2 &	p2,
		const ImVec2 &	p3,
		ImU32	col,
		float	thickness,
		int	num_segments = 0
	)

{
    if ((col & IM_COL32_A_MASK) == 0)
        return;
 
    PathLineTo(p1);
    PathBezierQuadraticCurveTo(p2, p3, num_segments);
    PathStroke(col, 0, thickness);
}

References col(), IM_COL32_A_MASK, PathBezierQuadraticCurveTo(), PathLineTo(), and PathStroke().

Referenced by ShowExampleAppCustomRendering().

Here is the call graph for this function:

Here is the caller graph for this function:

AddCallback()

void ImDrawList::AddCallback	(	ImDrawCallback	callback,
		void *	callback_data
	)

{
    ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
    IM_ASSERT(curr_cmd->UserCallback == NULL);
    if (curr_cmd->ElemCount != 0)
    {
        AddDrawCmd();
        curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
    }
    curr_cmd->UserCallback = callback;
    curr_cmd->UserCallbackData = callback_data;
 
    AddDrawCmd(); // Force a new command after us (see comment below)
}

References AddDrawCmd(), CmdBuffer, ImVector< T >::Data, ImDrawCmd::ElemCount, IM_ASSERT, ImVector< T >::Size, ImDrawCmd::UserCallback, and ImDrawCmd::UserCallbackData.

Here is the call graph for this function:

AddCircle()

void ImDrawList::AddCircle	(	const ImVec2 &	center,
		float	radius,
		ImU32	col,
		int	num_segments = 0,
		float	thickness = 1.0f
	)

{
    if ((col & IM_COL32_A_MASK) == 0 || radius <= 0.0f)
        return;
 
    // Obtain segment count
    if (num_segments <= 0)
    {
        // Automatic segment count
        num_segments = _CalcCircleAutoSegmentCount(radius);
    }
    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 - 1);
    else
        PathArcTo(center, radius - 0.5f, 0.0f, a_max, num_segments - 1);
    PathStroke(col, ImDrawFlags_Closed, thickness);
}

References _CalcCircleAutoSegmentCount(), col(), IM_COL32_A_MASK, IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MAX, IM_PI, ImClamp(), ImDrawFlags_Closed, PathArcTo(), PathArcToFast(), and PathStroke().

Referenced by ImGui::ColorPicker4(), ImGui::RadioButton(), ShowExampleAppCustomRendering(), and ImGui::ShowStyleEditor().

Here is the call graph for this function:

Here is the caller graph for this function:

AddCircleFilled()

void ImDrawList::AddCircleFilled	(	const ImVec2 &	center,
		float	radius,
		ImU32	col,
		int	num_segments = 0
	)

{
    if ((col & IM_COL32_A_MASK) == 0 || radius <= 0.0f)
        return;
 
    // Obtain segment count
    if (num_segments <= 0)
    {
        // Automatic segment count
        num_segments = _CalcCircleAutoSegmentCount(radius);
    }
    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 - 1);
    else
        PathArcTo(center, radius, 0.0f, a_max, num_segments - 1);
    PathFillConvex(col);
}

References _CalcCircleAutoSegmentCount(), col(), IM_COL32_A_MASK, IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MAX, IM_PI, ImClamp(), PathArcTo(), PathArcToFast(), and PathFillConvex().

Referenced by ImGui::CloseButton(), ImGui::CollapseButton(), ImGui::ColorPicker4(), ImGui::NavUpdate(), ImGui::RadioButton(), Slic3r::GUI::GCodeViewer::render_legend(), ImGui::RenderBullet(), and ShowExampleAppCustomRendering().

Here is the call graph for this function:

Here is the caller graph for this function:

AddConvexPolyFilled()

void ImDrawList::AddConvexPolyFilled	(	const ImVec2 *	points,
		int	num_points,
		ImU32	col
	)

{
    if (points_count < 3)
        return;
 
    const ImVec2 uv = _Data->TexUvWhitePixel;
 
    if (Flags & ImDrawListFlags_AntiAliasedFill)
    {
        // Anti-aliased Fill
        const float AA_SIZE = _FringeScale;
        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;
    }
}

References _Data, _FringeScale, _IdxWritePtr, _VtxCurrentIdx, _VtxWritePtr, col(), ImDrawVert::col, Flags, IM_FIXNORMAL2F, IM_NORMALIZE2F_OVER_ZERO, ImDrawListFlags_AntiAliasedFill, ImDrawVert::pos, PrimReserve(), ImDrawListSharedData::TexUvWhitePixel, ImDrawVert::uv, ImVec2::x, and ImVec2::y.

Here is the call graph for this function:

AddDrawCmd()

void ImDrawList::AddDrawCmd

(

)

{
    ImDrawCmd draw_cmd;
    draw_cmd.ClipRect = _CmdHeader.ClipRect;    // Same as calling ImDrawCmd_HeaderCopy()
    draw_cmd.TextureId = _CmdHeader.TextureId;
    draw_cmd.VtxOffset = _CmdHeader.VtxOffset;
    draw_cmd.IdxOffset = IdxBuffer.Size;
 
    IM_ASSERT(draw_cmd.ClipRect.x <= draw_cmd.ClipRect.z && draw_cmd.ClipRect.y <= draw_cmd.ClipRect.w);
    CmdBuffer.push_back(draw_cmd);
}

References _CmdHeader, ImDrawCmd::ClipRect, ImDrawCmdHeader::ClipRect, CmdBuffer, IdxBuffer, ImDrawCmd::IdxOffset, IM_ASSERT, ImVector< T >::push_back(), ImVector< T >::Size, ImDrawCmd::TextureId, ImDrawCmdHeader::TextureId, ImDrawCmd::VtxOffset, ImDrawCmdHeader::VtxOffset, ImVec4::w, ImVec4::x, ImVec4::y, and ImVec4::z.

Referenced by _OnChangedClipRect(), _OnChangedTextureID(), _OnChangedVtxOffset(), AddCallback(), ImDrawListSplitter::Merge(), and ImDrawListSplitter::SetCurrentChannel().

Here is the call graph for this function:

Here is the caller graph for this function:

AddImage()

void ImDrawList::AddImage	(	ImTextureID	user_texture_id,
		const ImVec2 &	p_min,
		const ImVec2 &	p_max,
		const ImVec2 &	uv_min = ImVec2(0, 0),
		const ImVec2 &	uv_max = ImVec2(1, 1),
		ImU32	col = IM_COL32_WHITE
	)

{
    if ((col & IM_COL32_A_MASK) == 0)
        return;
 
    const bool push_texture_id = user_texture_id != _CmdHeader.TextureId;
    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();
}

References _CmdHeader, col(), IM_COL32_A_MASK, PopTextureID(), PrimRectUV(), PrimReserve(), PushTextureID(), and ImDrawCmdHeader::TextureId.

Referenced by AddImageRounded(), Slic3r::GUI::ImGuiWrapper::draw_icon(), ImGui::Image(), Slic3r::GUI::image_button_ex(), ImGui::ImageButtonEx(), and ImGui::RenderMouseCursor().

Here is the call graph for this function:

Here is the caller graph for this function:

AddImageQuad()

void ImDrawList::AddImageQuad	(	ImTextureID	user_texture_id,
		const ImVec2 &	p1,
		const ImVec2 &	p2,
		const ImVec2 &	p3,
		const ImVec2 &	p4,
		const ImVec2 &	uv1 = ImVec2(0, 0),
		const ImVec2 &	uv2 = ImVec2(1, 0),
		const ImVec2 &	uv3 = ImVec2(1, 1),
		const ImVec2 &	uv4 = ImVec2(0, 1),
		ImU32	col = IM_COL32_WHITE
	)

{
    if ((col & IM_COL32_A_MASK) == 0)
        return;
 
    const bool push_texture_id = user_texture_id != _CmdHeader.TextureId;
    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();
}

References _CmdHeader, col(), IM_COL32_A_MASK, PopTextureID(), PrimQuadUV(), PrimReserve(), PushTextureID(), and ImDrawCmdHeader::TextureId.

Here is the call graph for this function:

AddImageRounded()

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,
		ImDrawFlags	flags = 0
	)

{
    if ((col & IM_COL32_A_MASK) == 0)
        return;
 
    flags = FixRectCornerFlags(flags);
    if (rounding <= 0.0f || (flags & ImDrawFlags_RoundCornersMask_) == ImDrawFlags_RoundCornersNone)
    {
        AddImage(user_texture_id, p_min, p_max, uv_min, uv_max, col);
        return;
    }
 
    const bool push_texture_id = user_texture_id != _CmdHeader.TextureId;
    if (push_texture_id)
        PushTextureID(user_texture_id);
 
    int vert_start_idx = VtxBuffer.Size;
    PathRect(p_min, p_max, rounding, flags);
    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();
}

References _CmdHeader, AddImage(), col(), FixRectCornerFlags(), IM_COL32_A_MASK, ImDrawFlags_RoundCornersMask_, ImDrawFlags_RoundCornersNone, PathFillConvex(), PathRect(), PopTextureID(), PushTextureID(), ImGui::ShadeVertsLinearUV(), ImVector< T >::Size, ImDrawCmdHeader::TextureId, and VtxBuffer.

Here is the call graph for this function:

AddLine()

void ImDrawList::AddLine	(	const ImVec2 &	p1,
		const ImVec2 &	p2,
		ImU32	col,
		float	thickness = 1.0f
	)

{
    if ((col & IM_COL32_A_MASK) == 0)
        return;
    PathLineTo(p1 + ImVec2(0.5f, 0.5f));
    PathLineTo(p2 + ImVec2(0.5f, 0.5f));
    PathStroke(col, 0, thickness);
}

References col(), IM_COL32_A_MASK, PathLineTo(), and PathStroke().

Referenced by ImGui::BeginTabBarEx(), ImGui::CloseButton(), ImGui::DebugNodeTabBar(), Slic3r::GUI::ImGuiWrapper::draw(), ImGui::EndColumns(), ImGui::InputTextEx(), ImGui::PlotEx(), Slic3r::GUI::NotificationManager::ProgressBarNotification::render_bar(), Slic3r::GUI::NotificationManager::PopNotification::render_hypertext(), Slic3r::GUI::GCodeViewer::render_legend(), ImGui::RenderWindowDecorations(), ImGui::RenderWindowOuterBorders(), ImGui::SeparatorEx(), ShowDemoWindowMisc(), ShowExampleAppCustomRendering(), ImGui::TableDrawBorders(), and ImGui::TableEndRow().

Here is the call graph for this function:

Here is the caller graph for this function:

AddNgon()

void ImDrawList::AddNgon	(	const ImVec2 &	center,
		float	radius,
		ImU32	col,
		int	num_segments,
		float	thickness = 1.0f
	)

{
    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, ImDrawFlags_Closed, thickness);
}

References col(), IM_COL32_A_MASK, IM_PI, ImDrawFlags_Closed, PathArcTo(), and PathStroke().

Referenced by ShowExampleAppCustomRendering().

Here is the call graph for this function:

Here is the caller graph for this function:

AddNgonFilled()

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);
}

References col(), IM_COL32_A_MASK, IM_PI, PathArcTo(), and PathFillConvex().

Referenced by Slic3r::GUI::GLGizmoCut3D::render_color_marker(), Slic3r::GUI::GCodeViewer::render_legend(), and ShowExampleAppCustomRendering().

Here is the call graph for this function:

Here is the caller graph for this function:

AddPolyline()

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

{
    if (points_count < 2)
        return;
 
    const bool closed = (flags & ImDrawFlags_Closed) != 0;
    const ImVec2 opaque_uv = _Data->TexUvWhitePixel;
    const int count = closed ? points_count : points_count - 1; // The number of line segments we need to draw
    const bool thick_line = (thickness > _FringeScale);
 
    if (Flags & ImDrawListFlags_AntiAliasedLines)
    {
        // Anti-aliased stroke
        const float AA_SIZE = _FringeScale;
        const ImU32 col_trans = col & ~IM_COL32_A_MASK;
 
        // Thicknesses <1.0 should behave like thickness 1.0
        thickness = ImMax(thickness, 1.0f);
        const int integer_thickness = (int)thickness;
        const float fractional_thickness = thickness - integer_thickness;
 
        // Do we want to draw this line using a texture?
        // - For now, only draw integer-width lines using textures to avoid issues with the way scaling occurs, could be improved.
        // - If AA_SIZE is not 1.0f we cannot use the texture path.
        const bool use_texture = (Flags & ImDrawListFlags_AntiAliasedLinesUseTex) && (integer_thickness < IM_DRAWLIST_TEX_LINES_WIDTH_MAX) && (fractional_thickness <= 0.00001f) && (AA_SIZE == 1.0f);
 
        // We should never hit this, because NewFrame() doesn't set ImDrawListFlags_AntiAliasedLinesUseTex unless ImFontAtlasFlags_NoBakedLines is off
        IM_ASSERT_PARANOID(!use_texture || !(_Data->Font->ContainerAtlas->Flags & ImFontAtlasFlags_NoBakedLines));
 
        const int idx_count = use_texture ? (count * 6) : (thick_line ? count * 18 : count * 12);
        const int vtx_count = use_texture ? (points_count * 2) : (thick_line ? points_count * 4 : points_count * 3);
        PrimReserve(idx_count, vtx_count);
 
        // Temporary buffer
        // The first <points_count> items are normals at each line point, then after that there are either 2 or 4 temp points for each line point
        ImVec2* temp_normals = (ImVec2*)alloca(points_count * ((use_texture || !thick_line) ? 3 : 5) * sizeof(ImVec2)); //-V630
        ImVec2* temp_points = temp_normals + points_count;
 
        // Calculate normals (tangents) for each line segment
        for (int i1 = 0; i1 < count; i1++)
        {
            const int i2 = (i1 + 1) == points_count ? 0 : i1 + 1;
            float dx = points[i2].x - points[i1].x;
            float dy = points[i2].y - points[i1].y;
            IM_NORMALIZE2F_OVER_ZERO(dx, dy);
            temp_normals[i1].x = dy;
            temp_normals[i1].y = -dx;
        }
        if (!closed)
            temp_normals[points_count - 1] = temp_normals[points_count - 2];
 
        // If we are drawing a one-pixel-wide line without a texture, or a textured line of any width, we only need 2 or 3 vertices per point
        if (use_texture || !thick_line)
        {
            // [PATH 1] Texture-based lines (thick or non-thick)
            // [PATH 2] Non texture-based lines (non-thick)
 
            // The width of the geometry we need to draw - this is essentially <thickness> pixels for the line itself, plus "one pixel" for AA.
            // - In the texture-based path, we don't use AA_SIZE here because the +1 is tied to the generated texture
            //   (see ImFontAtlasBuildRenderLinesTexData() function), and so alternate values won't work without changes to that code.
            // - In the non texture-based paths, we would allow AA_SIZE to potentially be != 1.0f with a patch (e.g. fringe_scale patch to
            //   allow scaling geometry while preserving one-screen-pixel AA fringe).
            const float half_draw_size = use_texture ? ((thickness * 0.5f) + 1) : AA_SIZE;
 
            // If line is not closed, the first and last points need to be generated differently as there are no normals to blend
            if (!closed)
            {
                temp_points[0] = points[0] + temp_normals[0] * half_draw_size;
                temp_points[1] = points[0] - temp_normals[0] * half_draw_size;
                temp_points[(points_count-1)*2+0] = points[points_count-1] + temp_normals[points_count-1] * half_draw_size;
                temp_points[(points_count-1)*2+1] = points[points_count-1] - temp_normals[points_count-1] * half_draw_size;
            }
 
            // Generate the indices to form a number of triangles for each line segment, and the vertices for the line edges
            // This takes points n and n+1 and writes into n+1, with the first point in a closed line being generated from the final one (as n+1 wraps)
            // FIXME-OPT: Merge the different loops, possibly remove the temporary buffer.
            unsigned int idx1 = _VtxCurrentIdx; // Vertex index for start of line segment
            for (int i1 = 0; i1 < count; i1++) // i1 is the first point of the line segment
            {
                const int i2 = (i1 + 1) == points_count ? 0 : i1 + 1; // i2 is the second point of the line segment
                const unsigned int idx2 = ((i1 + 1) == points_count) ? _VtxCurrentIdx : (idx1 + (use_texture ? 2 : 3)); // Vertex index for end of segment
 
                // Average normals
                float dm_x = (temp_normals[i1].x + temp_normals[i2].x) * 0.5f;
                float dm_y = (temp_normals[i1].y + temp_normals[i2].y) * 0.5f;
                IM_FIXNORMAL2F(dm_x, dm_y);
                dm_x *= half_draw_size; // dm_x, dm_y are offset to the outer edge of the AA area
                dm_y *= half_draw_size;
 
                // Add temporary vertexes for the outer edges
                ImVec2* out_vtx = &temp_points[i2 * 2];
                out_vtx[0].x = points[i2].x + dm_x;
                out_vtx[0].y = points[i2].y + dm_y;
                out_vtx[1].x = points[i2].x - dm_x;
                out_vtx[1].y = points[i2].y - dm_y;
 
                if (use_texture)
                {
                    // Add indices for two triangles
                    _IdxWritePtr[0] = (ImDrawIdx)(idx2 + 0); _IdxWritePtr[1] = (ImDrawIdx)(idx1 + 0); _IdxWritePtr[2] = (ImDrawIdx)(idx1 + 1); // Right tri
                    _IdxWritePtr[3] = (ImDrawIdx)(idx2 + 1); _IdxWritePtr[4] = (ImDrawIdx)(idx1 + 1); _IdxWritePtr[5] = (ImDrawIdx)(idx2 + 0); // Left tri
                    _IdxWritePtr += 6;
                }
                else
                {
                    // Add indexes for four triangles
                    _IdxWritePtr[0] = (ImDrawIdx)(idx2 + 0); _IdxWritePtr[1] = (ImDrawIdx)(idx1 + 0); _IdxWritePtr[2] = (ImDrawIdx)(idx1 + 2); // Right tri 1
                    _IdxWritePtr[3] = (ImDrawIdx)(idx1 + 2); _IdxWritePtr[4] = (ImDrawIdx)(idx2 + 2); _IdxWritePtr[5] = (ImDrawIdx)(idx2 + 0); // Right tri 2
                    _IdxWritePtr[6] = (ImDrawIdx)(idx2 + 1); _IdxWritePtr[7] = (ImDrawIdx)(idx1 + 1); _IdxWritePtr[8] = (ImDrawIdx)(idx1 + 0); // Left tri 1
                    _IdxWritePtr[9] = (ImDrawIdx)(idx1 + 0); _IdxWritePtr[10] = (ImDrawIdx)(idx2 + 0); _IdxWritePtr[11] = (ImDrawIdx)(idx2 + 1); // Left tri 2
                    _IdxWritePtr += 12;
                }
 
                idx1 = idx2;
            }
 
            // Add vertexes for each point on the line
            if (use_texture)
            {
                // If we're using textures we only need to emit the left/right edge vertices
                ImVec4 tex_uvs = _Data->TexUvLines[integer_thickness];
                /*if (fractional_thickness != 0.0f) // Currently always zero when use_texture==false!
                {
                    const ImVec4 tex_uvs_1 = _Data->TexUvLines[integer_thickness + 1];
                    tex_uvs.x = tex_uvs.x + (tex_uvs_1.x - tex_uvs.x) * fractional_thickness; // inlined ImLerp()
                    tex_uvs.y = tex_uvs.y + (tex_uvs_1.y - tex_uvs.y) * fractional_thickness;
                    tex_uvs.z = tex_uvs.z + (tex_uvs_1.z - tex_uvs.z) * fractional_thickness;
                    tex_uvs.w = tex_uvs.w + (tex_uvs_1.w - tex_uvs.w) * fractional_thickness;
                }*/
                ImVec2 tex_uv0(tex_uvs.x, tex_uvs.y);
                ImVec2 tex_uv1(tex_uvs.z, tex_uvs.w);
                for (int i = 0; i < points_count; i++)
                {
                    _VtxWritePtr[0].pos = temp_points[i * 2 + 0]; _VtxWritePtr[0].uv = tex_uv0; _VtxWritePtr[0].col = col; // Left-side outer edge
                    _VtxWritePtr[1].pos = temp_points[i * 2 + 1]; _VtxWritePtr[1].uv = tex_uv1; _VtxWritePtr[1].col = col; // Right-side outer edge
                    _VtxWritePtr += 2;
                }
            }
            else
            {
                // If we're not using a texture, we need the center vertex as well
                for (int i = 0; i < points_count; i++)
                {
                    _VtxWritePtr[0].pos = points[i];              _VtxWritePtr[0].uv = opaque_uv; _VtxWritePtr[0].col = col;       // Center of line
                    _VtxWritePtr[1].pos = temp_points[i * 2 + 0]; _VtxWritePtr[1].uv = opaque_uv; _VtxWritePtr[1].col = col_trans; // Left-side outer edge
                    _VtxWritePtr[2].pos = temp_points[i * 2 + 1]; _VtxWritePtr[2].uv = opaque_uv; _VtxWritePtr[2].col = col_trans; // Right-side outer edge
                    _VtxWritePtr += 3;
                }
            }
        }
        else
        {
            // [PATH 2] Non texture-based lines (thick): we need to draw the solid line core and thus require four vertices per point
            const float half_inner_thickness = (thickness - AA_SIZE) * 0.5f;
 
            // If line is not closed, the first and last points need to be generated differently as there are no normals to blend
            if (!closed)
            {
                const int points_last = points_count - 1;
                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_last * 4 + 0] = points[points_last] + temp_normals[points_last] * (half_inner_thickness + AA_SIZE);
                temp_points[points_last * 4 + 1] = points[points_last] + temp_normals[points_last] * (half_inner_thickness);
                temp_points[points_last * 4 + 2] = points[points_last] - temp_normals[points_last] * (half_inner_thickness);
                temp_points[points_last * 4 + 3] = points[points_last] - temp_normals[points_last] * (half_inner_thickness + AA_SIZE);
            }
 
            // Generate the indices to form a number of triangles for each line segment, and the vertices for the line edges
            // This takes points n and n+1 and writes into n+1, with the first point in a closed line being generated from the final one (as n+1 wraps)
            // FIXME-OPT: Merge the different loops, possibly remove the temporary buffer.
            unsigned int idx1 = _VtxCurrentIdx; // Vertex index for start of line segment
            for (int i1 = 0; i1 < count; i1++) // i1 is the first point of the line segment
            {
                const int i2 = (i1 + 1) == points_count ? 0 : (i1 + 1); // i2 is the second point of the line segment
                const unsigned int idx2 = (i1 + 1) == points_count ? _VtxCurrentIdx : (idx1 + 4); // Vertex index for end of segment
 
                // Average normals
                float dm_x = (temp_normals[i1].x + temp_normals[i2].x) * 0.5f;
                float dm_y = (temp_normals[i1].y + temp_normals[i2].y) * 0.5f;
                IM_FIXNORMAL2F(dm_x, dm_y);
                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 vertices
                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 vertices
            for (int i = 0; i < points_count; i++)
            {
                _VtxWritePtr[0].pos = temp_points[i * 4 + 0]; _VtxWritePtr[0].uv = opaque_uv; _VtxWritePtr[0].col = col_trans;
                _VtxWritePtr[1].pos = temp_points[i * 4 + 1]; _VtxWritePtr[1].uv = opaque_uv; _VtxWritePtr[1].col = col;
                _VtxWritePtr[2].pos = temp_points[i * 4 + 2]; _VtxWritePtr[2].uv = opaque_uv; _VtxWritePtr[2].col = col;
                _VtxWritePtr[3].pos = temp_points[i * 4 + 3]; _VtxWritePtr[3].uv = opaque_uv; _VtxWritePtr[3].col = col_trans;
                _VtxWritePtr += 4;
            }
        }
        _VtxCurrentIdx += (ImDrawIdx)vtx_count;
    }
    else
    {
        // [PATH 4] Non texture-based, Non anti-aliased lines
        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 = opaque_uv; _VtxWritePtr[0].col = col;
            _VtxWritePtr[1].pos.x = p2.x + dy; _VtxWritePtr[1].pos.y = p2.y - dx; _VtxWritePtr[1].uv = opaque_uv; _VtxWritePtr[1].col = col;
            _VtxWritePtr[2].pos.x = p2.x - dy; _VtxWritePtr[2].pos.y = p2.y + dx; _VtxWritePtr[2].uv = opaque_uv; _VtxWritePtr[2].col = col;
            _VtxWritePtr[3].pos.x = p1.x - dy; _VtxWritePtr[3].pos.y = p1.y + dx; _VtxWritePtr[3].uv = opaque_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;
        }
    }
}

References _Data, _FringeScale, _IdxWritePtr, _VtxCurrentIdx, _VtxWritePtr, col(), ImDrawVert::col, ImFont::ContainerAtlas, Flags, ImFontAtlas::Flags, ImDrawListSharedData::Font, IM_ASSERT_PARANOID, IM_DRAWLIST_TEX_LINES_WIDTH_MAX, IM_FIXNORMAL2F, IM_NORMALIZE2F_OVER_ZERO, ImDrawFlags_Closed, ImDrawListFlags_AntiAliasedLines, ImDrawListFlags_AntiAliasedLinesUseTex, ImFontAtlasFlags_NoBakedLines, ImMax(), ImDrawVert::pos, PrimReserve(), ImDrawListSharedData::TexUvLines, ImDrawListSharedData::TexUvWhitePixel, ImDrawVert::uv, ImVec4::w, ImVec2::x, ImVec4::x, ImVec2::y, ImVec4::y, and ImVec4::z.

Referenced by ImGui::DebugNodeDrawCmdShowMeshAndBoundingBox(), and ImGui::DebugNodeDrawList().

Here is the call graph for this function:

Here is the caller graph for this function:

AddQuad()

void ImDrawList::AddQuad	(	const ImVec2 &	p1,
		const ImVec2 &	p2,
		const ImVec2 &	p3,
		const ImVec2 &	p4,
		ImU32	col,
		float	thickness = 1.0f
	)

{
    if ((col & IM_COL32_A_MASK) == 0)
        return;
 
    PathLineTo(p1);
    PathLineTo(p2);
    PathLineTo(p3);
    PathLineTo(p4);
    PathStroke(col, ImDrawFlags_Closed, thickness);
}

References col(), IM_COL32_A_MASK, ImDrawFlags_Closed, PathLineTo(), and PathStroke().

Here is the call graph for this function:

AddQuadFilled()

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);
}

References col(), IM_COL32_A_MASK, PathFillConvex(), and PathLineTo().

Here is the call graph for this function:

AddRect()

void ImDrawList::AddRect	(	const ImVec2 &	p_min,
		const ImVec2 &	p_max,
		ImU32	col,
		float	rounding = 0.0f,
		ImDrawFlags	flags = 0,
		float	thickness = 1.0f
	)

{
    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, flags);
    else
        PathRect(p_min + ImVec2(0.50f, 0.50f), p_max - ImVec2(0.49f, 0.49f), rounding, flags); // Better looking lower-right corner and rounded non-AA shapes.
    PathStroke(col, ImDrawFlags_Closed, thickness);
}

References col(), Flags, IM_COL32_A_MASK, ImDrawFlags_Closed, ImDrawListFlags_AntiAliasedLines, PathRect(), and PathStroke().

Referenced by ImGui::AcceptDragDropPayload(), ImGui::Begin(), ImGui::ColorButton(), ImGui::DebugDrawItemRect(), ImGui::DebugNodeDrawCmdShowMeshAndBoundingBox(), ImGui::DebugNodeDrawList(), ImGui::DebugNodeTabBar(), ImGui::DebugNodeTable(), ImGui::DebugNodeWindow(), ImGui::DebugRenderViewportThumbnail(), Slic3r::GUI::ImGuiWrapper::draw_radio_button(), ImGui::Image(), ImGui::ItemHoverable(), ImGui::NavScoreItem(), ImGui::NavUpdate(), Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::render(), Slic3r::GUI::render_extruders_combo(), ImGui::RenderFrame(), ImGui::RenderFrameBorder(), ImGui::RenderNavHighlight(), ImGui::RenderWindowOuterBorders(), ShowDemoWindowWidgets(), ShowExampleAppCustomRendering(), ShowFont(), ImGui::ShowMetricsWindow(), ImGui::TableDrawBorders(), and ImGui::TableMergeDrawChannels().

Here is the call graph for this function:

Here is the caller graph for this function:

AddRectFilled()

void ImDrawList::AddRectFilled	(	const ImVec2 &	p_min,
		const ImVec2 &	p_max,
		ImU32	col,
		float	rounding = 0.0f,
		ImDrawFlags	flags = 0
	)

{
    if ((col & IM_COL32_A_MASK) == 0)
        return;
    if (rounding <= 0.0f || (flags & ImDrawFlags_RoundCornersMask_) == ImDrawFlags_RoundCornersNone)
    {
        PrimReserve(6, 4);
        PrimRect(p_min, p_max, col);
    }
    else
    {
        PathRect(p_min, p_max, rounding, flags);
        PathFillConvex(col);
    }
}

References col(), IM_COL32_A_MASK, ImDrawFlags_RoundCornersMask_, ImDrawFlags_RoundCornersNone, PathFillConvex(), PathRect(), PrimRect(), and PrimReserve().

Referenced by ImGui::Begin(), ImGui::BeginCombo(), ImGui::Checkbox(), ImGui::ColorButton(), ImGui::DebugRenderViewportThumbnail(), Slic3r::GUI::image_button_ex(), ImGui::ImageButtonEx(), ImGui::InputTextEx(), ImGui::NavScoreItem(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), ImGui::PlotEx(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), Slic3r::GUI::render_extruders_combo(), Slic3r::GUI::GCodeViewer::render_legend(), ImGui::RenderColorRectWithAlphaCheckerboard(), ImGui::RenderFrame(), ImGui::RenderRectFilledRangeH(), ImGui::RenderRectFilledWithHole(), ImGui::RenderWindowDecorations(), ImGui::ScrollbarEx(), ShowDemoWindowLayout(), ShowDemoWindowWidgets(), ShowExampleAppCustomRendering(), ShowExampleMenuFile(), ImGui::ShowMetricsWindow(), ImGui::SliderScalar(), ImGui::SplitterBehavior(), ImGui::TableEndRow(), ImGui::TableMergeDrawChannels(), and ImGui::VSliderScalar().

Here is the call graph for this function:

Here is the caller graph for this function:

AddRectFilledMultiColor()

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);
}

References _Data, _VtxCurrentIdx, IM_COL32_A_MASK, PrimReserve(), PrimWriteIdx(), PrimWriteVtx(), ImDrawListSharedData::TexUvWhitePixel, ImVec2::x, and ImVec2::y.

Referenced by ImGui::ColorPicker4(), and ShowExampleAppCustomRendering().

Here is the call graph for this function:

Here is the caller graph for this function:

AddText() [1/2]

void ImDrawList::AddText	(	const 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 ImVec4 *	cpu_fine_clip_rect = NULL
	)

{
    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 == _CmdHeader.TextureId);  // Use high-level ImGui::PushFont() or low-level ImDrawList::PushTextureId() to change font.
 
    ImVec4 clip_rect = _CmdHeader.ClipRect;
    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);
}

References _CmdHeader, _Data, ImDrawCmdHeader::ClipRect, col(), ImFont::ContainerAtlas, ImDrawListSharedData::Font, ImDrawListSharedData::FontSize, IM_ASSERT, IM_COL32_A_MASK, ImMax(), ImMin(), ImFont::RenderText(), ImFontAtlas::TexID, ImDrawCmdHeader::TextureId, ImVec4::w, ImVec4::x, ImVec4::y, and ImVec4::z.

Here is the call graph for this function:

AddText() [2/2]

void ImDrawList::AddText	(	const ImVec2 &	pos,
		ImU32	col,
		const char *	text_begin,
		const char *	text_end = NULL
	)

{
    AddText(NULL, 0.0f, pos, col, text_begin, text_end);
}

References AddText(), and col().

Referenced by AddText(), ImGui::DebugRenderViewportThumbnail(), igl::opengl::glfw::imgui::ImGuiMenu::draw_text(), ImGui::InputTextEx(), ImGui::NavScoreItem(), ImGui::NavUpdate(), ImGui::RenderText(), ImGui::RenderTextClippedEx(), ImGui::RenderTextWrapped(), ShowDemoWindowLayout(), ImGui::ShowMetricsWindow(), and ImGui::TableMergeDrawChannels().

Here is the call graph for this function:

Here is the caller graph for this function:

AddTriangle()

void ImDrawList::AddTriangle	(	const ImVec2 &	p1,
		const ImVec2 &	p2,
		const ImVec2 &	p3,
		ImU32	col,
		float	thickness = 1.0f
	)

{
    if ((col & IM_COL32_A_MASK) == 0)
        return;
 
    PathLineTo(p1);
    PathLineTo(p2);
    PathLineTo(p3);
    PathStroke(col, ImDrawFlags_Closed, thickness);
}

References col(), IM_COL32_A_MASK, ImDrawFlags_Closed, PathLineTo(), and PathStroke().

Referenced by ImGui::ColorPicker4(), and ShowExampleAppCustomRendering().

Here is the call graph for this function:

Here is the caller graph for this function:

AddTriangleFilled()

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);
}

References col(), IM_COL32_A_MASK, PathFillConvex(), and PathLineTo().

Referenced by ImGui::RenderArrow(), ImGui::RenderArrowPointingAt(), and ShowExampleAppCustomRendering().

Here is the call graph for this function:

Here is the caller graph for this function:

ChannelsMerge()

void ImDrawList::ChannelsMerge ( )

inline

{ _Splitter.Merge(this); }

References ImDrawListSplitter::Merge().

Here is the call graph for this function:

ChannelsSetCurrent()

void ImDrawList::ChannelsSetCurrent ( int  n )

inline

{ _Splitter.SetCurrentChannel(this, n); }

References ImDrawListSplitter::SetCurrentChannel().

Here is the call graph for this function:

ChannelsSplit()

void ImDrawList::ChannelsSplit ( int  count )

inline

{ _Splitter.Split(this, count); }

References ImDrawListSplitter::Split().

Here is the call graph for this function:

CloneOutput()

ImDrawList * ImDrawList::CloneOutput

(

)

const

{
    ImDrawList* dst = IM_NEW(ImDrawList(_Data));
    dst->CmdBuffer = CmdBuffer;
    dst->IdxBuffer = IdxBuffer;
    dst->VtxBuffer = VtxBuffer;
    dst->Flags = Flags;
    return dst;
}

References _Data, CmdBuffer, Flags, IdxBuffer, IM_NEW, and VtxBuffer.

GetClipRectMax()

ImVec2 ImDrawList::GetClipRectMax ( ) const

inline

{ const ImVec4& cr = _ClipRectStack.back(); return ImVec2(cr.z, cr.w); }

References ImVector< T >::back(), ImVec4::w, and ImVec4::z.

Here is the call graph for this function:

GetClipRectMin()

ImVec2 ImDrawList::GetClipRectMin ( ) const

inline

{ const ImVec4& cr = _ClipRectStack.back(); return ImVec2(cr.x, cr.y); }

References ImVector< T >::back(), ImVec4::x, and ImVec4::y.

Here is the call graph for this function:

PathArcTo()

void ImDrawList::PathArcTo	(	const ImVec2 &	center,
		float	radius,
		float	a_min,
		float	a_max,
		int	num_segments = 0
	)

{
    if (radius <= 0.0f)
    {
        _Path.push_back(center);
        return;
    }
 
    if (num_segments > 0)
    {
        _PathArcToN(center, radius, a_min, a_max, num_segments);
        return;
    }
 
    // Automatic segment count
    if (radius <= _Data->ArcFastRadiusCutoff)
    {
        const bool a_is_reverse = a_max < a_min;
 
        // We are going to use precomputed values for mid samples.
        // Determine first and last sample in lookup table that belong to the arc.
        const float a_min_sample_f = IM_DRAWLIST_ARCFAST_SAMPLE_MAX * a_min / (IM_PI * 2.0f);
        const float a_max_sample_f = IM_DRAWLIST_ARCFAST_SAMPLE_MAX * a_max / (IM_PI * 2.0f);
 
        const int a_min_sample = a_is_reverse ? (int)ImFloorSigned(a_min_sample_f) : (int)ImCeil(a_min_sample_f);
        const int a_max_sample = a_is_reverse ? (int)ImCeil(a_max_sample_f) : (int)ImFloorSigned(a_max_sample_f);
        const int a_mid_samples = a_is_reverse ? ImMax(a_min_sample - a_max_sample, 0) : ImMax(a_max_sample - a_min_sample, 0);
 
        const float a_min_segment_angle = a_min_sample * IM_PI * 2.0f / IM_DRAWLIST_ARCFAST_SAMPLE_MAX;
        const float a_max_segment_angle = a_max_sample * IM_PI * 2.0f / IM_DRAWLIST_ARCFAST_SAMPLE_MAX;
        const bool a_emit_start = (a_min_segment_angle - a_min) != 0.0f;
        const bool a_emit_end = (a_max - a_max_segment_angle) != 0.0f;
 
        _Path.reserve(_Path.Size + (a_mid_samples + 1 + (a_emit_start ? 1 : 0) + (a_emit_end ? 1 : 0)));
        if (a_emit_start)
            _Path.push_back(ImVec2(center.x + ImCos(a_min) * radius, center.y + ImSin(a_min) * radius));
        if (a_mid_samples > 0)
            _PathArcToFastEx(center, radius, a_min_sample, a_max_sample, 0);
        if (a_emit_end)
            _Path.push_back(ImVec2(center.x + ImCos(a_max) * radius, center.y + ImSin(a_max) * radius));
    }
    else
    {
        const float arc_length = ImAbs(a_max - a_min);
        const int circle_segment_count = _CalcCircleAutoSegmentCount(radius);
        const int arc_segment_count = ImMax((int)ImCeil(circle_segment_count * arc_length / (IM_PI * 2.0f)), (int)(2.0f * IM_PI / arc_length));
        _PathArcToN(center, radius, a_min, a_max, arc_segment_count);
    }
}

References _CalcCircleAutoSegmentCount(), _Path, _PathArcToFastEx(), _PathArcToN(), IM_DRAWLIST_ARCFAST_SAMPLE_MAX, IM_PI, ImAbs(), ImCeil, ImCos, ImFloorSigned(), ImMax(), ImSin, ImVector< T >::push_back(), ImVector< T >::reserve(), ImVector< T >::Size, ImVec2::x, and ImVec2::y.

Referenced by AddCircle(), AddCircleFilled(), AddNgon(), AddNgonFilled(), ImGui::ColorPicker4(), ImGui::RenderRectFilledRangeH(), and ImGui::RenderWindowOuterBorders().

Here is the call graph for this function:

Here is the caller graph for this function:

PathArcToFast()

void ImDrawList::PathArcToFast	(	const ImVec2 &	center,
		float	radius,
		int	a_min_of_12,
		int	a_max_of_12
	)

{
    if (radius <= 0.0f)
    {
        _Path.push_back(center);
        return;
    }
    _PathArcToFastEx(center, radius, a_min_of_12 * IM_DRAWLIST_ARCFAST_SAMPLE_MAX / 12, a_max_of_12 * IM_DRAWLIST_ARCFAST_SAMPLE_MAX / 12, 0);
}

References _Path, _PathArcToFastEx(), IM_DRAWLIST_ARCFAST_SAMPLE_MAX, and ImVector< T >::push_back().

Referenced by AddCircle(), AddCircleFilled(), PathRect(), ImGui::RenderRectFilledRangeH(), ImGui::RenderWindowDecorations(), and ImGui::TabItemBackground().

Here is the call graph for this function:

Here is the caller graph for this function:

PathBezierCubicCurveTo()

void ImDrawList::PathBezierCubicCurveTo	(	const ImVec2 &	p2,
		const ImVec2 &	p3,
		const ImVec2 &	p4,
		int	num_segments = 0
	)

{
    ImVec2 p1 = _Path.back();
    if (num_segments == 0)
    {
        PathBezierCubicCurveToCasteljau(&_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(ImBezierCubicCalc(p1, p2, p3, p4, t_step * i_step));
    }
}

References _Data, _Path, ImVector< T >::back(), ImDrawListSharedData::CurveTessellationTol, ImBezierCubicCalc(), PathBezierCubicCurveToCasteljau(), ImVector< T >::push_back(), ImVec2::x, and ImVec2::y.

Referenced by AddBezierCubic().

Here is the call graph for this function:

Here is the caller graph for this function:

PathBezierCurveTo()

void ImDrawList::PathBezierCurveTo ( const ImVec2 &  p2, const ImVec2 &  p3, const ImVec2 &  p4, int  num_segments = 0  )

inline

{ PathBezierCubicCurveTo(p2, p3, p4, num_segments); }

PathBezierQuadraticCurveTo()

void ImDrawList::PathBezierQuadraticCurveTo	(	const ImVec2 &	p2,
		const ImVec2 &	p3,
		int	num_segments = 0
	)

{
    ImVec2 p1 = _Path.back();
    if (num_segments == 0)
    {
        PathBezierQuadraticCurveToCasteljau(&_Path, p1.x, p1.y, p2.x, p2.y, p3.x, p3.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(ImBezierQuadraticCalc(p1, p2, p3, t_step * i_step));
    }
}

References _Data, _Path, ImVector< T >::back(), ImDrawListSharedData::CurveTessellationTol, ImBezierQuadraticCalc(), PathBezierQuadraticCurveToCasteljau(), ImVector< T >::push_back(), ImVec2::x, and ImVec2::y.

Referenced by AddBezierQuadratic().

Here is the call graph for this function:

Here is the caller graph for this function:

PathClear()

void ImDrawList::PathClear ( )

inline

{ _Path.Size = 0; }

References ImVector< T >::Size.

PathFillConvex()

void ImDrawList::PathFillConvex ( ImU32  col )

inline

{ AddConvexPolyFilled(_Path.Data, _Path.Size, col); _Path.Size = 0; }  // Note: Anti-aliased filling requires points to be in clockwise order.

References col(), ImVector< T >::Data, and ImVector< T >::Size.

Referenced by AddCircleFilled(), AddImageRounded(), AddNgonFilled(), AddQuadFilled(), AddRectFilled(), AddTriangleFilled(), ImGui::RenderRectFilledRangeH(), ImGui::RenderWindowDecorations(), and ImGui::TabItemBackground().

Here is the call graph for this function:

Here is the caller graph for this function:

PathLineTo()

void ImDrawList::PathLineTo ( const ImVec2 &  pos )

inline

{ _Path.push_back(pos); }

References ImVector< T >::push_back().

Referenced by AddBezierCubic(), AddBezierQuadratic(), AddLine(), AddQuad(), AddQuadFilled(), AddTriangle(), AddTriangleFilled(), PathRect(), ImGui::RenderCheckMark(), ImGui::RenderRectFilledRangeH(), ImGui::RenderWindowDecorations(), and ImGui::TabItemBackground().

Here is the call graph for this function:

Here is the caller graph for this function:

PathLineToMergeDuplicate()

void ImDrawList::PathLineToMergeDuplicate ( const ImVec2 &  pos )

inline

{ if (_Path.Size == 0 || memcmp(&_Path.Data[_Path.Size - 1], &pos, 8) != 0) _Path.push_back(pos); }

References ImVector< T >::Data, ImVector< T >::push_back(), and ImVector< T >::Size.

Here is the call graph for this function:

PathRect()

void ImDrawList::PathRect	(	const ImVec2 &	rect_min,
		const ImVec2 &	rect_max,
		float	rounding = 0.0f,
		ImDrawFlags	flags = 0
	)

{
    flags = FixRectCornerFlags(flags);
    rounding = ImMin(rounding, ImFabs(b.x - a.x) * ( ((flags & ImDrawFlags_RoundCornersTop)  == ImDrawFlags_RoundCornersTop)  || ((flags & ImDrawFlags_RoundCornersBottom) == ImDrawFlags_RoundCornersBottom) ? 0.5f : 1.0f ) - 1.0f);
    rounding = ImMin(rounding, ImFabs(b.y - a.y) * ( ((flags & ImDrawFlags_RoundCornersLeft) == ImDrawFlags_RoundCornersLeft) || ((flags & ImDrawFlags_RoundCornersRight)  == ImDrawFlags_RoundCornersRight)  ? 0.5f : 1.0f ) - 1.0f);
 
    if (rounding <= 0.0f || (flags & ImDrawFlags_RoundCornersMask_) == ImDrawFlags_RoundCornersNone)
    {
        PathLineTo(a);
        PathLineTo(ImVec2(b.x, a.y));
        PathLineTo(b);
        PathLineTo(ImVec2(a.x, b.y));
    }
    else
    {
        const float rounding_tl = (flags & ImDrawFlags_RoundCornersTopLeft)     ? rounding : 0.0f;
        const float rounding_tr = (flags & ImDrawFlags_RoundCornersTopRight)    ? rounding : 0.0f;
        const float rounding_br = (flags & ImDrawFlags_RoundCornersBottomRight) ? rounding : 0.0f;
        const float rounding_bl = (flags & ImDrawFlags_RoundCornersBottomLeft)  ? 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);
    }
}

References FixRectCornerFlags(), ImDrawFlags_RoundCornersBottom, ImDrawFlags_RoundCornersBottomLeft, ImDrawFlags_RoundCornersBottomRight, ImDrawFlags_RoundCornersLeft, ImDrawFlags_RoundCornersMask_, ImDrawFlags_RoundCornersNone, ImDrawFlags_RoundCornersRight, ImDrawFlags_RoundCornersTop, ImDrawFlags_RoundCornersTopLeft, ImDrawFlags_RoundCornersTopRight, ImFabs, ImMin(), PathArcToFast(), and PathLineTo().

Referenced by AddImageRounded(), AddRect(), and AddRectFilled().

Here is the call graph for this function:

Here is the caller graph for this function:

PathStroke()

void ImDrawList::PathStroke ( ImU32  col, ImDrawFlags  flags = 0, float  thickness = 1.0f  )

inline

{ AddPolyline(_Path.Data, _Path.Size, col, flags, thickness); _Path.Size = 0; }

References col(), ImVector< T >::Data, and ImVector< T >::Size.

Referenced by AddBezierCubic(), AddBezierQuadratic(), AddCircle(), AddLine(), AddNgon(), AddQuad(), AddRect(), AddTriangle(), ImGui::ColorPicker4(), ImGui::RenderCheckMark(), ImGui::RenderWindowOuterBorders(), and ImGui::TabItemBackground().

Here is the call graph for this function:

Here is the caller graph for this function:

PopClipRect()

void ImDrawList::PopClipRect

(

)

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

References _ClipRectStack, _CmdHeader, _Data, _OnChangedClipRect(), ImDrawCmdHeader::ClipRect, ImDrawListSharedData::ClipRectFullscreen, ImVector< T >::Data, ImVector< T >::pop_back(), and ImVector< T >::Size.

Referenced by ImGui::AcceptDragDropPayload(), ImGui::EndTable(), ImGui::PopClipRect(), ImGui::RenderNavHighlight(), ShowDemoWindowLayout(), ShowExampleAppCustomRendering(), and ImGui::TableDrawBorders().

Here is the call graph for this function:

Here is the caller graph for this function:

PopTextureID()

void ImDrawList::PopTextureID

(

)

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

References _CmdHeader, _OnChangedTextureID(), _TextureIdStack, ImVector< T >::Data, ImVector< T >::pop_back(), ImVector< T >::Size, and ImDrawCmdHeader::TextureId.

Referenced by AddImage(), AddImageQuad(), AddImageRounded(), ImGui::PopFont(), and ImGui::RenderMouseCursor().

Here is the call graph for this function:

Here is the caller graph for this function:

PrimQuadUV()

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;
}

References _IdxWritePtr, _VtxCurrentIdx, _VtxWritePtr, col(), ImDrawVert::col, ImDrawVert::pos, and ImDrawVert::uv.

Referenced by AddImageQuad().

Here is the call graph for this function:

Here is the caller graph for this function:

PrimRect()

void ImDrawList::PrimRect	(	const ImVec2 &	a,
		const ImVec2 &	b,
		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;
}

References _Data, _IdxWritePtr, _VtxCurrentIdx, _VtxWritePtr, col(), ImDrawVert::col, ImDrawVert::pos, ImDrawListSharedData::TexUvWhitePixel, and ImDrawVert::uv.

Referenced by AddRectFilled().

Here is the call graph for this function:

Here is the caller graph for this function:

PrimRectUV()

void ImDrawList::PrimRectUV	(	const ImVec2 &	a,
		const ImVec2 &	b,
		const ImVec2 &	uv_a,
		const ImVec2 &	uv_b,
		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;
}

References _IdxWritePtr, _VtxCurrentIdx, _VtxWritePtr, col(), ImDrawVert::col, ImDrawVert::pos, ImDrawVert::uv, ImVec2::x, and ImVec2::y.

Referenced by AddImage(), and ImFont::RenderChar().

Here is the call graph for this function:

Here is the caller graph for this function:

PrimReserve()

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

{
    // Large mesh support (when enabled)
    IM_ASSERT_PARANOID(idx_count >= 0 && vtx_count >= 0);
    if (sizeof(ImDrawIdx) == 2 && (_VtxCurrentIdx + vtx_count >= (1 << 16)) && (Flags & ImDrawListFlags_AllowVtxOffset))
    {
        // FIXME: In theory we should be testing that vtx_count <64k here.
        // In practice, RenderText() relies on reserving ahead for a worst case scenario so it is currently useful for us
        // to not make that check until we rework the text functions to handle clipping and large horizontal lines better.
        _CmdHeader.VtxOffset = VtxBuffer.Size;
        _OnChangedVtxOffset();
    }
 
    ImDrawCmd* draw_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
    draw_cmd->ElemCount += idx_count;
 
    int vtx_buffer_old_size = VtxBuffer.Size;
    VtxBuffer.resize(vtx_buffer_old_size + vtx_count);
    _VtxWritePtr = VtxBuffer.Data + vtx_buffer_old_size;
 
    int idx_buffer_old_size = IdxBuffer.Size;
    IdxBuffer.resize(idx_buffer_old_size + idx_count);
    _IdxWritePtr = IdxBuffer.Data + idx_buffer_old_size;
}

References _CmdHeader, _IdxWritePtr, _OnChangedVtxOffset(), _VtxCurrentIdx, _VtxWritePtr, CmdBuffer, ImVector< T >::Data, ImDrawCmd::ElemCount, Flags, IdxBuffer, IM_ASSERT_PARANOID, ImDrawListFlags_AllowVtxOffset, ImVector< T >::resize(), ImVector< T >::Size, VtxBuffer, and ImDrawCmdHeader::VtxOffset.

Referenced by AddConvexPolyFilled(), AddImage(), AddImageQuad(), AddPolyline(), AddRectFilled(), AddRectFilledMultiColor(), ImGui::ColorPicker4(), ImFont::RenderChar(), and ImFont::RenderText().

Here is the call graph for this function:

Here is the caller graph for this function:

PrimUnreserve()

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);
}

References CmdBuffer, ImVector< T >::Data, ImDrawCmd::ElemCount, IdxBuffer, IM_ASSERT_PARANOID, ImVector< T >::shrink(), ImVector< T >::Size, and VtxBuffer.

Here is the call graph for this function:

PrimVtx()

void ImDrawList::PrimVtx ( const ImVec2 &  pos, const ImVec2 &  uv, ImU32  col  )

inline

{ PrimWriteIdx((ImDrawIdx)_VtxCurrentIdx); PrimWriteVtx(pos, uv, col); } // Write vertex with unique index

References col().

Referenced by ImGui::ColorPicker4().

Here is the call graph for this function:

Here is the caller graph for this function:

PrimWriteIdx()

void ImDrawList::PrimWriteIdx ( ImDrawIdx  idx )

inline

{ *_IdxWritePtr = idx; _IdxWritePtr++; }

Referenced by AddRectFilledMultiColor().

Here is the caller graph for this function:

PrimWriteVtx()

void ImDrawList::PrimWriteVtx ( const ImVec2 &  pos, const ImVec2 &  uv, ImU32  col  )

inline

{ _VtxWritePtr->pos = pos; _VtxWritePtr->uv = uv; _VtxWritePtr->col = col; _VtxWritePtr++; _VtxCurrentIdx++; }

References col(), ImDrawVert::col, ImDrawVert::pos, and ImDrawVert::uv.

Referenced by AddRectFilledMultiColor().

Here is the call graph for this function:

Here is the caller graph for this function:

PushClipRect()

void ImDrawList::PushClipRect	(	ImVec2	clip_rect_min,
		ImVec2	clip_rect_max,
		bool	intersect_with_current_clip_rect = false
	)

{
    ImVec4 cr(cr_min.x, cr_min.y, cr_max.x, cr_max.y);
    if (intersect_with_current_clip_rect)
    {
        ImVec4 current = _CmdHeader.ClipRect;
        if (cr.x < current.x) cr.x = current.x;
        if (cr.y < current.y) cr.y = current.y;
        if (cr.z > current.z) cr.z = current.z;
        if (cr.w > current.w) cr.w = current.w;
    }
    cr.z = ImMax(cr.x, cr.z);
    cr.w = ImMax(cr.y, cr.w);
 
    _ClipRectStack.push_back(cr);
    _CmdHeader.ClipRect = cr;
    _OnChangedClipRect();
}

References _ClipRectStack, _CmdHeader, _OnChangedClipRect(), ImDrawCmdHeader::ClipRect, ImMax(), ImVector< T >::push_back(), ImVec4::w, ImVec2::x, ImVec4::x, ImVec2::y, ImVec4::y, and ImVec4::z.

Referenced by ImGui::AcceptDragDropPayload(), GetViewportDrawList(), ImGui::PushClipRect(), PushClipRectFullScreen(), ImGui::RenderNavHighlight(), ShowDemoWindowLayout(), ShowExampleAppCustomRendering(), ImGui::TableDrawBorders(), and ImGui::TableUpdateLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

PushClipRectFullScreen()

void ImDrawList::PushClipRectFullScreen

(

)

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

References _Data, ImDrawListSharedData::ClipRectFullscreen, PushClipRect(), ImVec4::w, ImVec4::x, ImVec4::y, and ImVec4::z.

Here is the call graph for this function:

PushTextureID()

void ImDrawList::PushTextureID

(

ImTextureID

texture_id

)

{
    _TextureIdStack.push_back(texture_id);
    _CmdHeader.TextureId = texture_id;
    _OnChangedTextureID();
}

References _CmdHeader, _OnChangedTextureID(), _TextureIdStack, ImVector< T >::push_back(), and ImDrawCmdHeader::TextureId.

Referenced by AddImage(), AddImageQuad(), AddImageRounded(), ImGui::Begin(), GetViewportDrawList(), ImGui::PushFont(), and ImGui::RenderMouseCursor().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

_ClipRectStack

ImVector<ImVec4> ImDrawList::_ClipRectStack

Referenced by _ClearFreeMemory(), _ResetForNewFrame(), ImGui::EndTable(), ImGui::PopClipRect(), PopClipRect(), ImGui::PushClipRect(), PushClipRect(), and ImGui::SetWindowClipRectBeforeSetChannel().

_CmdHeader

ImDrawCmdHeader ImDrawList::_CmdHeader

Referenced by _OnChangedClipRect(), _OnChangedTextureID(), _OnChangedVtxOffset(), _ResetForNewFrame(), AddDrawCmd(), AddImage(), AddImageQuad(), AddImageRounded(), AddText(), ImDrawListSplitter::Merge(), PopClipRect(), PopTextureID(), PrimReserve(), PushClipRect(), PushTextureID(), ImDrawListSplitter::SetCurrentChannel(), ImGui::SetWindowClipRectBeforeSetChannel(), and ImGui::TableEndRow().

_Data

const ImDrawListSharedData* ImDrawList::_Data

Referenced by ImGuiWindow::ImGuiWindow(), _CalcCircleAutoSegmentCount(), _PathArcToFastEx(), _ResetForNewFrame(), AddConvexPolyFilled(), AddPolyline(), AddRectFilledMultiColor(), AddText(), CloneOutput(), PathBezierCubicCurveTo(), PathBezierQuadraticCurveTo(), PopClipRect(), PrimRect(), PushClipRectFullScreen(), ImGui::RenderArrow(), ImGui::RenderBullet(), ImGui::RenderMouseCursor(), and ImGui::RenderTextEllipsis().

_FringeScale

float ImDrawList::_FringeScale

Referenced by _ResetForNewFrame(), AddConvexPolyFilled(), and AddPolyline().

_IdxWritePtr

ImDrawIdx* ImDrawList::_IdxWritePtr

Referenced by _ClearFreeMemory(), _ResetForNewFrame(), AddConvexPolyFilled(), AddDrawListToDrawData(), AddPolyline(), ImDrawListSplitter::Merge(), PrimQuadUV(), PrimRect(), PrimRectUV(), PrimReserve(), ImFont::RenderText(), and ImDrawListSplitter::SetCurrentChannel().

_OwnerName

const char* ImDrawList::_OwnerName

Referenced by ImGuiWindow::ImGuiWindow(), ImGui::DebugNodeDrawList(), and GetViewportDrawList().

_Path

ImVector<ImVec2> ImDrawList::_Path

Referenced by _ClearFreeMemory(), _PathArcToFastEx(), _PathArcToN(), _ResetForNewFrame(), PathArcTo(), PathArcToFast(), PathBezierCubicCurveTo(), and PathBezierQuadraticCurveTo().

_Splitter

ImDrawListSplitter ImDrawList::_Splitter

Referenced by _ClearFreeMemory(), and _ResetForNewFrame().

_TextureIdStack

ImVector<ImTextureID> ImDrawList::_TextureIdStack

Referenced by _ClearFreeMemory(), _ResetForNewFrame(), PopTextureID(), and PushTextureID().

_VtxCurrentIdx

unsigned int ImDrawList::_VtxCurrentIdx

Referenced by _ClearFreeMemory(), _OnChangedVtxOffset(), _ResetForNewFrame(), AddConvexPolyFilled(), AddDrawListToDrawData(), AddPolyline(), AddRectFilledMultiColor(), PrimQuadUV(), PrimRect(), PrimRectUV(), PrimReserve(), and ImFont::RenderText().

_VtxWritePtr

ImDrawVert* ImDrawList::_VtxWritePtr

Referenced by _ClearFreeMemory(), _ResetForNewFrame(), AddConvexPolyFilled(), AddDrawListToDrawData(), AddPolyline(), PrimQuadUV(), PrimRect(), PrimRectUV(), PrimReserve(), and ImFont::RenderText().

CmdBuffer

ImVector<ImDrawCmd> ImDrawList::CmdBuffer

Referenced by _ClearFreeMemory(), _OnChangedClipRect(), _OnChangedTextureID(), _OnChangedVtxOffset(), _PopUnusedDrawCmd(), _ResetForNewFrame(), AddCallback(), AddDrawCmd(), AddDrawListToDrawData(), ImGui::Begin(), CloneOutput(), ImGui::DebugNodeDrawList(), ImDrawListSplitter::Merge(), PrimReserve(), PrimUnreserve(), Slic3r::GUI::ImGuiWrapper::render_draw_data(), ImFont::RenderText(), ImDrawData::ScaleClipRects(), ImDrawListSplitter::SetCurrentChannel(), and ShowDemoWindowTables().

Flags

ImDrawListFlags ImDrawList::Flags

Referenced by _ClearFreeMemory(), _ResetForNewFrame(), AddConvexPolyFilled(), AddDrawListToDrawData(), AddPolyline(), AddRect(), CloneOutput(), ImGui::DebugNodeDrawCmdShowMeshAndBoundingBox(), ImGui::DebugNodeDrawList(), and PrimReserve().

IdxBuffer

ImVector<ImDrawIdx> ImDrawList::IdxBuffer

Referenced by _ClearFreeMemory(), _ResetForNewFrame(), AddDrawCmd(), AddDrawListToDrawData(), CloneOutput(), ImGui::DebugNodeDrawCmdShowMeshAndBoundingBox(), ImGui::DebugNodeDrawList(), ImDrawData::DeIndexAllBuffers(), ImGui::GcAwakeTransientWindowBuffers(), ImGui::GcCompactTransientWindowBuffers(), ImDrawListSplitter::Merge(), PrimReserve(), PrimUnreserve(), Slic3r::GUI::ImGuiWrapper::render_draw_data(), ImFont::RenderText(), and ImDrawListSplitter::SetCurrentChannel().

VtxBuffer

ImVector<ImDrawVert> ImDrawList::VtxBuffer

Referenced by _ClearFreeMemory(), _ResetForNewFrame(), AddDrawListToDrawData(), AddImageRounded(), ImGui::Begin(), CloneOutput(), ImGui::ColorPicker4(), ImGui::DebugNodeDrawCmdShowMeshAndBoundingBox(), ImGui::DebugNodeDrawList(), ImDrawData::DeIndexAllBuffers(), ImGui::GcAwakeTransientWindowBuffers(), ImGui::GcCompactTransientWindowBuffers(), PrimReserve(), PrimUnreserve(), Slic3r::GUI::ImGuiWrapper::render_draw_data(), ImFont::RenderText(), ImGui::ShadeVertsLinearColorGradientKeepAlpha(), and ImGui::ShadeVertsLinearUV().

---

The documentation for this struct was generated from the following files:

• src/imgui/imgui.h
• src/imgui/imgui_draw.cpp