jaildoctors_dilemma/source/surface.h

#pragma once

#include <SDL3/SDL.h>

#include <array>    // Para array
#include <memory>   // Para default_delete, shared_ptr, __shared_pt...
#include <numeric>  // Para iota
#include <string>   // Para string
#include <utility>  // Para move

#include "utils.h"  // Para PaletteColor

// Alias
using Palette = std::array<Uint32, 256>;
using SubPalette = std::array<Uint8, 256>;

// Carga una paleta desde un archivo .gif
Palette loadPalette(const std::string& file_path);

// Carga una paleta desde un archivo .pal
Palette readPalFile(const std::string& file_path);

struct SurfaceData {
        std::shared_ptr<Uint8[]> data;  // Usa std::shared_ptr para gestión automática
        float width;                    // Ancho de la imagen
        float height;                   // Alto de la imagen

        // Constructor por defecto
        SurfaceData()
            : data(nullptr),
              width(0),
              height(0) {}

        // Constructor que inicializa dimensiones y asigna memoria
        SurfaceData(float w, float h)
            : data(std::shared_ptr<Uint8[]>(new Uint8[static_cast<size_t>(w * h)](), std::default_delete<Uint8[]>())),
              width(w),
              height(h) {}

        // Constructor para inicializar directamente con datos
        SurfaceData(float w, float h, std::shared_ptr<Uint8[]> pixels)
            : data(std::move(pixels)),
              width(w),
              height(h) {}

        // Constructor de movimiento
        SurfaceData(SurfaceData&& other) noexcept = default;

        // Operador de movimiento
        SurfaceData& operator=(SurfaceData&& other) noexcept = default;

        // Evita copias accidentales
        SurfaceData(const SurfaceData&) = delete;
        SurfaceData& operator=(const SurfaceData&) = delete;
};

class Surface {
    private:
        std::shared_ptr<SurfaceData> surface_data_;  // Datos a dibujar
        Palette palette_;                            // Paleta para volcar la SurfaceData a una Textura
        SubPalette sub_palette_;                     // Paleta para reindexar colores
        int transparent_color_;                      // Indice de la paleta que se omite en la copia de datos

    public:
        // Constructor
        Surface(int w, int h);
        explicit Surface(const std::string& file_path);

        // Destructor
        ~Surface() = default;

        // Carga una SurfaceData desde un archivo
        SurfaceData loadSurface(const std::string& file_path);

        // Carga una paleta desde un archivo
        void loadPalette(const std::string& file_path);
        void loadPalette(Palette palette);

        // Copia una región de la SurfaceData de origen a la SurfaceData de destino
        void render(float dx, float dy, float sx, float sy, float w, float h);
        void render(int x, int y, SDL_FRect* clip = nullptr, SDL_FlipMode flip = SDL_FLIP_NONE);
        void render(SDL_FRect* srcRect = nullptr, SDL_FRect* dstRect = nullptr, SDL_FlipMode flip = SDL_FLIP_NONE);

        // Copia una región de la SurfaceData de origen a la SurfaceData de destino reemplazando un color por otro
        void renderWithColorReplace(int x, int y, Uint8 source_color = 0, Uint8 target_color = 0, SDL_FRect* srcRect = nullptr, SDL_FlipMode flip = SDL_FLIP_NONE);

        // Establece un color en la paleta
        void setColor(int index, Uint32 color);

        // Rellena la SurfaceData con un color
        void clear(Uint8 color);

        // Vuelca la SurfaceData a una textura
        void copyToTexture(SDL_Renderer* renderer, SDL_Texture* texture);
        void copyToTexture(SDL_Renderer* renderer, SDL_Texture* texture, SDL_FRect* srcRect, SDL_FRect* destRect);

        // Realiza un efecto de fundido en las paletas
        bool fadePalette();
        bool fadeSubPalette(Uint32 delay = 0);

        // Pone un pixel en la SurfaceData
        void putPixel(int x, int y, Uint8 color);

        // Obtiene el color de un pixel de la surface_data
        Uint8 getPixel(int x, int y);

        // Dibuja un rectangulo relleno
        void fillRect(const SDL_FRect* rect, Uint8 color);

        // Dibuja el borde de un rectangulo
        void drawRectBorder(const SDL_FRect* rect, Uint8 color);

        // Dibuja una linea
        void drawLine(float x1, float y1, float x2, float y2, Uint8 color);

        // Metodos para gestionar surface_data_
        std::shared_ptr<SurfaceData> getSurfaceData() const { return surface_data_; }
        void setSurfaceData(std::shared_ptr<SurfaceData> new_data) { surface_data_ = new_data; }

        // Obtien ancho y alto
        float getWidth() const { return surface_data_->width; }
        float getHeight() const { return surface_data_->height; }

        // Color transparente
        Uint8 getTransparentColor() const { return transparent_color_; }
        void setTransparentColor(Uint8 color = 255) { transparent_color_ = color; }

        // Paleta
        void setPalette(const std::array<Uint32, 256>& palette) { palette_ = palette; }

        // Inicializa la sub paleta
        void initializeSubPalette(SubPalette& palette) { std::iota(palette.begin(), palette.end(), 0); }
};