sdl-window.h

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2025-2026 Manuel Osorio
#pragma once
#include "IWindow.h"
 
#include "flint/core/config.h"
#include "flint/core/log.h"
#include "flint/graphics/gpu/gpu-context.h"
 
#include <SDL3/SDL.h>
#include <SDL3/SDL_gpu.h>
#include <SDL3/SDL_render.h>
 
namespace Flint {
  class SdlWindow : public IWindow, public Flint::IGPUContext {
    public:
      explicit SdlWindow(const ApplicationConfig &config, GRAPHICS_BACKEND backend);
      ~SdlWindow() override;
 
      void display() override;
      bool isOpen() const override;
      void setMouseCursor(CursorType type) override;
      void pollEvents(const std::function<void(const AppEvent &)> &handler) override;
 
      void setTitle(const std::string &name) override {
        SDL_SetWindowTitle(m_window, name.c_str());
      }
 
      void close() override {
        m_running = false;
      }
 
      Flint::Vec2i getSize() const override {
        int width, height;
        SDL_GetWindowSizeInPixels(m_window, &width, &height);
        return {width, height};
      }
 
      Flint::Vec2f getMousePosition() const override {
        float x, y;
        SDL_GetMouseState(&x, &y);
        return {x * SDL_GetWindowPixelDensity(m_window), y * SDL_GetWindowPixelDensity(m_window)};
      }
 
      Flint::Vec2f mapPixelToCoords(Flint::Vec2f pixel) const override {
        return {static_cast<float>(pixel.x * SDL_GetWindowPixelDensity(m_window)),
                static_cast<float>(pixel.y * SDL_GetWindowPixelDensity(m_window))};
      }
 
      void addGlobalEventListener(std::function<void(const AppEvent &)> callback) override;
      bool hasFocus() const override;
 
      void *getNativeHandle() const override {
        return static_cast<void *>(m_window);
      }
 
      void setGPUDevice(SDL_GPUDevice *device) override {
        m_gpuDevice = device;
      }
 
      SDL_GPUDevice *getGPUDevice() override {
        return m_gpuDevice;
      }
 
      SDL_GPUCommandBuffer *getCommandBuffer() override {
        return m_commandBuffer;
      }
 
      SDL_GPURenderPass *getRenderPass() override {
        return m_renderPass;
      }
 
      bool isFullscreen() const override {
        SDL_WindowFlags flags = SDL_GetWindowFlags(m_window);
        return (flags & SDL_WINDOW_FULLSCREEN) != 0;
      }
 
      void setFullscreen(bool fullscreen) override {
        SDL_SetWindowFullscreen(m_window, fullscreen ? SDL_WINDOW_FULLSCREEN : 0);
      }
 
    private:
      SDL_Window           *m_window = nullptr;
      SDL_Renderer         *m_renderer = nullptr;
      SDL_GPUDevice        *m_gpuDevice = nullptr;
      SDL_GPUCommandBuffer *m_commandBuffer = nullptr;
      SDL_GPURenderPass    *m_renderPass = nullptr;
      bool                  m_running = true;
 
      std::vector<std::function<void(const AppEvent &)>> m_globalEventListeners;
  };
}