coffee_crisis_arcade_edition/source/texture.cpp

#include "texture.h"
#include <SDL3/SDL_error.h>	  // Para SDL_GetError
#include <SDL3/SDL_surface.h> // Para SDL_CreateRGBSurfaceWithFormatFrom
#include <stdint.h>			  // Para uint32_t
#include <cstring>			  // Para memcpy, size_t
#include <fstream>			  // Para basic_ostream, operator<<, basic_ifstream
#include <iostream>			  // Para cerr, cout
#include <stdexcept>		  // Para runtime_error
#include <string>			  // Para char_traits, operator<<, operator+
#include <vector>			  // Para vector
#include "gif.h"			  // Para Gif
#include "utils.h"			  // Para getFileName, Color, printWithDots

#define STB_IMAGE_IMPLEMENTATION
#include "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_);
		}

		// .gif
		else if (extension == "gif")
		{
			// Crea la surface desde un fichero
			surface_ = loadSurface(path_);

			// Añade la propia paleta del fichero a la lista
			addPaletteFromFile(path_);

			// Crea la textura, establece el BlendMode y copia la surface a la textura
			createBlank(width_, height_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_STREAMING);
			SDL_SetTextureBlendMode(texture_, SDL_BLENDMODE_BLEND);
			flipSurface();
		}
	}
}

// Destructor
Texture::~Texture()
{
	unloadTexture();
	unloadSurface();
	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 depth, pitch;
	Uint32 pixel_format;

	// STBI_rgb_alpha (RGBA)
	depth = 32;
	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 loadedSurface = SDL_CreateRGBSurfaceWithFormatFrom(static_cast<void *>(data), width, height, depth, pitch, pixel_format);
	if (loadedSurface == 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_, loadedSurface);
		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_ = loadedSurface->w;
			height_ = loadedSurface->h;
		}

		// Elimina la textura cargada
		SDL_FreeSurface(loadedSurface);
	}

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

// Crea una textura en blanco
bool Texture::createBlank(int width, int height, SDL_PixelFormatEnum format, SDL_TextureAccess access)
{
	// Crea una textura sin inicializar
	texture_ = SDL_CreateTexture(renderer_, format, access, width, height);
	if (!texture_)
	{
		std::cout << "Unable to create blank texture! SDL Error: " << SDL_GetError() << std::endl;
	}
	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(int x, int y, SDL_Rect *clip, float zoomW, float zoomH, double angle, SDL_Point *center, SDL_RendererFlip flip)
{
	// Establece el destino de renderizado en la pantalla
	SDL_Rect renderQuad = {x, y, width_, height_};

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

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

	// Renderiza a pantalla
	SDL_RenderCopyEx(renderer_, texture_, clip, &renderQuad, 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_;
}

// Desencadenar la superficie actual
void Texture::unloadSurface()
{
	surface_.reset(); // Resetea el shared_ptr
	width_ = 0;
	height_ = 0;
}

// Crea una surface desde un fichero .gif
std::shared_ptr<Surface> Texture::loadSurface(const std::string &file_path)
{
	// Libera la superficie actual
	unloadSurface();

	// Abrir el archivo usando std::ifstream para manejo automático del recurso
	std::ifstream file(file_path, std::ios::binary | std::ios::ate);
	if (!file)
	{
		std::cerr << "Error: Fichero no encontrado " << file_path << std::endl;
		throw std::runtime_error("Fichero no encontrado: " + file_path);
	}

	// Obtener el tamaño del archivo
	std::streamsize size = file.tellg();
	file.seekg(0, std::ios::beg);

	// Leer el contenido del archivo en un buffer
	std::vector<Uint8> buffer(size);
	if (!file.read(reinterpret_cast<char *>(buffer.data()), size))
	{
		std::cerr << "Error al leer el fichero " << file_path << std::endl;
		throw std::runtime_error("Error al leer el fichero: " + file_path);
	}

	// Crear un objeto Gif y llamar a la función loadGif
	GIF::Gif gif;
	Uint16 w = 0, h = 0;
	std::vector<Uint8> rawPixels = gif.loadGif(buffer.data(), w, h);
	if (rawPixels.empty())
	{
		return nullptr;
	}

	// Si el constructor de Surface espera un std::shared_ptr<Uint8[]>,
	// reservamos un bloque dinámico y copiamos los datos del vector.
	size_t pixelCount = rawPixels.size();
	auto pixels = std::shared_ptr<Uint8[]>(new Uint8[pixelCount], std::default_delete<Uint8[]>());
	std::memcpy(pixels.get(), rawPixels.data(), pixelCount);

	auto surface = std::make_shared<Surface>(w, h, pixels);

	// Actualizar las dimensiones
	width_ = w;
	height_ = h;

	return surface;
}

// Vuelca la surface en la textura
void Texture::flipSurface()
{
	// Limpia la textura
	auto temp = SDL_GetRenderTarget(renderer_);
	SDL_SetRenderTarget(renderer_, texture_);
	SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0);
	SDL_RenderClear(renderer_);
	SDL_SetRenderTarget(renderer_, temp);

	// Vuelca los datos
	Uint32 *pixels;
	int pitch;
	SDL_LockTexture(texture_, nullptr, reinterpret_cast<void **>(&pixels), &pitch);
	for (int i = 0; i < width_ * height_; ++i)
	{
		pixels[i] = palettes_[current_palette_][surface_->data[i]];
	}
	SDL_UnlockTexture(texture_);
}

// Establece un color de la paleta
void Texture::setPaletteColor(int palette, int index, Uint32 color)
{
	palettes_.at(palette)[index] = color;
}

// Carga una paleta desde un fichero
std::vector<Uint32> Texture::loadPaletteFromFile(const std::string &file_path)
{
	std::vector<Uint32> palette;

	// Abrir el archivo GIF
	std::ifstream file(file_path, std::ios::binary | std::ios::ate);
	if (!file)
	{
		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 ]");
	}

	// Obtener el tamaño del archivo y leerlo en un buffer
	std::streamsize size = file.tellg();
	file.seekg(0, std::ios::beg);

	std::vector<Uint8> buffer(size);
	if (!file.read(reinterpret_cast<char *>(buffer.data()), size))
	{
		std::cerr << "Error: No se pudo leer completamente el fichero " << getFileName(file_path) << std::endl;
		throw std::runtime_error("Error al leer el fichero: " + getFileName(file_path));
	}

	// Usar la nueva función loadPalette, que devuelve un vector<uint32_t>
	GIF::Gif gif;
	std::vector<uint32_t> pal = gif.loadPalette(buffer.data());
	if (pal.empty())
	{
		return palette; // Devuelve un vector vacío si no hay paleta
	}

	// Modificar la conversión para obtener formato RGBA (0xRRGGBBAA)
	for (const auto &color : pal)
	{
		palette.push_back((color << 8) | 0xFF); // Resultado: 0xRRGGBBAA
	}

	return palette;
}

// Añade una paleta a la lista
void Texture::addPaletteFromFile(const std::string &path)
{
	palettes_.emplace_back(loadPaletteFromFile(path));
	setPaletteColor((int)palettes_.size() - 1, 0, 0x00000000);
}

// Cambia la paleta de la textura
void Texture::setPalette(int palette)
{
	if (palette < (int)palettes_.size())
	{
		current_palette_ = palette;
		flipSurface();
	}
}

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