gpu-texture.h

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2025-2026 Manuel Osorio
#pragma once
#include "flint/core/log.h"
#include "flint/graphics/gpu/gpu-tracker.h"
 
#include <SDL3/SDL_gpu.h>
#include <SDL3_image/SDL_image.h>
 
#include <cstddef>
#include <cstring>
 
namespace Flint {
  class GPUTexture {
    public:
      GPUTexture() = default;
 
      virtual ~GPUTexture() {
        free();
      }
 
      GPUTexture(const GPUTexture &) = delete;
      GPUTexture &operator=(const GPUTexture &) = delete;
 
      GPUTexture(GPUTexture &&other) noexcept
        : m_device(other.m_device),
          m_texture(other.m_texture),
          m_sampler(other.m_sampler),
          m_width(other.m_width),
          m_height(other.m_height) {
        other.m_device = nullptr;
        other.m_texture = nullptr;
        other.m_sampler = nullptr;
        other.m_width = 0;
        other.m_height = 0;
      }
 
      GPUTexture &operator=(GPUTexture &&other) noexcept {
        if (this != &other) {
          free();
          m_device = other.m_device;
          m_texture = other.m_texture;
          m_sampler = other.m_sampler;
          m_width = other.m_width;
          m_height = other.m_height;
 
          other.m_device = nullptr;
          other.m_texture = nullptr;
          other.m_sampler = nullptr;
          other.m_width = 0;
          other.m_height = 0;
        }
        return *this;
      }
 
      bool loadFromMemory(SDL_GPUDevice *device, const void *data, size_t size) {
        m_device = device;
 
        SDL_IOStream *rw = SDL_IOFromConstMem(data, static_cast<int>(size));
        if (!rw) {
          FLINT_ENGINE_ERROR("Failed to create IO stream from memory");
          return false;
        }
 
        SDL_Surface *loaded = IMG_Load_IO(rw, true);
        if (!loaded) {
          FLINT_ENGINE_ERROR("Failed to load image: {}", SDL_GetError());
          return false;
        }
 
        SDL_Surface *surface = loaded;
        if (loaded->format != SDL_PIXELFORMAT_RGBA32) {
          surface = SDL_ConvertSurface(loaded, SDL_PIXELFORMAT_RGBA32);
          SDL_DestroySurface(loaded);
          if (!surface) {
            FLINT_ENGINE_ERROR("Failed to convert surface to RGBA32: {}", SDL_GetError());
            return false;
          }
        }
 
        m_width = surface->w;
        m_height = surface->h;
 
        const Uint32 bytesPerRow = static_cast<Uint32>(m_width) * 4;
        const Uint32 dataSize = bytesPerRow * static_cast<Uint32>(m_height);
 
        SDL_GPUTextureCreateInfo textureInfo = {};
        textureInfo.type = SDL_GPU_TEXTURETYPE_2D;
        textureInfo.format = SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM;
        textureInfo.width = m_width;
        textureInfo.height = m_height;
        textureInfo.layer_count_or_depth = 1;
        textureInfo.num_levels = 1;
        textureInfo.sample_count = SDL_GPU_SAMPLECOUNT_1;
        textureInfo.usage = SDL_GPU_TEXTUREUSAGE_SAMPLER;
 
        m_texture = SDL_CreateGPUTexture(m_device, &textureInfo);
        if (!m_texture) {
          FLINT_ENGINE_ERROR("Failed to create GPU texture: {}", SDL_GetError());
          SDL_DestroySurface(surface);
          return false;
        }
 
        SDL_GPUCommandBuffer *uploadCmd = SDL_AcquireGPUCommandBuffer(m_device);
        if (!uploadCmd) {
          FLINT_ENGINE_ERROR("Failed to acquire command buffer for upload");
          SDL_DestroySurface(surface);
          GPU_RELEASE_TEXTURE(m_device, m_texture);
          return false;
        }
 
        SDL_GPUCopyPass *copyPass = SDL_BeginGPUCopyPass(uploadCmd);
        if (!copyPass) {
          FLINT_ENGINE_ERROR("Failed to begin GPU copy pass: {}", SDL_GetError());
          return false;
        }
 
        SDL_GPUTransferBufferCreateInfo transferBufferInfo = {};
        transferBufferInfo.usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD;
        transferBufferInfo.size = dataSize;
 
        SDL_GPUTransferBuffer *transferBuffer = SDL_CreateGPUTransferBuffer(m_device,
                                                                            &transferBufferInfo);
        if (!transferBuffer) {
          FLINT_ENGINE_ERROR("Failed to create transfer buffer");
          SDL_DestroySurface(surface);
          SDL_EndGPUCopyPass(copyPass);
          SDL_SubmitGPUCommandBuffer(uploadCmd);
          return false;
        }
 
        void *mapped = SDL_MapGPUTransferBuffer(m_device, transferBuffer, false);
        if (!mapped) {
          FLINT_ENGINE_ERROR("Failed to map transfer buffer: {}", SDL_GetError());
          SDL_EndGPUCopyPass(copyPass);
          SDL_SubmitGPUCommandBuffer(uploadCmd);
          SDL_ReleaseGPUTransferBuffer(m_device, transferBuffer);
          GPU_RELEASE_TEXTURE(m_device, m_texture);
          SDL_DestroySurface(surface);
          return false;
        }
        auto *dstBytes = static_cast<Uint8 *>(mapped);
        auto *srcBytes = static_cast<const Uint8 *>(surface->pixels);
        for (int y = 0; y < m_height; ++y) {
          memcpy(dstBytes + y * bytesPerRow, srcBytes + y * surface->pitch, bytesPerRow);
        }
        SDL_UnmapGPUTransferBuffer(m_device, transferBuffer);
 
        SDL_GPUTextureTransferInfo uploadInfo = {};
        uploadInfo.transfer_buffer = transferBuffer;
        uploadInfo.offset = 0;
        uploadInfo.pixels_per_row = m_width;
        uploadInfo.rows_per_layer = m_height;
 
        SDL_GPUTextureRegion textureRegion = {};
        textureRegion.texture = m_texture;
        textureRegion.w = m_width;
        textureRegion.h = m_height;
        textureRegion.d = 1;
 
        SDL_UploadToGPUTexture(copyPass, &uploadInfo, &textureRegion, false);
 
        SDL_EndGPUCopyPass(copyPass);
        SDL_SubmitGPUCommandBuffer(uploadCmd);
 
        SDL_ReleaseGPUTransferBuffer(m_device, transferBuffer);
        SDL_DestroySurface(surface);
 
        SDL_GPUSamplerCreateInfo samplerInfo = {};
        samplerInfo.min_filter = SDL_GPU_FILTER_NEAREST;
        samplerInfo.mag_filter = SDL_GPU_FILTER_NEAREST;
        samplerInfo.mipmap_mode = SDL_GPU_SAMPLERMIPMAPMODE_NEAREST;
        samplerInfo.address_mode_u = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE;
        samplerInfo.address_mode_v = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE;
        samplerInfo.address_mode_w = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE;
 
        m_sampler = SDL_CreateGPUSampler(m_device, &samplerInfo);
        if (!m_sampler) {
          FLINT_ENGINE_ERROR("Failed to create GPU sampler: {}", SDL_GetError());
          GPU_RELEASE_TEXTURE(m_device, m_texture);
          return false;
        }
 
        FLINT_ENGINE_INFO("GPU texture loaded successfully ({}x{})", m_width, m_height);
        return true;
      }
 
      void free() {
        FLINT_ENGINE_DEBUG("Releasing GPUTexture resources");
        FLINT_ENGINE_DEBUG("Device pointer: {}", std::uintptr_t(m_device));
        if (m_sampler) {
          SDL_ReleaseGPUSampler(m_device, m_sampler);
          m_sampler = nullptr;
        }
        FLINT_ENGINE_DEBUG("Sampler released");
        FLINT_ENGINE_DEBUG("Texture pointer: {}", std::uintptr_t(m_texture));
        if (m_texture) {
          GPU_RELEASE_TEXTURE(m_device, m_texture);
          m_texture = nullptr;
        }
        FLINT_ENGINE_DEBUG("Texture released");
        m_width = 0;
        m_height = 0;
        FLINT_ENGINE_DEBUG("GPUTexture resources released");
      }
 
      SDL_GPUTexture *getTexture() const {
        return m_texture;
      }
 
      SDL_GPUSampler *getSampler() const {
        return m_sampler;
      }
 
      int getWidth() const {
        return m_width;
      }
 
      int getHeight() const {
        return m_height;
      }
 
      static GPUTexture fromRenderer(SDL_GPUDevice *device, const void *data, size_t size) {
        GPUTexture gpuTexture;
        if (gpuTexture.loadFromMemory(device, data, size)) {
          return gpuTexture;
        } else {
          throw std::runtime_error("Failed to create GPUTexture from memory");
        }
      }
 
    private:
      SDL_GPUDevice  *m_device = nullptr;
      SDL_GPUTexture *m_texture = nullptr;
      SDL_GPUSampler *m_sampler = nullptr;
      int             m_width = 0, m_height = 0;
  };
}