application.h

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2025-2026 Manuel Osorio
#pragma once
#include "flint/audio/audio.h"
#include "flint/core/asset-loader.h"
#include "flint/core/config.h"
#include "flint/core/state.h"
#include "flint/resource/assets-manager.h"
#include "flint/ui/ui-canvas.h"
#include "flint/ui/ui-system.h"
#include "flint/window/IWindow.h"
 
#include <memory>
#include <string>
 
namespace Flint {
  class GPURenderer;
 
  class Application {
    public:
      Application(const FlintConfig &config, IAssetLoader *assetLoader = nullptr);
 
      Application(const FlintConfig &config, IAssetLoader &assetLoader)
        : Application(config, &assetLoader) {
      }
 
      virtual ~Application();
      void run();
 
      IWindow &getWindow() {
        return *m_window;
      }
 
      GPURenderer &getRenderer() const {
        return *m_gpuRenderer;
      }
 
      UISystem &getUISystem() {
        return m_uiSystem;
      }
 
      UICanvas &getUICanvas() {
        return *m_uiCanvas;
      }
 
      std::string loadUIContent(const std::string &filePath);
 
      StateManager &getStateManager() {
        return m_stateManager;
      }
 
      Audio &getAudioEngine() {
        return m_audioEngine;
      }
 
      IAssetLoader &getAssetLoader() {
        return *m_assetLoader;
      }
 
      AssetManager &getAssetManager() {
        return *m_assetManager;
      }
 
      const AssetManager &getAssetManager() const {
        return *m_assetManager;
      }
 
      const FlintConfig &getConfig() const {
        return m_config;
      }
 
      virtual void close();
 
    protected:
      virtual std::unique_ptr<State> createInitialState() = 0;
 
      virtual void onInit() {
      }
 
      virtual void onShutdown() {
      }
 
    private:
      void init();
      void setupGlobalEvents();
      void updateDisplayScale();
 
      SDL_GPUPresentMode getPresentMode(GRAPHICS_PRESENT_MODE presentMode);
 
      FlintConfig                   m_config;
      GRAPHICS_BACKEND              m_backend;
      std::unique_ptr<IAssetLoader> m_ownedAssetLoader;
      IAssetLoader                 *m_assetLoader;
      std::unique_ptr<IWindow>      m_window;
      Audio                         m_audioEngine;
      std::unique_ptr<GPURenderer>  m_gpuRenderer;
      std::unique_ptr<AssetManager> m_assetManager;
      UISystem                      m_uiSystem;
      std::unique_ptr<UICanvas>     m_uiCanvas;
      StateManager                  m_stateManager;
      bool                          m_minimized = false;
  };
}