renderer.h

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2025-2026 Manuel Osorio
#pragma once
 
#include "flint/camera/camera.h"
#include "flint/core/asset-loader.h"
#include "flint/graphics/drawable.h"
#include "flint/graphics/pipelines/batch-pipeline.h"
#include "flint/graphics/pipelines/primitives-pipeline.h"
#include "flint/graphics/pipelines/ui-pipeline.h"
#include "flint/graphics/types/color.h"
#include "flint/window/IWindow.h"
 
#include <SDL3/SDL_gpu.h>
#include <SDL3/SDL_render.h>
 
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
namespace Flint {
  struct FrameData;
 
  class GPURenderer {
    public:
      explicit GPURenderer(IWindow *window, IAssetLoader &assetLoader, ShaderFormat shaderFormat);
      virtual ~GPURenderer();
 
      bool beginFrame();
 
      void draw(const std::function<void(RenderQueue &)> &overlayEmit = {});
      void endFrame();
 
      void submit(std::shared_ptr<const Drawable> drawable, DrawLayer layer = DrawLayer::Midground);
 
      [[deprecated("Use submit(std::shared_ptr<const Drawable>, DrawLayer) instead.")]]
      void submit(const Drawable *drawable, DrawLayer layer = DrawLayer::Midground);
 
      void setClearColor(Color color);
 
      void setViewport(const SDL_GPUViewport &viewport);
 
      void setCamera(const Camera &camera);
 
      [[nodiscard]] std::unique_ptr<Shader> createShader() const {
        return std::make_unique<Shader>(m_gpuDevice, m_shaderFormat);
      }
 
      [[nodiscard]] std::vector<char> loadShader(const std::string &basePath) const;
 
      [[nodiscard]] std::string getShaderPath(const std::string &basePath) const;
 
      [[nodiscard]] ShaderFormat getShaderFormat() const {
        return m_shaderFormat;
      }
 
      [[deprecated("Do not query getRenderPass() during emission. Use RenderQueue::custom() for "
                   "custom GPU draw passes.")]] [[nodiscard]] SDL_GPURenderPass *
      getRenderPass() const {
        return m_renderPass;
      }
 
      void setGPUPresentMode(SDL_GPUPresentMode mode) {
        if (mode != SDL_GPU_PRESENTMODE_VSYNC &&
            !SDL_WindowSupportsGPUPresentMode(m_gpuDevice, m_sdlWindow, mode)) {
          FLINT_ENGINE_WARN("Present mode {} unsupported, falling back to VSYNC",
                            static_cast<int>(mode));
          mode = SDL_GPU_PRESENTMODE_VSYNC;
        }
        if (!SDL_SetGPUSwapchainParameters(m_gpuDevice, m_sdlWindow,
                                           SDL_GPU_SWAPCHAINCOMPOSITION_SDR, mode)) {
          FLINT_ENGINE_ERROR("SDL_SetGPUSwapchainParameters failed: {}", SDL_GetError());
        }
      }
 
      [[deprecated(
          "Do not query getCommandBuffer() during emission. Use RenderQueue::deferUpload() or "
          "RenderQueue::custom().")]] [[nodiscard]] SDL_GPUCommandBuffer *
      getCommandBuffer() const {
        return m_commandBuffer;
      }
 
      [[nodiscard]] const FloatRect &getCurrentCameraView() const {
        return m_currentCameraView;
      }
 
      [[nodiscard]] SDL_GPUDevice *getGPUDevice() const {
        return m_gpuDevice;
      }
 
      [[nodiscard]] IAssetLoader &getAssetLoader() const {
        return m_assetLoader;
      }
 
      [[nodiscard]] const SDL_GPUViewport &getDefaultViewport() const {
        return m_defaultViewport;
      }
 
      [[nodiscard]] SDL_Renderer *getSDLRenderer() const;
 
      [[nodiscard]] UIPipeline &getUIPipeline() {
        return m_uiPipeline;
      }
 
      [[nodiscard]] PrimitivePipeline &getPrimitivePipeline() {
        return m_primitivePipeline;
      }
 
      [[nodiscard]] SDL_GPUTexture *getWhiteTexture() {
        return m_defaultWhiteTexture;
      }
 
    private:
      IWindow              *m_iWindow = nullptr;
      SDL_Window           *m_sdlWindow = nullptr;
      ShaderFormat          m_shaderFormat;
      SDL_GPURenderPass    *m_renderPass = nullptr;
      SDL_GPUDevice        *m_gpuDevice = nullptr;
      SDL_GPUCommandBuffer *m_commandBuffer = nullptr;
      SDL_GPUTexture       *m_swapTexture = nullptr;
      Uint32                m_swapWidth = 0, m_swapHeight = 0;
 
      std::vector<DrawCommand> m_commands;
      FloatRect                m_currentCameraView = FloatRect({0, 0}, {320, 180});
 
      UIPipeline        m_uiPipeline;
      BatchPipeline     m_batchPipeline;
      PrimitivePipeline m_primitivePipeline;
 
      Color m_clearColor = {0, 0, 0, 255};
 
      SDL_GPUTexture *m_defaultWhiteTexture = nullptr;
      SDL_GPUSampler *m_defaultSampler = nullptr;
      SDL_GPUViewport m_defaultViewport{};
 
      IAssetLoader &m_assetLoader;
 
      std::unique_ptr<FrameData>
          m_frame;  
 
      bool uploadFrameBuffers();
 
      void ensureBuffer(SDL_GPUBuffer *&buffer, Uint32 &capacity, Uint32 neededBytes,
                        SDL_GPUBufferUsageFlags usage, const char *debugName);
 
      void resetFrameData();
 
      void destroyFrameBuffers();
 
      void createDefaultViewport(SDL_GPURenderPass *renderPass);
      bool createDefaultTexture();
      void initializePipelines();
      void cleanupPipelines();
  };
 
}