void EmuinoSDL::postsetup()
{
TileLayerInfo layer_info;
// set up the palettes
for (int i = 0; i < NUM_PALETTES; i++) {
palettes[i] = SDL_AllocPalette(NUM_PALETTE_ENTRIES);
SDL_Color colors[NUM_PALETTE_ENTRIES];
SharedRAM.read(PALETTE(i) | 0x8000, colors, NUM_PALETTE_ENTRIES * 4);
for (int z = 0; z < NUM_PALETTE_ENTRIES; z++)
colors[z].a = 255;
SDL_SetPaletteColors(palettes[i], colors, 0, NUM_PALETTE_ENTRIES);
}
screenSurface = SDL_CreateRGBSurface(0, 320, 240, 32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000);
screenTexture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_TARGET, 320, 240);
// create the tile textures
for (int i = 0; i < NUM_TILE_LAYERS; i++) {
tileMapSurfaces[i] = SDL_CreateRGBSurface(0, 32 * 16, 32 * 16, 32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000);
tileMapTextures[i] = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, 32 * 16, 32 * 16);
SDL_SetTextureBlendMode(tileMapTextures[i], SDL_BLENDMODE_BLEND);
}
setup = true;
}
int display_init() {
memset(&display, 0, sizeof(display));
if (SDL_Init(SDL_INIT_EVERYTHING) != 0)
return 0;
display.window = SDL_CreateWindow("Gamebuino",
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
84*DISPLAY_SCALE_X, 48*DISPLAY_SCALE_Y, 0);
if (display.window == NULL)
return 0;
display.renderer = SDL_CreateRenderer(display.window, -1,
SDL_RENDERER_PRESENTVSYNC);
display.texture = SDL_CreateTexture(display.renderer,
SDL_PIXELFORMAT_RGB332,
SDL_TEXTUREACCESS_STREAMING, 84, 48);
if (display.texture == NULL)
return 0;
SDL_Surface* numbers_surface = SDL_CreateRGBSurfaceFrom((void*) numbers_bitmap,
numbers_bitmap_width, numbers_bitmap_height, 1, numbers_bitmap_width / 8,
0x80000000, 0x80000000, 0x80000000, 0xFFFFFFFF);
SDL_Palette* palette = SDL_AllocPalette(2);
SDL_SetPaletteColors(palette, numbers_palette_colors, 0, 2);
SDL_SetSurfacePalette(numbers_surface, palette);
display.numbers_texture = SDL_CreateTextureFromSurface(display.renderer, numbers_surface);
if (display.numbers_texture == 0)
return 0;
SDL_FreeSurface(numbers_surface);
return 1;
}
static void osinterface_resize(int width, int height)
{
rct_drawpixelinfo *screenDPI;
int newScreenBufferSize;
void *newScreenBuffer;
if (_surface != NULL)
SDL_FreeSurface(_surface);
if (_palette != NULL)
SDL_FreePalette(_palette);
_surface = SDL_CreateRGBSurface(0, width, height, 8, 0, 0, 0, 0);
_palette = SDL_AllocPalette(256);
SDL_SetSurfacePalette(_surface, _palette);
newScreenBufferSize = _surface->pitch * _surface->h;
newScreenBuffer = malloc(newScreenBufferSize);
if (_screenBuffer == NULL) {
memset(newScreenBuffer, 0, newScreenBufferSize);
} else {
memcpy(newScreenBuffer, _screenBuffer, min(_screenBufferSize, newScreenBufferSize));
if (newScreenBufferSize - _screenBufferSize > 0)
memset((uint8*)newScreenBuffer + _screenBufferSize, 0, newScreenBufferSize - _screenBufferSize);
free(_screenBuffer);
}
_screenBuffer = newScreenBuffer;
_screenBufferSize = newScreenBufferSize;
RCT2_GLOBAL(RCT2_ADDRESS_SCREEN_WIDTH, sint16) = width;
RCT2_GLOBAL(RCT2_ADDRESS_SCREEN_HEIGHT, sint16) = height;
screenDPI = RCT2_ADDRESS(RCT2_ADDRESS_SCREEN_DPI, rct_drawpixelinfo);
screenDPI->bits = _screenBuffer;
screenDPI->x = 0;
screenDPI->y = 0;
screenDPI->width = width;
screenDPI->height = height;
screenDPI->pitch = _surface->pitch - _surface->w;
RCT2_GLOBAL(0x009ABDF0, uint8) = 6;
RCT2_GLOBAL(0x009ABDF1, uint8) = 3;
RCT2_GLOBAL(0x009ABDF2, uint8) = 1;
RCT2_GLOBAL(RCT2_ADDRESS_DIRTY_BLOCK_WIDTH, sint16) = 64;
RCT2_GLOBAL(RCT2_ADDRESS_DIRTY_BLOCK_HEIGHT, sint16) = 8;
RCT2_GLOBAL(RCT2_ADDRESS_DIRTY_BLOCK_COLUMNS, sint32) = (width >> 6) + 1;
RCT2_GLOBAL(RCT2_ADDRESS_DIRTY_BLOCK_ROWS, sint32) = (height >> 3) + 1;
RCT2_CALLPROC_EBPSAFE(0x0066B905); // resize_gui()
gfx_invalidate_screen();
}
void vga_setpalette(unsigned char* palette)
{
SDL_Color colors[256];
int i;
for(i=0; i<256; i++)
{
colors[i].r = palette[0];
colors[i].g = palette[1];
colors[i].b = palette[2];
palette += 3;
}
if(!screenPalette) screenPalette = SDL_AllocPalette(256);
SDL_SetPaletteColors(screenPalette, colors, 0, 256);
}
void SDLImageLoader::init(Point SpriteSize, Point Margins, Point FullSize, SDL_Color *pal)
{
//Init image
image->surf = SDL_CreateRGBSurface(SDL_SWSURFACE, SpriteSize.x, SpriteSize.y, 8, 0, 0, 0, 0);
image->margins = Margins;
image->fullSize = FullSize;
//Prepare surface
SDL_Palette * p = SDL_AllocPalette(256);
SDL_SetPaletteColors(p, pal, 0, 256);
SDL_SetSurfacePalette(image->surf, p);
SDL_FreePalette(p);
SDL_LockSurface(image->surf);
lineStart = position = (ui8*)image->surf->pixels;
}
s_videomodes setupPreBlitProcessing(s_videomodes videomodes)
{
bytes_per_pixel = videomodes.pixel;
if(screen) { SDL_FreeSurface(screen); screen=NULL; }
if(bscreen) { SDL_FreeSurface(bscreen); bscreen=NULL; }
if(bscreen2) { SDL_FreeSurface(bscreen2); bscreen2=NULL; }
// set scale factors to 1 by default
videomodes.hScale = savedata.glscale;
videomodes.vScale = savedata.glscale;
// set up indexed to RGB conversion
if(videomodes.pixel == 1)
{
bscreen = SDL_CreateRGBSurface(0, videomodes.hRes, videomodes.vRes, 8, 0,0,0,0);
screen = SDL_CreateRGBSurface(0, videomodes.hRes, videomodes.vRes, 32, masks[3][0], masks[3][1], masks[3][2], masks[3][3]);
if(!screenPalette) screenPalette = SDL_AllocPalette(256);
SDL_SetSurfacePalette(bscreen, screenPalette);
videomodes.pixel = 4;
}
// set up software scaling
if(savedata.swfilter && (savedata.glscale >= 2.0 || savedata.fullscreen))
{
if (screen) SDL_FreeSurface(screen);
screen = SDL_CreateRGBSurface(0, videomodes.hRes*2, videomodes.vRes*2, 16, masks[1][0], masks[1][1], masks[1][2], masks[1][3]);
if (!bscreen) bscreen = SDL_CreateRGBSurface(0, videomodes.hRes, videomodes.vRes, 8*bytes_per_pixel, masks[bytes_per_pixel-1][0], masks[bytes_per_pixel-1][1], masks[bytes_per_pixel-1][2], masks[bytes_per_pixel-1][3]); // 24bit mask
bscreen2 = SDL_CreateRGBSurface(0, videomodes.hRes+4, videomodes.vRes+8, 16, masks[1][0], masks[1][1], masks[1][2], masks[1][3]);
Init_Gfx(565, 16);
memset(pDeltaBuffer, 0x00, 1244160);
assert(bscreen);
assert(bscreen2);
videomodes.hRes *= 2;
videomodes.vRes *= 2;
videomodes.hScale /= 2;
videomodes.vScale /= 2;
videomodes.pixel = 2;
}
return videomodes;
}
static void VL_SDL2_SetVideoMode(int mode)
{
if (mode == 0x0D)
{
// Here is how the dimensions of the window are currently picked:
// 1. The emulated 320x200 sub-window is first zoomed
// by a factor of 3 (for each dimension) to 960x600.
// 2. The height is then multiplied by 1.2, so the internal contents
// (without the borders) have the aspect ratio of 4:3.
//
// There are a few more tricks in use to handle the overscan border
// and VGA line doubling.
vl_sdl2_window = SDL_CreateWindow(VL_WINDOW_TITLE, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
VL_DEFAULT_WINDOW_WIDTH, VL_DEFAULT_WINDOW_HEIGHT,
SDL_WINDOW_RESIZABLE | (vl_isFullScreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0));
SDL_SetWindowMinimumSize(vl_sdl2_window, VL_VGA_GFX_SCALED_WIDTH_PLUS_BORDER / VL_VGA_GFX_WIDTH_SCALEFACTOR, VL_VGA_GFX_SCALED_HEIGHT_PLUS_BORDER / VL_VGA_GFX_HEIGHT_SCALEFACTOR);
//VL_SDL2GL_SetIcon(vl_sdl2_window);
vl_sdl2_renderer = SDL_CreateRenderer(vl_sdl2_window, -1, SDL_RENDERER_ACCELERATED);
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "0");
vl_sdl2_texture = SDL_CreateTexture(vl_sdl2_renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, VL_EGAVGA_GFX_WIDTH, VL_EGAVGA_GFX_HEIGHT);
vl_sdl2_palette = SDL_AllocPalette(256);
// As we can't do on-GPU palette conversions with SDL2,
// we do a PAL8->RGBA conversion of the visible area to this surface each frame.
vl_sdl2_stagingSurface = SDL_CreateRGBSurface(0, VL_EGAVGA_GFX_WIDTH, VL_EGAVGA_GFX_HEIGHT, 32, 0, 0, 0, 0);
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1");
vl_sdl2_scaledTarget = SDL_CreateTexture(vl_sdl2_renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_TARGET, VL_EGAVGA_GFX_WIDTH * 3, VL_EGAVGA_GFX_HEIGHT * 3);
SDL_ShowCursor(0);
}
else
{
SDL_ShowCursor(1);
SDL_DestroyTexture(vl_sdl2_scaledTarget);
SDL_DestroyTexture(vl_sdl2_texture);
SDL_DestroyRenderer(vl_sdl2_renderer);
SDL_DestroyWindow(vl_sdl2_window);
}
}
static void sdl2_init_font(sdl2_video_t *vid, const char *font_path,
unsigned font_size)
{
int i, r, g, b;
SDL_Color colors[256];
SDL_Surface *tmp = NULL;
SDL_Palette *pal = NULL;
const struct font_atlas *atlas = NULL;
settings_t *settings = config_get_ptr();
if (!settings->video.font_enable)
return;
if (!font_renderer_create_default(&vid->font_driver, &vid->font_data,
*font_path ? font_path : NULL, font_size))
{
RARCH_WARN("[SDL]: Could not initialize fonts.\n");
return;
}
r = settings->video.msg_color_r * 255;
g = settings->video.msg_color_g * 255;
b = settings->video.msg_color_b * 255;
r = (r < 0) ? 0 : (r > 255 ? 255 : r);
g = (g < 0) ? 0 : (g > 255 ? 255 : g);
b = (b < 0) ? 0 : (b > 255 ? 255 : b);
vid->font_r = r;
vid->font_g = g;
vid->font_b = b;
atlas = vid->font_driver->get_atlas(vid->font_data);
tmp = SDL_CreateRGBSurfaceFrom(atlas->buffer, atlas->width,
atlas->height, 8, atlas->width,
0, 0, 0, 0);
for (i = 0; i < 256; ++i)
{
colors[i].r = colors[i].g = colors[i].b = i;
colors[i].a = 255;
}
pal = SDL_AllocPalette(256);
SDL_SetPaletteColors(pal, colors, 0, 256);
SDL_SetSurfacePalette(tmp, pal);
SDL_SetColorKey(tmp, SDL_TRUE, 0);
vid->font.tex = SDL_CreateTextureFromSurface(vid->renderer, tmp);
if (vid->font.tex)
{
vid->font.w = atlas->width;
vid->font.h = atlas->height;
vid->font.active = true;
SDL_SetTextureBlendMode(vid->font.tex, SDL_BLENDMODE_ADD);
}
else
RARCH_WARN("[SDL]: Failed to initialize font texture: %s\n", SDL_GetError());
SDL_FreePalette(pal);
SDL_FreeSurface(tmp);
}
/*
* Create an empty RGB surface of the appropriate depth
*/
SDL_Surface *
SDL_CreateRGBSurface(Uint32 flags,
int width, int height, int depth,
Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)
{
SDL_Surface *surface;
Uint32 format;
/* The flags are no longer used, make the compiler happy */
(void)flags;
/* Get the pixel format */
format = SDL_MasksToPixelFormatEnum(depth, Rmask, Gmask, Bmask, Amask);
if (format == SDL_PIXELFORMAT_UNKNOWN) {
SDL_SetError("Unknown pixel format");
return NULL;
}
/* Allocate the surface */
surface = (SDL_Surface *) SDL_calloc(1, sizeof(*surface));
if (surface == NULL) {
SDL_OutOfMemory();
return NULL;
}
surface->format = SDL_AllocFormat(format);
if (!surface->format) {
SDL_FreeSurface(surface);
return NULL;
}
surface->w = width;
surface->h = height;
surface->pitch = SDL_CalculatePitch(surface);
SDL_SetClipRect(surface, NULL);
if (SDL_ISPIXELFORMAT_INDEXED(surface->format->format)) {
SDL_Palette *palette =
SDL_AllocPalette((1 << surface->format->BitsPerPixel));
if (!palette) {
SDL_FreeSurface(surface);
return NULL;
}
if (palette->ncolors == 2) {
/* Create a black and white bitmap palette */
palette->colors[0].r = 0xFF;
palette->colors[0].g = 0xFF;
palette->colors[0].b = 0xFF;
palette->colors[1].r = 0x00;
palette->colors[1].g = 0x00;
palette->colors[1].b = 0x00;
}
SDL_SetSurfacePalette(surface, palette);
SDL_FreePalette(palette);
}
/* Get the pixels */
if (surface->w && surface->h) {
surface->pixels = SDL_malloc(surface->h * surface->pitch);
if (!surface->pixels) {
SDL_FreeSurface(surface);
SDL_OutOfMemory();
return NULL;
}
/* This is important for bitmaps */
SDL_memset(surface->pixels, 0, surface->h * surface->pitch);
}
/* Allocate an empty mapping */
surface->map = SDL_AllocBlitMap();
if (!surface->map) {
SDL_FreeSurface(surface);
return NULL;
}
/* By default surface with an alpha mask are set up for blending */
if (Amask) {
SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_BLEND);
}
/* The surface is ready to go */
surface->refcount = 1;
return surface;
}
SDL_Surface*
Blitter::scale_surface(SDL_Surface* surface, int width, int height)
{
int i;
int j;
unsigned char *pixels;
unsigned char *new_pixels;
int x;
int bpp;
int new_pitch;
SDL_Surface* new_surface;
bpp = surface->format->BytesPerPixel;
if (bpp == 1) {
SDL_Palette* pal = SDL_AllocPalette(256);
Uint32 ckey;
int useckey = 0;
useckey = SDL_GetColorKey(surface, &ckey) == 0;
new_surface = SDL_CreateRGBSurface(0, width, height, 8, 0, 0, 0, 0);
SDL_LockSurface(surface);
SDL_LockSurface(new_surface);
pixels = static_cast<unsigned char*>(surface->pixels);
new_pixels = static_cast<unsigned char*>(new_surface->pixels);
new_pitch = new_surface->pitch;
memcpy(pal->colors, surface->format->palette->colors, sizeof(SDL_Color) * 256);
for (i = 0; i < height; ++i) {
x = i * new_pitch;
for (j = 0; j < width; ++j) {
new_pixels[x] = pixels[(i * surface->h / height) * surface->pitch + j * surface->w / width];
++x;
}
}
SDL_UnlockSurface(surface);
SDL_UnlockSurface(new_surface);
SDL_SetSurfacePalette(new_surface, pal);
if (useckey)
{
SDL_SetColorKey(new_surface, SDL_TRUE, ckey);
SDL_SetSurfaceRLE(new_surface, SDL_TRUE);
}
} else {
int ix, iy;
float fx, fy, fz;
unsigned char *p1, *p2, *p3, *p4;
new_surface = SDL_CreateRGBSurface(0, width, height, surface->format->BitsPerPixel,
surface->format->Rmask, surface->format->Gmask, surface->format->Bmask, surface->format->Amask);
SDL_LockSurface(surface);
SDL_LockSurface(new_surface);
pixels = static_cast<unsigned char*>(surface->pixels);
new_pixels = static_cast<unsigned char*>(new_surface->pixels);
new_pitch = new_surface->pitch;
for (i = 0; i < height; ++i) {
x = i * new_pitch;
fy = static_cast<float>(i) * static_cast<float>(surface->h) / static_cast<float>(height);
iy = static_cast<int>(fy);
fy -= static_cast<float>(iy);
for (j = 0; j < width; ++j) {
fx = static_cast<float>(j) * static_cast<float>(surface->w) / static_cast<float>(width);
ix = static_cast<int>(fx);
fx -= static_cast<float>(ix);
fz = (fx + fy) / 2;
p1 = &pixels[iy * surface->pitch + ix * bpp];
p2 = (iy != surface->h - 1) ?
&pixels[(iy + 1) * surface->pitch + ix * bpp] : p1;
p3 = (ix != surface->w - 1) ?
&pixels[iy * surface->pitch + (ix + 1) * bpp] : p1;
p4 = (iy != surface->h - 1 && ix != surface->w - 1) ?
&pixels[(iy + 1) * surface->pitch + (ix + 1) * bpp] : p1;
new_pixels[x + 0] = static_cast<unsigned char>(
(static_cast<float>(p1[0]) * (1 - fy) + static_cast<float>(p2[0]) * fy +
static_cast<float>(p1[0]) * (1 - fx) + static_cast<float>(p3[0]) * fx +
static_cast<float>(p1[0]) * (1 - fz) + static_cast<float>(p4[0]) * fz) / 3.0 + .5);
new_pixels[x + 1] = static_cast<unsigned char>(
(static_cast<float>(p1[1]) * (1 - fy) + static_cast<float>(p2[1]) * fy +
static_cast<float>(p1[1]) * (1 - fx) + static_cast<float>(p3[1]) * fx +
static_cast<float>(p1[1]) * (1 - fz) + static_cast<float>(p4[1]) * fz) / 3.0 + .5);
new_pixels[x + 2] = static_cast<unsigned char>(
(static_cast<float>(p1[2]) * (1 - fy) + static_cast<float>(p2[2]) * fy +
static_cast<float>(p1[2]) * (1 - fx) + static_cast<float>(p3[2]) * fx +
static_cast<float>(p1[2]) * (1 - fz) + static_cast<float>(p4[2]) * fz) / 3.0 + .5);
if (bpp == 4) {
new_pixels[x + 3] = static_cast<unsigned char>(
(static_cast<float>(p1[3]) * (1 - fy) + static_cast<float>(p2[3]) * fy +
static_cast<float>(p1[3]) * (1 - fx) + static_cast<float>(p3[3]) * fx +
static_cast<float>(p1[3]) * (1 - fz) + static_cast<float>(p4[3]) * fz) / 3.0 + .5);
}
x += bpp;
}
}
SDL_UnlockSurface(surface);
SDL_UnlockSurface(new_surface);
}
return new_surface;
}
/*
* Sets the window icon
*/
static void
SetSDLIcon()
{
SDL_Surface *icon;
SDL_Color transColor, solidColor;
Uint8 *ptr;
int i;
int mask;
icon = SDL_CreateRGBSurface(SDL_SWSURFACE,
q2icon_width, q2icon_height, 8,
0, 0, 0, 0);
if (icon == NULL)
{
return;
}
SDL_SetColorKey(icon, SDL_SRCCOLORKEY, 0);
transColor.r = 255;
transColor.g = 255;
transColor.b = 255;
solidColor.r = 0;
solidColor.g = 16;
solidColor.b = 0;
#if SDL_VERSION_ATLEAST(2, 0, 0)
// only SDL2 has alphas there and they must be set apparently
transColor.a = 0;
solidColor.a = 255;
SDL_Palette* palette = SDL_AllocPalette(256);
SDL_SetPaletteColors(palette, &transColor, 0, 1);
SDL_SetPaletteColors(palette, &solidColor, 1, 1);
SDL_SetSurfacePalette(icon, palette);
#else
SDL_SetColors(icon, &transColor, 0, 1);
SDL_SetColors(icon, &solidColor, 1, 1);
#endif
ptr = (Uint8 *)icon->pixels;
for (i = 0; i < sizeof(q2icon_bits); i++)
{
for (mask = 1; mask != 0x100; mask <<= 1)
{
*ptr = (q2icon_bits[i] & mask) ? 1 : 0;
ptr++;
}
}
#if SDL_VERSION_ATLEAST(2, 0, 0)
SDL_SetWindowIcon(window, icon);
SDL_FreePalette(palette);
#else
SDL_WM_SetIcon(icon, NULL);
#endif
SDL_FreeSurface(icon);
}
bool sdl_set_video_mode(struct graphics_data *graphics, int width, int height,
int depth, bool fullscreen, bool resize)
{
struct sdl_render_data *render_data = graphics->render_data;
#if SDL_VERSION_ATLEAST(2,0,0)
bool matched = false;
Uint32 fmt;
render_data->window = SDL_CreateWindow("MegaZeux",
SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height,
sdl_flags(depth, fullscreen, resize));
if(!render_data->window)
{
warn("Failed to create window: %s\n", SDL_GetError());
goto err_out;
}
render_data->renderer =
SDL_CreateRenderer(render_data->window, -1, SDL_RENDERER_SOFTWARE);
if(!render_data->renderer)
{
warn("Failed to create renderer: %s\n", SDL_GetError());
goto err_destroy_window;
}
render_data->screen = SDL_GetWindowSurface(render_data->window);
if(!render_data->screen)
{
warn("Failed to get window surface: %s\n", SDL_GetError());
goto err_destroy_renderer;
}
/* SDL 2.0 allows the window system to offer up buffers of a specific
* format, and expects the application to perform a blit if the format
* doesn't match what the app wanted. To accomodate this, allocate a
* shadow screen that we render to in the case the formats do not match,
* and blit it at present time.
*/
fmt = SDL_GetWindowPixelFormat(render_data->window);
switch(depth)
{
case 8:
matched = fmt == SDL_PIXELFORMAT_INDEX8;
fmt = SDL_PIXELFORMAT_INDEX8;
break;
case 16:
switch(fmt)
{
case SDL_PIXELFORMAT_RGB565:
case SDL_PIXELFORMAT_BGR565:
matched = true;
break;
default:
fmt = SDL_PIXELFORMAT_RGB565;
break;
}
break;
case 32:
switch(fmt)
{
case SDL_PIXELFORMAT_RGB888:
case SDL_PIXELFORMAT_RGBX8888:
case SDL_PIXELFORMAT_RGBA8888:
case SDL_PIXELFORMAT_BGRX8888:
case SDL_PIXELFORMAT_BGRA8888:
case SDL_PIXELFORMAT_ARGB8888:
case SDL_PIXELFORMAT_ABGR8888:
matched = true;
break;
default:
fmt = SDL_PIXELFORMAT_RGBA8888;
break;
}
break;
}
if(!matched)
{
Uint32 Rmask, Gmask, Bmask, Amask;
int bpp;
SDL_PixelFormatEnumToMasks(fmt, &bpp, &Rmask, &Gmask, &Bmask, &Amask);
render_data->shadow = SDL_CreateRGBSurface(0, width, height, bpp,
Rmask, Gmask, Bmask, Amask);
debug("Blitting enabled. Rendering performance will be reduced.\n");
}
else
{
render_data->shadow = NULL;
}
if(fmt == SDL_PIXELFORMAT_INDEX8)
{
SDL_PixelFormat *format =
render_data->shadow ? render_data->shadow->format :
render_data->screen->format;
render_data->palette = SDL_AllocPalette(SMZX_PAL_SIZE);
if(!render_data->palette)
{
warn("Failed to allocate palette: %s\n", SDL_GetError());
goto err_destroy_renderer;
}
if(SDL_SetPixelFormatPalette(format, render_data->palette))
{
warn("Failed to set pixel format palette: %s\n", SDL_GetError());
goto err_free_palette;
}
}
else
{
render_data->palette = NULL;
}
sdl_window_id = SDL_GetWindowID(render_data->window);
#else // !SDL_VERSION_ATLEAST(2,0,0)
render_data->screen = SDL_SetVideoMode(width, height, depth,
sdl_flags(depth, fullscreen, resize));
if(!render_data->screen)
return false;
render_data->shadow = NULL;
#endif // !SDL_VERSION_ATLEAST(2,0,0)
return true;
#if SDL_VERSION_ATLEAST(2,0,0)
err_free_palette:
SDL_FreePalette(render_data->palette);
render_data->palette = NULL;
err_destroy_renderer:
SDL_DestroyRenderer(render_data->renderer);
render_data->renderer = NULL;
err_destroy_window:
SDL_DestroyWindow(render_data->window);
render_data->window = NULL;
err_out:
return false;
#endif // SDL_VERSION_ATLEAST(2,0,0)
}
/*
* Create an empty RGB surface of the appropriate depth using the given
* enum SDL_PIXELFORMAT_* format
*/
SDL_Surface *
SDL_CreateRGBSurfaceWithFormat(Uint32 flags, int width, int height, int depth,
Uint32 format)
{
SDL_Surface *surface;
/* The flags are no longer used, make the compiler happy */
(void)flags;
/* Allocate the surface */
surface = (SDL_Surface *) SDL_calloc(1, sizeof(*surface));
if (surface == NULL) {
SDL_OutOfMemory();
return NULL;
}
surface->format = SDL_AllocFormat(format);
if (!surface->format) {
SDL_FreeSurface(surface);
return NULL;
}
surface->w = width;
surface->h = height;
surface->pitch = SDL_CalculatePitch(format, width);
SDL_SetClipRect(surface, NULL);
if (SDL_ISPIXELFORMAT_INDEXED(surface->format->format)) {
SDL_Palette *palette =
SDL_AllocPalette((1 << surface->format->BitsPerPixel));
if (!palette) {
SDL_FreeSurface(surface);
return NULL;
}
if (palette->ncolors == 2) {
/* Create a black and white bitmap palette */
palette->colors[0].r = 0xFF;
palette->colors[0].g = 0xFF;
palette->colors[0].b = 0xFF;
palette->colors[1].r = 0x00;
palette->colors[1].g = 0x00;
palette->colors[1].b = 0x00;
}
SDL_SetSurfacePalette(surface, palette);
SDL_FreePalette(palette);
}
/* Get the pixels */
if (surface->w && surface->h) {
/* Assumptions checked in surface_size_assumptions assert above */
Sint64 size = ((Sint64)surface->h * surface->pitch);
if (size < 0 || size > SDL_MAX_SINT32) {
/* Overflow... */
SDL_FreeSurface(surface);
SDL_OutOfMemory();
return NULL;
}
surface->pixels = SDL_malloc((size_t)size);
if (!surface->pixels) {
SDL_FreeSurface(surface);
SDL_OutOfMemory();
return NULL;
}
/* This is important for bitmaps */
SDL_memset(surface->pixels, 0, surface->h * surface->pitch);
}
/* Allocate an empty mapping */
surface->map = SDL_AllocBlitMap();
if (!surface->map) {
SDL_FreeSurface(surface);
return NULL;
}
/* By default surface with an alpha mask are set up for blending */
if (surface->format->Amask) {
SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_BLEND);
}
/* The surface is ready to go */
surface->refcount = 1;
return surface;
}
int idris_paletteCreate(int length) {
colors = malloc(length * sizeof(SDL_Color));
palette = SDL_AllocPalette(length);
ci = 0;
return colors != NULL;
}
/**
* @brief Call to SDL_AllocPalette and SDL_FreePalette
*
* @sa http://wiki.libsdl.org/moin.fcg/SDL_AllocPalette
* @sa http://wiki.libsdl.org/moin.fcg/SDL_FreePalette
*/
int
pixels_allocFreePalette(void *arg)
{
const char *expectedError1 = "Parameter 'ncolors' is invalid";
const char *expectedError2 = "Parameter 'palette' is invalid";
const char *error;
int variation;
int i;
int ncolors;
SDL_Palette* result;
/* Allocate palette */
for (variation = 1; variation <= 3; variation++) {
switch (variation) {
/* Just one color */
case 1:
ncolors = 1;
break;
/* Two colors */
case 2:
ncolors = 2;
break;
/* More than two colors */
case 3:
ncolors = SDLTest_RandomIntegerInRange(8, 16);
break;
}
result = SDL_AllocPalette(ncolors);
SDLTest_AssertPass("Call to SDL_AllocPalette(%d)", ncolors);
SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
if (result != NULL) {
SDLTest_AssertCheck(result->ncolors == ncolors, "Verify value of result.ncolors; expected: %u, got %u", ncolors, result->ncolors);
if (result->ncolors > 0) {
SDLTest_AssertCheck(result->colors != NULL, "Verify value of result.colors is not NULL");
if (result->colors != NULL) {
for(i = 0; i < result->ncolors; i++) {
SDLTest_AssertCheck(result->colors[i].r == 255, "Verify value of result.colors[%d].r; expected: 255, got %u", i, result->colors[i].r);
SDLTest_AssertCheck(result->colors[i].g == 255, "Verify value of result.colors[%d].g; expected: 255, got %u", i, result->colors[i].g);
SDLTest_AssertCheck(result->colors[i].b == 255, "Verify value of result.colors[%d].b; expected: 255, got %u", i, result->colors[i].b);
}
}
}
/* Deallocate again */
SDL_FreePalette(result);
SDLTest_AssertPass("Call to SDL_FreePalette()");
}
}
/* Negative cases */
/* Invalid number of colors */
for (ncolors = 0; ncolors > -3; ncolors--) {
SDL_ClearError();
SDLTest_AssertPass("Call to SDL_ClearError()");
result = SDL_AllocPalette(ncolors);
SDLTest_AssertPass("Call to SDL_AllocPalette(%d)", ncolors);
SDLTest_AssertCheck(result == NULL, "Verify result is NULL");
error = SDL_GetError();
SDLTest_AssertPass("Call to SDL_GetError()");
SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
if (error != NULL) {
SDLTest_AssertCheck(SDL_strcmp(error, expectedError1) == 0,
"Validate error message, expected: '%s', got: '%s'", expectedError1, error);
}
}
/* Invalid free pointer */
SDL_ClearError();
SDLTest_AssertPass("Call to SDL_ClearError()");
SDL_FreePalette(NULL);
SDLTest_AssertPass("Call to SDL_FreePalette(NULL)");
error = SDL_GetError();
SDLTest_AssertPass("Call to SDL_GetError()");
SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
if (error != NULL) {
SDLTest_AssertCheck(SDL_strcmp(error, expectedError2) == 0,
"Validate error message, expected: '%s', got: '%s'", expectedError2, error);
}
return TEST_COMPLETED;
}