shaders.h

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2025-2026 Manuel Osorio
#pragma once
#include "flint/core/config.h"
#include "flint/core/log.h"
#include "flint/graphics/gpu/gpu-tracker.h"
 
#include <SDL3/SDL_gpu.h>
 
#include <memory>
 
namespace Flint {
  enum class ShaderStage {
    Vertex,  
    Fragment 
  };
 
  enum class ShaderFormat {
    SPIRV, 
    MSL,   
    DXIL   
  };
 
  inline ShaderFormat getShaderFormat(GRAPHICS_BACKEND backend) {
    switch (backend) {
      case GRAPHICS_BACKEND::METAL:
        {
          return ShaderFormat::MSL;
        }
      case GRAPHICS_BACKEND::D3D12:
        {
          return ShaderFormat::DXIL;
        }
      case GRAPHICS_BACKEND::VULKAN:
      case GRAPHICS_BACKEND::AUTO:
      default:
        {
          return ShaderFormat::SPIRV;
        }
    }
  }
 
  inline const char *getShaderExtension(ShaderFormat format) {
    if (format == ShaderFormat::SPIRV) {
      return ".spv";
    }
    if (format == ShaderFormat::MSL) {
      return ".msl";
    }
    if (format == ShaderFormat::DXIL) {
      return ".dxil";
    }
    return ".spv";
  }
 
  class Shader {
    public:
      Shader(SDL_GPUDevice *device, ShaderFormat format)
        : m_device(device),
          m_format(format) {
      }
 
      virtual ~Shader() {
        FLINT_ENGINE_INFO("Shader class destroyed");
        cleanup();
      }
 
      bool loadFromMemory(ShaderStage stage, const void *data, size_t size, Uint32 numSamplers = 0,
                          Uint32 numStorageTextures = 0, Uint32 numStorageBuffers = 0,
                          Uint32 numUniformBuffers = 0) {
        SDL_GPUShaderCreateInfo createInfo{};
        createInfo.code = static_cast<const Uint8 *>(data);
        createInfo.code_size = size;
        createInfo.entrypoint = (m_format == ShaderFormat::MSL) ? "main0" : "main";
 
        switch (m_format) {
          case ShaderFormat::SPIRV:
            createInfo.format = SDL_GPU_SHADERFORMAT_SPIRV;
            break;
          case ShaderFormat::MSL:
            createInfo.format = SDL_GPU_SHADERFORMAT_MSL;
            break;
          case ShaderFormat::DXIL:
            createInfo.format = SDL_GPU_SHADERFORMAT_DXIL;
            break;
          default:
            return false;
        }
 
        createInfo.stage = (stage == ShaderStage::Vertex) ? SDL_GPU_SHADERSTAGE_VERTEX
                                                          : SDL_GPU_SHADERSTAGE_FRAGMENT;
 
        createInfo.num_samplers = numSamplers;
        createInfo.num_storage_textures = numStorageTextures;
        createInfo.num_storage_buffers = numStorageBuffers;
        createInfo.num_uniform_buffers = numUniformBuffers;
 
        SDL_GPUShader *shader = SDL_CreateGPUShader(m_device, &createInfo);
        if (!shader) {
          FLINT_ENGINE_ERROR("Failed to create shader: {}", SDL_GetError());
          return false;
        }
 
        if (stage == ShaderStage::Vertex) {
          if (m_vertexShader) {
            GPU_RELEASE_SHADER(m_device, m_vertexShader);
          }
          m_vertexShader = shader;
          GPU_TRACK_SHADER(m_vertexShader, "Vertex Shader in Shader class");
        } else {
          if (m_fragmentShader) {
            GPU_RELEASE_SHADER(m_device, m_fragmentShader);
          }
          m_fragmentShader = shader;
          GPU_TRACK_SHADER(m_fragmentShader, "Fragment Shader in Shader class");
        }
 
        return true;
      }
 
      SDL_GPUShader *getVertexShader() const {
        return m_vertexShader;
      }
 
      SDL_GPUShader *getFragmentShader() const {
        return m_fragmentShader;
      }
 
      SDL_GPUDevice *getDevice() const {
        return m_device;
      }
 
      void cleanup() {
        FLINT_ENGINE_INFO("Releasing Shader resources");
        if (m_vertexShader) {
          FLINT_ENGINE_INFO("Releasing vertex shader");
          GPU_RELEASE_SHADER(m_device, m_vertexShader);
          m_vertexShader = nullptr;
        }
        if (m_fragmentShader) {
          FLINT_ENGINE_INFO("Releasing fragment shader");
          GPU_RELEASE_SHADER(m_device, m_fragmentShader);
          m_fragmentShader = nullptr;
        }
        FLINT_ENGINE_INFO("Shader resources released");
      }
 
    protected:
      SDL_GPUDevice *m_device = nullptr;
      SDL_GPUShader *m_vertexShader = nullptr;
      SDL_GPUShader *m_fragmentShader = nullptr;
      ShaderFormat   m_format;
  };
}