Smart Update System: Multi-Language Changelogs, GitHub-Style Alerts, and Release Automation

Markdown Engine & UI Enhancements:
    - Implemented GitHub-style Alert blocks in MarkdownRenderer: Added support for [!NOTE], [!TIP], [!IMPORTANT], [!WARNING], and [!CAUTION] with dynamic icons and framework-standard colors.
    - Upgraded WelcomeWindow: Added a dedicated "Update Experience" mode to display remote changelogs after a version bump.
    - Modernized MainWindow Update Popup: Migrated the update changelog view to the full Markdown engine, enabling rich text and alerts.
    - UI Component Fix: Updated UIElements::Button to correctly respect ImGui::BeginDisabled() state (visual dimming and text color).

API & Integration:
    - Standardized Response Parsing: Aligned ApiService with the server-side JSON 'data' wrapper across all endpoints (Updates, Release Notes, Patrons).
    - Intelligent Language Fallback: Implemented client-side support for smart translation matching (User Language -> English -> Default).
    - Robust Version Parsing: Improved Version::FromString to handle various semantic version formats more reliably.

Framework Core & Infrastructure:
    - CommunicationManager Refactoring: Implemented asynchronous release notes fetching logic and new signals (OnReleaseNotesReceived) for real-time UI updates.
    - Decoupled System Metadata: Finalized SystemUtils integration for centralized OS versioning, architecture, and high-precision locale detection.
    - Smart Post-Update Logic: UIManager now automatically detects an "Updated" state and triggers a background fetch for localized release announcements.

Author: Track'n'Truck Devs

README.md

@@ -96,6 +96,9 @@
    ✔ Markdown Rendering (MD4C):
     To provide rich text formatting, SPF uses a proprietary Markdown renderer built directly on the **md4c (Markdown for C) parser**. This custom engine ensures perfect layout flow across different styles, supporting GFM tables, custom inline colors, and integrated clipboard support for code blocks.
 
+   ✔ Image Loading (stb_image):
+    For efficient and memory-safe image decoding, SPF integrates the **stb_image** library. This allows plugins to load textures directly from common formats like PNG and JPG into GPU-ready buffers.
+
 
 
 <h2 align="center">❤️ Support the Project</h2>
@@ -374,6 +377,7 @@ This project would not be possible without the incredible work of the open-sourc
 *   **[nlohmann/json](https://github.com/nlohmann/json)**: For easy and powerful JSON manipulation.
 *   **[cpr (C++ Requests)](https://github.com/libcpr/cpr)**: For handling all external web requests with a clean, modern interface.
 *   **[md4c](https://github.com/mity/md4c)**: For providing fast and lightweight Markdown rendering within the UI.
+*   **[stb_image](https://github.com/nothings/stb)**: For reliable and easy image uploads.
 *   **[zlib](https://github.com/madler/zlib)**: For data compression, used as a dependency by other core components.
 *   **[SCS SDK](https://modding.scssoft.com/wiki/Documentation/Engine/SDK/Telemetry)**: For providing the official telemetry interface that makes this all possible.
 

include/SPF/Modules/CommunicationManager.hpp

@@ -65,12 +65,21 @@ namespace Modules {
          */
         void RequestPatronsFetch(bool forceRefresh = false);
 
+        /**
+         * @brief Requests release notes for the current framework version.
+         */
+        void RequestReleaseNotesFetch();
+
         // --- Data Submission (SET) ---
         /**
          * @brief Queues analytics session data for submission.
          */
         void RequestTrackUsage();
 
+        // --- Signals ---
+        Utils::Signal<void(const System::UpdateInfo&)> OnUpdateInfoReceived;
+        Utils::Signal<void(const System::ChangelogData&)> OnReleaseNotesReceived;
+
     private:
         // --- Event Handlers ---
         void OnRequestTrackUsage(const Events::System::OnRequestTrackUsage& e);
@@ -101,11 +110,13 @@ namespace Modules {
         // --- Cache States ---
         ResourceState<System::UpdateInfo> m_updateState;
         ResourceState<std::vector<System::Patron>> m_patronsState;
+        ResourceState<System::ChangelogData> m_releaseNotesState;
         std::mutex m_stateMutex;
 
         // --- Futures for async processing ---
         std::optional<std::future<System::ApiResult<System::UpdateInfo>>> m_updateFuture;
         std::optional<std::future<System::ApiResult<std::vector<System::Patron>>>> m_patronsFuture;
+        std::optional<std::future<System::ApiResult<System::ChangelogData>>> m_releaseNotesFuture;
         std::optional<std::future<void>> m_trackUsageFuture;
 
         // --- Sinks ---

include/SPF/System/ApiService.hpp

@@ -56,17 +56,29 @@ namespace System {
             uint32_t count;
         };
 
+        /**
+         * @brief Holds markdown changelog data for a specific version.
+         */
+        struct ChangelogData {
+            std::string title;
+            std::string markdown;
+        };
+
         /**
          * @brief Holds information about the latest framework update.
          */
         struct UpdateInfo {
             bool updateAvailable = false;
-            std::string status;   // e.g., "update_available", "up_to_date", "switch_to_release"
-            std::string severity; // e.g., "major", "minor", "patch"
-            Version latestVersion;
-            std::string formattedLatestVersion;
+            struct {
+                Version ver;
+                std::string full;
+            } latestVersion;
             std::string downloadUrl;
-            std::string changelog;
+            struct {
+                std::string archive;
+                std::string binary;
+            } md5;
+            ChangelogData content;
         };
 
         /**
@@ -91,9 +103,12 @@ namespace System {
             ApiService();
             ~ApiService() = default;
 
-            // Asynchronously fetches the latest update information.
-            std::future<ApiResult<UpdateInfo>> FetchUpdateInfoAsync(const std::string& baseUrl, int major, int minor, int patch, const std::string& channel);
+            // Asynchronously fetches the latest update information using the new get_framework_update.php.
+            std::future<ApiResult<UpdateInfo>> FetchUpdateInfoAsync(const std::string& baseUrl, int major, int minor, int patch, const std::string& channel, const std::string& lang);
 
+            // Asynchronously fetches localized release notes for a specific version using get_release_notes.php.
+            std::future<ApiResult<ChangelogData>> FetchReleaseNotesAsync(const std::string& baseUrl, int major, int minor, int patch, const std::string& lang);
+
             // Asynchronously fetches the list of patrons.
             std::future<ApiResult<std::vector<Patron>>> FetchPatronsAsync(const std::string& baseUrl);
 

include/SPF/UI/MainWindow.hpp

@@ -96,7 +96,6 @@ class MainWindow : public BaseWindow {
   //  State for Update Check
   bool m_updateCheckInitiated = false;
   Modules::CommunicationManager::UpdateStatus m_currentUpdateStatus = Modules::CommunicationManager::UpdateStatus::Unknown;
-  std::string m_updateApiStatus; // To store the status string from the API, e.g., "switch_to_release"
   std::optional<System::UpdateInfo> m_lastUpdateInfo;
   std::optional<std::string> m_lastUpdateError;
   bool m_isUpdatePopupOpen = false;

include/SPF/UI/MarkdownRenderer.hpp

@@ -26,6 +26,15 @@ class MarkdownRenderer {
 
 private:
     // --- Rendering Context ---
+    enum class AlertType {
+        None,
+        Note,      // [!NOTE] -> Blue
+        Tip,       // [!TIP] -> Green
+        Important, // [!IMPORTANT] -> Purple
+        Warning,   // [!WARNING] -> Orange/Gold
+        Caution    // [!CAUTION] -> Red
+    };
+
     struct Style {
         bool isBold = false;
         bool isItalic = false;
@@ -34,6 +43,7 @@ class MarkdownRenderer {
         bool isCode = false;
         bool isLink = false;
         bool isBlockQuote = false;
+        AlertType alertType = AlertType::None;
         unsigned int hLevel = 0; // 0 = no heading, 1-6 = H1-H6
         ImVec4 customColor = {0,0,0,0}; // (0,0,0,0) means no custom color
     };
@@ -71,6 +81,8 @@ class MarkdownRenderer {
     float m_quoteStartY = 0.0f;
     bool m_isAtStartOfLine = true;
     bool m_isInsideCodeBlock = false; // Flag to distinguish block vs inline code
+    bool m_isWaitingForAlertMarker = false; // Flag to detect [!NOTE] etc.
+    bool m_skipNextNewline = false;
 };
 
 } // namespace UI

include/SPF/UI/UIManager.hpp

@@ -30,6 +30,7 @@ class InputManager;
 }
 namespace Modules {
 class PluginManager;
+class CommunicationManager;
 }
 namespace Config {
 struct IConfigService;
@@ -58,7 +59,7 @@ class UIManager : public Config::IConfigurable {
 
   // Initialize method to pass dependencies, replacing constructor parameters
   void Init(Events::EventManager& eventManager, Input::InputManager& inputManager, Config::IConfigService& configService, Modules::KeyBindsManager& keyBindsManager,
-            Modules::PluginManager& pluginManager, Logging::LoggerFactory& loggerFactory, Modules::ITelemetryService& telemetryService);
+            Modules::PluginManager& pluginManager, Modules::CommunicationManager& communicationManager, Logging::LoggerFactory& loggerFactory, Modules::ITelemetryService& telemetryService);
 
   // Creates and registers all framework-defined UI windows.
   // This method centralizes UI window creation within UIManager.
@@ -125,6 +126,7 @@ class UIManager : public Config::IConfigurable {
  private:
   void OnPluginLoaded(const Events::OnPluginDidLoad& e);
   void OnPluginUnloaded(const Events::OnPluginWillBeUnloaded& e);
+  void OnReleaseNotesReceived(const System::ChangelogData& data);
 
   void InitializeImGui();
   void ShutdownImGui();
@@ -149,6 +151,7 @@ class UIManager : public Config::IConfigurable {
   Config::IConfigService* m_configService = nullptr;
   Modules::KeyBindsManager* m_keyBindsManager = nullptr;
   Modules::PluginManager* m_pluginManager = nullptr;
+  Modules::CommunicationManager* m_communicationManager = nullptr;
   Logging::LoggerFactory* m_loggerFactory = nullptr;
   Modules::ITelemetryService* m_telemetryService = nullptr;
   Rendering::Renderer* m_renderer = nullptr;
@@ -165,6 +168,7 @@ class UIManager : public Config::IConfigurable {
 
   std::unique_ptr<Utils::Sink<void(const Events::OnPluginDidLoad&)>> m_onPluginDidLoadSink;
   std::unique_ptr<Utils::Sink<void(const Events::OnPluginWillBeUnloaded&)>> m_onPluginWillBeUnloadedSink;
+  std::unique_ptr<Utils::Sink<void(const System::ChangelogData&)>> m_onReleaseNotesReceivedSink;
 };
 }  // namespace UI
 

include/SPF/UI/WelcomeWindow.hpp

@@ -10,6 +10,11 @@ SPF_NS_BEGIN
 
 namespace UI {
 
+enum class WelcomeMode {
+    FirstInstall,
+    FrameworkUpdate
+};
+
 class WelcomeWindow : public IWindow {
  public:
   WelcomeWindow(const std::string& componentName, const std::string& windowId);
@@ -31,6 +36,8 @@ class WelcomeWindow : public IWindow {
 
   // Helpers
   void SetVisibility(bool visible) { m_isVisible = visible; }
+  void SetMode(WelcomeMode mode) { m_mode = mode; }
+  void SetUpdateContent(const std::string& title, const std::string& changelogMarkdown);
 
  private:
   void InitializeResources();
@@ -44,6 +51,10 @@ class WelcomeWindow : public IWindow {
   bool m_isFocused = false;
   bool m_wasVisibleLastFrame = false;
 
+  WelcomeMode m_mode = WelcomeMode::FirstInstall;
+  std::string m_updateTitle;
+  std::string m_updateChangelog;
+
   std::unique_ptr<Rendering::ITexture> m_logoTexture;
   MarkdownRenderer m_markdownRenderer;
   bool m_resourcesInitialized = false;

plugins/ExamplePlugin/ExamplePlugin.cpp

@@ -1590,7 +1590,20 @@ void RenderStylingTab(SPF_UI_API* ui, void* user_data) {
         "And `inline code` is still here.\n\n"
         "| Header 1 | Header 2 |\n"
         "|----------|----------|\n"
-        "| Cell 1   | Cell 2   |\n";
+        "| Cell 1   | Cell 2   |\n\n"
+        "--- \n"
+        "### 4. GitHub-style Alerts\n"
+        "> [!NOTE]\n"
+        "> This is a blue information block.\n"
+        "> This is a blue information block.\n\n"
+        "> [!TIP]\n"
+        "> This is a green tip block.\n\n"
+        "> [!IMPORTANT]\n"
+        "> This is a purple important block.\n\n"
+        "> [!WARNING]\n"
+        "> This is a gold warning block.\n\n"
+        "> [!CAUTION]\n"
+        "> This is a red caution block.\n";
 
     // The base style for markdown can have padding, but the renderer will handle fonts/colors.
     ui->UI_Style_SetPadding(markdown_base_style, 10.0f, 5.0f);

src/Core/Core.cpp

@@ -371,8 +371,14 @@ void Core::InitFeatureHooks() {
   }
 
   const auto& frameworkSettings = frameworkSettingsNode->at("framework");
+  const bool isNewInstall = (System::EnvironmentManager::GetInstance().GetFrameworkInfo().installStatus == System::InstallationStatus::NewInstall);
+
   if (!frameworkSettings.contains("hook_states")) {
-    m_logger->Warn("'hook_states' not found in framework settings. Hooks will use default values.");
+    if (isNewInstall) {
+        m_logger->Debug("'hook_states' not found in framework settings (expected for new install). Hooks will use default values.");
+    } else {
+        m_logger->Warn("'hook_states' not found in framework settings. Hooks will use default values.");
+    }
     return;
   }
 
@@ -386,9 +392,14 @@ void Core::InitFeatureHooks() {
       hookManager.ReconcileHookState(hook, isEnabled);  // Use ReconcileHookState
       m_logger->Info("Applied config for hook: {}. Enabled: {}.", hookName, isEnabled);
     } else {
-      // If no config entry, use the hook's default enabled state (which is false for GameLogHook)
+      // If no config entry, use the hook's default enabled state
       hookManager.ReconcileHookState(hook, hook->IsEnabled());
-      m_logger->Warn("No config entry found for hook: {}. Using default state (Enabled: {}).", hookName, hook->IsEnabled());
+      
+      if (isNewInstall) {
+          m_logger->Debug("No config entry found for hook: {}. Using default state (Enabled: {}).", hookName, hook->IsEnabled());
+      } else {
+          m_logger->Warn("No config entry found for hook: {}. Using default state (Enabled: {}).", hookName, hook->IsEnabled());
+      }
     }
   }
 }
@@ -438,7 +449,7 @@ void Core::InitManagersAndPlugins() {
   m_keyBindsManager = std::make_unique<KeyBindsManager>(*m_inputManager, *m_eventManager);
   m_configurableServices.push_back(m_keyBindsManager.get());
   // Initialize the UIManager singleton
-  UIManager::GetInstance().Init(*m_eventManager, *m_inputManager, *m_configService, *m_keyBindsManager, PluginManager::GetInstance(), LoggerFactory::GetInstance(), *m_telemetryService);
+  UIManager::GetInstance().Init(*m_eventManager, *m_inputManager, *m_configService, *m_keyBindsManager, PluginManager::GetInstance(), *m_communicationManager, LoggerFactory::GetInstance(), *m_telemetryService);
   m_configurableServices.push_back(&UIManager::GetInstance());  // Add the singleton to configurable services
   //  Initialize the CommunicationManager
   reports.push_back(m_communicationManager->Initialize());