pwmgr

// dear imgui, v1.92.5

// [SECTION] ImFontAtlas, ImFontAtlasBuilder

// [SECTION] ImFontAtlas: backend for stb_truetype

// [SECTION] ImFontAtlas: glyph ranges helpers

#include <stdint.h> // intptr_t

#pragma warning (disable: 26812) // [Static Analyzer] The enum type 'xxx' is unscoped. Prefer 'enum class' over 'enum' (Enum.3).

#pragma clang diagnostic ignored "-Wcast-qual" // warning: cast from 'const xxxx *' to 'xxx *' drops const qualifier

#pragma clang diagnostic ignored "-Wswitch-default" // warning: 'switch' missing 'default' label

#pragma GCC diagnostic ignored "-Wfloat-equal" // warning: comparing floating-point with '==' or '!=' is unsafe

#pragma GCC diagnostic ignored "-Wstrict-overflow" // warning: assuming signed overflow does not occur when simplifying division / ..when changing X +- C1 cmp C2 to X cmp C2 -+ C1

#pragma GCC diagnostic ignored "-Wcast-qual" // warning: cast from type 'const xxxx *' to type 'xxxx *' casts away qualifiers

#pragma GCC diagnostic ignored "-Wimplicit-fallthrough" // warning: this statement may fall through

#define STBTT_strlen(x) ImStrlen(x)

colors[ImGuiCol_InputTextCursor] = colors[ImGuiCol_Text];

colors[ImGuiCol_TreeLines] = colors[ImGuiCol_Border];

colors[ImGuiCol_DragDropTargetBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);

colors[ImGuiCol_UnsavedMarker] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);

colors[ImGuiCol_InputTextCursor] = colors[ImGuiCol_Text];

colors[ImGuiCol_TreeLines] = colors[ImGuiCol_Border];

colors[ImGuiCol_DragDropTargetBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);

colors[ImGuiCol_UnsavedMarker] = ImVec4(0.90f, 0.90f, 0.90f, 1.00f);

colors[ImGuiCol_InputTextCursor] = colors[ImGuiCol_Text];

colors[ImGuiCol_TreeLines] = colors[ImGuiCol_Border];

colors[ImGuiCol_DragDropTargetBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);

colors[ImGuiCol_UnsavedMarker] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);

InitialFringeScale = 1.0f;

ImDrawListSharedData::~ImDrawListSharedData()

{

IM_ASSERT(DrawLists.Size == 0);

}

ImDrawList::ImDrawList(ImDrawListSharedData* shared_data)

{

memset(this, 0, sizeof(*this));

_SetDrawListSharedData(shared_data);

}

ImDrawList::~ImDrawList()

{

_ClearFreeMemory();

_SetDrawListSharedData(NULL);

}

void ImDrawList::_SetDrawListSharedData(ImDrawListSharedData* data)

{

if (_Data != NULL)

_Data->DrawLists.find_erase_unsorted(this);

_Data = data;

if (_Data != NULL)

_Data->DrawLists.push_back(this);

}

// In the majority of cases, you would want to call PushClipRect() and PushTexture() after this.

IM_STATIC_ASSERT(offsetof(ImDrawCmd, TexRef) == sizeof(ImVec4));

IM_STATIC_ASSERT(offsetof(ImDrawCmd, VtxOffset) == sizeof(ImVec4) + sizeof(ImTextureRef));

_TextureStack.resize(0);

_FringeScale = _Data->InitialFringeScale;

_TextureStack.clear();

// Note: For multi-threaded rendering, consider using `imgui_threaded_rendering` from https://github.com/ocornut/imgui_club

ImDrawList* dst = IM_NEW(ImDrawList(NULL));

draw_cmd.TexRef = _CmdHeader.TexRef;

IM_ASSERT(callback != NULL);

// Compare ClipRect, TexRef and VtxOffset with a single memcmp()

#define ImDrawCmd_HeaderCompare(CMD_LHS, CMD_RHS) (memcmp(CMD_LHS, CMD_RHS, ImDrawCmd_HeaderSize)) // Compare ClipRect, TexRef, VtxOffset

#define ImDrawCmd_HeaderCopy(CMD_DST, CMD_SRC) (memcpy(CMD_DST, CMD_SRC, ImDrawCmd_HeaderSize)) // Copy ClipRect, TexRef, VtxOffset

void ImDrawList::_OnChangedTexture()

if (curr_cmd->ElemCount != 0 && curr_cmd->TexRef != _CmdHeader.TexRef)

// Unlike other _OnChangedXXX functions this may be called by ImFontAtlasUpdateDrawListsTextures() in more locations so we need to handle this case.

if (curr_cmd->UserCallback != NULL)

return;

curr_cmd->TexRef = _CmdHeader.TexRef;

void ImDrawList::PushTexture(ImTextureRef tex_ref)

_TextureStack.push_back(tex_ref);

_CmdHeader.TexRef = tex_ref;

if (tex_ref._TexData != NULL)

IM_ASSERT(tex_ref._TexData->WantDestroyNextFrame == false);

_OnChangedTexture();

void ImDrawList::PopTexture()

_TextureStack.pop_back();

_CmdHeader.TexRef = (_TextureStack.Size == 0) ? ImTextureRef() : _TextureStack.Data[_TextureStack.Size - 1];

_OnChangedTexture();

// This is used by ImGui::PushFont()/PopFont(). It works because we never use _TextureIdStack[] elsewhere than in PushTexture()/PopTexture().

void ImDrawList::_SetTexture(ImTextureRef tex_ref)

if (_CmdHeader.TexRef == tex_ref)

_CmdHeader.TexRef = tex_ref;

_TextureStack.back() = tex_ref;

_OnChangedTexture();

IM_ASSERT_PARANOID(!use_texture || !(_Data->Font->OwnerAtlas->Flags & ImFontAtlasFlags_NoBakedLines));

// Add temporary vertices for the outer edges

// Add vertices for each point on the line

// No need to strlen() here: font->RenderText() will do it and may early out.

font->RenderText(this, font_size, pos, col, clip_rect, text_begin, text_end, wrap_width, (cpu_fine_clip_rect != NULL) ? ImDrawTextFlags_CpuFineClip : ImDrawTextFlags_None);

AddText(_Data->Font, _Data->FontSize, pos, col, text_begin, text_end);

void ImDrawList::AddImage(ImTextureRef tex_ref, const ImVec2& p_min, const ImVec2& p_max, const ImVec2& uv_min, const ImVec2& uv_max, ImU32 col)

const bool push_texture_id = tex_ref != _CmdHeader.TexRef;

PushTexture(tex_ref);

PopTexture();

void ImDrawList::AddImageQuad(ImTextureRef tex_ref, const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, const ImVec2& uv1, const ImVec2& uv2, const ImVec2& uv3, const ImVec2& uv4, ImU32 col)

const bool push_texture_id = tex_ref != _CmdHeader.TexRef;

PushTexture(tex_ref);

PopTexture();

void ImDrawList::AddImageRounded(ImTextureRef tex_ref, const ImVec2& p_min, const ImVec2& p_max, const ImVec2& uv_min, const ImVec2& uv_max, ImU32 col, float rounding, ImDrawFlags flags)

AddImage(tex_ref, p_min, p_max, uv_min, uv_max, col);

const bool push_texture_id = tex_ref != _CmdHeader.TexRef;

PushTexture(tex_ref);

PopTexture();

ImDrawCmd_HeaderCopy(curr_cmd, &draw_list->_CmdHeader); // Copy ClipRect, TexRef, VtxOffset

ImDrawCmd_HeaderCopy(curr_cmd, &draw_list->_CmdHeader); // Copy ClipRect, TexRef, VtxOffset

Textures = NULL;

for (ImDrawList* draw_list : CmdLists)

if (draw_list->IdxBuffer.empty())

new_vtx_buffer.resize(draw_list->IdxBuffer.Size);

for (int j = 0; j < draw_list->IdxBuffer.Size; j++)

new_vtx_buffer[j] = draw_list->VtxBuffer[draw_list->IdxBuffer[j]];

draw_list->VtxBuffer.swap(new_vtx_buffer);

draw_list->IdxBuffer.resize(0);

TotalVtxCount += draw_list->VtxBuffer.Size;

// FIXME-NEWATLAS: Oversample specification could be more dynamic. For now, favoring automatic selection.

OversampleH = 0; // Auto == 1 or 2 depending on size

OversampleV = 0; // Auto == 1

EllipsisChar = 0;

}

//-----------------------------------------------------------------------------

// [SECTION] ImTextureData

//-----------------------------------------------------------------------------

// - ImTextureData::Create()

// - ImTextureData::DestroyPixels()

//-----------------------------------------------------------------------------

int ImTextureDataGetFormatBytesPerPixel(ImTextureFormat format)

{

switch (format)

{

case ImTextureFormat_Alpha8: return 1;

case ImTextureFormat_RGBA32: return 4;

}

IM_ASSERT(0);

return 0;

}

const char* ImTextureDataGetStatusName(ImTextureStatus status)

{

switch (status)

{

case ImTextureStatus_OK: return "OK";

case ImTextureStatus_Destroyed: return "Destroyed";

case ImTextureStatus_WantCreate: return "WantCreate";

case ImTextureStatus_WantUpdates: return "WantUpdates";

case ImTextureStatus_WantDestroy: return "WantDestroy";

}

return "N/A";

}

const char* ImTextureDataGetFormatName(ImTextureFormat format)

{

switch (format)

{

case ImTextureFormat_Alpha8: return "Alpha8";

case ImTextureFormat_RGBA32: return "RGBA32";

}

return "N/A";

}

void ImTextureData::Create(ImTextureFormat format, int w, int h)

{

IM_ASSERT(Status == ImTextureStatus_Destroyed);

DestroyPixels();

Format = format;

Status = ImTextureStatus_WantCreate;

Width = w;

Height = h;

BytesPerPixel = ImTextureDataGetFormatBytesPerPixel(format);

UseColors = false;

Pixels = (unsigned char*)IM_ALLOC(Width * Height * BytesPerPixel);

IM_ASSERT(Pixels != NULL);

memset(Pixels, 0, Width * Height * BytesPerPixel);

UsedRect.x = UsedRect.y = UsedRect.w = UsedRect.h = 0;

UpdateRect.x = UpdateRect.y = (unsigned short)~0;

UpdateRect.w = UpdateRect.h = 0;

}

void ImTextureData::DestroyPixels()

{

if (Pixels)

IM_FREE(Pixels);

Pixels = NULL;

UseColors = false;

// [SECTION] ImFontAtlas, ImFontAtlasBuilder

//-----------------------------------------------------------------------------

// - Default texture data encoded in ASCII

// - ImFontAtlas()

// - ImFontAtlas::Clear()

// - ImFontAtlas::CompactCache()

// - ImFontAtlas::ClearInputData()

// - ImFontAtlas::ClearTexData()

// - ImFontAtlas::ClearFonts()

//-----------------------------------------------------------------------------

// - ImFontAtlasUpdateNewFrame()

// - ImFontAtlasTextureBlockConvert()

// - ImFontAtlasTextureBlockPostProcess()

// - ImFontAtlasTextureBlockPostProcessMultiply()

// - ImFontAtlasTextureBlockFill()

// - ImFontAtlasTextureBlockCopy()

// - ImFontAtlasTextureBlockQueueUpload()

//-----------------------------------------------------------------------------

// - ImFontAtlas::GetTexDataAsAlpha8() [legacy]

// - ImFontAtlas::GetTexDataAsRGBA32() [legacy]

// - ImFontAtlas::Build() [legacy]

//-----------------------------------------------------------------------------

// - ImFontAtlas::AddFont()

// - ImFontAtlas::AddFontDefault()

// - ImFontAtlas::AddFontFromFileTTF()

// - ImFontAtlas::AddFontFromMemoryTTF()

// - ImFontAtlas::AddFontFromMemoryCompressedTTF()

// - ImFontAtlas::AddFontFromMemoryCompressedBase85TTF()

// - ImFontAtlas::RemoveFont()

// - ImFontAtlasBuildNotifySetFont()

//-----------------------------------------------------------------------------

// - ImFontAtlas::AddCustomRect()

// - ImFontAtlas::RemoveCustomRect()

// - ImFontAtlas::GetCustomRect()

// - ImFontAtlas::AddCustomRectFontGlyph() [legacy]

// - ImFontAtlas::AddCustomRectFontGlyphForSize() [legacy]

// - ImFontAtlasGetMouseCursorTexData()

//-----------------------------------------------------------------------------

// - ImFontAtlasBuildMain()

// - ImFontAtlasBuildSetupFontLoader()

// - ImFontAtlasBuildPreloadAllGlyphRanges()

// - ImFontAtlasBuildUpdatePointers()

// - ImFontAtlasBuildRenderBitmapFromString()

// - ImFontAtlasBuildUpdateBasicTexData()

// - ImFontAtlasBuildUpdateLinesTexData()

// - ImFontAtlasBuildAddFont()

// - ImFontAtlasBuildSetupFontBakedEllipsis()

// - ImFontAtlasBuildSetupFontBakedBlanks()

// - ImFontAtlasBuildSetupFontBakedFallback()

// - ImFontAtlasBuildSetupFontSpecialGlyphs()

// - ImFontAtlasBuildDiscardBakes()

// - ImFontAtlasBuildDiscardFontBakedGlyph()

// - ImFontAtlasBuildDiscardFontBaked()

// - ImFontAtlasBuildDiscardFontBakes()

//-----------------------------------------------------------------------------

// - ImFontAtlasAddDrawListSharedData()

// - ImFontAtlasRemoveDrawListSharedData()

// - ImFontAtlasUpdateDrawListsTextures()

// - ImFontAtlasUpdateDrawListsSharedData()

//-----------------------------------------------------------------------------

// - ImFontAtlasBuildSetTexture()

// - ImFontAtlasBuildAddTexture()

// - ImFontAtlasBuildMakeSpace()

// - ImFontAtlasBuildRepackTexture()

// - ImFontAtlasBuildGrowTexture()

// - ImFontAtlasBuildRepackOrGrowTexture()

// - ImFontAtlasBuildGetTextureSizeEstimate()

// - ImFontAtlasBuildCompactTexture()

// - ImFontAtlasBuildInit()

// - ImFontAtlasBuildDestroy()

//-----------------------------------------------------------------------------

// - ImFontAtlasPackInit()

// - ImFontAtlasPackAllocRectEntry()

// - ImFontAtlasPackReuseRectEntry()

// - ImFontAtlasPackDiscardRect()

// - ImFontAtlasPackAddRect()

// - ImFontAtlasPackGetRect()

//-----------------------------------------------------------------------------

// - ImFontBaked_BuildGrowIndex()

// - ImFontBaked_BuildLoadGlyph()

// - ImFontBaked_BuildLoadGlyphAdvanceX()

// - ImFontAtlasDebugLogTextureRequests()

//-----------------------------------------------------------------------------

// - ImFontAtlasGetFontLoaderForStbTruetype()

{ ImVec2(0,3), ImVec2(12,19), ImVec2(0, 0) }, // ImGuiMouseCursor_Wait // Arrow + custom code in ImGui::RenderMouseCursor()

{ ImVec2(0,3), ImVec2(12,19), ImVec2(0, 0) }, // ImGuiMouseCursor_Progress // Arrow + custom code in ImGui::RenderMouseCursor()

#define IM_FONTGLYPH_INDEX_UNUSED ((ImU16)-1) // 0xFFFF

#define IM_FONTGLYPH_INDEX_NOT_FOUND ((ImU16)-2) // 0xFFFE

TexDesiredFormat = ImTextureFormat_RGBA32;

TexMinWidth = 512;

TexMinHeight = 128;

TexMaxWidth = 8192;

TexMaxHeight = 8192;

TexRef._TexID = ImTextureID_Invalid;

RendererHasTextures = false; // Assumed false by default, as apps can call e.g Atlas::Build() after backend init and before ImGui can update.

TexNextUniqueID = 1;

FontNextUniqueID = 1;

Builder = NULL;

IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas!");

RendererHasTextures = false; // Full Clear() is supported, but ClearTexData() only isn't.

ClearFonts();

ClearTexData();

TexList.clear_delete();

TexData = NULL;

// If you call this mid-frame, you would need to add new font and bind them!

void ImFontAtlas::Clear()

bool backup_renderer_has_textures = RendererHasTextures;

RendererHasTextures = false; // Full Clear() is supported, but ClearTexData() only isn't.

ClearFonts();

ClearTexData();

RendererHasTextures = backup_renderer_has_textures;

}

void ImFontAtlas::CompactCache()

{

ImFontAtlasTextureCompact(this);

}

void ImFontAtlas::SetFontLoader(const ImFontLoader* font_loader)

{

ImFontAtlasBuildSetupFontLoader(this, font_loader);

}

void ImFontAtlas::ClearInputData()

{

IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas!");

for (ImFont* font : Fonts)

ImFontAtlasFontDestroyOutput(this, font);

for (ImFontConfig& font_cfg : Sources)

ImFontAtlasFontDestroySourceData(this, &font_cfg);

for (ImFont* font : Fonts)

{

// When clearing this we lose access to the font name and other information used to build the font.

font->Sources.clear();

font->Flags |= ImFontFlags_NoLoadGlyphs;

}

Sources.clear();

}

// Clear CPU-side copy of the texture data.

void ImFontAtlas::ClearTexData()

{

IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas!");

IM_ASSERT(RendererHasTextures == false && "Not supported for dynamic atlases, but you may call Clear().");

for (ImTextureData* tex : TexList)

tex->DestroyPixels();

//Locked = true; // Hoped to be able to lock this down but some reload patterns may not be happy with it.

}

void ImFontAtlas::ClearFonts()

{

// FIXME-NEWATLAS: Illegal to remove currently bound font.

IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas!");

ImFontAtlasBuildNotifySetFont(this, font, NULL);

ImFontAtlasBuildDestroy(this);

ClearInputData();

Fonts.clear_delete();

TexIsBuilt = false;

for (ImDrawListSharedData* shared_data : DrawListSharedDatas)

if (shared_data->FontAtlas == this)

shared_data->Font = NULL;

shared_data->FontScale = shared_data->FontSize = 0.0f;

static void ImFontAtlasBuildUpdateRendererHasTexturesFromContext(ImFontAtlas* atlas)

// [LEGACY] Copy back the ImGuiBackendFlags_RendererHasTextures flag from ImGui context.

// - This is the 1% exceptional case where that dependency if useful, to bypass an issue where otherwise at the

// time of an early call to Build(), it would be impossible for us to tell if the backend supports texture update.

// - Without this hack, we would have quite a pitfall as many legacy codebases have an early call to Build().

// Whereas conversely, the portion of people using ImDrawList without ImGui is expected to be pathologically rare.

for (ImDrawListSharedData* shared_data : atlas->DrawListSharedDatas)

if (ImGuiContext* imgui_ctx = shared_data->Context)

{

atlas->RendererHasTextures = (imgui_ctx->IO.BackendFlags & ImGuiBackendFlags_RendererHasTextures) != 0;

break;

}

// Called by NewFrame() for atlases owned by a context.

// If you manually manage font atlases, you'll need to call this yourself.

// - 'frame_count' needs to be provided because we can gc/prioritize baked fonts based on their age.

// - 'frame_count' may not match those of all imgui contexts using this atlas, as contexts may be updated as different frequencies. But generally you can use ImGui::GetFrameCount() on one of your context.

void ImFontAtlasUpdateNewFrame(ImFontAtlas* atlas, int frame_count, bool renderer_has_textures)

IM_ASSERT(atlas->Builder == NULL || atlas->Builder->FrameCount < frame_count); // Protection against being called twice.

atlas->RendererHasTextures = renderer_has_textures;

// Check that font atlas was built or backend support texture reload in which case we can build now

if (atlas->RendererHasTextures)

{

atlas->TexIsBuilt = true;

if (atlas->Builder == NULL) // This will only happen if fonts were not already loaded.

ImFontAtlasBuildMain(atlas);

}

// Legacy backend

if (!atlas->RendererHasTextures)

IM_ASSERT_USER_ERROR(atlas->TexIsBuilt, "Backend does not support ImGuiBackendFlags_RendererHasTextures, and font atlas is not built! Update backend OR make sure you called ImGui_ImplXXXX_NewFrame() function for renderer backend, which should call io.Fonts->GetTexDataAsRGBA32() / GetTexDataAsAlpha8().");

if (atlas->TexIsBuilt && atlas->Builder->PreloadedAllGlyphsRanges)

IM_ASSERT_USER_ERROR(atlas->RendererHasTextures == false, "Called ImFontAtlas::Build() before ImGuiBackendFlags_RendererHasTextures got set! With new backends: you don't need to call Build().");

// Clear BakedCurrent cache, this is important because it ensure the uncached path gets taken once.

// We also rely on ImFontBaked* pointers never crossing frames.

ImFontAtlasBuilder* builder = atlas->Builder;

builder->FrameCount = frame_count;

for (ImFont* font : atlas->Fonts)

font->LastBaked = NULL;

// Garbage collect BakedPool

if (builder->BakedDiscardedCount > 0)

{

int dst_n = 0, src_n = 0;

for (; src_n < builder->BakedPool.Size; src_n++)

{

ImFontBaked* p_src = &builder->BakedPool[src_n];

if (p_src->WantDestroy)

continue;

ImFontBaked* p_dst = &builder->BakedPool[dst_n++];

if (p_dst == p_src)

continue;

memcpy(p_dst, p_src, sizeof(ImFontBaked));

builder->BakedMap.SetVoidPtr(p_dst->BakedId, p_dst);

}

IM_ASSERT(dst_n + builder->BakedDiscardedCount == src_n);

builder->BakedPool.Size -= builder->BakedDiscardedCount;

builder->BakedDiscardedCount = 0;

}

// Update texture status

for (int tex_n = 0; tex_n < atlas->TexList.Size; tex_n++)

{

ImTextureData* tex = atlas->TexList[tex_n];

bool remove_from_list = false;

if (tex->Status == ImTextureStatus_OK)

{

tex->Updates.resize(0);

tex->UpdateRect.x = tex->UpdateRect.y = (unsigned short)~0;

tex->UpdateRect.w = tex->UpdateRect.h = 0;

}

if (tex->Status == ImTextureStatus_WantCreate && atlas->RendererHasTextures)

IM_ASSERT(tex->TexID == ImTextureID_Invalid && tex->BackendUserData == NULL && "Backend set texture's TexID/BackendUserData but did not update Status to OK.");

// Request destroy

// - Keep bool to true in order to differentiate a planned destroy vs a destroy decided by the backend.

// - We don't destroy pixels right away, as backend may have an in-flight copy from RAM.

if (tex->WantDestroyNextFrame && tex->Status != ImTextureStatus_Destroyed && tex->Status != ImTextureStatus_WantDestroy)

{

IM_ASSERT(tex->Status == ImTextureStatus_OK || tex->Status == ImTextureStatus_WantCreate || tex->Status == ImTextureStatus_WantUpdates);

tex->Status = ImTextureStatus_WantDestroy;

}

// If a texture has never reached the backend, they don't need to know about it.

// (note: backends between 1.92.0 and 1.92.4 could set an already destroyed texture to ImTextureStatus_WantDestroy

// when invalidating graphics objects twice, which would previously remove it from the list and crash.)

if (tex->Status == ImTextureStatus_WantDestroy && tex->TexID == ImTextureID_Invalid && tex->BackendUserData == NULL)

tex->Status = ImTextureStatus_Destroyed;

// Process texture being destroyed

if (tex->Status == ImTextureStatus_Destroyed)

{

IM_ASSERT(tex->TexID == ImTextureID_Invalid && tex->BackendUserData == NULL && "Backend set texture Status to Destroyed but did not clear TexID/BackendUserData!");

if (tex->WantDestroyNextFrame)

remove_from_list = true; // Destroy was scheduled by us

else

tex->Status = ImTextureStatus_WantCreate; // Destroy was done was backend: recreate it (e.g. freed resources mid-run)

}

// The backend may need defer destroying by a few frames, to handle texture used by previous in-flight rendering.

// We allow the texture staying in _WantDestroy state and increment a counter which the backend can use to take its decision.

if (tex->Status == ImTextureStatus_WantDestroy)

tex->UnusedFrames++;

// Destroy and remove

if (remove_from_list)

{

IM_ASSERT(atlas->TexData != tex);

tex->DestroyPixels();

IM_DELETE(tex);

atlas->TexList.erase(atlas->TexList.begin() + tex_n);

tex_n--;

}

}

void ImFontAtlasTextureBlockConvert(const unsigned char* src_pixels, ImTextureFormat src_fmt, int src_pitch, unsigned char* dst_pixels, ImTextureFormat dst_fmt, int dst_pitch, int w, int h)

IM_ASSERT(src_pixels != NULL && dst_pixels != NULL);

if (src_fmt == dst_fmt)

{

int line_sz = w * ImTextureDataGetFormatBytesPerPixel(src_fmt);

for (int ny = h; ny > 0; ny--, src_pixels += src_pitch, dst_pixels += dst_pitch)

memcpy(dst_pixels, src_pixels, line_sz);

}

else if (src_fmt == ImTextureFormat_Alpha8 && dst_fmt == ImTextureFormat_RGBA32)

{

for (int ny = h; ny > 0; ny--, src_pixels += src_pitch, dst_pixels += dst_pitch)

{

const ImU8* src_p = (const ImU8*)src_pixels;

ImU32* dst_p = (ImU32*)(void*)dst_pixels;

for (int nx = w; nx > 0; nx--)

*dst_p++ = IM_COL32(255, 255, 255, (unsigned int)(*src_p++));

}

}

else if (src_fmt == ImTextureFormat_RGBA32 && dst_fmt == ImTextureFormat_Alpha8)

{

for (int ny = h; ny > 0; ny--, src_pixels += src_pitch, dst_pixels += dst_pitch)

{

const ImU32* src_p = (const ImU32*)(void*)src_pixels;

ImU8* dst_p = (ImU8*)dst_pixels;

for (int nx = w; nx > 0; nx--)

*dst_p++ = ((*src_p++) >> IM_COL32_A_SHIFT) & 0xFF;

}

}

else

{

IM_ASSERT(0);

}

// Source buffer may be written to (used for in-place mods).

// Post-process hooks may eventually be added here.

void ImFontAtlasTextureBlockPostProcess(ImFontAtlasPostProcessData* data)

// Multiply operator (legacy)

if (data->FontSrc->RasterizerMultiply != 1.0f)

ImFontAtlasTextureBlockPostProcessMultiply(data, data->FontSrc->RasterizerMultiply);

}

void ImFontAtlasTextureBlockPostProcessMultiply(ImFontAtlasPostProcessData* data, float multiply_factor)

{

unsigned char* pixels = (unsigned char*)data->Pixels;

int pitch = data->Pitch;

if (data->Format == ImTextureFormat_Alpha8)

{

for (int ny = data->Height; ny > 0; ny--, pixels += pitch)

{

ImU8* p = (ImU8*)pixels;

for (int nx = data->Width; nx > 0; nx--, p++)

{

unsigned int v = ImMin((unsigned int)(*p * multiply_factor), (unsigned int)255);

*p = (unsigned char)v;

}

}

}

else if (data->Format == ImTextureFormat_RGBA32) //-V547

{

for (int ny = data->Height; ny > 0; ny--, pixels += pitch)

{

ImU32* p = (ImU32*)(void*)pixels;

for (int nx = data->Width; nx > 0; nx--, p++)

{

unsigned int a = ImMin((unsigned int)(((*p >> IM_COL32_A_SHIFT) & 0xFF) * multiply_factor), (unsigned int)255);

*p = IM_COL32((*p >> IM_COL32_R_SHIFT) & 0xFF, (*p >> IM_COL32_G_SHIFT) & 0xFF, (*p >> IM_COL32_B_SHIFT) & 0xFF, a);

}

}

}

else

{

IM_ASSERT(0);

}

// Fill with single color. We don't use this directly but it is convenient for anyone working on uploading custom rects.

void ImFontAtlasTextureBlockFill(ImTextureData* dst_tex, int dst_x, int dst_y, int w, int h, ImU32 col)

if (dst_tex->Format == ImTextureFormat_Alpha8)

{

ImU8 col_a = (col >> IM_COL32_A_SHIFT) & 0xFF;

for (int y = 0; y < h; y++)

memset((ImU8*)dst_tex->GetPixelsAt(dst_x, dst_y + y), col_a, w);

}

else

for (int y = 0; y < h; y++)

ImU32* p = (ImU32*)(void*)dst_tex->GetPixelsAt(dst_x, dst_y + y);

for (int x = w; x > 0; x--, p++)

*p = col;

}

// Copy block from one texture to another

void ImFontAtlasTextureBlockCopy(ImTextureData* src_tex, int src_x, int src_y, ImTextureData* dst_tex, int dst_x, int dst_y, int w, int h)

{

IM_ASSERT(src_tex->Pixels != NULL && dst_tex->Pixels != NULL);

IM_ASSERT(src_tex->Format == dst_tex->Format);

IM_ASSERT(src_x >= 0 && src_x + w <= src_tex->Width);

IM_ASSERT(src_y >= 0 && src_y + h <= src_tex->Height);

IM_ASSERT(dst_x >= 0 && dst_x + w <= dst_tex->Width);

IM_ASSERT(dst_y >= 0 && dst_y + h <= dst_tex->Height);

for (int y = 0; y < h; y++)

memcpy(dst_tex->GetPixelsAt(dst_x, dst_y + y), src_tex->GetPixelsAt(src_x, src_y + y), w * dst_tex->BytesPerPixel);

}

// Queue texture block update for renderer backend

void ImFontAtlasTextureBlockQueueUpload(ImFontAtlas* atlas, ImTextureData* tex, int x, int y, int w, int h)

{

IM_ASSERT(tex->Status != ImTextureStatus_WantDestroy && tex->Status != ImTextureStatus_Destroyed);

IM_ASSERT(x >= 0 && x <= 0xFFFF && y >= 0 && y <= 0xFFFF && w >= 0 && x + w <= 0x10000 && h >= 0 && y + h <= 0x10000);

IM_UNUSED(atlas);

ImTextureRect req = { (unsigned short)x, (unsigned short)y, (unsigned short)w, (unsigned short)h };

int new_x1 = ImMax(tex->UpdateRect.w == 0 ? 0 : tex->UpdateRect.x + tex->UpdateRect.w, req.x + req.w);

int new_y1 = ImMax(tex->UpdateRect.h == 0 ? 0 : tex->UpdateRect.y + tex->UpdateRect.h, req.y + req.h);

tex->UpdateRect.x = ImMin(tex->UpdateRect.x, req.x);

tex->UpdateRect.y = ImMin(tex->UpdateRect.y, req.y);

tex->UpdateRect.w = (unsigned short)(new_x1 - tex->UpdateRect.x);

tex->UpdateRect.h = (unsigned short)(new_y1 - tex->UpdateRect.y);

tex->UsedRect.x = ImMin(tex->UsedRect.x, req.x);

tex->UsedRect.y = ImMin(tex->UsedRect.y, req.y);

tex->UsedRect.w = (unsigned short)(ImMax(tex->UsedRect.x + tex->UsedRect.w, req.x + req.w) - tex->UsedRect.x);

tex->UsedRect.h = (unsigned short)(ImMax(tex->UsedRect.y + tex->UsedRect.h, req.y + req.h) - tex->UsedRect.y);

atlas->TexIsBuilt = false;

// No need to queue if status is == ImTextureStatus_WantCreate

if (tex->Status == ImTextureStatus_OK || tex->Status == ImTextureStatus_WantUpdates)

{

tex->Status = ImTextureStatus_WantUpdates;

tex->Updates.push_back(req);

}

}

#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

static void GetTexDataAsFormat(ImFontAtlas* atlas, ImTextureFormat format, unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel)

{

ImTextureData* tex = atlas->TexData;

if (!atlas->TexIsBuilt || tex == NULL || tex->Pixels == NULL || atlas->TexDesiredFormat != format)

{

atlas->TexDesiredFormat = format;

atlas->Build();

tex = atlas->TexData;

}

if (out_pixels) { *out_pixels = (unsigned char*)tex->Pixels; };

if (out_width) { *out_width = tex->Width; };

if (out_height) { *out_height = tex->Height; };

if (out_bytes_per_pixel) { *out_bytes_per_pixel = tex->BytesPerPixel; }

}

void ImFontAtlas::GetTexDataAsAlpha8(unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel)

{

GetTexDataAsFormat(this, ImTextureFormat_Alpha8, out_pixels, out_width, out_height, out_bytes_per_pixel);

}

void ImFontAtlas::GetTexDataAsRGBA32(unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel)

{

GetTexDataAsFormat(this, ImTextureFormat_RGBA32, out_pixels, out_width, out_height, out_bytes_per_pixel);

}

bool ImFontAtlas::Build()

{

ImFontAtlasBuildMain(this);

return true;

#endif // #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

ImFont* ImFontAtlas::AddFont(const ImFontConfig* font_cfg_in)

// Sanity Checks

IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas!");

IM_ASSERT((font_cfg_in->FontData != NULL && font_cfg_in->FontDataSize > 0) || (font_cfg_in->FontLoader != NULL));

//IM_ASSERT(font_cfg_in->SizePixels > 0.0f && "Is ImFontConfig struct correctly initialized?");

IM_ASSERT(font_cfg_in->RasterizerDensity > 0.0f && "Is ImFontConfig struct correctly initialized?");

if (font_cfg_in->GlyphOffset.x != 0.0f || font_cfg_in->GlyphOffset.y != 0.0f || font_cfg_in->GlyphMinAdvanceX != 0.0f || font_cfg_in->GlyphMaxAdvanceX != FLT_MAX)

IM_ASSERT(font_cfg_in->SizePixels != 0.0f && "Specifying glyph offset/advances requires a reference size to base it on.");

// Lazily create builder on the first call to AddFont

if (Builder == NULL)

ImFontAtlasBuildInit(this);

ImFont* font;

if (!font_cfg_in->MergeMode)

{

font = IM_NEW(ImFont)();

font->FontId = FontNextUniqueID++;

font->Flags = font_cfg_in->Flags;

font->LegacySize = font_cfg_in->SizePixels;

font->CurrentRasterizerDensity = font_cfg_in->RasterizerDensity;

Fonts.push_back(font);

}

{

font = font_cfg_in->DstFont ? font_cfg_in->DstFont : Fonts.back();

}

// Add to list

Sources.push_back(*font_cfg_in);

ImFontConfig* font_cfg = &Sources.back();

if (font_cfg->DstFont == NULL)

font_cfg->DstFont = font;

font->Sources.push_back(font_cfg);

ImFontAtlasBuildUpdatePointers(this); // Pointers to Sources are otherwise dangling after we called Sources.push_back().

if (font_cfg->FontDataOwnedByAtlas == false)

font_cfg->FontDataOwnedByAtlas = true;

font_cfg->FontData = ImMemdup(font_cfg->FontData, (size_t)font_cfg->FontDataSize);

// Sanity check

// We don't round cfg.SizePixels yet as relative size of merged fonts are used afterwards.

if (font_cfg->GlyphExcludeRanges != NULL)

{

int size = 0;

for (const ImWchar* p = font_cfg->GlyphExcludeRanges; p[0] != 0; p++, size++) {}

IM_ASSERT((size & 1) == 0 && "GlyphExcludeRanges[] size must be multiple of two!");

IM_ASSERT((size <= 64) && "GlyphExcludeRanges[] size must be small!");

font_cfg->GlyphExcludeRanges = (ImWchar*)ImMemdup(font_cfg->GlyphExcludeRanges, sizeof(font_cfg->GlyphExcludeRanges[0]) * (size + 1));

}

if (font_cfg->FontLoader != NULL)

{

IM_ASSERT(font_cfg->FontLoader->FontBakedLoadGlyph != NULL);

IM_ASSERT(font_cfg->FontLoader->LoaderInit == NULL && font_cfg->FontLoader->LoaderShutdown == NULL); // FIXME-NEWATLAS: Unsupported yet.

}

IM_ASSERT(font_cfg->FontLoaderData == NULL);

if (!ImFontAtlasFontSourceInit(this, font_cfg))

{

// Rollback (this is a fragile/rarely exercised code-path. TestSuite's "misc_atlas_add_invalid_font" aim to test this)

ImFontAtlasFontDestroySourceData(this, font_cfg);

Sources.pop_back();

font->Sources.pop_back();

if (!font_cfg->MergeMode)

{

IM_DELETE(font);

Fonts.pop_back();

}

return NULL;

}

ImFontAtlasFontSourceAddToFont(this, font, font_cfg);

return font;

#ifndef IMGUI_DISABLE_DEFAULT_FONT

static const char* GetDefaultCompressedFontDataTTF(int* out_size);

#endif

// If you want a similar font which may be better scaled, consider using ProggyVector from the same author!

#ifndef IMGUI_DISABLE_DEFAULT_FONT

ImFormatString(font_cfg.Name, IM_ARRAYSIZE(font_cfg.Name), "ProggyClean.ttf");

font_cfg.GlyphOffset.y += 1.0f * IM_TRUNC(font_cfg.SizePixels / 13.0f); // Add +1 offset per 13 units

int ttf_compressed_size = 0;

const char* ttf_compressed = GetDefaultCompressedFontDataTTF(&ttf_compressed_size);

return AddFontFromMemoryCompressedTTF(ttf_compressed, ttf_compressed_size, font_cfg.SizePixels, &font_cfg);

#else

IM_ASSERT(0 && "AddFontDefault() disabled in this build.");

IM_UNUSED(font_cfg_template);

return NULL;

#endif // #ifndef IMGUI_DISABLE_DEFAULT_FONT

IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas!");

if (font_cfg_template == NULL || (font_cfg_template->Flags & ImFontFlags_NoLoadError) == 0)

{

IMGUI_DEBUG_LOG("While loading '%s'\n", filename);

IM_ASSERT_USER_ERROR(0, "Could not load font file!");

}

for (p = filename + ImStrlen(filename); p > filename && p[-1] != '/' && p[-1] != '\\'; p--) {}

ImFormatString(font_cfg.Name, IM_ARRAYSIZE(font_cfg.Name), "%s", p);

IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas!");

int compressed_ttf_size = (((int)ImStrlen(compressed_ttf_data_base85) + 4) / 5) * 4;

// On font removal we need to remove references (otherwise we could queue removal?)

// We allow old_font == new_font which forces updating all values (e.g. sizes)

void ImFontAtlasBuildNotifySetFont(ImFontAtlas* atlas, ImFont* old_font, ImFont* new_font)

{

for (ImDrawListSharedData* shared_data : atlas->DrawListSharedDatas)

{

if (shared_data->Font == old_font)

shared_data->Font = new_font;

if (ImGuiContext* ctx = shared_data->Context)

{

if (ctx->IO.FontDefault == old_font)

ctx->IO.FontDefault = new_font;

if (ctx->Font == old_font)

{

ImGuiContext* curr_ctx = ImGui::GetCurrentContext();

bool need_bind_ctx = ctx != curr_ctx;

if (need_bind_ctx)

ImGui::SetCurrentContext(ctx);

ImGui::SetCurrentFont(new_font, ctx->FontSizeBase, ctx->FontSize);

if (need_bind_ctx)

ImGui::SetCurrentContext(curr_ctx);

}

for (ImFontStackData& font_stack_data : ctx->FontStack)

if (font_stack_data.Font == old_font)

font_stack_data.Font = new_font;

}

}

}

void ImFontAtlas::RemoveFont(ImFont* font)

{

IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas!");

font->ClearOutputData();

ImFontAtlasFontDestroyOutput(this, font);

for (ImFontConfig* src : font->Sources)

ImFontAtlasFontDestroySourceData(this, src);

for (int src_n = 0; src_n < Sources.Size; src_n++)

if (Sources[src_n].DstFont == font)

Sources.erase(&Sources[src_n--]);

bool removed = Fonts.find_erase(font);

IM_ASSERT(removed);

IM_UNUSED(removed);

ImFontAtlasBuildUpdatePointers(this);

font->OwnerAtlas = NULL;

IM_DELETE(font);

// Notify external systems

ImFont* new_current_font = Fonts.empty() ? NULL : Fonts[0];

ImFontAtlasBuildNotifySetFont(this, font, new_current_font);

}

// At it is common to do an AddCustomRect() followed by a GetCustomRect(), we provide an optional 'ImFontAtlasRect* out_r = NULL' argument to retrieve the info straight away.

ImFontAtlasRectId ImFontAtlas::AddCustomRect(int width, int height, ImFontAtlasRect* out_r)

if (Builder == NULL)

ImFontAtlasBuildInit(this);

ImFontAtlasRectId r_id = ImFontAtlasPackAddRect(this, width, height);

if (r_id == ImFontAtlasRectId_Invalid)

return ImFontAtlasRectId_Invalid;

if (out_r != NULL)

GetCustomRect(r_id, out_r);

if (RendererHasTextures)

{

ImTextureRect* r = ImFontAtlasPackGetRect(this, r_id);

ImFontAtlasTextureBlockQueueUpload(this, TexData, r->x, r->y, r->w, r->h);

}

return r_id;

void ImFontAtlas::RemoveCustomRect(ImFontAtlasRectId id)

{

if (ImFontAtlasPackGetRectSafe(this, id) == NULL)

return;

ImFontAtlasPackDiscardRect(this, id);

}

#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

// This API does not make sense anymore with scalable fonts.

// - Prefer adding a font source (ImFontConfig) using a custom/procedural loader.

// - You may use ImFontFlags_LockBakedSizes to limit an existing font to known baked sizes:

// ImFont* myfont = io.Fonts->AddFontFromFileTTF(....);

// myfont->GetFontBaked(16.0f);

// myfont->Flags |= ImFontFlags_LockBakedSizes;

ImFontAtlasRectId ImFontAtlas::AddCustomRectFontGlyph(ImFont* font, ImWchar codepoint, int width, int height, float advance_x, const ImVec2& offset)

{

float font_size = font->LegacySize;

return AddCustomRectFontGlyphForSize(font, font_size, codepoint, width, height, advance_x, offset);

}

// FIXME: we automatically set glyph.Colored=true by default.

// If you need to alter this, you can write 'font->Glyphs.back()->Colored' after calling AddCustomRectFontGlyph().

ImFontAtlasRectId ImFontAtlas::AddCustomRectFontGlyphForSize(ImFont* font, float font_size, ImWchar codepoint, int width, int height, float advance_x, const ImVec2& offset)

IM_ASSERT(codepoint <= IM_UNICODE_CODEPOINT_MAX);

ImFontBaked* baked = font->GetFontBaked(font_size);

ImFontAtlasRectId r_id = ImFontAtlasPackAddRect(this, width, height);

if (r_id == ImFontAtlasRectId_Invalid)

return ImFontAtlasRectId_Invalid;

ImTextureRect* r = ImFontAtlasPackGetRect(this, r_id);

if (RendererHasTextures)

ImFontAtlasTextureBlockQueueUpload(this, TexData, r->x, r->y, r->w, r->h);