jaildoctors_dilemma/source/core/rendering/texture.cpp

#include "core/rendering/texture.hpp"

#include <SDL3/SDL.h>

#include <iostream>   // Para basic_ostream, operator<<, endl, cout
#include <stdexcept>  // Para runtime_error
#include <string>     // Para char_traits, operator<<, string, opera...
#include <vector>     // Para vector

#include "utils/utils.hpp"  // Para getFileName, Color, printWithDots

#define STB_IMAGE_IMPLEMENTATION
#include "external/stb_image.h"  // para stbi_failure_reason, stbi_image_free

// Constructor
Texture::Texture(SDL_Renderer* renderer, const std::string& path)
    : renderer_(renderer),
      path_(path) {
    // Carga el fichero en la textura
    if (!path_.empty()) {
        // Obtiene la extensión
        const std::string extension = path_.substr(path_.find_last_of(".") + 1);

        // .png
        if (extension == "png") {
            loadFromFile(path_);
        }
    }
}

// Destructor
Texture::~Texture() {
    unloadTexture();
    palettes_.clear();
}

// Carga una imagen desde un fichero
bool Texture::loadFromFile(const std::string& file_path) {
    if (file_path.empty()) {
        return false;
    }

    int req_format = STBI_rgb_alpha;
    int width, height, orig_format;
    unsigned char* data = stbi_load(file_path.c_str(), &width, &height, &orig_format, req_format);
    if (!data) {
        std::cerr << "Error: Fichero no encontrado " << getFileName(file_path) << std::endl;
        throw std::runtime_error("Fichero no encontrado: " + getFileName(file_path));
    } else {
        printWithDots("Image : ", getFileName(file_path), "[ LOADED ]");
    }

    int pitch;
    SDL_PixelFormat pixel_format;
    // STBI_rgb_alpha (RGBA)
    pitch = 4 * width;
    pixel_format = SDL_PIXELFORMAT_RGBA32;

    // Limpia
    unloadTexture();

    // La textura final
    SDL_Texture* newTexture = nullptr;

    // Carga la imagen desde una ruta específica
    auto* loaded_surface = SDL_CreateSurfaceFrom(width, height, pixel_format, static_cast<void*>(data), pitch);
    if (loaded_surface == nullptr) {
        std::cout << "Unable to load image " << file_path << std::endl;
    } else {
        // Crea la textura desde los pixels de la surface
        newTexture = SDL_CreateTextureFromSurface(renderer_, loaded_surface);
        if (newTexture == nullptr) {
            std::cout << "Unable to create texture from " << file_path << "! SDL Error: " << SDL_GetError() << std::endl;
        } else {
            // Obtiene las dimensiones de la imagen
            width_ = loaded_surface->w;
            height_ = loaded_surface->h;
        }

        // Elimina la textura cargada
        SDL_DestroySurface(loaded_surface);
    }

    // Return success
    stbi_image_free(data);
    texture_ = newTexture;
    return texture_ != nullptr;
}

// Crea una textura en blanco
auto Texture::createBlank(int width, int height, SDL_PixelFormat format, SDL_TextureAccess access) -> bool {
    // Crea una textura sin inicializar
    texture_ = SDL_CreateTexture(renderer_, format, access, width, height);
    if (texture_ == nullptr) {
        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Unable to create blank texture! SDL Error: %s", SDL_GetError());
    } else {
        width_ = width;
        height_ = height;
    }

    return texture_ != nullptr;
}

// Libera la memoria de la textura
void Texture::unloadTexture() {
    // Libera la textura
    if (texture_) {
        SDL_DestroyTexture(texture_);
        texture_ = nullptr;
        width_ = 0;
        height_ = 0;
    }
}

// Establece el color para la modulacion
void Texture::setColor(Uint8 red, Uint8 green, Uint8 blue) { SDL_SetTextureColorMod(texture_, red, green, blue); }
void Texture::setColor(Color color) { SDL_SetTextureColorMod(texture_, color.r, color.g, color.b); }

// Establece el blending
void Texture::setBlendMode(SDL_BlendMode blending) { SDL_SetTextureBlendMode(texture_, blending); }

// Establece el alpha para la modulación
void Texture::setAlpha(Uint8 alpha) { SDL_SetTextureAlphaMod(texture_, alpha); }

// Renderiza la textura en un punto específico
void Texture::render(float x, float y, SDL_FRect* clip, float zoomW, float zoomH, double angle, SDL_FPoint* center, SDL_FlipMode flip) {
    // Establece el destino de renderizado en la pantalla
    SDL_FRect render_quad = {x, y, width_, height_};

    // Obtiene las dimesiones del clip de renderizado
    if (clip != nullptr) {
        render_quad.w = clip->w;
        render_quad.h = clip->h;
    }

    // Calcula el zoom y las coordenadas
    if (zoomH != 1.0f || zoomW != 1.0f) {
        render_quad.x = render_quad.x + (render_quad.w / 2);
        render_quad.y = render_quad.y + (render_quad.h / 2);
        render_quad.w = render_quad.w * zoomW;
        render_quad.h = render_quad.h * zoomH;
        render_quad.x = render_quad.x - (render_quad.w / 2);
        render_quad.y = render_quad.y - (render_quad.h / 2);
    }

    // Renderiza a pantalla
    SDL_RenderTextureRotated(renderer_, texture_, clip, &render_quad, angle, center, flip);
}

// Establece la textura como objetivo de renderizado
void Texture::setAsRenderTarget(SDL_Renderer* renderer) { SDL_SetRenderTarget(renderer, texture_); }

// Obtiene el ancho de la imagen
int Texture::getWidth() { return width_; }

// Obtiene el alto de la imagen
int Texture::getHeight() { return height_; }

// Recarga la textura
bool Texture::reLoad() { return loadFromFile(path_); }

// Obtiene la textura
SDL_Texture* Texture::getSDLTexture() { return texture_; }

// Obtiene el renderizador
SDL_Renderer* Texture::getRenderer() { return renderer_; }