jaildesigner-demos/demo6_palette
1
0
Fork 0
Code Activity

migrat a SDL3

Browse Source 
arreglos estetics i d'estil
This commit is contained in:
Sergio
2025-03-24 22:54:14 +01:00
parent 7abbaee706
commit 0c89cd5138
9 changed files with 663 additions and 614 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
source/defines.h Normal file
View File

@@ -0,0 +1,15 @@
#pragma once
#include <SDL3/SDL.h>
constexpr int SPRITE_WIDTH = 29;
constexpr int SPRITE_HEIGHT = 64;
constexpr int WINDOW_WIDTH = 160;
constexpr int WINDOW_HEIGHT = 160;
constexpr int WINDOW_ZOOM = 4;
constexpr int SPRITE_POS_X = (WINDOW_WIDTH - SPRITE_WIDTH) / 2;
constexpr int SPRITE_POS_Y = (WINDOW_HEIGHT - SPRITE_HEIGHT) / 2;
constexpr int NUM_PALETTES = 2;
constexpr int NUM_FRAMES = 4;
constexpr Uint64 ANIMATION_SPEED = 200;

17
source/game.cpp
View File

@@ -1,17 +0,0 @@
#include "jUnit.h"
void init()
{
jInit("demo6_palette", 320, 240, 2);
jSetPal(0, 0x00000000);
jCls(0);
jSurface peiv = jLoadSurface("resources/williams.gif");
jLoadPal("resources/pal01.gif");
jSetSource(peiv);
}
void update()
{
jCls(0);
jBlit(100, 60, 0, 0, 29, 64);
}

56
source/gif.c
View File

@@ -3,6 +3,8 @@
#include <string.h>
#include <fcntl.h>
namespace GIF
{
#define EXTENSION_INTRODUCER 0x21
#define IMAGE_DESCRIPTOR 0x2C
#define TRAILER 0x3B
@@ -12,7 +14,9 @@
#define COMMENT_EXTENSION 0xFE
#define PLAINTEXT_EXTENSION 0x01
#define READ(dst, size) memcpy(dst, buffer, size); buffer += size
#define READ(dst, size) \
memcpy(dst, buffer, size); \
buffer += size
typedef struct
{
@@ -21,16 +25,14 @@ typedef struct
unsigned char fields;
unsigned char background_color_index;
unsigned char pixel_aspect_ratio;
}
screen_descriptor_t;
} screen_descriptor_t;
typedef struct
{
unsigned char r;
unsigned char g;
unsigned char b;
}
rgb;
} rgb;
typedef struct
{
@@ -39,38 +41,33 @@ typedef struct
unsigned short image_width;
unsigned short image_height;
unsigned char fields;
}
image_descriptor_t;
} image_descriptor_t;
typedef struct
{
unsigned char byte;
int prev;
int len;
}
dictionary_entry_t;
} dictionary_entry_t;
typedef struct
{
unsigned char extension_code;
unsigned char block_size;
}
extension_t;
} extension_t;
typedef struct
{
unsigned char fields;
unsigned short delay_time;
unsigned char transparent_color_index;
}
graphic_control_extension_t;
} graphic_control_extension_t;
typedef struct
{
unsigned char application_id[8];
unsigned char version[3];
}
application_extension_t;
} application_extension_t;
typedef struct
{
@@ -82,8 +79,7 @@ typedef struct
unsigned char cell_height;
unsigned char foreground_color;
unsigned char background_color;
}
plaintext_extension_t;
} plaintext_extension_t;
// static unsigned short width = 0;
// static unsigned short height = 0;
@@ -319,7 +315,8 @@ unsigned char* process_image_descriptor( unsigned char* buffer,
uncompress(lzw_code_size, compressed_data, compressed_data_length,
uncompressed_data);
if ( compressed_data ) free( compressed_data );
if (compressed_data)
free(compressed_data);
// if ( uncompressed_data )
// free( uncompressed_data );
@@ -334,7 +331,8 @@ unsigned char* process_image_descriptor( unsigned char* buffer,
*/
#define rb (*(buffer++))
uint32_t* LoadPalette(unsigned char *buffer) {
uint32_t *LoadPalette(unsigned char *buffer)
{
unsigned char header[7];
screen_descriptor_t screen_descriptor;
// int color_resolution_bits;
@@ -348,13 +346,15 @@ uint32_t* LoadPalette(unsigned char *buffer) {
// color_resolution_bits = ((screen_descriptor.fields & 0x70) >> 4) + 1;
global_color_table = (uint32_t *)calloc(1, 1024);
if (screen_descriptor.fields & 0x80) {
if (screen_descriptor.fields & 0x80)
{
global_color_table_size = 1 << (((screen_descriptor.fields & 0x07) + 1));
// global_color_table = (rgb *)malloc(3 * global_color_table_size);
// READ(global_color_table, 3 * global_color_table_size);
for (int i=0; i<global_color_table_size;++i) {
global_color_table[i] = (buffer[0]<<16) + (buffer[1]<<8) + buffer[2];
for (int i = 0; i < global_color_table_size; ++i)
{
global_color_table[i] = (0xFF << 24) + (buffer[0] << 16) + (buffer[1] << 8) + buffer[2];
buffer += 3;
}
}
@@ -402,8 +402,7 @@ static unsigned char* process_gif_stream(unsigned char *buffer, unsigned short*
{
// int i;
// If bit 7 is set, the next block is a global color table; read it
global_color_table_size = 1 <<
( ( ( screen_descriptor.fields & 0x07 ) + 1 ) );
global_color_table_size = 1 << (((screen_descriptor.fields & 0x07) + 1));
global_color_table = (rgb *)malloc(3 * global_color_table_size);
@@ -428,7 +427,8 @@ static unsigned char* process_gif_stream(unsigned char *buffer, unsigned short*
buffer++;
size = *(buffer++);
buffer += size;
do {
do
{
size = *(buffer++);
buffer += size;
} while (size != 0);
@@ -449,8 +449,8 @@ static unsigned char* process_gif_stream(unsigned char *buffer, unsigned short*
return NULL;
}
unsigned char* LoadGif(unsigned char *buffer, unsigned short* w, unsigned short* h) {
unsigned char *LoadGif(unsigned char *buffer, unsigned short *w, unsigned short *h)
{
return process_gif_stream(buffer, w, h);
}
@@ -475,4 +475,4 @@ unsigned char* LoadGif(unsigned char *buffer, unsigned short* w, unsigned short*
process_gif_stream( gif_file );
fclose( gif_file );
}*/
}*/}

176
source/jUnit.cpp
View File

@@ -1,176 +0,0 @@
#include "jUnit.h"
#include "gif.c"
#include <stdio.h>
struct jSurface_s
{
Uint8 *data;
Uint16 w, h;
};
static SDL_Window *jWin = nullptr;
static SDL_Renderer *jRen = nullptr;
static SDL_Texture *jTex = nullptr;
static jSurface jScreen;
static jSurface jDestSurf;
static jSurface jSourceSurf = nullptr;
static Uint32 paleta[256];
static int jWidth = 320;
static int jHeight = 240;
static int jZoom = 2;
static int transparentColor = 0;
jSurface jNewSurface(int w, int h)
{
jSurface surf = (jSurface)malloc(sizeof(jSurface_s));
surf->w = w;
surf->h = h;
surf->data = (Uint8 *)malloc(w * h);
return surf;
}
void jDeleteSurface(jSurface surf)
{
if (surf)
{
free(surf->data);
free(surf);
}
}
void jSetDest(jSurface surf)
{
jDestSurf = (surf == nullptr) ? jScreen : surf;
}
void jSetSource(jSurface surf)
{
jSourceSurf = surf;
}
void jBlit(int dx, int dy, int sx, int sy, int w, int h)
{
if (jSourceSurf == nullptr)
{
return;
}
for (int iy = 0; iy < h; ++iy)
{
for (int ix = 0; ix < w; ++ix)
{
jPutPixel(dx + ix, dy + iy, jGetPixel(sx + ix, sy + iy));
}
}
}
jSurface jLoadSurface(const char *filename)
{
FILE *f = fopen(filename, "rb");
if (!f)
{
return nullptr;
}
fseek(f, 0, SEEK_END);
long size = ftell(f);
fseek(f, 0, SEEK_SET);
Uint8 *buffer = (Uint8 *)malloc(size);
fread(buffer, size, 1, f);
fclose(f);
Uint16 w, h;
Uint8 *pixels = LoadGif(buffer, &w, &h);
if (pixels == nullptr)
{
return nullptr;
}
jSurface surf = (jSurface)malloc(sizeof(jSurface_s));
surf->w = w;
surf->h = h;
surf->data = pixels;
free(buffer);
return surf;
}
void jLoadPal(const char *filename)
{
FILE *f = fopen(filename, "rb");
if (!f)
{
return;
}
fseek(f, 0, SEEK_END);
long size = ftell(f);
fseek(f, 0, SEEK_SET);
Uint8 *buffer = (Uint8 *)malloc(size);
fread(buffer, size, 1, f);
fclose(f);
Uint32 *pal = LoadPalette(buffer);
if (pal == nullptr)
{
return;
}
free(buffer);
for (int i = 0; i < 256; ++i)
{
paleta[i] = pal[i];
}
}
void jInit(const char *titol, int w, int h, int z)
{
SDL_Init(SDL_INIT_VIDEO);
jWidth = w;
jHeight = h;
jZoom = z;
jWin = SDL_CreateWindow(titol, w * z, h * z, 0);
jRen = SDL_CreateRenderer(jWin, nullptr);
SDL_SetRenderLogicalPresentation(jRen, w, h, SDL_LOGICAL_PRESENTATION_INTEGER_SCALE);
jTex = SDL_CreateTexture(jRen, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, w, h);
jScreen = jNewSurface(w, h);
jDestSurf = jScreen;
}
void jSetPal(int index, Uint32 color)
{
paleta[index] = color;
}
void jCls(Uint8 color)
{
for (int i = 0; i < jDestSurf->w * jDestSurf->h; ++i)
{
jDestSurf->data[i] = color;
}
}
void jFlip()
{
Uint32 *pixels;
int pitch;
SDL_LockTexture(jTex, nullptr, (void **)&pixels, &pitch);
for (int i = 0; i < jWidth * jHeight; ++i)
{
pixels[i] = paleta[jScreen->data[i]];
}
SDL_UnlockTexture(jTex);
SDL_RenderTexture(jRen, jTex, nullptr, nullptr);
SDL_RenderPresent(jRen);
}
void jPutPixel(int x, int y, Uint8 color)
{
if (x < 0 || y < 0 || x >= jDestSurf->w || y >= jDestSurf->h || color == transparentColor)
{
return;
}
jDestSurf->data[x + y * jDestSurf->w] = color;
}
Uint8 jGetPixel(int x, int y)
{
return jSourceSurf->data[x + y * jSourceSurf->w];
}

28
source/jUnit.h
View File

@@ -1,28 +0,0 @@
#pragma once
#include <SDL3/SDL.h>
typedef struct jSurface_s *jSurface;
void init();
void update();
jSurface jNewSurface(int w, int h);
void jDeleteSurface(jSurface surf);
void jSetDest(jSurface surf);
void jSetSource(jSurface surf);
jSurface jLoadSurface(const char* filename);
void jPutPixel(int x, int y, Uint8 color);
Uint8 jGetPixel(int x, int y);
void jBlit(int dx, int dy, int sx, int sy, int w, int h);
void jInit(const char *titol, int w, int h, int z);
void jSetPal(int index, Uint32 color);
void jLoadPal(const char *filename);
void jCls(Uint8 color);
void jFlip();

55
source/main.cpp Normal file
View File

@@ -0,0 +1,55 @@
#include "palette.h"
#include "defines.h"
#include <SDL3/SDL.h>
void init()
{
Palette::init("demo6_palette", WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_ZOOM);
Palette::Surface peiv = Palette::loadSurface("resources/williams.gif");
Palette::loadPalette("resources/pal01.gif");
Palette::setSrc(peiv);
}
void update()
{
const int FRAME = (SDL_GetTicks() / ANIMATION_SPEED) % NUM_FRAMES;
Palette::setPalette(255, 0xFF444466);
Palette::clear(255);
Palette::blit(SPRITE_POS_X, SPRITE_POS_Y, FRAME * SPRITE_WIDTH, 0, SPRITE_WIDTH, SPRITE_HEIGHT);
}
int main(int argc, char *argv[])
{
init();
SDL_Event event;
bool should_exit = false;
while (!should_exit)
{
while (SDL_PollEvent(&event))
{
// Evento de salida
if (event.type == SDL_EVENT_QUIT)
{
should_exit = true;
break;
}
// Eventos de teclado
if (event.type == SDL_EVENT_KEY_DOWN && event.key.repeat == 0)
{
switch (event.key.key)
{
case SDLK_ESCAPE:
should_exit = true;
break;
case SDLK_SPACE:
Palette::switchPalette();
break;
}
}
}
update();
Palette::flip();
}
}

21
source/paleta.cpp
View File

@@ -1,21 +0,0 @@
#include "jUnit.h"
int main(int argc, char *argv[])
{
init();
SDL_Event event;
bool exit = false;
while (!exit)
{
while (SDL_PollEvent(&event))
{
if ((event.type == SDL_EVENT_QUIT) || (event.type == SDL_EVENT_KEY_DOWN && event.key.repeat == 0 && event.key.key == SDLK_ESCAPE))
{
exit = true;
break;
}
update();
jFlip();
}
}
}

191
source/palette.cpp Normal file
View File

@@ -0,0 +1,191 @@
#include "palette.h"
#include "gif.c"
#include <stdio.h>
#include <array>
#include <string>
#include "defines.h"
namespace Palette
{
struct SurfaceData
{
Uint8 *data;
Uint16 w, h;
};
static SDL_Window *window = nullptr;
static SDL_Renderer *renderer = nullptr;
static SDL_Texture *texture = nullptr;
static Surface screen;
static Surface dst_surface;
static Surface src_surface = nullptr;
static Uint32 palette[256];
static int width = 0;
static int height = 0;
static int zoom = 0;
static int transparent_color = 14;
static int palette_number = 0;
Surface newSurface(int w, int h)
{
Surface surf = (Surface)malloc(sizeof(SurfaceData));
surf->w = w;
surf->h = h;
surf->data = (Uint8 *)malloc(w * h);
return surf;
}
void deleteSurface(Surface surf)
{
if (surf)
{
free(surf->data);
free(surf);
}
}
void setDst(Surface surf)
{
dst_surface = (surf == nullptr) ? screen : surf;
}
void setSrc(Surface surf)
{
src_surface = surf;
}
void blit(int dx, int dy, int sx, int sy, int w, int h)
{
if (src_surface == nullptr)
{
return;
}
for (int iy = 0; iy < h; ++iy)
{
for (int ix = 0; ix < w; ++ix)
{
putPixel(dx + ix, dy + iy, getPixel(sx + ix, sy + iy));
}
}
}
Surface loadSurface(const char *filename)
{
FILE *f = fopen(filename, "rb");
if (!f)
{
return nullptr;
}
fseek(f, 0, SEEK_END);
long size = ftell(f);
fseek(f, 0, SEEK_SET);
Uint8 *buffer = (Uint8 *)malloc(size);
fread(buffer, size, 1, f);
fclose(f);
Uint16 w, h;
Uint8 *pixels = GIF::LoadGif(buffer, &w, &h);
if (pixels == nullptr)
{
return nullptr;
}
Surface surf = (Surface)malloc(sizeof(SurfaceData));
surf->w = w;
surf->h = h;
surf->data = pixels;
free(buffer);
return surf;
}
void loadPalette(const char *filename)
{
FILE *f = fopen(filename, "rb");
if (!f)
{
return;
}
fseek(f, 0, SEEK_END);
long size = ftell(f);
fseek(f, 0, SEEK_SET);
Uint8 *buffer = (Uint8 *)malloc(size);
fread(buffer, size, 1, f);
fclose(f);
Uint32 *pal = GIF::LoadPalette(buffer);
if (pal == nullptr)
{
return;
}
free(buffer);
for (int i = 0; i < 256; ++i)
{
palette[i] = pal[i];
}
}
void init(const char *titol, int w, int h, int z)
{
SDL_Init(SDL_INIT_VIDEO);
width = w;
height = h;
zoom = z;
window = SDL_CreateWindow(titol, w * z, h * z, 0);
renderer = SDL_CreateRenderer(window, nullptr);
SDL_SetRenderLogicalPresentation(renderer, w, h, SDL_LOGICAL_PRESENTATION_INTEGER_SCALE);
texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, w, h);
SDL_SetTextureScaleMode(texture, SDL_SCALEMODE_NEAREST);
screen = newSurface(w, h);
dst_surface = screen;
}
void setPalette(int index, Uint32 color)
{
palette[index] = color;
}
void clear(Uint8 color)
{
for (int i = 0; i < dst_surface->w * dst_surface->h; ++i)
{
dst_surface->data[i] = color;
}
}
void flip()
{
Uint32 *pixels;
int pitch;
SDL_LockTexture(texture, nullptr, (void **)&pixels, &pitch);
for (int i = 0; i < width * height; ++i)
{
pixels[i] = palette[screen->data[i]];
}
SDL_UnlockTexture(texture);
SDL_RenderTexture(renderer, texture, nullptr, nullptr);
SDL_RenderPresent(renderer);
}
void putPixel(int x, int y, Uint8 color)
{
if (x < 0 || y < 0 || x >= dst_surface->w || y >= dst_surface->h || color == transparent_color)
{
return;
}
dst_surface->data[x + y * dst_surface->w] = color;
}
Uint8 getPixel(int x, int y)
{
return src_surface->data[x + y * src_surface->w];
}
void switchPalette()
{
palette_number = (palette_number + 1) % NUM_PALETTES;
std::array<std::string, NUM_PALETTES> palettes{"resources/pal01.gif", "resources/pal02.gif"};
loadPalette(palettes.at(palette_number).c_str());
}
}

30
source/palette.h Normal file
View File

@@ -0,0 +1,30 @@
#pragma once
#include <SDL3/SDL.h>
namespace Palette
{
typedef struct SurfaceData *Surface;
Surface newSurface(int w, int h);
void deleteSurface(Surface surf);
void setDst(Surface surf);
void setSrc(Surface surf);
Surface loadSurface(const char *filename);
void putPixel(int x, int y, Uint8 color);
Uint8 getPixel(int x, int y);
void blit(int dx, int dy, int sx, int sy, int w, int h);
void init(const char *titol, int w, int h, int z);
void setPalette(int index, Uint32 color);
void loadPalette(const char *filename);
void clear(Uint8 color);
void flip();
void switchPalette();
}