impr: Better font loading logic
This commit is contained in:
WerWolv
parent
deee76e455
commit
f49715c7a0
@ -123,7 +123,7 @@ target_link_directories(libimhex ${LIBIMHEX_LIBRARY_TYPE} ${MBEDTLS_LIBRARY_DIR}
|
||||
|
||||
if (NOT EMSCRIPTEN)
|
||||
# curl is only used in non-emscripten builds
|
||||
target_link_libraries(libimhex ${LIBIMHEX_LIBRARY_TYPE} ${CURL_LIBRARIES})
|
||||
target_link_libraries(libimhex ${LIBIMHEX_LIBRARY_TYPE} CURL::libcurl)
|
||||
endif()
|
||||
|
||||
|
||||
|
||||
@ -932,9 +932,9 @@ namespace hex {
|
||||
s_fontSize = size;
|
||||
}
|
||||
|
||||
static AutoReset<std::shared_ptr<ImFontAtlas>> s_fontAtlas;
|
||||
static AutoReset<ImFontAtlas*> s_fontAtlas;
|
||||
void setFontAtlas(ImFontAtlas* fontAtlas) {
|
||||
s_fontAtlas = std::unique_ptr<ImFontAtlas, void(*)(ImFontAtlas*)>(fontAtlas, IM_DELETE);
|
||||
s_fontAtlas = fontAtlas;
|
||||
}
|
||||
|
||||
static ImFont *s_boldFont = nullptr;
|
||||
@ -1017,7 +1017,7 @@ namespace hex {
|
||||
}
|
||||
|
||||
ImFontAtlas* getFontAtlas() {
|
||||
return impl::s_fontAtlas->get();
|
||||
return impl::s_fontAtlas;
|
||||
}
|
||||
|
||||
ImFont* Bold() {
|
||||
|
||||
@ -270,7 +270,6 @@ namespace hex {
|
||||
glfwWaitEventsTimeout(targetFrameTime - frameTime);
|
||||
|
||||
// glfwWaitEventsTimeout might return early if there's an event
|
||||
const auto frameTime = glfwGetTime() - m_lastStartFrameTime;
|
||||
if (frameTime < targetFrameTime) {
|
||||
const auto timeToSleepMs = (int)((targetFrameTime - frameTime) * 1000);
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(timeToSleepMs));
|
||||
|
||||
@ -4,18 +4,10 @@
|
||||
|
||||
#include <hex/api/task_manager.hpp>
|
||||
#include <hex/helpers/http_requests.hpp>
|
||||
#include <hex/helpers/fs.hpp>
|
||||
#include <hex/helpers/utils.hpp>
|
||||
#include <hex/helpers/logger.hpp>
|
||||
|
||||
#include <wolv/utils/string.hpp>
|
||||
#include <wolv/hash/uuid.hpp>
|
||||
|
||||
#include <imgui.h>
|
||||
#include <imgui_freetype.h>
|
||||
|
||||
#include <cstring>
|
||||
|
||||
namespace hex::plugin::builtin {
|
||||
|
||||
namespace {
|
||||
@ -119,253 +111,6 @@ namespace hex::plugin::builtin {
|
||||
return true;
|
||||
}
|
||||
|
||||
bool loadFontsImpl(bool loadUnicode) {
|
||||
float defaultFontSize = ImHexApi::Fonts::DefaultFontSize * ImHexApi::System::getGlobalScale();
|
||||
|
||||
if (defaultFontSize == 0.0F)
|
||||
defaultFontSize = ImHexApi::Fonts::DefaultFontSize;
|
||||
|
||||
// Reset used font size back to the default size
|
||||
ImHexApi::Fonts::impl::setFontSize(defaultFontSize);
|
||||
|
||||
// Load custom font related settings
|
||||
if (ContentRegistry::Settings::read<bool>("hex.builtin.setting.font", "hex.builtin.setting.font.custom_font_enable", false)) {
|
||||
auto fontFile = ContentRegistry::Settings::read<std::fs::path>("hex.builtin.setting.font", "hex.builtin.setting.font.font_path", "");
|
||||
if (!fontFile.empty()) {
|
||||
if (!wolv::io::fs::exists(fontFile) || !wolv::io::fs::isRegularFile(fontFile)) {
|
||||
log::warn("Custom font file {} not found! Falling back to default font.", wolv::util::toUTF8String(fontFile));
|
||||
fontFile.clear();
|
||||
}
|
||||
|
||||
log::info("Loading custom font from {}", wolv::util::toUTF8String(fontFile));
|
||||
}
|
||||
|
||||
// If no custom font has been specified, search for a file called "font.ttf" in one of the resource folders
|
||||
if (fontFile.empty()) {
|
||||
for (const auto &dir : fs::getDefaultPaths(fs::ImHexPath::Resources)) {
|
||||
auto path = dir / "font.ttf";
|
||||
if (wolv::io::fs::exists(path)) {
|
||||
log::info("Loading custom font from {}", wolv::util::toUTF8String(path));
|
||||
|
||||
fontFile = path;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ImHexApi::Fonts::impl::setCustomFontPath(fontFile);
|
||||
|
||||
// If a custom font has been loaded now, also load the font size
|
||||
float fontSize = defaultFontSize;
|
||||
if (!fontFile.empty()) {
|
||||
fontSize = float(ContentRegistry::Settings::read<int>("hex.builtin.setting.font", "hex.builtin.setting.font.font_size", 13)) * ImHexApi::System::getGlobalScale();
|
||||
}
|
||||
|
||||
ImHexApi::Fonts::impl::setFontSize(fontSize);
|
||||
}
|
||||
|
||||
float fontSize = ImHexApi::Fonts::getFontSize();
|
||||
|
||||
const auto &fontFile = ImHexApi::Fonts::getCustomFontPath();
|
||||
|
||||
// Setup basic font configuration
|
||||
auto fonts = IM_NEW(ImFontAtlas)();
|
||||
ImFontConfig cfg = {};
|
||||
cfg.OversampleH = cfg.OversampleV = 1, cfg.PixelSnapH = true;
|
||||
cfg.SizePixels = fontSize;
|
||||
|
||||
fonts->Flags |= ImFontAtlasFlags_NoPowerOfTwoHeight;
|
||||
fonts->TexDesiredWidth = 4096;
|
||||
|
||||
// Configure font glyph ranges that should be loaded from the default font and unifont
|
||||
static ImVector<ImWchar> defaultGlyphRanges;
|
||||
defaultGlyphRanges = { };
|
||||
{
|
||||
ImFontGlyphRangesBuilder glyphRangesBuilder;
|
||||
|
||||
{
|
||||
constexpr static std::array<ImWchar, 3> controlCodeRange = { 0x0001, 0x001F, 0 };
|
||||
constexpr static std::array<ImWchar, 3> extendedAsciiRange = { 0x007F, 0x00FF, 0 };
|
||||
constexpr static std::array<ImWchar, 3> latinExtendedARange = { 0x0100, 0x017F, 0 };
|
||||
|
||||
glyphRangesBuilder.AddRanges(controlCodeRange.data());
|
||||
glyphRangesBuilder.AddRanges(fonts->GetGlyphRangesDefault());
|
||||
glyphRangesBuilder.AddRanges(extendedAsciiRange.data());
|
||||
glyphRangesBuilder.AddRanges(latinExtendedARange.data());
|
||||
}
|
||||
|
||||
if (loadUnicode) {
|
||||
constexpr static std::array<ImWchar, 3> fullRange = { 0x0180, 0xFFEF, 0 };
|
||||
|
||||
glyphRangesBuilder.AddRanges(fullRange.data());
|
||||
} else {
|
||||
glyphRangesBuilder.AddRanges(fonts->GetGlyphRangesJapanese());
|
||||
glyphRangesBuilder.AddRanges(fonts->GetGlyphRangesChineseFull());
|
||||
glyphRangesBuilder.AddRanges(fonts->GetGlyphRangesCyrillic());
|
||||
glyphRangesBuilder.AddRanges(fonts->GetGlyphRangesKorean());
|
||||
glyphRangesBuilder.AddRanges(fonts->GetGlyphRangesThai());
|
||||
glyphRangesBuilder.AddRanges(fonts->GetGlyphRangesVietnamese());
|
||||
}
|
||||
|
||||
glyphRangesBuilder.BuildRanges(&defaultGlyphRanges);
|
||||
}
|
||||
|
||||
std::vector<u8> customFontData;
|
||||
|
||||
if (fontFile.empty()) {
|
||||
fonts->Clear();
|
||||
} else {
|
||||
wolv::io::File file(fontFile, wolv::io::File::Mode::Read);
|
||||
customFontData = file.readVector();
|
||||
}
|
||||
|
||||
if (ContentRegistry::Settings::read<bool>("hex.builtin.setting.font", "hex.builtin.setting.font.custom_font_enable", false)) {
|
||||
if (ContentRegistry::Settings::read<bool>("hex.builtin.setting.font", "hex.builtin.setting.font.font_bold", false))
|
||||
cfg.FontBuilderFlags |= ImGuiFreeTypeBuilderFlags_Bold;
|
||||
if (ContentRegistry::Settings::read<bool>("hex.builtin.setting.font", "hex.builtin.setting.font.font_italic", false))
|
||||
cfg.FontBuilderFlags |= ImGuiFreeTypeBuilderFlags_Oblique;
|
||||
if (!ContentRegistry::Settings::read<bool>("hex.builtin.setting.font", "hex.builtin.setting.font.font_antialias", true))
|
||||
cfg.FontBuilderFlags |= ImGuiFreeTypeBuilderFlags_Monochrome | ImGuiFreeTypeBuilderFlags_MonoHinting;
|
||||
}
|
||||
|
||||
auto loadDefaultFont = [&](const char *fontName, u32 flags = 0) {
|
||||
ImFontConfig defaultConfig = cfg;
|
||||
|
||||
defaultConfig.FontBuilderFlags |= flags;
|
||||
|
||||
std::strncpy(defaultConfig.Name, fontName, sizeof(defaultConfig.Name) - 1);
|
||||
|
||||
if (!fontFile.empty()) {
|
||||
if (!customFontData.empty()) {
|
||||
defaultConfig.FontDataOwnedByAtlas = false;
|
||||
return fonts->AddFontFromMemoryTTF(customFontData.data(), customFontData.size(), 0, &defaultConfig, defaultGlyphRanges.Data);
|
||||
}
|
||||
}
|
||||
|
||||
defaultConfig.FontBuilderFlags |= ImGuiFreeTypeBuilderFlags_Monochrome | ImGuiFreeTypeBuilderFlags_MonoHinting;
|
||||
defaultConfig.SizePixels = std::floor(ImHexApi::Fonts::getFontSize() / ImHexApi::Fonts::DefaultFontSize) * ImHexApi::Fonts::DefaultFontSize;
|
||||
|
||||
return fonts->AddFontDefault(&defaultConfig);
|
||||
};
|
||||
|
||||
// Load main font
|
||||
// If a custom font has been specified, load it, otherwise load the default ImGui font
|
||||
ImFont *defaultFont = loadDefaultFont("Default Font");
|
||||
if (defaultFont == nullptr) {
|
||||
log::warn("Failed to load custom font! Falling back to default font.");
|
||||
|
||||
ImHexApi::Fonts::impl::setFontSize(defaultFontSize);
|
||||
cfg.SizePixels = defaultFontSize;
|
||||
defaultFont = fonts->AddFontDefault(&cfg);
|
||||
}
|
||||
|
||||
fonts->Build();
|
||||
|
||||
cfg.FontDataOwnedByAtlas = false;
|
||||
|
||||
// Add all other fonts to the atlas
|
||||
auto startFlags = cfg.FontBuilderFlags;
|
||||
std::list<ImVector<ImWchar>> ranges;
|
||||
for (auto &font : ImHexApi::Fonts::impl::getFonts()) {
|
||||
ImVector<ImWchar> fontRange;
|
||||
if (font.glyphRanges.empty()) {
|
||||
fontRange = defaultGlyphRanges;
|
||||
} else {
|
||||
for (const auto &range : font.glyphRanges) {
|
||||
fontRange.push_back(range.begin);
|
||||
fontRange.push_back(range.end);
|
||||
}
|
||||
fontRange.push_back(0x00);
|
||||
}
|
||||
|
||||
ranges.push_back(fontRange);
|
||||
|
||||
cfg.FontBuilderFlags = font.flags;
|
||||
|
||||
float descent = [&] {
|
||||
ImFontAtlas atlas;
|
||||
|
||||
// Disable merge mode for this font but retain the rest of the configuration
|
||||
cfg.MergeMode = false;
|
||||
|
||||
auto size = fontSize;
|
||||
if (font.defaultSize.has_value())
|
||||
size = font.defaultSize.value() * std::floor(ImHexApi::Fonts::getFontSize() / ImHexApi::Fonts::DefaultFontSize);
|
||||
else
|
||||
size = std::max(1.0F, std::floor(size / ImHexApi::Fonts::DefaultFontSize)) * ImHexApi::Fonts::DefaultFontSize;
|
||||
|
||||
cfg.SizePixels = size;
|
||||
|
||||
ON_SCOPE_EXIT { cfg.MergeMode = true; };
|
||||
|
||||
// Construct a range that only contains the first glyph of the font
|
||||
ImVector<ImWchar> queryRange;
|
||||
{
|
||||
auto firstGlyph = font.glyphRanges.empty() ? defaultGlyphRanges.front() : font.glyphRanges.front().begin;
|
||||
queryRange.push_back(firstGlyph);
|
||||
queryRange.push_back(firstGlyph);
|
||||
}
|
||||
queryRange.push_back(0x00);
|
||||
|
||||
// Build the font atlas with the query range
|
||||
auto newFont = atlas.AddFontFromMemoryTTF(const_cast<u8 *>(font.fontData.data()), int(font.fontData.size()), 0, &cfg, queryRange.Data);
|
||||
atlas.Build();
|
||||
|
||||
return newFont->Descent;
|
||||
}();
|
||||
|
||||
|
||||
std::memset(cfg.Name, 0x00, sizeof(cfg.Name));
|
||||
std::strncpy(cfg.Name, font.name.c_str(), sizeof(cfg.Name) - 1);
|
||||
cfg.GlyphOffset = { font.offset.x, font.offset.y - defaultFont->Descent + descent };
|
||||
fonts->AddFontFromMemoryTTF(const_cast<u8 *>(font.fontData.data()), int(font.fontData.size()), 0, &cfg, ranges.back().Data);
|
||||
}
|
||||
cfg.FontBuilderFlags = startFlags;
|
||||
|
||||
// Create bold and italic font
|
||||
cfg.MergeMode = false;
|
||||
ImFont *boldFont = loadDefaultFont("Bold Font", ImGuiFreeTypeBuilderFlags_Bold);
|
||||
ImFont *italicFont = loadDefaultFont("Italic Font", ImGuiFreeTypeBuilderFlags_Oblique);
|
||||
ImHexApi::Fonts::impl::setFonts(boldFont, italicFont);
|
||||
|
||||
// Try to build the font atlas
|
||||
if (!fonts->Build()) {
|
||||
// The main reason the font atlas failed to build is that the font is too big for the GPU to handle
|
||||
// If unicode support is enabled, therefor try to load the font atlas without unicode support
|
||||
// If that still didn't work, there's probably something else going on with the graphics drivers
|
||||
// Especially Intel GPU drivers are known to have various bugs
|
||||
|
||||
if (loadUnicode) {
|
||||
log::error("Failed to build font atlas! Disabling Unicode support.");
|
||||
IM_DELETE(fonts);
|
||||
|
||||
// Disable unicode support in settings
|
||||
ContentRegistry::Settings::write<bool>("hex.builtin.setting.font", "hex.builtin.setting.font.load_all_unicode_chars", false);
|
||||
|
||||
// Try to load the font atlas again
|
||||
return loadFontsImpl(false);
|
||||
} else {
|
||||
log::error("Failed to build font atlas! Check your Graphics driver!");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Configure ImGui to use the font atlas
|
||||
ImHexApi::Fonts::impl::setFontAtlas(fonts);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool loadFonts() {
|
||||
// Check if unicode support is enabled in the settings and that the user doesn't use the No GPU version on Windows
|
||||
// The Mesa3D software renderer on Windows identifies itself as "VMware, Inc."
|
||||
bool shouldLoadUnicode =
|
||||
ContentRegistry::Settings::read<bool>("hex.builtin.setting.font", "hex.builtin.setting.font.load_all_unicode_chars", false) &&
|
||||
ImHexApi::System::getGPUVendor() != "VMware, Inc.";
|
||||
|
||||
return loadFontsImpl(shouldLoadUnicode);
|
||||
}
|
||||
|
||||
bool loadWindowSettings() {
|
||||
bool multiWindowEnabled = ContentRegistry::Settings::read<bool>("hex.builtin.setting.interface", "hex.builtin.setting.interface.multi_windows", false);
|
||||
ImHexApi::System::impl::setMultiWindowMode(multiWindowEnabled);
|
||||
@ -392,7 +137,6 @@ namespace hex::plugin::builtin {
|
||||
void addInitTasks() {
|
||||
ImHexApi::System::addStartupTask("Load Window Settings", false, loadWindowSettings);
|
||||
ImHexApi::System::addStartupTask("Configuring UI scale", true, configureUIScale);
|
||||
ImHexApi::System::addStartupTask("Loading fonts", true, loadFonts);
|
||||
ImHexApi::System::addStartupTask("Checking for updates", true, checkForUpdates);
|
||||
}
|
||||
}
|
||||
@ -7,6 +7,7 @@ add_imhex_plugin(
|
||||
fonts
|
||||
SOURCES
|
||||
source/library_fonts.cpp
|
||||
source/font_loader.cpp
|
||||
source/fonts.cpp
|
||||
INCLUDES
|
||||
include
|
||||
|
||||
340
plugins/fonts/source/font_loader.cpp
Normal file
340
plugins/fonts/source/font_loader.cpp
Normal file
@ -0,0 +1,340 @@
|
||||
#include <imgui.h>
|
||||
#include <imgui_internal.h>
|
||||
#include <imgui_freetype.h>
|
||||
|
||||
#include <memory>
|
||||
#include <list>
|
||||
#include <hex/api/imhex_api.hpp>
|
||||
|
||||
#include <romfs/romfs.hpp>
|
||||
#include "wolv/io/file.hpp"
|
||||
#include "hex/api/content_registry.hpp"
|
||||
#include "hex/helpers/logger.hpp"
|
||||
#include "wolv/utils/string.hpp"
|
||||
#include "hex/helpers/fs.hpp"
|
||||
|
||||
namespace hex::fonts {
|
||||
|
||||
namespace {
|
||||
|
||||
class Font {
|
||||
public:
|
||||
Font() = default;
|
||||
|
||||
float getDescent() const {
|
||||
return m_font->Descent;
|
||||
}
|
||||
|
||||
private:
|
||||
explicit Font(ImFont *font) : m_font(font) { }
|
||||
|
||||
private:
|
||||
friend class FontAtlas;
|
||||
|
||||
ImFont *m_font;
|
||||
};
|
||||
|
||||
class FontAtlas {
|
||||
public:
|
||||
FontAtlas() : m_fontAtlas(IM_NEW(ImFontAtlas)) {
|
||||
enableUnicodeCharacters(false);
|
||||
|
||||
// Set the default configuration for the font atlas
|
||||
m_config.OversampleH = m_config.OversampleV = 1;
|
||||
m_config.PixelSnapH = true;
|
||||
m_config.MergeMode = false;
|
||||
|
||||
// Make sure the font atlas doesn't get too large, otherwise weaker GPUs might reject it
|
||||
m_fontAtlas->Flags |= ImFontAtlasFlags_NoPowerOfTwoHeight;
|
||||
m_fontAtlas->TexDesiredWidth = 4096;
|
||||
}
|
||||
|
||||
~FontAtlas() {
|
||||
IM_DELETE(m_fontAtlas);
|
||||
}
|
||||
|
||||
Font addDefaultFont() {
|
||||
ImFontConfig config = m_config;
|
||||
config.FontBuilderFlags |= ImGuiFreeTypeBuilderFlags_Monochrome | ImGuiFreeTypeBuilderFlags_MonoHinting;
|
||||
config.SizePixels = std::floor(ImHexApi::System::getGlobalScale()) * 13.0F;
|
||||
|
||||
auto font = m_fontAtlas->AddFontDefault(&config);
|
||||
|
||||
m_config.MergeMode = true;
|
||||
|
||||
return Font(font);
|
||||
}
|
||||
|
||||
Font addFontFromMemory(const std::vector<u8> &fontData, float fontSize, ImVec2 offset, bool ownedByImGui = false, const ImVector<ImWchar> &glyphRange = {}) {
|
||||
auto &storedFontData = m_fontData.emplace_back(fontData);
|
||||
|
||||
ImFontConfig config = m_config;
|
||||
config.FontDataOwnedByAtlas = ownedByImGui;
|
||||
|
||||
config.GlyphOffset = { offset.x, offset.y };
|
||||
auto font = m_fontAtlas->AddFontFromMemoryTTF(storedFontData.data(), int(storedFontData.size()), fontSize, &config, !glyphRange.empty() ? glyphRange.Data : m_glyphRange.Data);
|
||||
|
||||
m_config.MergeMode = true;
|
||||
|
||||
return Font(font);
|
||||
}
|
||||
|
||||
Font addFontFromRomFs(const std::fs::path &path, float fontSize, ImVec2 offset, const ImVector<ImWchar> &glyphRange = {}) {
|
||||
auto data = romfs::get(path).span<u8>();
|
||||
return addFontFromMemory({ data.begin(), data.end() }, fontSize, offset, false, glyphRange);
|
||||
}
|
||||
|
||||
Font addFontFromFile(const std::fs::path &path, float fontSize, ImVec2 offset, const ImVector<ImWchar> &glyphRange = {}) {
|
||||
wolv::io::File file(path, wolv::io::File::Mode::Read);
|
||||
|
||||
auto data = file.readVector();
|
||||
return addFontFromMemory(data, fontSize, offset, true, glyphRange);
|
||||
}
|
||||
|
||||
void setBold(bool enabled) {
|
||||
if (enabled)
|
||||
m_config.FontBuilderFlags |= ImGuiFreeTypeBuilderFlags_Bold;
|
||||
else
|
||||
m_config.FontBuilderFlags &= ~ImGuiFreeTypeBuilderFlags_Bold;
|
||||
}
|
||||
|
||||
void setItalic(bool enabled) {
|
||||
if (enabled)
|
||||
m_config.FontBuilderFlags |= ImGuiFreeTypeBuilderFlags_Oblique;
|
||||
else
|
||||
m_config.FontBuilderFlags &= ~ImGuiFreeTypeBuilderFlags_Oblique;
|
||||
}
|
||||
|
||||
void setAntiAliasing(bool enabled) {
|
||||
if (enabled)
|
||||
m_config.FontBuilderFlags &= ~ImGuiFreeTypeBuilderFlags_Monochrome | ImGuiFreeTypeBuilderFlags_MonoHinting;
|
||||
else
|
||||
m_config.FontBuilderFlags |= ImGuiFreeTypeBuilderFlags_Monochrome | ImGuiFreeTypeBuilderFlags_MonoHinting;
|
||||
}
|
||||
|
||||
void enableUnicodeCharacters(bool enabled) {
|
||||
ImFontGlyphRangesBuilder glyphRangesBuilder;
|
||||
|
||||
{
|
||||
constexpr static std::array<ImWchar, 3> controlCodeRange = { 0x0001, 0x001F, 0 };
|
||||
constexpr static std::array<ImWchar, 3> extendedAsciiRange = { 0x007F, 0x00FF, 0 };
|
||||
constexpr static std::array<ImWchar, 3> latinExtendedARange = { 0x0100, 0x017F, 0 };
|
||||
|
||||
glyphRangesBuilder.AddRanges(controlCodeRange.data());
|
||||
glyphRangesBuilder.AddRanges(m_fontAtlas->GetGlyphRangesDefault());
|
||||
glyphRangesBuilder.AddRanges(extendedAsciiRange.data());
|
||||
glyphRangesBuilder.AddRanges(latinExtendedARange.data());
|
||||
}
|
||||
|
||||
if (enabled) {
|
||||
constexpr static std::array<ImWchar, 3> fullRange = { 0x0180, 0xFFEF, 0 };
|
||||
|
||||
glyphRangesBuilder.AddRanges(fullRange.data());
|
||||
} else {
|
||||
glyphRangesBuilder.AddRanges(m_fontAtlas->GetGlyphRangesJapanese());
|
||||
glyphRangesBuilder.AddRanges(m_fontAtlas->GetGlyphRangesChineseFull());
|
||||
glyphRangesBuilder.AddRanges(m_fontAtlas->GetGlyphRangesCyrillic());
|
||||
glyphRangesBuilder.AddRanges(m_fontAtlas->GetGlyphRangesKorean());
|
||||
glyphRangesBuilder.AddRanges(m_fontAtlas->GetGlyphRangesThai());
|
||||
glyphRangesBuilder.AddRanges(m_fontAtlas->GetGlyphRangesVietnamese());
|
||||
}
|
||||
|
||||
m_glyphRange.clear();
|
||||
glyphRangesBuilder.BuildRanges(&m_glyphRange);
|
||||
}
|
||||
|
||||
bool build() const {
|
||||
return m_fontAtlas->Build();
|
||||
}
|
||||
|
||||
[[nodiscard]] ImFontAtlas* getAtlas() const {
|
||||
return m_fontAtlas;
|
||||
}
|
||||
|
||||
float calculateFontDescend(const ImHexApi::Fonts::Font &font, float fontSize) const {
|
||||
auto atlas = std::make_unique<ImFontAtlas>();
|
||||
auto cfg = m_config;
|
||||
|
||||
// Calculate the expected font size
|
||||
auto size = fontSize;
|
||||
if (font.defaultSize.has_value())
|
||||
size = font.defaultSize.value() * std::floor(ImHexApi::Fonts::getFontSize() / ImHexApi::Fonts::DefaultFontSize);
|
||||
else
|
||||
size = std::max(1.0F, std::floor(size / ImHexApi::Fonts::DefaultFontSize)) * ImHexApi::Fonts::DefaultFontSize;
|
||||
|
||||
cfg.MergeMode = false;
|
||||
cfg.SizePixels = size;
|
||||
cfg.FontDataOwnedByAtlas = false;
|
||||
|
||||
// Construct a range that only contains the first glyph of the font
|
||||
ImVector<ImWchar> queryRange;
|
||||
{
|
||||
auto firstGlyph = font.glyphRanges.empty() ? m_glyphRange.front() : font.glyphRanges.front().begin;
|
||||
queryRange.push_back(firstGlyph);
|
||||
queryRange.push_back(firstGlyph);
|
||||
}
|
||||
queryRange.push_back(0x00);
|
||||
|
||||
// Build the font atlas with the query range
|
||||
auto newFont = atlas->AddFontFromMemoryTTF(const_cast<u8 *>(font.fontData.data()), int(font.fontData.size()), 0, &cfg, queryRange.Data);
|
||||
atlas->Build();
|
||||
|
||||
return newFont->Descent;
|
||||
}
|
||||
|
||||
void reset() {
|
||||
IM_DELETE(m_fontAtlas);
|
||||
m_fontAtlas = IM_NEW(ImFontAtlas);
|
||||
|
||||
m_fontData.clear();
|
||||
m_config.MergeMode = false;
|
||||
}
|
||||
|
||||
private:
|
||||
ImFontAtlas* m_fontAtlas;
|
||||
ImFontConfig m_config;
|
||||
ImVector<ImWchar> m_glyphRange;
|
||||
|
||||
std::list<std::vector<u8>> m_fontData;
|
||||
};
|
||||
|
||||
std::fs::path findCustomFontPath() {
|
||||
// Find the custom font file specified in the settings
|
||||
auto fontFile = ContentRegistry::Settings::read<std::fs::path>("hex.builtin.setting.font", "hex.builtin.setting.font.font_path", "");
|
||||
if (!fontFile.empty()) {
|
||||
if (!wolv::io::fs::exists(fontFile) || !wolv::io::fs::isRegularFile(fontFile)) {
|
||||
log::warn("Custom font file {} not found! Falling back to default font.", wolv::util::toUTF8String(fontFile));
|
||||
fontFile.clear();
|
||||
}
|
||||
|
||||
log::info("Loading custom font from {}", wolv::util::toUTF8String(fontFile));
|
||||
}
|
||||
|
||||
// If no custom font has been specified, search for a file called "font.ttf" in one of the resource folders
|
||||
if (fontFile.empty()) {
|
||||
for (const auto &dir : fs::getDefaultPaths(fs::ImHexPath::Resources)) {
|
||||
auto path = dir / "font.ttf";
|
||||
if (wolv::io::fs::exists(path)) {
|
||||
log::info("Loading custom font from {}", wolv::util::toUTF8String(path));
|
||||
|
||||
fontFile = path;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return fontFile;
|
||||
}
|
||||
|
||||
float getFontSize() {
|
||||
float fontSize = ImHexApi::Fonts::DefaultFontSize * ImHexApi::System::getGlobalScale();
|
||||
|
||||
// Fall back to the default font if the global scale is 0
|
||||
if (fontSize == 0.0F)
|
||||
fontSize = ImHexApi::Fonts::DefaultFontSize;
|
||||
|
||||
// If a custom font is used, adjust the font size
|
||||
if (!ImHexApi::Fonts::getCustomFontPath().empty()) {
|
||||
fontSize = float(ContentRegistry::Settings::read<int>("hex.builtin.setting.font", "hex.builtin.setting.font.font_size", 13)) * ImHexApi::System::getGlobalScale();
|
||||
}
|
||||
|
||||
return fontSize;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
bool buildFontAtlasImpl(bool loadUnicodeCharacters) {
|
||||
static FontAtlas fontAtlas;
|
||||
fontAtlas.reset();
|
||||
|
||||
// Check if Unicode support is enabled in the settings and that the user doesn't use the No GPU version on Windows
|
||||
// The Mesa3D software renderer on Windows identifies itself as "VMware, Inc."
|
||||
bool shouldLoadUnicode =
|
||||
ContentRegistry::Settings::read<bool>("hex.builtin.setting.font", "hex.builtin.setting.font.load_all_unicode_chars", false) &&
|
||||
ImHexApi::System::getGPUVendor() != "VMware, Inc.";
|
||||
|
||||
if (!loadUnicodeCharacters)
|
||||
shouldLoadUnicode = false;
|
||||
|
||||
fontAtlas.enableUnicodeCharacters(shouldLoadUnicode);
|
||||
|
||||
// If a custom font is set in the settings, load the rest of the settings as well
|
||||
if (ContentRegistry::Settings::read<bool>("hex.builtin.setting.font", "hex.builtin.setting.font.custom_font_enable", false)) {
|
||||
fontAtlas.setBold(ContentRegistry::Settings::read<bool>("hex.builtin.setting.font", "hex.builtin.setting.font.font_bold", false));
|
||||
fontAtlas.setItalic(ContentRegistry::Settings::read<bool>("hex.builtin.setting.font", "hex.builtin.setting.font.font_italic", false));
|
||||
fontAtlas.setAntiAliasing(ContentRegistry::Settings::read<bool>("hex.builtin.setting.font", "hex.builtin.setting.font.font_antialias", true));
|
||||
|
||||
ImHexApi::Fonts::impl::setCustomFontPath(findCustomFontPath());
|
||||
}
|
||||
ImHexApi::Fonts::impl::setFontSize(getFontSize());
|
||||
|
||||
|
||||
const auto fontSize = ImHexApi::Fonts::getFontSize();
|
||||
const auto &customFontPath = ImHexApi::Fonts::getCustomFontPath();
|
||||
|
||||
// Try to load the custom font if one was set
|
||||
std::optional<Font> defaultFont;
|
||||
if (!customFontPath.empty()) {
|
||||
defaultFont = fontAtlas.addFontFromFile(customFontPath, fontSize, ImVec2());
|
||||
if (!fontAtlas.build()) {
|
||||
log::error("Failed to load custom font '{}'! Falling back to default font", wolv::util::toUTF8String(customFontPath));
|
||||
defaultFont.reset();
|
||||
}
|
||||
}
|
||||
|
||||
// If there's no custom font set, or it failed to load, fall back to the default font
|
||||
if (!defaultFont.has_value()) {
|
||||
defaultFont = fontAtlas.addDefaultFont();
|
||||
if (!fontAtlas.build()) {
|
||||
log::fatal("Failed to load default font!");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Add all the built-in fonts
|
||||
{
|
||||
static std::list<ImVector<ImWchar>> glyphRanges;
|
||||
glyphRanges.clear();
|
||||
|
||||
for (auto &font : ImHexApi::Fonts::impl::getFonts()) {
|
||||
// Construct the glyph range for the font
|
||||
ImVector<ImWchar> glyphRange;
|
||||
if (!font.glyphRanges.empty()) {
|
||||
for (const auto &range : font.glyphRanges) {
|
||||
glyphRange.push_back(range.begin);
|
||||
glyphRange.push_back(range.end);
|
||||
}
|
||||
glyphRange.push_back(0x00);
|
||||
}
|
||||
glyphRanges.push_back(glyphRange);
|
||||
|
||||
// Calculate the glyph offset for the font
|
||||
ImVec2 offset = { font.offset.x, font.offset.y - defaultFont->getDescent() + fontAtlas.calculateFontDescend(font, fontSize) };
|
||||
|
||||
// Load the font
|
||||
fontAtlas.addFontFromMemory(font.fontData, font.defaultSize.value_or(fontSize), offset, false, glyphRanges.back());
|
||||
}
|
||||
}
|
||||
|
||||
// Build the font atlas
|
||||
const bool result = fontAtlas.build();
|
||||
if (result) {
|
||||
// Set the font atlas if the build was successful
|
||||
ImHexApi::Fonts::impl::setFontAtlas(fontAtlas.getAtlas());
|
||||
return true;
|
||||
}
|
||||
|
||||
// If the build wasn't successful and Unicode characters are enabled, try again without them
|
||||
// If they were disabled already, something went wrong, and we can't recover from it
|
||||
if (!shouldLoadUnicode)
|
||||
return false;
|
||||
else
|
||||
return buildFontAtlasImpl(false);
|
||||
}
|
||||
|
||||
bool buildFontAtlas() {
|
||||
return buildFontAtlasImpl(true);
|
||||
}
|
||||
|
||||
}
|
||||
@ -9,7 +9,7 @@
|
||||
|
||||
namespace hex::fonts {
|
||||
|
||||
void loadFonts() {
|
||||
void registerFonts() {
|
||||
using namespace ImHexApi::Fonts;
|
||||
|
||||
/**
|
||||
|
||||
@ -6,11 +6,14 @@
|
||||
#include <romfs/romfs.hpp>
|
||||
|
||||
namespace hex::fonts {
|
||||
void loadFonts();
|
||||
void registerFonts();
|
||||
|
||||
bool buildFontAtlas();
|
||||
}
|
||||
|
||||
IMHEX_LIBRARY_SETUP("Fonts") {
|
||||
hex::log::debug("Using romfs: '{}'", romfs::name());
|
||||
|
||||
hex::fonts::loadFonts();
|
||||
hex::ImHexApi::System::addStartupTask("Loading fonts", true, hex::fonts::buildFontAtlas);
|
||||
hex::fonts::registerFonts();
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user