#include "imgui.h"
#include "imgui_internal.h"
#include "imconfig.h"
#include <stdio.h>
#include <stdlib.h>
#include "imstb_rectpack.h"
#include "imstb_truetype.h"

Include dependency graph for imgui_draw.cpp:

Go to the source code of this file.

Classes
struct	ImFontBuildSrcData

struct	ImFontBuildDstData

Macros
#define	IMGUI_DEFINE_MATH_OPERATORS

#define	STBRP_STATIC

#define	STBRP_ASSERT(x) do { IM_ASSERT(x); } while (0)

#define	STBRP_SORT ImQsort

#define	STB_RECT_PACK_IMPLEMENTATION

#define	STBTT_malloc(x, u) ((void)(u), IM_ALLOC(x))

#define	STBTT_free(x, u) ((void)(u), IM_FREE(x))

#define	STBTT_assert(x) do { IM_ASSERT(x); } while(0)

#define	STBTT_fmod(x, y) ImFmod(x,y)

#define	STBTT_sqrt(x) ImSqrt(x)

#define	STBTT_pow(x, y) ImPow(x,y)

#define	STBTT_fabs(x) ImFabs(x)

#define	STBTT_ifloor(x) ((int)ImFloorSigned(x))

#define	STBTT_iceil(x) ((int)ImCeil(x))

#define	STBTT_STATIC

#define	STB_TRUETYPE_IMPLEMENTATION

#define	ImDrawCmd_HeaderSize (IM_OFFSETOF(ImDrawCmd, VtxOffset) + sizeof(unsigned int))

#define	ImDrawCmd_HeaderCompare(CMD_LHS, CMD_RHS) (memcmp(CMD_LHS, CMD_RHS, ImDrawCmd_HeaderSize))

#define	ImDrawCmd_HeaderCopy(CMD_DST, CMD_SRC) (memcpy(CMD_DST, CMD_SRC, ImDrawCmd_HeaderSize))

#define	IM_NORMALIZE2F_OVER_ZERO(VX, VY) do { float d2 = VXVX + VYVY; if (d2 > 0.0f) { float inv_len = ImRsqrt(d2); VX = inv_len; VY = inv_len; } } while (0)

#define	IM_FIXNORMAL2F_MAX_INVLEN2 100.0f

#define	IM_FIXNORMAL2F(VX, VY) do { float d2 = VXVX + VYVY; if (d2 > 0.000001f) { float inv_len2 = 1.0f / d2; if (inv_len2 > IM_FIXNORMAL2F_MAX_INVLEN2) inv_len2 = IM_FIXNORMAL2F_MAX_INVLEN2; VX = inv_len2; VY = inv_len2; } } while (0)

#define	stb__in2(x) ((i[x] << 8) + i[(x)+1])

#define	stb__in3(x) ((i[x] << 16) + stb__in2((x)+1))

#define	stb__in4(x) ((i[x] << 24) + stb__in3((x)+1))

Functions
ImVec2	ImBezierCubicCalc (const ImVec2 &p1, const ImVec2 &p2, const ImVec2 &p3, const ImVec2 &p4, float t)

ImVec2	ImBezierQuadraticCalc (const ImVec2 &p1, const ImVec2 &p2, const ImVec2 &p3, float t)

static void	PathBezierCubicCurveToCasteljau (ImVector< ImVec2 > *path, float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4, float tess_tol, int level)

static void	PathBezierQuadraticCurveToCasteljau (ImVector< ImVec2 > *path, float x1, float y1, float x2, float y2, float x3, float y3, float tess_tol, int level)

	IM_STATIC_ASSERT (ImDrawFlags_RoundCornersTopLeft==(1<< 4))

static ImDrawFlags	FixRectCornerFlags (ImDrawFlags flags)

static unsigned int	stb_decompress_length (const unsigned char *input)

static unsigned int	stb_decompress (unsigned char output, const unsigned char input, unsigned int length)

static const char *	GetDefaultCompressedFontDataTTFBase85 ()

static unsigned int	Decode85Byte (char c)

static void	Decode85 (const unsigned char src, unsigned char dst)

void	ImFontAtlasBuildMultiplyCalcLookupTable (unsigned char out_table[256], float in_brighten_factor)

void	ImFontAtlasBuildMultiplyRectAlpha8 (const unsigned char table[256], unsigned char *pixels, int x, int y, int w, int h, int stride)

static void	UnpackBitVectorToFlatIndexList (const ImBitVector in, ImVector< int > out)

static bool	ImFontAtlasBuildWithStbTruetype (ImFontAtlas *atlas)

const ImFontBuilderIO *	ImFontAtlasGetBuilderForStbTruetype ()

void	ImFontAtlasBuildSetupFont (ImFontAtlas atlas, ImFont font, ImFontConfig *font_config, float ascent, float descent)

void	ImFontAtlasBuildPackCustomRects (ImFontAtlas atlas, void stbrp_context_opaque)

void	ImFontAtlasBuildRender8bppRectFromString (ImFontAtlas atlas, int x, int y, int w, int h, const char in_str, char in_marker_char, unsigned char in_marker_pixel_value)

void	ImFontAtlasBuildRender32bppRectFromString (ImFontAtlas atlas, int x, int y, int w, int h, const char in_str, char in_marker_char, unsigned int in_marker_pixel_value)

static void	ImFontAtlasBuildRenderDefaultTexData (ImFontAtlas *atlas)

static void	ImFontAtlasBuildRenderLinesTexData (ImFontAtlas *atlas)

void	ImFontAtlasBuildInit (ImFontAtlas *atlas)

void	ImFontAtlasBuildFinish (ImFontAtlas *atlas)

static void	UnpackAccumulativeOffsetsIntoRanges (int base_codepoint, const short accumulative_offsets, int accumulative_offsets_count, ImWchar out_ranges)

static float	ImAcos01 (float x)

static void	stb__match (const unsigned char *data, unsigned int length)

static void	stb__lit (const unsigned char *data, unsigned int length)

static const unsigned char *	stb_decompress_token (const unsigned char *i)

static unsigned int	stb_adler32 (unsigned int adler32, unsigned char *buffer, unsigned int buflen)

Variables
const int	FONT_ATLAS_DEFAULT_TEX_DATA_W = 108

const int	FONT_ATLAS_DEFAULT_TEX_DATA_H = 27

static const char	FONT_ATLAS_DEFAULT_TEX_DATA_PIXELS [FONT_ATLAS_DEFAULT_TEX_DATA_W *FONT_ATLAS_DEFAULT_TEX_DATA_H+1]

static const ImVec2	FONT_ATLAS_DEFAULT_TEX_CURSOR_DATA [ImGuiMouseCursor_COUNT][3]

static unsigned char *	stb__barrier_out_e

static unsigned char *	stb__barrier_out_b

static const unsigned char *	stb__barrier_in_b

static unsigned char *	stb__dout

static const char	proggy_clean_ttf_compressed_data_base85 [11980+1]

Class Documentation

◆ ImFontBuildSrcData

struct ImFontBuildSrcData

Collaboration diagram for ImFontBuildSrcData:

Class Members
int	DstIndex
stbtt_fontinfo	FontInfo
int	GlyphsCount
int	GlyphsHighest
ImVector< int >	GlyphsList
ImBitVector	GlyphsSet
stbtt_packedchar *	PackedChars
stbtt_pack_range	PackRange
stbrp_rect *	Rects
const ImWchar *	SrcRanges

◆ ImFontBuildDstData

struct ImFontBuildDstData

Collaboration diagram for ImFontBuildDstData:

Class Members
int	GlyphsCount
int	GlyphsHighest
ImBitVector	GlyphsSet
int	SrcCount

Macro Definition Documentation

◆ IM_FIXNORMAL2F

#define IM_FIXNORMAL2F	(	VX,
		VY
	)	do { float d2 = VXVX + VYVY; if (d2 > 0.000001f) { float inv_len2 = 1.0f / d2; if (inv_len2 > IM_FIXNORMAL2F_MAX_INVLEN2) inv_len2 = IM_FIXNORMAL2F_MAX_INVLEN2; VX = inv_len2; VY = inv_len2; } } while (0)

◆ IM_FIXNORMAL2F_MAX_INVLEN2

#define IM_FIXNORMAL2F_MAX_INVLEN2 100.0f

◆ IM_NORMALIZE2F_OVER_ZERO

#define IM_NORMALIZE2F_OVER_ZERO	(	VX,
		VY
	)	do { float d2 = VXVX + VYVY; if (d2 > 0.0f) { float inv_len = ImRsqrt(d2); VX = inv_len; VY = inv_len; } } while (0)

◆ ImDrawCmd_HeaderCompare

#define ImDrawCmd_HeaderCompare	(	CMD_LHS,
		CMD_RHS
	)	(memcmp(CMD_LHS, CMD_RHS, ImDrawCmd_HeaderSize))

◆ ImDrawCmd_HeaderCopy

#define ImDrawCmd_HeaderCopy	(	CMD_DST,
		CMD_SRC
	)	(memcpy(CMD_DST, CMD_SRC, ImDrawCmd_HeaderSize))

◆ ImDrawCmd_HeaderSize

#define ImDrawCmd_HeaderSize (IM_OFFSETOF(ImDrawCmd, VtxOffset) + sizeof(unsigned int))

◆ IMGUI_DEFINE_MATH_OPERATORS

#define IMGUI_DEFINE_MATH_OPERATORS

◆ stb__in2

#define stb__in2 ( x ) ((i[x] << 8) + i[(x)+1])

◆ stb__in3

#define stb__in3 ( x ) ((i[x] << 16) + stb__in2((x)+1))

◆ stb__in4

#define stb__in4 ( x ) ((i[x] << 24) + stb__in3((x)+1))

◆ STB_RECT_PACK_IMPLEMENTATION

#define STB_RECT_PACK_IMPLEMENTATION

◆ STB_TRUETYPE_IMPLEMENTATION

#define STB_TRUETYPE_IMPLEMENTATION

◆ STBRP_ASSERT

#define STBRP_ASSERT ( x ) do { IM_ASSERT(x); } while (0)

◆ STBRP_SORT

#define STBRP_SORT ImQsort

◆ STBRP_STATIC

#define STBRP_STATIC

◆ STBTT_assert

#define STBTT_assert ( x ) do { IM_ASSERT(x); } while(0)

◆ STBTT_fabs

#define STBTT_fabs ( x ) ImFabs(x)

◆ STBTT_fmod

#define STBTT_fmod	(	x,
		y
	)	ImFmod(x,y)

◆ STBTT_free

#define STBTT_free	(	x,
		u
	)	((void)(u), IM_FREE(x))

◆ STBTT_iceil

#define STBTT_iceil ( x ) ((int)ImCeil(x))

◆ STBTT_ifloor

#define STBTT_ifloor ( x ) ((int)ImFloorSigned(x))

◆ STBTT_malloc

#define STBTT_malloc	(	x,
		u
	)	((void)(u), IM_ALLOC(x))

◆ STBTT_pow

#define STBTT_pow	(	x,
		y
	)	ImPow(x,y)

◆ STBTT_sqrt

#define STBTT_sqrt ( x ) ImSqrt(x)

◆ STBTT_STATIC

#define STBTT_STATIC

Function Documentation

◆ Decode85()

static void Decode85	(	const unsigned char *	src,
		unsigned char *	dst
	)

static

{
    while (*src)
    {
        unsigned int tmp = Decode85Byte(src[0]) + 85 * (Decode85Byte(src[1]) + 85 * (Decode85Byte(src[2]) + 85 * (Decode85Byte(src[3]) + 85 * Decode85Byte(src[4]))));
        dst[0] = ((tmp >> 0) & 0xFF); dst[1] = ((tmp >> 8) & 0xFF); dst[2] = ((tmp >> 16) & 0xFF); dst[3] = ((tmp >> 24) & 0xFF);   // We can't assume little-endianness.
        src += 5;
        dst += 4;
    }
}

References Decode85Byte().

Referenced by ImFontAtlas::AddFontFromMemoryCompressedBase85TTF().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Decode85Byte()

static unsigned int Decode85Byte ( char c )

static

2098{ return c >= '\\' ? c-36 : c-35; }

marchsq::__impl::SquareTag::c

@ c

Referenced by Decode85().

Here is the caller graph for this function:

◆ FixRectCornerFlags()

static ImDrawFlags FixRectCornerFlags ( ImDrawFlags flags )

inlinestatic

{
#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
    // Legacy Support for hard coded ~0 (used to be a suggested equivalent to ImDrawCornerFlags_All)
    //   ~0   --> ImDrawFlags_RoundCornersAll or 0
    if (flags == ~0)
        return ImDrawFlags_RoundCornersAll;
 
    // Legacy Support for hard coded 0x01 to 0x0F (matching 15 out of 16 old flags combinations)
    //   0x01 --> ImDrawFlags_RoundCornersTopLeft (VALUE 0x01 OVERLAPS ImDrawFlags_Closed but ImDrawFlags_Closed is never valid in this path!)
    //   0x02 --> ImDrawFlags_RoundCornersTopRight
    //   0x03 --> ImDrawFlags_RoundCornersTopLeft | ImDrawFlags_RoundCornersTopRight
    //   0x04 --> ImDrawFlags_RoundCornersBotLeft
    //   0x05 --> ImDrawFlags_RoundCornersTopLeft | ImDrawFlags_RoundCornersBotLeft
    //   ...
    //   0x0F --> ImDrawFlags_RoundCornersAll or 0
    // (See all values in ImDrawCornerFlags_)
    if (flags >= 0x01 && flags <= 0x0F)
        return (flags << 4);
 
    // We cannot support hard coded 0x00 with 'float rounding > 0.0f' --> replace with ImDrawFlags_RoundCornersNone or use 'float rounding = 0.0f'
#endif
 
    // If this triggers, please update your code replacing hardcoded values with new ImDrawFlags_RoundCorners* values.
    // Note that ImDrawFlags_Closed (== 0x01) is an invalid flag for AddRect(), AddRectFilled(), PathRect() etc...
    IM_ASSERT((flags & 0x0F) == 0 && "Misuse of legacy hardcoded ImDrawCornerFlags values!");
 
    if ((flags & ImDrawFlags_RoundCornersMask_) == 0)
        flags |= ImDrawFlags_RoundCornersAll;
 
    return flags;
}

References IM_ASSERT, ImDrawFlags_RoundCornersAll, and ImDrawFlags_RoundCornersMask_.

Referenced by ImDrawList::AddImageRounded(), and ImDrawList::PathRect().

Here is the caller graph for this function:

◆ GetDefaultCompressedFontDataTTFBase85()

static const char * GetDefaultCompressedFontDataTTFBase85 ( )

static

{
    return proggy_clean_ttf_compressed_data_base85;
}

References proggy_clean_ttf_compressed_data_base85.

Referenced by ImFontAtlas::AddFontDefault().

Here is the caller graph for this function:

◆ IM_STATIC_ASSERT()

IM_STATIC_ASSERT ( ImDrawFlags_RoundCornersTopLeft = =(1<< 4) )

◆ ImAcos01()

static float ImAcos01 ( float x )

inlinestatic

{
    if (x <= 0.0f) return IM_PI * 0.5f;
    if (x >= 1.0f) return 0.0f;
    return ImAcos(x);
    //return (-0.69813170079773212f * x * x - 0.87266462599716477f) * x + 1.5707963267948966f; // Cheap approximation, may be enough for what we do.
}

References IM_PI, and ImAcos.

Referenced by ImGui::RenderRectFilledRangeH().

Here is the caller graph for this function:

◆ ImBezierCubicCalc()

ImVec2 ImBezierCubicCalc	(	const ImVec2 &	p1,
		const ImVec2 &	p2,
		const ImVec2 &	p3,
		const ImVec2 &	p4,
		float	t
	)

{
    float u = 1.0f - t;
    float w1 = u * u * u;
    float w2 = 3 * u * u * t;
    float w3 = 3 * u * t * t;
    float w4 = t * t * t;
    return ImVec2(w1 * p1.x + w2 * p2.x + w3 * p3.x + w4 * p4.x, w1 * p1.y + w2 * p2.y + w3 * p3.y + w4 * p4.y);
}

References ImVec2::x, and ImVec2::y.

Referenced by ImBezierCubicClosestPoint(), and ImDrawList::PathBezierCubicCurveTo().

Here is the caller graph for this function:

◆ ImBezierQuadraticCalc()

ImVec2 ImBezierQuadraticCalc	(	const ImVec2 &	p1,
		const ImVec2 &	p2,
		const ImVec2 &	p3,
		float	t
	)

{
    float u = 1.0f - t;
    float w1 = u * u;
    float w2 = 2 * u * t;
    float w3 = t * t;
    return ImVec2(w1 * p1.x + w2 * p2.x + w3 * p3.x, w1 * p1.y + w2 * p2.y + w3 * p3.y);
}

References ImVec2::x, and ImVec2::y.

Referenced by ImDrawList::PathBezierQuadraticCurveTo().

Here is the caller graph for this function:

◆ ImFontAtlasBuildFinish()

void ImFontAtlasBuildFinish ( ImFontAtlas * atlas )

{
    // Render into our custom data blocks
    IM_ASSERT(atlas->TexPixelsAlpha8 != NULL || atlas->TexPixelsRGBA32 != NULL);
    ImFontAtlasBuildRenderDefaultTexData(atlas);
    ImFontAtlasBuildRenderLinesTexData(atlas);
 
    // Register custom rectangle glyphs
    for (int i = 0; i < atlas->CustomRects.Size; i++)
    {
        const ImFontAtlasCustomRect* r = &atlas->CustomRects[i];
        if (r->Font == NULL || r->GlyphID == 0)
            continue;
 
        // Will ignore ImFontConfig settings: GlyphMinAdvanceX, GlyphMinAdvanceY, GlyphExtraSpacing, PixelSnapH
        IM_ASSERT(r->Font->ContainerAtlas == atlas);
        ImVec2 uv0, uv1;
        atlas->CalcCustomRectUV(r, &uv0, &uv1);
        r->Font->AddGlyph(NULL, (ImWchar)r->GlyphID, r->GlyphOffset.x, r->GlyphOffset.y, r->GlyphOffset.x + r->Width, r->GlyphOffset.y + r->Height, uv0.x, uv0.y, uv1.x, uv1.y, r->GlyphAdvanceX);
    }
 
    // Build all fonts lookup tables
    for (int i = 0; i < atlas->Fonts.Size; i++)
        if (atlas->Fonts[i]->DirtyLookupTables)
            atlas->Fonts[i]->BuildLookupTable();
 
    // Ellipsis character is required for rendering elided text. We prefer using U+2026 (horizontal ellipsis).
    // However some old fonts may contain ellipsis at U+0085. Here we auto-detect most suitable ellipsis character.
    // FIXME: Also note that 0x2026 is currently seldom included in our font ranges. Because of this we are more likely to use three individual dots.
    for (int i = 0; i < atlas->Fonts.size(); i++)
    {
        ImFont* font = atlas->Fonts[i];
        if (font->EllipsisChar != (ImWchar)-1)
            continue;
        const ImWchar ellipsis_variants[] = { (ImWchar)0x2026, (ImWchar)0x0085 };
        for (int j = 0; j < IM_ARRAYSIZE(ellipsis_variants); j++)
            if (font->FindGlyphNoFallback(ellipsis_variants[j]) != NULL) // Verify glyph exists
            {
                font->EllipsisChar = ellipsis_variants[j];
                break;
            }
    }
}

References ImFont::AddGlyph(), ImFontAtlas::CalcCustomRectUV(), ImFont::ContainerAtlas, ImFontAtlas::CustomRects, ImFont::EllipsisChar, ImFont::FindGlyphNoFallback(), ImFontAtlasCustomRect::Font, ImFontAtlas::Fonts, ImFontAtlasCustomRect::GlyphAdvanceX, ImFontAtlasCustomRect::GlyphID, ImFontAtlasCustomRect::GlyphOffset, ImFontAtlasCustomRect::Height, IM_ARRAYSIZE, IM_ASSERT, ImFontAtlasBuildRenderDefaultTexData(), ImFontAtlasBuildRenderLinesTexData(), ImVector< T >::Size, ImVector< T >::size(), ImFontAtlas::TexPixelsAlpha8, ImFontAtlas::TexPixelsRGBA32, ImFontAtlasCustomRect::Width, ImVec2::x, and ImVec2::y.

Referenced by ImFontAtlasBuildWithStbTruetype().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ImFontAtlasBuildInit()

void ImFontAtlasBuildInit ( ImFontAtlas * atlas )

{
    // Register texture region for mouse cursors or standard white pixels
    if (atlas->PackIdMouseCursors < 0)
    {
        if (!(atlas->Flags & ImFontAtlasFlags_NoMouseCursors))
            atlas->PackIdMouseCursors = atlas->AddCustomRectRegular(FONT_ATLAS_DEFAULT_TEX_DATA_W * 2 + 1, FONT_ATLAS_DEFAULT_TEX_DATA_H);
        else
            atlas->PackIdMouseCursors = atlas->AddCustomRectRegular(2, 2);
    }
 
    // Register texture region for thick lines
    // The +2 here is to give space for the end caps, whilst height +1 is to accommodate the fact we have a zero-width row
    if (atlas->PackIdLines < 0)
    {
        if (!(atlas->Flags & ImFontAtlasFlags_NoBakedLines))
            atlas->PackIdLines = atlas->AddCustomRectRegular(IM_DRAWLIST_TEX_LINES_WIDTH_MAX + 2, IM_DRAWLIST_TEX_LINES_WIDTH_MAX + 1);
    }
}

References ImFontAtlas::AddCustomRectRegular(), ImFontAtlas::Flags, FONT_ATLAS_DEFAULT_TEX_DATA_H, FONT_ATLAS_DEFAULT_TEX_DATA_W, IM_DRAWLIST_TEX_LINES_WIDTH_MAX, ImFontAtlasFlags_NoBakedLines, ImFontAtlasFlags_NoMouseCursors, ImFontAtlas::PackIdLines, and ImFontAtlas::PackIdMouseCursors.

Referenced by ImFontAtlasBuildWithStbTruetype().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ImFontAtlasBuildMultiplyCalcLookupTable()

void ImFontAtlasBuildMultiplyCalcLookupTable	(	unsigned char	out_table[256],
		float	in_brighten_factor
	)

{
    for (unsigned int i = 0; i < 256; i++)
    {
        unsigned int value = (unsigned int)(i * in_brighten_factor);
        out_table[i] = value > 255 ? 255 : (value & 0xFF);
    }
}

Referenced by ImFontAtlasBuildWithStbTruetype().

Here is the caller graph for this function:

◆ ImFontAtlasBuildMultiplyRectAlpha8()

void ImFontAtlasBuildMultiplyRectAlpha8	(	const unsigned char	table[256],
		unsigned char *	pixels,
		int	x,
		int	y,
		int	w,
		int	h,
		int	stride
	)

{
    unsigned char* data = pixels + x + y * stride;
    for (int j = h; j > 0; j--, data += stride)
        for (int i = 0; i < w; i++)
            data[i] = table[data[i]];
}

Referenced by ImFontAtlasBuildWithStbTruetype().

Here is the caller graph for this function:

◆ ImFontAtlasBuildPackCustomRects()

void ImFontAtlasBuildPackCustomRects	(	ImFontAtlas *	atlas,
		void *	stbrp_context_opaque
	)

{
    stbrp_context* pack_context = (stbrp_context*)stbrp_context_opaque;
    IM_ASSERT(pack_context != NULL);
 
    ImVector<ImFontAtlasCustomRect>& user_rects = atlas->CustomRects;
    IM_ASSERT(user_rects.Size >= 1); // We expect at least the default custom rects to be registered, else something went wrong.
 
    ImVector<stbrp_rect> pack_rects;
    pack_rects.resize(user_rects.Size);
    memset(pack_rects.Data, 0, (size_t)pack_rects.size_in_bytes());
    for (int i = 0; i < user_rects.Size; i++)
    {
        pack_rects[i].w = user_rects[i].Width;
        pack_rects[i].h = user_rects[i].Height;
    }
    stbrp_pack_rects(pack_context, &pack_rects[0], pack_rects.Size);
    for (int i = 0; i < pack_rects.Size; i++)
        if (pack_rects[i].was_packed)
        {
            user_rects[i].X = pack_rects[i].x;
            user_rects[i].Y = pack_rects[i].y;
            IM_ASSERT(pack_rects[i].w == user_rects[i].Width && pack_rects[i].h == user_rects[i].Height);
            atlas->TexHeight = ImMax(atlas->TexHeight, pack_rects[i].y + pack_rects[i].h);
        }
}

References ImFontAtlas::CustomRects, ImVector< T >::Data, IM_ASSERT, ImMax(), ImVector< T >::resize(), ImVector< T >::Size, ImVector< T >::size_in_bytes(), stbrp_pack_rects(), and ImFontAtlas::TexHeight.

Referenced by ImFontAtlasBuildWithStbTruetype().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ImFontAtlasBuildRender32bppRectFromString()

void ImFontAtlasBuildRender32bppRectFromString	(	ImFontAtlas *	atlas,
		int	x,
		int	y,
		int	w,
		int	h,
		const char *	in_str,
		char	in_marker_char,
		unsigned int	in_marker_pixel_value
	)

{
    IM_ASSERT(x >= 0 && x + w <= atlas->TexWidth);
    IM_ASSERT(y >= 0 && y + h <= atlas->TexHeight);
    unsigned int* out_pixel = atlas->TexPixelsRGBA32 + x + (y * atlas->TexWidth);
    for (int off_y = 0; off_y < h; off_y++, out_pixel += atlas->TexWidth, in_str += w)
        for (int off_x = 0; off_x < w; off_x++)
            out_pixel[off_x] = (in_str[off_x] == in_marker_char) ? in_marker_pixel_value : IM_COL32_BLACK_TRANS;
}

References IM_ASSERT, IM_COL32_BLACK_TRANS, ImFontAtlas::TexPixelsRGBA32, and ImFontAtlas::TexWidth.

Referenced by ImFontAtlasBuildRenderDefaultTexData().

Here is the caller graph for this function:

◆ ImFontAtlasBuildRender8bppRectFromString()

void ImFontAtlasBuildRender8bppRectFromString	(	ImFontAtlas *	atlas,
		int	x,
		int	y,
		int	w,
		int	h,
		const char *	in_str,
		char	in_marker_char,
		unsigned char	in_marker_pixel_value
	)

{
    IM_ASSERT(x >= 0 && x + w <= atlas->TexWidth);
    IM_ASSERT(y >= 0 && y + h <= atlas->TexHeight);
    unsigned char* out_pixel = atlas->TexPixelsAlpha8 + x + (y * atlas->TexWidth);
    for (int off_y = 0; off_y < h; off_y++, out_pixel += atlas->TexWidth, in_str += w)
        for (int off_x = 0; off_x < w; off_x++)
            out_pixel[off_x] = (in_str[off_x] == in_marker_char) ? in_marker_pixel_value : 0x00;
}

References IM_ASSERT, ImFontAtlas::TexPixelsAlpha8, and ImFontAtlas::TexWidth.

Referenced by ImFontAtlasBuildRenderDefaultTexData().

Here is the caller graph for this function:

◆ ImFontAtlasBuildRenderDefaultTexData()

static void ImFontAtlasBuildRenderDefaultTexData ( ImFontAtlas * atlas )

static

{
    ImFontAtlasCustomRect* r = atlas->GetCustomRectByIndex(atlas->PackIdMouseCursors);
    IM_ASSERT(r->IsPacked());
 
    const int w = atlas->TexWidth;
    if (!(atlas->Flags & ImFontAtlasFlags_NoMouseCursors))
    {
        // Render/copy pixels
        IM_ASSERT(r->Width == FONT_ATLAS_DEFAULT_TEX_DATA_W * 2 + 1 && r->Height == FONT_ATLAS_DEFAULT_TEX_DATA_H);
        const int x_for_white = r->X;
        const int x_for_black = r->X + FONT_ATLAS_DEFAULT_TEX_DATA_W + 1;
        if (atlas->TexPixelsAlpha8 != NULL)
        {
            ImFontAtlasBuildRender8bppRectFromString(atlas, x_for_white, r->Y, FONT_ATLAS_DEFAULT_TEX_DATA_W, FONT_ATLAS_DEFAULT_TEX_DATA_H, FONT_ATLAS_DEFAULT_TEX_DATA_PIXELS, '.', 0xFF);
            ImFontAtlasBuildRender8bppRectFromString(atlas, x_for_black, r->Y, FONT_ATLAS_DEFAULT_TEX_DATA_W, FONT_ATLAS_DEFAULT_TEX_DATA_H, FONT_ATLAS_DEFAULT_TEX_DATA_PIXELS, 'X', 0xFF);
        }
        else
        {
            ImFontAtlasBuildRender32bppRectFromString(atlas, x_for_white, r->Y, FONT_ATLAS_DEFAULT_TEX_DATA_W, FONT_ATLAS_DEFAULT_TEX_DATA_H, FONT_ATLAS_DEFAULT_TEX_DATA_PIXELS, '.', IM_COL32_WHITE);
            ImFontAtlasBuildRender32bppRectFromString(atlas, x_for_black, r->Y, FONT_ATLAS_DEFAULT_TEX_DATA_W, FONT_ATLAS_DEFAULT_TEX_DATA_H, FONT_ATLAS_DEFAULT_TEX_DATA_PIXELS, 'X', IM_COL32_WHITE);
        }
    }
    else
    {
        // Render 4 white pixels
        IM_ASSERT(r->Width == 2 && r->Height == 2);
        const int offset = (int)r->X + (int)r->Y * w;
        if (atlas->TexPixelsAlpha8 != NULL)
        {
            atlas->TexPixelsAlpha8[offset] = atlas->TexPixelsAlpha8[offset + 1] = atlas->TexPixelsAlpha8[offset + w] = atlas->TexPixelsAlpha8[offset + w + 1] = 0xFF;
        }
        else
        {
            atlas->TexPixelsRGBA32[offset] = atlas->TexPixelsRGBA32[offset + 1] = atlas->TexPixelsRGBA32[offset + w] = atlas->TexPixelsRGBA32[offset + w + 1] = IM_COL32_WHITE;
        }
    }
    atlas->TexUvWhitePixel = ImVec2((r->X + 0.5f) * atlas->TexUvScale.x, (r->Y + 0.5f) * atlas->TexUvScale.y);
}

References ImFontAtlas::Flags, FONT_ATLAS_DEFAULT_TEX_DATA_H, FONT_ATLAS_DEFAULT_TEX_DATA_PIXELS, FONT_ATLAS_DEFAULT_TEX_DATA_W, ImFontAtlas::GetCustomRectByIndex(), ImFontAtlasCustomRect::Height, IM_ASSERT, IM_COL32_WHITE, ImFontAtlasBuildRender32bppRectFromString(), ImFontAtlasBuildRender8bppRectFromString(), ImFontAtlasFlags_NoMouseCursors, ImFontAtlasCustomRect::IsPacked(), ImFontAtlas::PackIdMouseCursors, ImFontAtlas::TexPixelsAlpha8, ImFontAtlas::TexPixelsRGBA32, ImFontAtlas::TexUvScale, ImFontAtlas::TexUvWhitePixel, ImFontAtlas::TexWidth, ImFontAtlasCustomRect::Width, ImVec2::x, ImFontAtlasCustomRect::X, ImVec2::y, and ImFontAtlasCustomRect::Y.

Referenced by ImFontAtlasBuildFinish().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ImFontAtlasBuildRenderLinesTexData()

static void ImFontAtlasBuildRenderLinesTexData ( ImFontAtlas * atlas )

static

{
    if (atlas->Flags & ImFontAtlasFlags_NoBakedLines)
        return;
 
    // This generates a triangular shape in the texture, with the various line widths stacked on top of each other to allow interpolation between them
    ImFontAtlasCustomRect* r = atlas->GetCustomRectByIndex(atlas->PackIdLines);
    IM_ASSERT(r->IsPacked());
    for (unsigned int n = 0; n < IM_DRAWLIST_TEX_LINES_WIDTH_MAX + 1; n++) // +1 because of the zero-width row
    {
        // Each line consists of at least two empty pixels at the ends, with a line of solid pixels in the middle
        unsigned int y = n;
        unsigned int line_width = n;
        unsigned int pad_left = (r->Width - line_width) / 2;
        unsigned int pad_right = r->Width - (pad_left + line_width);
 
        // Write each slice
        IM_ASSERT(pad_left + line_width + pad_right == r->Width && y < r->Height); // Make sure we're inside the texture bounds before we start writing pixels
        if (atlas->TexPixelsAlpha8 != NULL)
        {
            unsigned char* write_ptr = &atlas->TexPixelsAlpha8[r->X + ((r->Y + y) * atlas->TexWidth)];
            for (unsigned int i = 0; i < pad_left; i++)
                *(write_ptr + i) = 0x00;
 
            for (unsigned int i = 0; i < line_width; i++)
                *(write_ptr + pad_left + i) = 0xFF;
 
            for (unsigned int i = 0; i < pad_right; i++)
                *(write_ptr + pad_left + line_width + i) = 0x00;
        }
        else
        {
            unsigned int* write_ptr = &atlas->TexPixelsRGBA32[r->X + ((r->Y + y) * atlas->TexWidth)];
            for (unsigned int i = 0; i < pad_left; i++)
                *(write_ptr + i) = IM_COL32_BLACK_TRANS;
 
            for (unsigned int i = 0; i < line_width; i++)
                *(write_ptr + pad_left + i) = IM_COL32_WHITE;
 
            for (unsigned int i = 0; i < pad_right; i++)
                *(write_ptr + pad_left + line_width + i) = IM_COL32_BLACK_TRANS;
        }
 
        // Calculate UVs for this line
        ImVec2 uv0 = ImVec2((float)(r->X + pad_left - 1), (float)(r->Y + y)) * atlas->TexUvScale;
        ImVec2 uv1 = ImVec2((float)(r->X + pad_left + line_width + 1), (float)(r->Y + y + 1)) * atlas->TexUvScale;
        float half_v = (uv0.y + uv1.y) * 0.5f; // Calculate a constant V in the middle of the row to avoid sampling artifacts
        atlas->TexUvLines[n] = ImVec4(uv0.x, half_v, uv1.x, half_v);
    }
}

References ImFontAtlas::Flags, ImFontAtlas::GetCustomRectByIndex(), IM_ASSERT, IM_COL32_BLACK_TRANS, IM_COL32_WHITE, IM_DRAWLIST_TEX_LINES_WIDTH_MAX, ImFontAtlasFlags_NoBakedLines, ImFontAtlasCustomRect::IsPacked(), ImFontAtlas::PackIdLines, ImFontAtlas::TexPixelsAlpha8, ImFontAtlas::TexPixelsRGBA32, ImFontAtlas::TexUvLines, ImFontAtlas::TexUvScale, ImFontAtlas::TexWidth, ImFontAtlasCustomRect::Width, ImVec2::x, ImFontAtlasCustomRect::X, ImVec2::y, and ImFontAtlasCustomRect::Y.

Referenced by ImFontAtlasBuildFinish().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ImFontAtlasBuildSetupFont()

void ImFontAtlasBuildSetupFont	(	ImFontAtlas *	atlas,
		ImFont *	font,
		ImFontConfig *	font_config,
		float	ascent,
		float	descent
	)

{
    if (!font_config->MergeMode)
    {
        font->ClearOutputData();
        font->FontSize = font_config->SizePixels;
        font->ConfigData = font_config;
        font->ConfigDataCount = 0;
        font->ContainerAtlas = atlas;
        font->Ascent = ascent;
        font->Descent = descent;
    }
    font->ConfigDataCount++;
}

References ImFont::Ascent, ImFont::ClearOutputData(), ImFont::ConfigData, ImFont::ConfigDataCount, ImFont::ContainerAtlas, ImFont::Descent, ImFont::FontSize, ImFontConfig::MergeMode, and ImFontConfig::SizePixels.

Referenced by ImFontAtlasBuildWithStbTruetype().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ImFontAtlasBuildWithStbTruetype()

static bool ImFontAtlasBuildWithStbTruetype ( ImFontAtlas * atlas )

static

{
    IM_ASSERT(atlas->ConfigData.Size > 0);
 
    ImFontAtlasBuildInit(atlas);
 
    // Clear atlas
    atlas->TexID = (ImTextureID)NULL;
    atlas->TexWidth = atlas->TexHeight = 0;
    atlas->TexUvScale = ImVec2(0.0f, 0.0f);
    atlas->TexUvWhitePixel = ImVec2(0.0f, 0.0f);
    atlas->ClearTexData();
 
    // Temporary storage for building
    ImVector<ImFontBuildSrcData> src_tmp_array;
    ImVector<ImFontBuildDstData> dst_tmp_array;
    src_tmp_array.resize(atlas->ConfigData.Size);
    dst_tmp_array.resize(atlas->Fonts.Size);
    memset(src_tmp_array.Data, 0, (size_t)src_tmp_array.size_in_bytes());
    memset(dst_tmp_array.Data, 0, (size_t)dst_tmp_array.size_in_bytes());
 
    // 1. Initialize font loading structure, check font data validity
    for (int src_i = 0; src_i < atlas->ConfigData.Size; src_i++)
    {
        ImFontBuildSrcData& src_tmp = src_tmp_array[src_i];
        ImFontConfig& cfg = atlas->ConfigData[src_i];
        IM_ASSERT(cfg.DstFont && (!cfg.DstFont->IsLoaded() || cfg.DstFont->ContainerAtlas == atlas));
 
        // Find index from cfg.DstFont (we allow the user to set cfg.DstFont. Also it makes casual debugging nicer than when storing indices)
        src_tmp.DstIndex = -1;
        for (int output_i = 0; output_i < atlas->Fonts.Size && src_tmp.DstIndex == -1; output_i++)
            if (cfg.DstFont == atlas->Fonts[output_i])
                src_tmp.DstIndex = output_i;
        if (src_tmp.DstIndex == -1)
        {
            IM_ASSERT(src_tmp.DstIndex != -1); // cfg.DstFont not pointing within atlas->Fonts[] array?
            return false;
        }
        // Initialize helper structure for font loading and verify that the TTF/OTF data is correct
        const int font_offset = stbtt_GetFontOffsetForIndex((unsigned char*)cfg.FontData, cfg.FontNo);
        IM_ASSERT(font_offset >= 0 && "FontData is incorrect, or FontNo cannot be found.");
        if (!stbtt_InitFont(&src_tmp.FontInfo, (unsigned char*)cfg.FontData, font_offset))
            return false;
 
        // Measure highest codepoints
        ImFontBuildDstData& dst_tmp = dst_tmp_array[src_tmp.DstIndex];
        src_tmp.SrcRanges = cfg.GlyphRanges ? cfg.GlyphRanges : atlas->GetGlyphRangesDefault();
        for (const ImWchar* src_range = src_tmp.SrcRanges; src_range[0] && src_range[1]; src_range += 2)
            src_tmp.GlyphsHighest = ImMax(src_tmp.GlyphsHighest, (int)src_range[1]);
        dst_tmp.SrcCount++;
        dst_tmp.GlyphsHighest = ImMax(dst_tmp.GlyphsHighest, src_tmp.GlyphsHighest);
    }
 
    // 2. For every requested codepoint, check for their presence in the font data, and handle redundancy or overlaps between source fonts to avoid unused glyphs.
    int total_glyphs_count = 0;
    for (int src_i = 0; src_i < src_tmp_array.Size; src_i++)
    {
        ImFontBuildSrcData& src_tmp = src_tmp_array[src_i];
        ImFontBuildDstData& dst_tmp = dst_tmp_array[src_tmp.DstIndex];
        src_tmp.GlyphsSet.Create(src_tmp.GlyphsHighest + 1);
        if (dst_tmp.GlyphsSet.Storage.empty())
            dst_tmp.GlyphsSet.Create(dst_tmp.GlyphsHighest + 1);
 
        for (const ImWchar* src_range = src_tmp.SrcRanges; src_range[0] && src_range[1]; src_range += 2)
            for (unsigned int codepoint = src_range[0]; codepoint <= src_range[1]; codepoint++)
            {
                if (dst_tmp.GlyphsSet.TestBit(codepoint))    // Don't overwrite existing glyphs. We could make this an option for MergeMode (e.g. MergeOverwrite==true)
                    continue;
                if (!stbtt_FindGlyphIndex(&src_tmp.FontInfo, codepoint))    // It is actually in the font?
                    continue;
 
                // Add to avail set/counters
                src_tmp.GlyphsCount++;
                dst_tmp.GlyphsCount++;
                src_tmp.GlyphsSet.SetBit(codepoint);
                dst_tmp.GlyphsSet.SetBit(codepoint);
                total_glyphs_count++;
            }
    }
 
    // 3. Unpack our bit map into a flat list (we now have all the Unicode points that we know are requested _and_ available _and_ not overlapping another)
    for (int src_i = 0; src_i < src_tmp_array.Size; src_i++)
    {
        ImFontBuildSrcData& src_tmp = src_tmp_array[src_i];
        src_tmp.GlyphsList.reserve(src_tmp.GlyphsCount);
        UnpackBitVectorToFlatIndexList(&src_tmp.GlyphsSet, &src_tmp.GlyphsList);
        src_tmp.GlyphsSet.Clear();
        IM_ASSERT(src_tmp.GlyphsList.Size == src_tmp.GlyphsCount);
    }
    for (int dst_i = 0; dst_i < dst_tmp_array.Size; dst_i++)
        dst_tmp_array[dst_i].GlyphsSet.Clear();
    dst_tmp_array.clear();
 
    // Allocate packing character data and flag packed characters buffer as non-packed (x0=y0=x1=y1=0)
    // (We technically don't need to zero-clear buf_rects, but let's do it for the sake of sanity)
    ImVector<stbrp_rect> buf_rects;
    ImVector<stbtt_packedchar> buf_packedchars;
    buf_rects.resize(total_glyphs_count);
    buf_packedchars.resize(total_glyphs_count);
    memset(buf_rects.Data, 0, (size_t)buf_rects.size_in_bytes());
    memset(buf_packedchars.Data, 0, (size_t)buf_packedchars.size_in_bytes());
 
    // 4. Gather glyphs sizes so we can pack them in our virtual canvas.
    int total_surface = 0;
    int buf_rects_out_n = 0;
    int buf_packedchars_out_n = 0;
    for (int src_i = 0; src_i < src_tmp_array.Size; src_i++)
    {
        ImFontBuildSrcData& src_tmp = src_tmp_array[src_i];
        if (src_tmp.GlyphsCount == 0)
            continue;
 
        src_tmp.Rects = &buf_rects[buf_rects_out_n];
        src_tmp.PackedChars = &buf_packedchars[buf_packedchars_out_n];
        buf_rects_out_n += src_tmp.GlyphsCount;
        buf_packedchars_out_n += src_tmp.GlyphsCount;
 
        // Convert our ranges in the format stb_truetype wants
        ImFontConfig& cfg = atlas->ConfigData[src_i];
        src_tmp.PackRange.font_size = cfg.SizePixels;
        src_tmp.PackRange.first_unicode_codepoint_in_range = 0;
        src_tmp.PackRange.array_of_unicode_codepoints = src_tmp.GlyphsList.Data;
        src_tmp.PackRange.num_chars = src_tmp.GlyphsList.Size;
        src_tmp.PackRange.chardata_for_range = src_tmp.PackedChars;
        src_tmp.PackRange.h_oversample = (unsigned char)cfg.OversampleH;
        src_tmp.PackRange.v_oversample = (unsigned char)cfg.OversampleV;
 
        // Gather the sizes of all rectangles we will need to pack (this loop is based on stbtt_PackFontRangesGatherRects)
        const float scale = (cfg.SizePixels > 0) ? stbtt_ScaleForPixelHeight(&src_tmp.FontInfo, cfg.SizePixels) : stbtt_ScaleForMappingEmToPixels(&src_tmp.FontInfo, -cfg.SizePixels);
        const int padding = atlas->TexGlyphPadding;
        for (int glyph_i = 0; glyph_i < src_tmp.GlyphsList.Size; glyph_i++)
        {
            int x0, y0, x1, y1;
            const int glyph_index_in_font = stbtt_FindGlyphIndex(&src_tmp.FontInfo, src_tmp.GlyphsList[glyph_i]);
            IM_ASSERT(glyph_index_in_font != 0);
            stbtt_GetGlyphBitmapBoxSubpixel(&src_tmp.FontInfo, glyph_index_in_font, scale * cfg.OversampleH, scale * cfg.OversampleV, 0, 0, &x0, &y0, &x1, &y1);
            src_tmp.Rects[glyph_i].w = (stbrp_coord)(x1 - x0 + padding + cfg.OversampleH - 1);
            src_tmp.Rects[glyph_i].h = (stbrp_coord)(y1 - y0 + padding + cfg.OversampleV - 1);
            total_surface += src_tmp.Rects[glyph_i].w * src_tmp.Rects[glyph_i].h;
        }
    }
 
    // We need a width for the skyline algorithm, any width!
    // The exact width doesn't really matter much, but some API/GPU have texture size limitations and increasing width can decrease height.
    // User can override TexDesiredWidth and TexGlyphPadding if they wish, otherwise we use a simple heuristic to select the width based on expected surface.
    const int surface_sqrt = (int)ImSqrt((float)total_surface) + 1;
    atlas->TexHeight = 0;
    if (atlas->TexDesiredWidth > 0)
        atlas->TexWidth = atlas->TexDesiredWidth;
    else
        atlas->TexWidth = (surface_sqrt >= 4096 * 0.7f) ? 4096 : (surface_sqrt >= 2048 * 0.7f) ? 2048 : (surface_sqrt >= 1024 * 0.7f) ? 1024 : 512;
 
    // 5. Start packing
    // Pack our extra data rectangles first, so it will be on the upper-left corner of our texture (UV will have small values).
    const int TEX_HEIGHT_MAX = 1024 * 32;
    stbtt_pack_context spc = {};
    stbtt_PackBegin(&spc, NULL, atlas->TexWidth, TEX_HEIGHT_MAX, 0, atlas->TexGlyphPadding, NULL);
    ImFontAtlasBuildPackCustomRects(atlas, spc.pack_info);
 
    // 6. Pack each source font. No rendering yet, we are working with rectangles in an infinitely tall texture at this point.
    for (int src_i = 0; src_i < src_tmp_array.Size; src_i++)
    {
        ImFontBuildSrcData& src_tmp = src_tmp_array[src_i];
        if (src_tmp.GlyphsCount == 0)
            continue;
 
        stbrp_pack_rects((stbrp_context*)spc.pack_info, src_tmp.Rects, src_tmp.GlyphsCount);
 
        // Extend texture height and mark missing glyphs as non-packed so we won't render them.
        // FIXME: We are not handling packing failure here (would happen if we got off TEX_HEIGHT_MAX or if a single if larger than TexWidth?)
        for (int glyph_i = 0; glyph_i < src_tmp.GlyphsCount; glyph_i++)
            if (src_tmp.Rects[glyph_i].was_packed)
                atlas->TexHeight = ImMax(atlas->TexHeight, src_tmp.Rects[glyph_i].y + src_tmp.Rects[glyph_i].h);
    }
 
    // 7. Allocate texture
    atlas->TexHeight = (atlas->Flags & ImFontAtlasFlags_NoPowerOfTwoHeight) ? (atlas->TexHeight + 1) : ImUpperPowerOfTwo(atlas->TexHeight);
    atlas->TexUvScale = ImVec2(1.0f / atlas->TexWidth, 1.0f / atlas->TexHeight);
    atlas->TexPixelsAlpha8 = (unsigned char*)IM_ALLOC(atlas->TexWidth * atlas->TexHeight);
    memset(atlas->TexPixelsAlpha8, 0, atlas->TexWidth * atlas->TexHeight);
    spc.pixels = atlas->TexPixelsAlpha8;
    spc.height = atlas->TexHeight;
 
    // 8. Render/rasterize font characters into the texture
    for (int src_i = 0; src_i < src_tmp_array.Size; src_i++)
    {
        ImFontConfig& cfg = atlas->ConfigData[src_i];
        ImFontBuildSrcData& src_tmp = src_tmp_array[src_i];
        if (src_tmp.GlyphsCount == 0)
            continue;
 
        stbtt_PackFontRangesRenderIntoRects(&spc, &src_tmp.FontInfo, &src_tmp.PackRange, 1, src_tmp.Rects);
 
        // Apply multiply operator
        if (cfg.RasterizerMultiply != 1.0f)
        {
            unsigned char multiply_table[256];
            ImFontAtlasBuildMultiplyCalcLookupTable(multiply_table, cfg.RasterizerMultiply);
            stbrp_rect* r = &src_tmp.Rects[0];
            for (int glyph_i = 0; glyph_i < src_tmp.GlyphsCount; glyph_i++, r++)
                if (r->was_packed)
                    ImFontAtlasBuildMultiplyRectAlpha8(multiply_table, atlas->TexPixelsAlpha8, r->x, r->y, r->w, r->h, atlas->TexWidth * 1);
        }
        src_tmp.Rects = NULL;
    }
 
    // End packing
    stbtt_PackEnd(&spc);
    buf_rects.clear();
 
    // 9. Setup ImFont and glyphs for runtime
    for (int src_i = 0; src_i < src_tmp_array.Size; src_i++)
    {
        ImFontBuildSrcData& src_tmp = src_tmp_array[src_i];
        if (src_tmp.GlyphsCount == 0)
            continue;
 
        // When merging fonts with MergeMode=true:
        // - We can have multiple input fonts writing into a same destination font.
        // - dst_font->ConfigData is != from cfg which is our source configuration.
        ImFontConfig& cfg = atlas->ConfigData[src_i];
        ImFont* dst_font = cfg.DstFont;
 
        const float font_scale = stbtt_ScaleForPixelHeight(&src_tmp.FontInfo, cfg.SizePixels);
        int unscaled_ascent, unscaled_descent, unscaled_line_gap;
        stbtt_GetFontVMetrics(&src_tmp.FontInfo, &unscaled_ascent, &unscaled_descent, &unscaled_line_gap);
 
        const float ascent = ImFloor(unscaled_ascent * font_scale + ((unscaled_ascent > 0.0f) ? +1 : -1));
        const float descent = ImFloor(unscaled_descent * font_scale + ((unscaled_descent > 0.0f) ? +1 : -1));
        ImFontAtlasBuildSetupFont(atlas, dst_font, &cfg, ascent, descent);
        const float font_off_x = cfg.GlyphOffset.x;
        const float font_off_y = cfg.GlyphOffset.y + IM_ROUND(dst_font->Ascent);
 
        for (int glyph_i = 0; glyph_i < src_tmp.GlyphsCount; glyph_i++)
        {
            // Register glyph
            const int codepoint = src_tmp.GlyphsList[glyph_i];
            const stbtt_packedchar& pc = src_tmp.PackedChars[glyph_i];
            stbtt_aligned_quad q;
            float unused_x = 0.0f, unused_y = 0.0f;
            stbtt_GetPackedQuad(src_tmp.PackedChars, atlas->TexWidth, atlas->TexHeight, glyph_i, &unused_x, &unused_y, &q, 0);
            dst_font->AddGlyph(&cfg, (ImWchar)codepoint, q.x0 + font_off_x, q.y0 + font_off_y, q.x1 + font_off_x, q.y1 + font_off_y, q.s0, q.t0, q.s1, q.t1, pc.xadvance);
        }
    }
 
    // Cleanup temporary (ImVector doesn't honor destructor)
    for (int src_i = 0; src_i < src_tmp_array.Size; src_i++)
        src_tmp_array[src_i].~ImFontBuildSrcData();
 
    ImFontAtlasBuildFinish(atlas);
    return true;
}

Referenced by ImFontAtlasGetBuilderForStbTruetype().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ImFontAtlasGetBuilderForStbTruetype()

const ImFontBuilderIO * ImFontAtlasGetBuilderForStbTruetype ( )

{
    static ImFontBuilderIO io;
    io.FontBuilder_Build = ImFontAtlasBuildWithStbTruetype;
    return &io;
}

References ImFontBuilderIO::FontBuilder_Build, and ImFontAtlasBuildWithStbTruetype().

Referenced by ImFontAtlas::Build().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PathBezierCubicCurveToCasteljau()

static void PathBezierCubicCurveToCasteljau	(	ImVector< ImVec2 > *	path,
		float	x1,
		float	y1,
		float	x2,
		float	y2,
		float	x3,
		float	y3,
		float	x4,
		float	y4,
		float	tess_tol,
		int	level
	)

static

{
    float dx = x4 - x1;
    float dy = y4 - y1;
    float d2 = (x2 - x4) * dy - (y2 - y4) * dx;
    float d3 = (x3 - x4) * dy - (y3 - y4) * dx;
    d2 = (d2 >= 0) ? d2 : -d2;
    d3 = (d3 >= 0) ? d3 : -d3;
    if ((d2 + d3) * (d2 + d3) < tess_tol * (dx * dx + dy * dy))
    {
        path->push_back(ImVec2(x4, y4));
    }
    else if (level < 10)
    {
        float x12 = (x1 + x2) * 0.5f, y12 = (y1 + y2) * 0.5f;
        float x23 = (x2 + x3) * 0.5f, y23 = (y2 + y3) * 0.5f;
        float x34 = (x3 + x4) * 0.5f, y34 = (y3 + y4) * 0.5f;
        float x123 = (x12 + x23) * 0.5f, y123 = (y12 + y23) * 0.5f;
        float x234 = (x23 + x34) * 0.5f, y234 = (y23 + y34) * 0.5f;
        float x1234 = (x123 + x234) * 0.5f, y1234 = (y123 + y234) * 0.5f;
        PathBezierCubicCurveToCasteljau(path, x1, y1, x12, y12, x123, y123, x1234, y1234, tess_tol, level + 1);
        PathBezierCubicCurveToCasteljau(path, x1234, y1234, x234, y234, x34, y34, x4, y4, tess_tol, level + 1);
    }
}

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

Referenced by ImDrawList::PathBezierCubicCurveTo(), and PathBezierCubicCurveToCasteljau().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PathBezierQuadraticCurveToCasteljau()

static void PathBezierQuadraticCurveToCasteljau	(	ImVector< ImVec2 > *	path,
		float	x1,
		float	y1,
		float	x2,
		float	y2,
		float	x3,
		float	y3,
		float	tess_tol,
		int	level
	)

static

{
    float dx = x3 - x1, dy = y3 - y1;
    float det = (x2 - x3) * dy - (y2 - y3) * dx;
    if (det * det * 4.0f < tess_tol * (dx * dx + dy * dy))
    {
        path->push_back(ImVec2(x3, y3));
    }
    else if (level < 10)
    {
        float x12 = (x1 + x2) * 0.5f, y12 = (y1 + y2) * 0.5f;
        float x23 = (x2 + x3) * 0.5f, y23 = (y2 + y3) * 0.5f;
        float x123 = (x12 + x23) * 0.5f, y123 = (y12 + y23) * 0.5f;
        PathBezierQuadraticCurveToCasteljau(path, x1, y1, x12, y12, x123, y123, tess_tol, level + 1);
        PathBezierQuadraticCurveToCasteljau(path, x123, y123, x23, y23, x3, y3, tess_tol, level + 1);
    }
}

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

Referenced by ImDrawList::PathBezierQuadraticCurveTo(), and PathBezierQuadraticCurveToCasteljau().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stb__lit()

static void stb__lit	(	const unsigned char *	data,
		unsigned int	length
	)

static

{
    IM_ASSERT(stb__dout + length <= stb__barrier_out_e);
    if (stb__dout + length > stb__barrier_out_e) { stb__dout += length; return; }
    if (data < stb__barrier_in_b) { stb__dout = stb__barrier_out_e+1; return; }
    memcpy(stb__dout, data, length);
    stb__dout += length;
}

References IM_ASSERT, stb__barrier_in_b, stb__barrier_out_e, and stb__dout.

Referenced by stb_decompress_token().

Here is the caller graph for this function:

◆ stb__match()

static void stb__match	(	const unsigned char *	data,
		unsigned int	length
	)

static

{
    // INVERSE of memmove... write each byte before copying the next...
    IM_ASSERT(stb__dout + length <= stb__barrier_out_e);
    if (stb__dout + length > stb__barrier_out_e) { stb__dout += length; return; }
    if (data < stb__barrier_out_b) { stb__dout = stb__barrier_out_e+1; return; }
    while (length--) *stb__dout++ = *data++;
}

References IM_ASSERT, stb__barrier_out_b, stb__barrier_out_e, and stb__dout.

Referenced by stb_decompress_token().

Here is the caller graph for this function:

◆ stb_adler32()

static unsigned int stb_adler32	(	unsigned int	adler32,
		unsigned char *	buffer,
		unsigned int	buflen
	)

static

{
    const unsigned long ADLER_MOD = 65521;
    unsigned long s1 = adler32 & 0xffff, s2 = adler32 >> 16;
    unsigned long blocklen = buflen % 5552;
 
    unsigned long i;
    while (buflen) {
        for (i=0; i + 7 < blocklen; i += 8) {
            s1 += buffer[0], s2 += s1;
            s1 += buffer[1], s2 += s1;
            s1 += buffer[2], s2 += s1;
            s1 += buffer[3], s2 += s1;
            s1 += buffer[4], s2 += s1;
            s1 += buffer[5], s2 += s1;
            s1 += buffer[6], s2 += s1;
            s1 += buffer[7], s2 += s1;
 
            buffer += 8;
        }
 
        for (; i < blocklen; ++i)
            s1 += *buffer++, s2 += s1;
 
        s1 %= ADLER_MOD, s2 %= ADLER_MOD;
        buflen -= blocklen;
        blocklen = 5552;
    }
    return (unsigned int)(s2 << 16) + (unsigned int)s1;
}

References adler32.

Referenced by stb_decompress().

Here is the caller graph for this function:

◆ stb_decompress()

static unsigned int stb_decompress	(	unsigned char *	output,
		const unsigned char *	input,
		unsigned int	length
	)

static

{
    if (stb__in4(0) != 0x57bC0000) return 0;
    if (stb__in4(4) != 0)          return 0; // error! stream is > 4GB
    const unsigned int olen = stb_decompress_length(i);
    stb__barrier_in_b = i;
    stb__barrier_out_e = output + olen;
    stb__barrier_out_b = output;
    i += 16;
 
    stb__dout = output;
    for (;;) {
        const unsigned char *old_i = i;
        i = stb_decompress_token(i);
        if (i == old_i) {
            if (*i == 0x05 && i[1] == 0xfa) {
                IM_ASSERT(stb__dout == output + olen);
                if (stb__dout != output + olen) return 0;
                if (stb_adler32(1, output, olen) != (unsigned int) stb__in4(2))
                    return 0;
                return olen;
            } else {
                IM_ASSERT(0); /* NOTREACHED */
                return 0;
            }
        }
        IM_ASSERT(stb__dout <= output + olen);
        if (stb__dout > output + olen)
            return 0;
    }
}

References IM_ASSERT, stb__barrier_in_b, stb__barrier_out_b, stb__barrier_out_e, stb__dout, stb__in4, stb_adler32(), stb_decompress_length(), and stb_decompress_token().

Referenced by ImFontAtlas::AddFontFromMemoryCompressedTTF().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stb_decompress_length()

static unsigned int stb_decompress_length ( const unsigned char * input )

static

{
    return (input[8] << 24) + (input[9] << 16) + (input[10] << 8) + input[11];
}

References input().

Referenced by ImFontAtlas::AddFontFromMemoryCompressedTTF(), and stb_decompress().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stb_decompress_token()

static const unsigned char * stb_decompress_token ( const unsigned char * i )

static

{
    if (*i >= 0x20) { // use fewer if's for cases that expand small
        if (*i >= 0x80)       stb__match(stb__dout-i[1]-1, i[0] - 0x80 + 1), i += 2;
        else if (*i >= 0x40)  stb__match(stb__dout-(stb__in2(0) - 0x4000 + 1), i[2]+1), i += 3;
        else /* *i >= 0x20 */ stb__lit(i+1, i[0] - 0x20 + 1), i += 1 + (i[0] - 0x20 + 1);
    } else { // more ifs for cases that expand large, since overhead is amortized
        if (*i >= 0x18)       stb__match(stb__dout-(stb__in3(0) - 0x180000 + 1), i[3]+1), i += 4;
        else if (*i >= 0x10)  stb__match(stb__dout-(stb__in3(0) - 0x100000 + 1), stb__in2(3)+1), i += 5;
        else if (*i >= 0x08)  stb__lit(i+2, stb__in2(0) - 0x0800 + 1), i += 2 + (stb__in2(0) - 0x0800 + 1);
        else if (*i == 0x07)  stb__lit(i+3, stb__in2(1) + 1), i += 3 + (stb__in2(1) + 1);
        else if (*i == 0x06)  stb__match(stb__dout-(stb__in3(1)+1), i[4]+1), i += 5;
        else if (*i == 0x04)  stb__match(stb__dout-(stb__in3(1)+1), stb__in2(4)+1), i += 6;
    }
    return i;
}

References stb__dout, stb__in2, stb__in3, stb__lit(), and stb__match().

Referenced by stb_decompress().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UnpackAccumulativeOffsetsIntoRanges()

static void UnpackAccumulativeOffsetsIntoRanges	(	int	base_codepoint,
		const short *	accumulative_offsets,
		int	accumulative_offsets_count,
		ImWchar *	out_ranges
	)

static

{
    for (int n = 0; n < accumulative_offsets_count; n++, out_ranges += 2)
    {
        out_ranges[0] = out_ranges[1] = (ImWchar)(base_codepoint + accumulative_offsets[n]);
        base_codepoint += accumulative_offsets[n];
    }
    out_ranges[0] = 0;
}

Referenced by ImFontAtlas::GetGlyphRangesChineseSimplifiedCommon(), and ImFontAtlas::GetGlyphRangesJapanese().

Here is the caller graph for this function:

◆ UnpackBitVectorToFlatIndexList()

static void UnpackBitVectorToFlatIndexList	(	const ImBitVector *	in,
		ImVector< int > *	out
	)

static

{
    IM_ASSERT(sizeof(in->Storage.Data[0]) == sizeof(int));
    const ImU32* it_begin = in->Storage.begin();
    const ImU32* it_end = in->Storage.end();
    for (const ImU32* it = it_begin; it < it_end; it++)
        if (ImU32 entries_32 = *it)
            for (ImU32 bit_n = 0; bit_n < 32; bit_n++)
                if (entries_32 & ((ImU32)1 << bit_n))
                    out->push_back((int)(((it - it_begin) << 5) + bit_n));
}

References ImVector< T >::begin(), ImVector< T >::Data, ImVector< T >::end(), IM_ASSERT, ImVector< T >::push_back(), and ImBitVector::Storage.

Referenced by ImFontAtlasBuildWithStbTruetype().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ FONT_ATLAS_DEFAULT_TEX_CURSOR_DATA

const ImVec2 FONT_ATLAS_DEFAULT_TEX_CURSOR_DATA[ImGuiMouseCursor_COUNT][3]

static

Initial value:

=
{
    
    { ImVec2( 0,3), ImVec2(12,19), ImVec2( 0, 0) }, 
    { ImVec2(13,0), ImVec2( 7,16), ImVec2( 1, 8) }, 
    { ImVec2(31,0), ImVec2(23,23), ImVec2(11,11) }, 
    { ImVec2(21,0), ImVec2( 9,23), ImVec2( 4,11) }, 
    { ImVec2(55,18),ImVec2(23, 9), ImVec2(11, 4) }, 
    { ImVec2(73,0), ImVec2(17,17), ImVec2( 8, 8) }, 
    { ImVec2(55,0), ImVec2(17,17), ImVec2( 8, 8) }, 
    { ImVec2(91,0), ImVec2(17,22), ImVec2( 5, 0) }, 
}

Referenced by ImFontAtlas::GetMouseCursorTexData().

◆ FONT_ATLAS_DEFAULT_TEX_DATA_H

const int FONT_ATLAS_DEFAULT_TEX_DATA_H = 27

Referenced by ImFontAtlasBuildInit(), and ImFontAtlasBuildRenderDefaultTexData().

◆ FONT_ATLAS_DEFAULT_TEX_DATA_PIXELS

const char FONT_ATLAS_DEFAULT_TEX_DATA_PIXELS[FONT_ATLAS_DEFAULT_TEX_DATA_W *FONT_ATLAS_DEFAULT_TEX_DATA_H+1]

static

Initial value:

=
{
    "..-         -XXXXXXX-    X    -           X           -XXXXXXX          -          XXXXXXX-     XX          "
    "..-         -X.....X-   X.X   -          X.X          -X.....X          -          X.....X-    X..X         "
    "---         -XXX.XXX-  X...X  -         X...X         -X....X           -           X....X-    X..X         "
    "X           -  X.X  - X.....X -        X.....X        -X...X            -            X...X-    X..X         "
    "XX          -  X.X  -X.......X-       X.......X       -X..X.X           -           X.X..X-    X..X         "
    "X.X         -  X.X  -XXXX.XXXX-       XXXX.XXXX       -X.X X.X          -          X.X X.X-    X..XXX       "
    "X..X        -  X.X  -   X.X   -          X.X          -XX   X.X         -         X.X   XX-    X..X..XXX    "
    "X...X       -  X.X  -   X.X   -    XX    X.X    XX    -      X.X        -        X.X      -    X..X..X..XX  "
    "X....X      -  X.X  -   X.X   -   X.X    X.X    X.X   -       X.X       -       X.X       -    X..X..X..X.X "
    "X.....X     -  X.X  -   X.X   -  X..X    X.X    X..X  -        X.X      -      X.X        -XXX X..X..X..X..X"
    "X......X    -  X.X  -   X.X   - X...XXXXXX.XXXXXX...X -         X.X   XX-XX   X.X         -X..XX........X..X"
    "X.......X   -  X.X  -   X.X   -X.....................X-          X.X X.X-X.X X.X          -X...X...........X"
    "X........X  -  X.X  -   X.X   - X...XXXXXX.XXXXXX...X -           X.X..X-X..X.X           - X..............X"
    "X.........X -XXX.XXX-   X.X   -  X..X    X.X    X..X  -            X...X-X...X            -  X.............X"
    "X..........X-X.....X-   X.X   -   X.X    X.X    X.X   -           X....X-X....X           -  X.............X"
    "X......XXXXX-XXXXXXX-   X.X   -    XX    X.X    XX    -          X.....X-X.....X          -   X............X"
    "X...X..X    ---------   X.X   -          X.X          -          XXXXXXX-XXXXXXX          -   X...........X "
    "X..X X..X   -       -XXXX.XXXX-       XXXX.XXXX       -------------------------------------    X..........X "
    "X.X  X..X   -       -X.......X-       X.......X       -    XX           XX    -           -    X..........X "
    "XX    X..X  -       - X.....X -        X.....X        -   X.X           X.X   -           -     X........X  "
    "      X..X          -  X...X  -         X...X         -  X..X           X..X  -           -     X........X  "
    "       XX           -   X.X   -          X.X          - X...XXXXXXXXXXXXX...X -           -     XXXXXXXXXX  "
    "------------        -    X    -           X           -X.....................X-           ------------------"
    "                    ----------------------------------- X...XXXXXXXXXXXXX...X -                             "
    "                                                      -  X..X           X..X  -                             "
    "                                                      -   X.X           X.X   -                             "
    "                                                      -    XX           XX    -                             "
}

Referenced by ImFontAtlasBuildRenderDefaultTexData().

◆ FONT_ATLAS_DEFAULT_TEX_DATA_W

const int FONT_ATLAS_DEFAULT_TEX_DATA_W = 108

Referenced by ImFontAtlas::GetMouseCursorTexData(), ImFontAtlasBuildInit(), and ImFontAtlasBuildRenderDefaultTexData().

◆ proggy_clean_ttf_compressed_data_base85

const char proggy_clean_ttf_compressed_data_base85[11980+1]

static

Referenced by GetDefaultCompressedFontDataTTFBase85().

◆ stb__barrier_in_b

const unsigned char* stb__barrier_in_b

static

Referenced by stb__lit(), and stb_decompress().

◆ stb__barrier_out_b

unsigned char * stb__barrier_out_b

static

Referenced by stb__match(), and stb_decompress().

◆ stb__barrier_out_e

unsigned char* stb__barrier_out_e

static

Referenced by stb__lit(), stb__match(), and stb_decompress().

◆ stb__dout

unsigned char* stb__dout

static

Referenced by stb__lit(), stb__match(), stb_decompress(), and stb_decompress_token().

Classes

Macros

Functions

Variables

Class Documentation

◆ ImFontBuildSrcData

◆ ImFontBuildDstData

Macro Definition Documentation

◆ IM_FIXNORMAL2F

◆ IM_FIXNORMAL2F_MAX_INVLEN2

◆ IM_NORMALIZE2F_OVER_ZERO

◆ ImDrawCmd_HeaderCompare

◆ ImDrawCmd_HeaderCopy

◆ ImDrawCmd_HeaderSize

◆ IMGUI_DEFINE_MATH_OPERATORS

◆ stb__in2

◆ stb__in3

◆ stb__in4

◆ STB_RECT_PACK_IMPLEMENTATION

◆ STB_TRUETYPE_IMPLEMENTATION

◆ STBRP_ASSERT

◆ STBRP_SORT

◆ STBRP_STATIC

◆ STBTT_assert

◆ STBTT_fabs

◆ STBTT_fmod

◆ STBTT_free

◆ STBTT_iceil

◆ STBTT_ifloor

◆ STBTT_malloc

◆ STBTT_pow

◆ STBTT_sqrt

◆ STBTT_STATIC

Function Documentation

◆ Decode85()

◆ Decode85Byte()

◆ FixRectCornerFlags()

◆ GetDefaultCompressedFontDataTTFBase85()

◆ IM_STATIC_ASSERT()

◆ ImAcos01()

◆ ImBezierCubicCalc()

◆ ImBezierQuadraticCalc()

◆ ImFontAtlasBuildFinish()

◆ ImFontAtlasBuildInit()

◆ ImFontAtlasBuildMultiplyCalcLookupTable()

◆ ImFontAtlasBuildMultiplyRectAlpha8()

◆ ImFontAtlasBuildPackCustomRects()

◆ ImFontAtlasBuildRender32bppRectFromString()

◆ ImFontAtlasBuildRender8bppRectFromString()

◆ ImFontAtlasBuildRenderDefaultTexData()

◆ ImFontAtlasBuildRenderLinesTexData()

◆ ImFontAtlasBuildSetupFont()

◆ ImFontAtlasBuildWithStbTruetype()

◆ ImFontAtlasGetBuilderForStbTruetype()

◆ PathBezierCubicCurveToCasteljau()

◆ PathBezierQuadraticCurveToCasteljau()

◆ stb__lit()

◆ stb__match()

◆ stb_adler32()

◆ stb_decompress()

◆ stb_decompress_length()

◆ stb_decompress_token()

◆ UnpackAccumulativeOffsetsIntoRanges()

◆ UnpackBitVectorToFlatIndexList()

Variable Documentation

◆ FONT_ATLAS_DEFAULT_TEX_CURSOR_DATA

◆ FONT_ATLAS_DEFAULT_TEX_DATA_H

◆ FONT_ATLAS_DEFAULT_TEX_DATA_PIXELS

◆ FONT_ATLAS_DEFAULT_TEX_DATA_W

◆ proggy_clean_ttf_compressed_data_base85

◆ stb__barrier_in_b

◆ stb__barrier_out_b

◆ stb__barrier_out_e

◆ stb__dout