pipeline-base.h

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2025-2026 Manuel Osorio
#pragma once
#include "flint/core/log.h"
#include "flint/graphics/shaders.h"
 
#include <SDL3/SDL_gpu.h>
 
namespace Flint {
  struct PipelineConfig {
      Uint32 vertexStride = sizeof(float) * 4; 
      bool               enableBlending = true;
      SDL_GPUBlendFactor srcColorBlend = SDL_GPU_BLENDFACTOR_SRC_ALPHA;
      SDL_GPUBlendFactor dstColorBlend = SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA;
      SDL_GPUBlendFactor srcAlphaBlend = SDL_GPU_BLENDFACTOR_ONE;
      SDL_GPUBlendFactor dstAlphaBlend = SDL_GPU_BLENDFACTOR_ZERO;
 
      bool enableDepthTest = false;
      bool enableDepthWrite = false;
 
      SDL_GPUCullMode cullMode = SDL_GPU_CULLMODE_NONE;
      SDL_GPUFillMode fillMode = SDL_GPU_FILLMODE_FILL;
 
      SDL_GPUTextureFormat colorFormat = SDL_GPU_TEXTUREFORMAT_B8G8R8A8_UNORM;
  };
 
  class Pipeline {
    public:
      Pipeline(SDL_GPUDevice *device)
        : m_device(device) {
      }
 
      Pipeline() = default;
 
      virtual ~Pipeline() {
        Pipeline::cleanup();
      }
 
      virtual bool initialize(Shader *shader, const PipelineConfig &config) {
        if (!shader || !shader->getVertexShader() || !shader->getFragmentShader()) {
          FLINT_ENGINE_ERROR("Pipeline: Invalid shader provided");
          return false;
        }
 
        m_shader = shader;
 
        SDL_GPUVertexBufferDescription vertexBinding = {};
        vertexBinding.slot = 0;
        vertexBinding.pitch = config.vertexStride;
        vertexBinding.input_rate = SDL_GPU_VERTEXINPUTRATE_VERTEX;
 
        SDL_GPUVertexAttribute vertexAttributes[2] = {};
        vertexAttributes[0].location = 0;
        vertexAttributes[0].buffer_slot = 0;
        vertexAttributes[0].format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT2;
        vertexAttributes[0].offset = 0;
 
        vertexAttributes[1].location = 1;
        vertexAttributes[1].buffer_slot = 0;
        vertexAttributes[1].format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT2;
        vertexAttributes[1].offset = sizeof(float) * 2;
 
        SDL_GPUVertexInputState vertexInputState = {};
        vertexInputState.num_vertex_buffers = 1;
        vertexInputState.vertex_buffer_descriptions = &vertexBinding;
        vertexInputState.num_vertex_attributes = 2;
        vertexInputState.vertex_attributes = vertexAttributes;
 
        SDL_GPUGraphicsPipelineCreateInfo pipelineInfo{};
        pipelineInfo.vertex_shader = m_shader->getVertexShader();
        pipelineInfo.fragment_shader = m_shader->getFragmentShader();
        pipelineInfo.vertex_input_state = vertexInputState;
        pipelineInfo.primitive_type = SDL_GPU_PRIMITIVETYPE_TRIANGLELIST;
 
        pipelineInfo.rasterizer_state.cull_mode = config.cullMode;
        pipelineInfo.rasterizer_state.fill_mode = config.fillMode;
        pipelineInfo.rasterizer_state.front_face = SDL_GPU_FRONTFACE_COUNTER_CLOCKWISE;
 
        pipelineInfo.depth_stencil_state.enable_depth_test = config.enableDepthTest;
        pipelineInfo.depth_stencil_state.enable_depth_write = config.enableDepthWrite;
 
        SDL_GPUColorTargetDescription colorTarget = {};
        colorTarget.format = config.colorFormat;
        colorTarget.blend_state.enable_blend = config.enableBlending;
        colorTarget.blend_state.src_color_blendfactor = config.srcColorBlend;
        colorTarget.blend_state.dst_color_blendfactor = config.dstColorBlend;
        colorTarget.blend_state.color_blend_op = SDL_GPU_BLENDOP_ADD;
        colorTarget.blend_state.src_alpha_blendfactor = config.srcAlphaBlend;
        colorTarget.blend_state.dst_alpha_blendfactor = config.dstAlphaBlend;
        colorTarget.blend_state.alpha_blend_op = SDL_GPU_BLENDOP_ADD;
        colorTarget.blend_state.color_write_mask = 0xF;
 
        pipelineInfo.target_info.num_color_targets = 1;
        pipelineInfo.target_info.color_target_descriptions = &colorTarget;
        pipelineInfo.target_info.depth_stencil_format = SDL_GPU_TEXTUREFORMAT_INVALID;
 
        if (!configurePipeline(pipelineInfo)) {
          return false;
        }
 
        m_pipeline = SDL_CreateGPUGraphicsPipeline(m_device, &pipelineInfo);
        if (!m_pipeline) {
          FLINT_ENGINE_ERROR("Failed to create graphics pipeline: {}", SDL_GetError());
          return false;
        }
 
        return true;
      }
 
      void bind(SDL_GPURenderPass *renderPass) {
        if (m_pipeline) {
          SDL_BindGPUGraphicsPipeline(renderPass, m_pipeline);
        }
      }
 
      SDL_GPUGraphicsPipeline *getPipeline() const {
        return m_pipeline;
      }
 
      Shader *getShader() const {
        return m_shader;
      }
 
    protected:
      virtual bool configurePipeline(SDL_GPUGraphicsPipelineCreateInfo &pipelineInfo) {
        return true;
      }
 
      virtual void cleanup() {
        if (m_pipeline) {
          SDL_ReleaseGPUGraphicsPipeline(m_device, m_pipeline);
          m_pipeline = nullptr;
        }
      }
 
      SDL_GPUDevice           *m_device = nullptr;
      SDL_GPUGraphicsPipeline *m_pipeline = nullptr;
      Shader                  *m_shader = nullptr;
  };
}