impr: Replace achievement icons with font icons

lib/libimhex/include/hex/api/achievement_manager.hpp

@@ -145,62 +145,17 @@ EXPORT_MODULE namespace hex {
          * @brief Returns the icon of the achievement
          * @return Icon of the achievement
          */
-        [[nodiscard]] const ImGuiExt::Texture &getIcon() const {
-            if (m_iconData.empty())
-                return m_icon;
-
-            if (m_icon.isValid())
-                return m_icon;
-
-            m_icon = ImGuiExt::Texture::fromImage(m_iconData.data(), m_iconData.size(), ImGuiExt::Texture::Filter::Linear);
-
-            return m_icon;
+        [[nodiscard]] const char* getIcon() const {
+            return m_icon.c_str();
         }
 
         /**
          * @brief Sets the icon of the achievement
-         * @param data Icon data
+         * @param icon Icon glyph
          * @return Reference to the achievement
          */
-        Achievement& setIcon(std::span<const std::byte> data) {
-            m_iconData.reserve(data.size());
-            for (auto &byte : data)
-                m_iconData.emplace_back(static_cast<u8>(byte));
-
-            return *this;
-        }
-
-        /**
-         * @brief Sets the icon of the achievement
-         * @param data Icon data
-         * @return Reference to the achievement
-         */
-        Achievement& setIcon(std::span<const u8> data) {
-            m_iconData.assign(data.begin(), data.end());
-
-            return *this;
-        }
-
-        /**
-         * @brief Sets the icon of the achievement
-         * @param data Icon data
-         * @return Reference to the achievement
-         */
-        Achievement& setIcon(std::vector<u8> data) {
-            m_iconData = std::move(data);
-
-            return *this;
-        }
-
-        /**
-         * @brief Sets the icon of the achievement
-         * @param data Icon data
-         * @return Reference to the achievement
-         */
-        Achievement& setIcon(const std::vector<std::byte> &data) {
-            m_iconData.reserve(data.size());
-            for (auto &byte : data)
-                m_iconData.emplace_back(static_cast<u8>(byte));
+        Achievement& setIcon(std::string icon) {
+            m_icon = std::move(icon);
 
             return *this;
         }
@@ -284,8 +239,7 @@ EXPORT_MODULE namespace hex {
 
         std::function<void(Achievement &)> m_clickCallback;
 
-        std::vector<u8> m_iconData;
-        mutable ImGuiExt::Texture m_icon;
+        std::string m_icon;
 
         u32 m_progress = 0;
         u32 m_maxProgress = 1;

plugins/builtin/source/content/achievements.cpp

@@ -1,4 +1,5 @@
 #include <iostream>
+#include <fonts/tabler_icons.hpp>
 #include <hex/api/achievement_manager.hpp>
 #include <hex/api/project_file_manager.hpp>
 
@@ -53,60 +54,60 @@ namespace hex::plugin::builtin {
         void registerGettingStartedAchievements() {
             AchievementManager::addAchievement<AchievementStartingOut>("hex.builtin.achievement.starting_out.docs.name")
                     .setDescription("hex.builtin.achievement.starting_out.docs.desc")
-                    .setIcon(romfs::get("assets/achievements/open-book.png").span());
+                    .setIcon(ICON_TA_BOOK);
 
             AchievementManager::addAchievement<AchievementStartingOut>("hex.builtin.achievement.starting_out.open_file.name")
                     .setDescription("hex.builtin.achievement.starting_out.open_file.desc")
-                    .setIcon(romfs::get("assets/achievements/page-facing-up.png").span());
+                    .setIcon(ICON_VS_NEW_FILE);
 
             AchievementManager::addAchievement<AchievementStartingOut>("hex.builtin.achievement.starting_out.save_project.name")
                     .setDescription("hex.builtin.achievement.starting_out.save_project.desc")
-                    .setIcon(romfs::get("assets/achievements/card-index-dividers.png").span())
+                    .setIcon(ICON_VS_NOTEBOOK)
                     .addRequirement("hex.builtin.achievement.starting_out.open_file.name");
 
 
             AchievementManager::addAchievement<AchievementStartingOut>("hex.builtin.achievement.starting_out.crash.name")
                     .setDescription("hex.builtin.achievement.starting_out.crash.desc")
-                    .setIcon(romfs::get("assets/achievements/collision-symbol.png").span())
+                    .setIcon(ICON_TA_BOOM)
                     .setInvisible();
         }
 
         void registerHexEditorAchievements() {
             AchievementManager::addAchievement<AchievementHexEditor>("hex.builtin.achievement.hex_editor.select_byte.name")
                     .setDescription("hex.builtin.achievement.hex_editor.select_byte.desc")
-                    .setIcon(romfs::get("assets/achievements/bookmark-tabs.png").span())
+                    .setIcon(ICON_VS_LIST_SELECTION)
                     .addRequirement("hex.builtin.achievement.starting_out.open_file.name");
 
             AchievementManager::addAchievement<AchievementHexEditor>("hex.builtin.achievement.hex_editor.open_new_view.name")
                     .setDescription("hex.builtin.achievement.hex_editor.open_new_view.desc")
-                    .setIcon(romfs::get("assets/achievements/frame-with-picture.png").span())
+                    .setIcon(ICON_VS_GO_TO_FILE)
                     .addRequirement("hex.builtin.achievement.hex_editor.create_bookmark.name");
 
             AchievementManager::addAchievement<AchievementHexEditor>("hex.builtin.achievement.hex_editor.modify_byte.name")
                     .setDescription("hex.builtin.achievement.hex_editor.modify_byte.desc")
-                    .setIcon(romfs::get("assets/achievements/pencil.png").span())
+                    .setIcon(ICON_VS_EDIT)
                     .addRequirement("hex.builtin.achievement.hex_editor.select_byte.name")
                     .addVisibilityRequirement("hex.builtin.achievement.hex_editor.select_byte.name");
 
             AchievementManager::addAchievement<AchievementHexEditor>("hex.builtin.achievement.hex_editor.copy_as.name")
                     .setDescription("hex.builtin.achievement.hex_editor.copy_as.desc")
-                    .setIcon(romfs::get("assets/achievements/copy.png").span())
+                    .setIcon(ICON_VS_PREVIEW)
                     .addRequirement("hex.builtin.achievement.hex_editor.modify_byte.name");
 
             AchievementManager::addAchievement<AchievementHexEditor>("hex.builtin.achievement.hex_editor.create_patch.name")
                     .setDescription("hex.builtin.achievement.hex_editor.create_patch.desc")
-                    .setIcon(romfs::get("assets/achievements/adhesive-bandage.png").span())
+                    .setIcon(ICON_TA_BANDAGE)
                     .addRequirement("hex.builtin.achievement.hex_editor.modify_byte.name");
 
             AchievementManager::addAchievement<AchievementHexEditor>("hex.builtin.achievement.hex_editor.fill.name")
                     .setDescription("hex.builtin.achievement.hex_editor.fill.desc")
-                    .setIcon(romfs::get("assets/achievements/water-wave.png").span())
+                    .setIcon(ICON_VS_PAINTCAN)
                     .addRequirement("hex.builtin.achievement.hex_editor.select_byte.name")
                     .addVisibilityRequirement("hex.builtin.achievement.hex_editor.select_byte.name");
 
             AchievementManager::addAchievement<AchievementHexEditor>("hex.builtin.achievement.hex_editor.create_bookmark.name")
                     .setDescription("hex.builtin.achievement.hex_editor.create_bookmark.desc")
-                    .setIcon(romfs::get("assets/achievements/bookmark.png").span())
+                    .setIcon(ICON_VS_BOOKMARK)
                     .addRequirement("hex.builtin.achievement.hex_editor.select_byte.name")
                     .addVisibilityRequirement("hex.builtin.achievement.hex_editor.select_byte.name");
         }
@@ -114,23 +115,23 @@ namespace hex::plugin::builtin {
         void registerPatternsAchievements() {
             AchievementManager::addAchievement<AchievementPatterns>("hex.builtin.achievement.patterns.place_menu.name")
                     .setDescription("hex.builtin.achievement.patterns.place_menu.desc")
-                    .setIcon(romfs::get("assets/achievements/clipboard.png").span())
+                    .setIcon(ICON_TA_CATEGORY_2)
                     .addRequirement("hex.builtin.achievement.hex_editor.select_byte.name");
 
             AchievementManager::addAchievement<AchievementPatterns>("hex.builtin.achievement.patterns.load_existing.name")
                     .setDescription("hex.builtin.achievement.patterns.load_existing.desc")
-                    .setIcon(romfs::get("assets/achievements/hourglass.png").span())
+                    .setIcon(ICON_TA_HOURGLASS)
                     .addRequirement("hex.builtin.achievement.patterns.place_menu.name");
 
             AchievementManager::addAchievement<AchievementPatterns>("hex.builtin.achievement.patterns.modify_data.name")
                     .setDescription("hex.builtin.achievement.patterns.modify_data.desc")
-                    .setIcon(romfs::get("assets/achievements/hammer.png").span())
+                    .setIcon(ICON_TA_HAMMER)
                     .addRequirement("hex.builtin.achievement.patterns.place_menu.name");
 
 
             AchievementManager::addAchievement<AchievementPatterns>("hex.builtin.achievement.patterns.data_inspector.name")
                     .setDescription("hex.builtin.achievement.patterns.data_inspector.desc")
-                    .setIcon(romfs::get("assets/achievements/eye-in-speech-bubble.png").span())
+                    .setIcon(ICON_TA_BUBBLE_TEXT)
                     .addRequirement("hex.builtin.achievement.hex_editor.select_byte.name");
         }
 
@@ -138,51 +139,51 @@ namespace hex::plugin::builtin {
         void registerFindAchievements() {
             AchievementManager::addAchievement<AchievementFind>("hex.builtin.achievement.find.find_strings.name")
                     .setDescription("hex.builtin.achievement.find.find_strings.desc")
-                    .setIcon(romfs::get("assets/achievements/ring.png").span())
+                    .setIcon(ICON_TA_HAND_RING_FINGER)
                     .addRequirement("hex.builtin.achievement.starting_out.open_file.name");
 
             AchievementManager::addAchievement<AchievementFind>("hex.builtin.achievement.find.find_specific_string.name")
                     .setDescription("hex.builtin.achievement.find.find_specific_string.desc")
-                    .setIcon(romfs::get("assets/achievements/right-pointing-magnifying-glass.png").span())
+                    .setIcon(ICON_TA_DIAMOND)
                     .addRequirement("hex.builtin.achievement.find.find_strings.name");
 
             AchievementManager::addAchievement<AchievementFind>("hex.builtin.achievement.find.find_numeric.name")
                     .setDescription("hex.builtin.achievement.find.find_numeric.desc")
-                    .setIcon(romfs::get("assets/achievements/abacus.png").span())
+                    .setIcon(ICON_TA_ABACUS)
                     .addRequirement("hex.builtin.achievement.find.find_strings.name");
         }
 
         void registerDataProcessorAchievements() {
             AchievementManager::addAchievement<AchievementDataProcessor>("hex.builtin.achievement.data_processor.place_node.name")
                     .setDescription("hex.builtin.achievement.data_processor.place_node.desc")
-                    .setIcon(romfs::get("assets/achievements/cloud.png").span())
+                    .setIcon(ICON_TA_CLOUD)
                     .addRequirement("hex.builtin.achievement.starting_out.open_file.name");
 
             AchievementManager::addAchievement<AchievementDataProcessor>("hex.builtin.achievement.data_processor.create_connection.name")
                     .setDescription("hex.builtin.achievement.data_processor.create_connection.desc")
-                    .setIcon(romfs::get("assets/achievements/linked-paperclips.png").span())
+                    .setIcon(ICON_TA_SHARE)
                     .addRequirement("hex.builtin.achievement.data_processor.place_node.name");
 
             AchievementManager::addAchievement<AchievementDataProcessor>("hex.builtin.achievement.data_processor.modify_data.name")
                     .setDescription("hex.builtin.achievement.data_processor.modify_data.desc")
-                    .setIcon(romfs::get("assets/achievements/hammer-and-pick.png").span())
+                    .setIcon(ICON_TA_LAYERS_SUBTRACT)
                     .addRequirement("hex.builtin.achievement.data_processor.create_connection.name");
 
             AchievementManager::addAchievement<AchievementDataProcessor>("hex.builtin.achievement.data_processor.custom_node.name")
                     .setDescription("hex.builtin.achievement.data_processor.custom_node.desc")
-                    .setIcon(romfs::get("assets/achievements/wrench.png").span())
+                    .setIcon(ICON_TA_MANUAL_GEARBOX)
                     .addRequirement("hex.builtin.achievement.data_processor.create_connection.name");
         }
 
         void registerMiscAchievements() {
             AchievementManager::addAchievement<AchievementMisc>("hex.builtin.achievement.misc.analyze_file.name")
                     .setDescription("hex.builtin.achievement.misc.analyze_file.desc")
-                    .setIcon(romfs::get("assets/achievements/brain.png").span())
+                    .setIcon(ICON_TA_BRAIN)
                     .addRequirement("hex.builtin.achievement.starting_out.open_file.name");
 
             AchievementManager::addAchievement<AchievementMisc>("hex.builtin.achievement.misc.download_from_store.name")
                     .setDescription("hex.builtin.achievement.misc.download_from_store.desc")
-                    .setIcon(romfs::get("assets/achievements/package.png").span())
+                    .setIcon(ICON_TA_PACKAGE)
                     .addRequirement("hex.builtin.achievement.starting_out.open_file.name");
         }
 
@@ -199,7 +200,7 @@ namespace hex::plugin::builtin {
 
             EventProviderDataModified::subscribe([](const prv::Provider *, u64, const u64, const u8*) {
                 // Warning: overlaps with the "Flood fill" achievement, since "Fill" works by writing to bytes one-by-one.
-                    // Thus, we do not check for size, that will always be equal to 1 even during a fill operation.
+                // Thus, we do not check for size, that will always be equal to 1 even during a fill operation.
                 AchievementManager::unlockAchievement("hex.builtin.achievement.hex_editor", "hex.builtin.achievement.hex_editor.modify_byte.name");
             });
 
@@ -226,8 +227,6 @@ namespace hex::plugin::builtin {
             static std::string challengeAchievement;
             static std::string challengeDescription;
 
-            static std::map<std::string, std::vector<u8>> icons;
-
             ProjectFile::registerHandler({
                 .basePath = "challenge",
                 .required = false,
@@ -253,11 +252,9 @@ namespace hex::plugin::builtin {
 
                                 if (achievement.contains("icon")) {
                                     if (const auto &icon = achievement["icon"]; icon.is_string() && !icon.is_null()) {
-                                        auto iconPath = icon.get<std::string>();
+                                        auto glyph = icon.get<std::string>();
 
-                                        auto data = tar.readVector(basePath / iconPath);
-                                        newAchievement.setIcon(data);
-                                        icons[iconPath] = std::move(data);
+                                        newAchievement.setIcon(glyph);
                                     }
                                 }
 
@@ -319,10 +316,6 @@ namespace hex::plugin::builtin {
                     if (!challengeDescription.empty())
                         tar.writeString(basePath / "description.txt", challengeDescription);
 
-                    for (const auto &[iconPath, data] : icons) {
-                        tar.writeVector(basePath / iconPath, data);
-                    }
-
                     nlohmann::json unlockedJson;
 
                     unlockedJson["achievements"] = nlohmann::json::array();

plugins/builtin/source/content/views/view_achievements.cpp

@@ -3,6 +3,7 @@
 #include <algorithm>
 #include <hex/api/content_registry/user_interface.hpp>
 #include <hex/api/content_registry/settings.hpp>
+#include <hex/api/imhex_api/fonts.hpp>
 #include <hex/api/task_manager.hpp>
 #include <hex/api/events/requests_gui.hpp>
 #include <hex/api/events/events_interaction.hpp>
@@ -78,28 +79,21 @@ namespace hex::plugin::builtin {
 
         // Draw achievement background
         if (achievement.isUnlocked()) {
-            drawList->AddRectFilled(position, position + achievementSize, fillColor, 5_scaled, 0);
-            drawList->AddRect(position, position + achievementSize, borderColor, 5_scaled, 0, 2_scaled);
+            drawList->AddRectFilled(position, position + achievementSize, fillColor, 2_scaled, 0);
+            drawList->AddRect(position, position + achievementSize, borderColor, 2_scaled, 0, 1_scaled);
         } else {
-            drawList->AddRectFilled(position, position + achievementSize, ImGui::GetColorU32(ImGuiCol_WindowBg) | 0xFF000000, 5_scaled, 0);
+            drawList->AddRectFilled(position, position + achievementSize, ImGui::GetColorU32(ImGuiCol_WindowBg) | 0xFF000000, 2_scaled, 0);
         }
 
         // Draw achievement icon if available
-        if (const auto &icon = achievement.getIcon(); icon.isValid()) {
-            ImVec2 iconSize;
-            if (icon.getSize().x > icon.getSize().y) {
-                iconSize.x = achievementSize.x;
-                iconSize.y = iconSize.x / icon.getSize().x * icon.getSize().y;
-            } else {
-                iconSize.y = achievementSize.y;
-                iconSize.x = iconSize.y / icon.getSize().y * icon.getSize().x;
-            }
+        ImHexApi::Fonts::getDefaultFont().push(2);
+        if (const auto &icon = achievement.getIcon(); icon != nullptr) {
+            const auto textSize = ImGui::CalcTextSize(icon);
 
-            iconSize *= 0.7F;
-
-            ImVec2 margin = (achievementSize - iconSize) / 2.0F;
-            drawList->AddImage(icon, position + margin, position + margin + iconSize);
+            const auto centeredPosition = position + (achievementSize - textSize) / 2.0F;
+            drawList->AddText(centeredPosition, ImGui::GetColorU32(ImGuiCol_Text), icon);
         }
+        ImHexApi::Fonts::getDefaultFont().pop();
 
         // Dim achievement if it is not unlocked
         if (!achievement.isUnlocked()) {
@@ -214,25 +208,18 @@ namespace hex::plugin::builtin {
     }
 
     void drawBackground(ImDrawList *drawList, ImVec2 min, ImVec2 max, ImVec2 offset) {
-        const auto patternSize = scaled({ 10, 10 });
+        const auto patternSize = scaled({ 20, 20 });
 
-        const auto darkColor  = ImGui::GetColorU32(ImGuiCol_TableRowBg);
-        const auto lightColor = ImGui::GetColorU32(ImGuiCol_TableRowBgAlt);
+        const auto lineColor = ImGui::GetColorU32(ImGuiCol_Text, 0.03F);
 
         // Draw a border around the entire background
+        drawList->AddRectFilled(min, max, ImGui::GetColorU32(ImGuiCol_WindowBg));
         drawList->AddRect(min, max, ImGui::GetColorU32(ImGuiCol_Border), 0.0F, 0, 1.0_scaled);
 
         // Draw a checkerboard pattern
-        bool light = false;
-        bool prevStart = false;
         for (float x = min.x + offset.x; x < max.x; x += i32(patternSize.x)) {
-            if (prevStart == light)
-                light = !light;
-            prevStart = light;
-
             for (float y = min.y + offset.y; y < max.y; y += i32(patternSize.y)) {
-                drawList->AddRectFilled({ x, y }, { x + patternSize.x, y + patternSize.y }, light ? lightColor : darkColor);
-                light = !light;
+                drawList->AddRect({ x, y }, { x + patternSize.x, y + patternSize.y }, lineColor);
             }
         }
     }
@@ -240,6 +227,8 @@ namespace hex::plugin::builtin {
     ImVec2 ViewAchievements::drawAchievementTree(ImDrawList *drawList, const AchievementManager::AchievementNode * prevNode, const std::vector<AchievementManager::AchievementNode*> &nodes, ImVec2 position) {
         ImVec2 maxPos = position;
 
+        ImHexApi::System::unlockFrameRate();
+
         // Loop over all available achievement nodes
         for (auto &node : nodes) {
             // If the achievement is invisible and not unlocked yet, don't draw anything
@@ -436,7 +425,9 @@ for (const auto &[categoryName, achievements] : startNodes) {
                     ImGuiExt::TextFormattedColored(ImGuiExt::GetCustomColorVec4(ImGuiCustomCol_AchievementUnlocked), "{}", "hex.builtin.view.achievements.unlocked"_lang);
 
                     // Draw achievement icon
-                    ImGui::Image(m_currAchievement->getIcon(), scaled({ 20, 20 }));
+                    ImHexApi::Fonts::getDefaultFont().push(1.25F);
+                    ImGui::TextUnformatted(m_currAchievement->getIcon());
+                    ImHexApi::Fonts::getDefaultFont().pop();
 
                     ImGui::SameLine();
                     ImGui::SeparatorEx(ImGuiSeparatorFlags_Vertical);

plugins/hashes/source/plugin_hashes.cpp

@@ -8,6 +8,7 @@
 #include <romfs/romfs.hpp>
 
 #include <content/views/view_hashes.hpp>
+#include <fonts/tabler_icons.hpp>
 
 namespace hex::plugin::hashes {
 
@@ -29,6 +30,6 @@ IMHEX_PLUGIN_SETUP("Hashes", "WerWolv", "Hashing algorithms") {
 
     AchievementManager::addAchievement<Achievement>("hex.builtin.achievement.misc", "hex.hashes.achievement.misc.create_hash.name")
         .setDescription("hex.hashes.achievement.misc.create_hash.desc")
-        .setIcon(romfs::get("assets/achievements/fortune-cookie.png").span())
+        .setIcon(ICON_TA_CRYSTAL_BALL)
         .addRequirement("hex.builtin.achievement.starting_out.open_file.name");
 }