278 lines
11 KiB
C++
278 lines
11 KiB
C++
#include "jdraw.h"
|
|
#include "SDL2/SDL.h"
|
|
#include "gif.c"
|
|
#include "jfile.h"
|
|
|
|
namespace draw
|
|
{
|
|
// La idea de esta unitat es usar "superficies", que no son mes que arrays de bytes, per a anar pintant.
|
|
// El resultat final s'ha de pintar en algun moment a la superficie "screen" (o siga, especificar nullptr en setDestination)
|
|
// Aleshores, en "render" el contingut de screen se volca a la textura SDL que crearem,
|
|
// i eixa textura se pintarà a pantalla com se sol fer amb SDL. Ho anirem veient en el codi.
|
|
|
|
SDL_Window *sdl_window = nullptr; // La finestra de SDL
|
|
SDL_Renderer *sdl_renderer = nullptr; // El renderer de SDL
|
|
SDL_Texture *sdl_texture = nullptr; // La textura de SDL a la que pintarem la nostra superficie "screen" i que despres volcarem a pantalla
|
|
|
|
surface *screen = nullptr; // La superficie screen, que representa la pantalla. Se crea i destrueix internament
|
|
surface *destination = nullptr; // Punter a la actual superficie de destí
|
|
surface *source = nullptr; // Punter a la actual superficie de oritge
|
|
|
|
uint32_t palette[256]; // La paleta de colors
|
|
uint8_t transparent = 0; // El color transparent
|
|
|
|
// Inicialització de tot el que fa falta per a carregar gràfics i pintar en pantalla
|
|
void init(const std::string &titol, const uint16_t width, const uint16_t height, const int zoom)
|
|
{
|
|
// [TODO] Incloure gestió de pantalla completa
|
|
|
|
// Inicialització de les estructures de SDL
|
|
sdl_window = SDL_CreateWindow(titol.c_str(), SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, width * zoom, height * zoom, SDL_WINDOW_SHOWN);
|
|
sdl_renderer = SDL_CreateRenderer(sdl_window, -1, 0);
|
|
sdl_texture = SDL_CreateTexture(sdl_renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, width, height);
|
|
|
|
// Establim el tamany "logic", indepndent del tamany de finestra
|
|
SDL_RenderSetLogicalSize(sdl_renderer, width, height);
|
|
|
|
// Creem la superficie "screen" i la establim com a superficie destinació
|
|
screen = createSurface(width, height);
|
|
destination = screen;
|
|
transparent = 0;
|
|
}
|
|
|
|
// Finalització del sistema
|
|
void quit()
|
|
{
|
|
// Si la superficie "screen" existia, alliberem la seua memòria
|
|
if (screen != nullptr)
|
|
{
|
|
freeSurface(screen);
|
|
}
|
|
|
|
// Destruim tot el relacionat amb SDL
|
|
SDL_DestroyTexture(sdl_texture);
|
|
SDL_DestroyRenderer(sdl_renderer);
|
|
SDL_DestroyWindow(sdl_window);
|
|
|
|
// Fiquem tots els punters a nullptr, per si de cas no estem eixint del programa
|
|
// i anem a tornar a inicialitzar el sistema
|
|
sdl_window = nullptr;
|
|
sdl_renderer = nullptr;
|
|
sdl_texture = nullptr;
|
|
screen = destination = source = nullptr;
|
|
}
|
|
|
|
// Crea una superficie i torna un punter a ella
|
|
surface *createSurface(const uint16_t w, const uint16_t h)
|
|
{
|
|
// Primer reservem memòria per a la estructura "surface"
|
|
surface *surf = (surface *)malloc(sizeof(surface));
|
|
|
|
// Després reservem memòria per als pixels
|
|
surf->pixels = (uint8_t *)malloc(w * h);
|
|
|
|
// I apuntem el ample i alt de la superficie
|
|
surf->w = w;
|
|
surf->h = h;
|
|
|
|
// ...i tornem la superficie creada, clar
|
|
return surf;
|
|
}
|
|
|
|
// Carrega un gràfic d'un arxiu (en format GIF) a una nova superficie, i torna un punter a ella
|
|
surface *loadSurface(const std::string &filename)
|
|
{
|
|
// Agafem un buffer de bytes de l'arxiu especificat
|
|
// getFileBuffer() simplement ens torna el arxiu sencer dins de un array de char
|
|
int size;
|
|
uint8_t *buffer = (uint8_t *)file::getFileBuffer(filename, size);
|
|
|
|
// Si ens ha tornat nullptr, es que no l'ha trobat, tornem nosaltres també nullptr ja que no s'ha pogut crear la superficie
|
|
if (buffer == nullptr)
|
|
{
|
|
return nullptr;
|
|
}
|
|
|
|
// Primer reservem memòria per a la estructura "surface"
|
|
surface *surf = (surface *)malloc(sizeof(surface));
|
|
|
|
// Després li passem el buffer de bytes a la funció de carregar un GIF.
|
|
// El resultat es un array de bytes, els pixels en sí. Ja havem reservat
|
|
// la memòria necessaria en "LoadGif", així que no tenim que fer-ho ara,
|
|
// però, ojo, sí que tindrem que alliberar-la.
|
|
surf->pixels = LoadGif(buffer, &surf->w, &surf->h);
|
|
|
|
// Com ja no ens fa falta, alliberem la memòria del buffer del arxiu
|
|
free(buffer);
|
|
|
|
// I finalment tornem la superficie
|
|
return surf;
|
|
}
|
|
|
|
// Allibera la memòria d'una superficie, els seus pixels inclosos
|
|
void freeSurface(surface *surf)
|
|
{
|
|
// Si la superficie existeix...
|
|
if (surf != nullptr)
|
|
{
|
|
// Si el array de pixels existeix, l'alliberem
|
|
if (surf->pixels != nullptr)
|
|
{
|
|
free(surf->pixels);
|
|
}
|
|
|
|
// ... alliberem la superficie
|
|
free(surf);
|
|
}
|
|
}
|
|
|
|
// Estableix una superficie com a superficie que rebrà les funcions de pintat (especificar nullptr per a pintar a pantalla)
|
|
void setDestination(surface *surf)
|
|
{
|
|
// Si han especificat nullptr, fiquem "screen" com a destinació
|
|
destination = surf == nullptr ? screen : surf;
|
|
}
|
|
|
|
// Estableix una superficie com a superficie de la que s'agafaràn els gràfics per a pintar
|
|
void setSource(surface *surf)
|
|
{
|
|
// Si han especificat nullptr, fiquem "screen" com a font
|
|
source = surf == nullptr ? screen : surf;
|
|
}
|
|
|
|
// Estableix la paleta del sistema carregant-la d'un GIF
|
|
void loadPalette(const std::string &filename)
|
|
{
|
|
// Agafem un buffer de bytes de l'arxiu especificat
|
|
// getFileBuffer() simplement ens torna el arxiu sencer dins de un array de char
|
|
int size;
|
|
uint8_t *buffer = (uint8_t *)file::getFileBuffer(filename, size);
|
|
|
|
// Li passem el array del arxiu a LoadPalette. Ell ens torna un array de uint32_t amb la paleta
|
|
// Van a ser 256 entrades de 32 bits, cada entrada es un color, amb el format 0xAARRGGBB
|
|
uint32_t *pal = LoadPalette(buffer);
|
|
|
|
// Copiem eixe array al nostre array de la paleta de sistema. Ara ja tenim la paleta carregada.
|
|
memcpy(palette, pal, 1024); // 32 bits per entrada == 4 bytes x 256 entrades == 1024
|
|
|
|
// Alliberem el array que ens habia tornat LoadPalette()
|
|
free(pal);
|
|
|
|
// I també el buffer del arxiu
|
|
free(buffer);
|
|
}
|
|
|
|
// Esborra la superficie "destination" amb el color especificat
|
|
void cls(const uint8_t color)
|
|
{
|
|
// El tamany es width x height bytes
|
|
const int size = destination->w * destination->h;
|
|
|
|
// Omplim la memòria dels pixels de la superficie de destinació amb "color"
|
|
memset(destination->pixels, color, size);
|
|
}
|
|
|
|
//Estableix el color especificat com a transparent
|
|
void setTrans(const uint8_t color)
|
|
{
|
|
transparent = color;
|
|
}
|
|
|
|
// Funció interna per a pintar un pixel d'una superficie sense eixir-se'n de la memòria i petar el mame
|
|
void pset(surface *surface, const int x, const int y, const uint8_t color)
|
|
{
|
|
// Si la coordenada està dins del rang que abarca la superficie,
|
|
// escriure el byte "color" on toca en el array de pixels de la superficie
|
|
if (color != transparent && x >= 0 && y >= 0 && x < surface->w && y < surface->h)
|
|
{
|
|
surface->pixels[x + y * surface->w] = color;
|
|
}
|
|
}
|
|
|
|
// Funció interna per a llegir un pixel d'una superficie eixir-se'n de la memòria i petar el mame
|
|
const uint8_t pget(surface *surface, const int x, const int y)
|
|
{
|
|
// Si la coordenada està dins del rang que abarca la superficie,
|
|
// tornar el byte que toca del array de pixels de la superficie
|
|
if (x >= 0 && y >= 0 && x < surface->w && y < surface->h)
|
|
{
|
|
return surface->pixels[x + y * surface->w];
|
|
}
|
|
|
|
// Si no, algo tenim que tornar... pos "0"
|
|
return 0;
|
|
}
|
|
|
|
// Pinta un troç de la superficie "source" en la superficie "destination".
|
|
void draw(const int dx, const int dy, const int w, const int h, const int sx, const int sy, const int flip = DRAW_FLIP_NONE)
|
|
{
|
|
// Si no hi ha superficie d'oritge especificada, no fem res, o petarà el mame
|
|
if (source == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// En principi, el quadrat de l'oritge començarà en (sx,sy) i avançarem 1 pixel en positiu tant en x com en y
|
|
int sdx = 1, sdy = 1, ssx = sx, ssy = sy;
|
|
|
|
// Però si s'ha especificat que fem flip en horitzontal...
|
|
if (flip & DRAW_FLIP_HORIZONTAL)
|
|
{
|
|
sdx = -1; // Avançarem 1 pixel en negatiu
|
|
ssx = sx + w - 1; // I començarem al final, o siga, sumarem a sx el ample
|
|
}
|
|
|
|
// De igual forma per al flip en vertical, per a la y
|
|
if (flip & DRAW_FLIP_VERTICAL)
|
|
{
|
|
sdy = -1;
|
|
ssy = sy + h - 1;
|
|
}
|
|
|
|
// guardem la coordenada d'oritge en x per a restablir-la a cada linea
|
|
int csx = ssx;
|
|
|
|
// Anem linea per linea. Les variables dels dos bucles for controlen les coordenades en la destinació, que sempre van avant.
|
|
for (int y = dy; y < dy + h; ++y)
|
|
{
|
|
ssx = csx; // fiquem la coordenada de l'oritge al principi
|
|
|
|
// en cada linea, anem pixel a pixel
|
|
for (int x = dx; x < dx + w; ++x)
|
|
{
|
|
pset(destination, x, y, pget(source, ssx, ssy)); // Agafem pixel de l'oritge i el fiquem en la destinació
|
|
ssx += sdx; // avancem (o retrocedim) la coordenada x de l'oritge
|
|
}
|
|
ssy += sdy; // avancem (o retrocedim) la coordenada y de l'oritge
|
|
}
|
|
}
|
|
|
|
// Refresca la pantalla
|
|
void render()
|
|
{
|
|
Uint32 *sdl_pixels; // Punter al array de pixels que enstornarà SDL_LockTexture
|
|
int sdl_pitch; // Ací estarà guardat el pitch de la textura, com es de 32 bits, no m'afecta
|
|
const int size = screen->w * screen->h; // tamany de la superficie
|
|
|
|
// Bloquejem la textura SDL i agafem els seus pixels (son enters de 32 bits amb format 0xAARRGGBB)
|
|
SDL_LockTexture(sdl_texture, NULL, (void **)&sdl_pixels, &sdl_pitch);
|
|
|
|
// Cada pixel de la superficie "screen" es un enter de 8 bits que representa un index en la paleta de colors
|
|
// Per tant, per a pintar en la textura SDL, pillem el color de la paleta que correspon al index en "screen"
|
|
// i el enviem a la textura SDL
|
|
for (uint32_t i = 0; i < size; ++i)
|
|
{
|
|
sdl_pixels[i] = palette[screen->pixels[i]];
|
|
}
|
|
|
|
// Desbloquejem la textura
|
|
SDL_UnlockTexture(sdl_texture);
|
|
|
|
// Pintem la textura a pantalla
|
|
SDL_RenderCopy(sdl_renderer, sdl_texture, NULL, NULL);
|
|
|
|
// I ho presentem
|
|
SDL_RenderPresent(sdl_renderer);
|
|
}
|
|
}
|