+ return -1;
+}
+
+void sge_pPutPixel(SDL_Surface *surface, Sint16 x, Sint32 ypitch, Uint32 color)
+{
+ if (x >= 0 && x <= surface->w - 1 && ypitch >= 0)
+ {
+ switch (surface->format->BytesPerPixel)
+ {
+ case 1:
+ {
+ /* Assuming 8-bpp */
+ *((Uint8 *)surface->pixels + ypitch + x) = color;
+ }
+ break;
+
+ case 2:
+ {
+ /* Probably 15-bpp or 16-bpp */
+ *((Uint16 *)surface->pixels + ypitch + x) = color;
+ }
+ break;
+
+ case 3:
+ {
+ /* Slow 24-bpp mode, usually not used */
+ Uint8 *pix;
+ int shift;
+
+ /* Gack - slow, but endian correct */
+ pix = (Uint8 *)surface->pixels + ypitch + x*3;
+ shift = surface->format->Rshift;
+ *(pix+shift/8) = color>>shift;
+ shift = surface->format->Gshift;
+ *(pix+shift/8) = color>>shift;
+ shift = surface->format->Bshift;
+ *(pix+shift/8) = color>>shift;
+ }
+ break;
+
+ case 4:
+ {
+ /* Probably 32-bpp */
+ *((Uint32 *)surface->pixels + ypitch + x) = color;
+ }
+ break;
+ }
+ }
+}
+
+void sge_HLine(SDL_Surface *Surface, Sint16 x1, Sint16 x2, Sint16 y,
+ Uint32 Color)
+{
+ SDL_Rect l;
+
+ if (SDL_MUSTLOCK(Surface))
+ {
+ if (SDL_LockSurface(Surface) < 0)
+ {
+ return;
+ }
+ }
+
+ if (x1 > x2)
+ {
+ Sint16 tmp = x1;
+ x1 = x2;
+ x2 = tmp;
+ }
+
+ /* Do the clipping */
+ if (y < 0 || y > Surface->h - 1 || x1 > Surface->w - 1 || x2 < 0)
+ return;
+ if (x1 < 0)
+ x1 = 0;
+ if (x2 > Surface->w - 1)
+ x2 = Surface->w - 1;
+
+ l.x = x1;
+ l.y = y;
+ l.w = x2 - x1 + 1;
+ l.h = 1;
+
+ SDL_FillRect(Surface, &l, Color);
+
+ if (SDL_MUSTLOCK(Surface))
+ {
+ SDL_UnlockSurface(Surface);
+ }
+}
+
+void sge_HLineRGB(SDL_Surface *Surface, Sint16 x1, Sint16 x2, Sint16 y,
+ Uint8 R, Uint8 G, Uint8 B)
+{
+ sge_HLine(Surface, x1, x2, y, SDL_MapRGB(Surface->format, R, G, B));
+}
+
+void _HLine(SDL_Surface *Surface, Sint16 x1, Sint16 x2, Sint16 y, Uint32 Color)
+{
+ SDL_Rect l;
+
+ if (x1 > x2)
+ {
+ Sint16 tmp = x1;
+ x1 = x2;
+ x2 = tmp;
+ }
+
+ /* Do the clipping */
+ if (y < 0 || y > Surface->h - 1 || x1 > Surface->w - 1 || x2 < 0)
+ return;
+ if (x1 < 0)
+ x1 = 0;
+ if (x2 > Surface->w - 1)
+ x2 = Surface->w - 1;
+
+ l.x = x1;
+ l.y = y;
+ l.w = x2 - x1 + 1;
+ l.h = 1;
+
+ SDL_FillRect(Surface, &l, Color);
+}
+
+void sge_VLine(SDL_Surface *Surface, Sint16 x, Sint16 y1, Sint16 y2,
+ Uint32 Color)
+{
+ SDL_Rect l;
+
+ if (SDL_MUSTLOCK(Surface))
+ {
+ if (SDL_LockSurface(Surface) < 0)
+ {
+ return;
+ }
+ }
+
+ if (y1 > y2)
+ {
+ Sint16 tmp = y1;
+ y1 = y2;
+ y2 = tmp;
+ }
+
+ /* Do the clipping */
+ if (x < 0 || x > Surface->w - 1 || y1 > Surface->h - 1 || y2 < 0)
+ return;
+ if (y1 < 0)
+ y1 = 0;
+ if (y2 > Surface->h - 1)
+ y2 = Surface->h - 1;
+
+ l.x = x;
+ l.y = y1;
+ l.w = 1;
+ l.h = y2 - y1 + 1;
+
+ SDL_FillRect(Surface, &l, Color);
+
+ if (SDL_MUSTLOCK(Surface))
+ {
+ SDL_UnlockSurface(Surface);
+ }
+}
+
+void sge_VLineRGB(SDL_Surface *Surface, Sint16 x, Sint16 y1, Sint16 y2,
+ Uint8 R, Uint8 G, Uint8 B)
+{
+ sge_VLine(Surface, x, y1, y2, SDL_MapRGB(Surface->format, R, G, B));
+}
+
+void _VLine(SDL_Surface *Surface, Sint16 x, Sint16 y1, Sint16 y2, Uint32 Color)
+{
+ SDL_Rect l;
+
+ if (y1 > y2)
+ {
+ Sint16 tmp = y1;
+ y1 = y2;
+ y2 = tmp;
+ }
+
+ /* Do the clipping */
+ if (x < 0 || x > Surface->w - 1 || y1 > Surface->h - 1 || y2 < 0)
+ return;
+ if (y1 < 0)
+ y1 = 0;
+ if (y2 > Surface->h - 1)
+ y2 = Surface->h - 1;
+
+ l.x = x;
+ l.y = y1;
+ l.w = 1;
+ l.h = y2 - y1 + 1;
+
+ SDL_FillRect(Surface, &l, Color);
+}
+
+void sge_DoLine(SDL_Surface *Surface, Sint16 x1, Sint16 y1,
+ Sint16 x2, Sint16 y2, Uint32 Color,
+ void Callback(SDL_Surface *Surf, Sint16 X, Sint16 Y,
+ Uint32 Color))
+{
+ Sint16 dx, dy, sdx, sdy, x, y, px, py;
+
+ dx = x2 - x1;
+ dy = y2 - y1;
+
+ sdx = (dx < 0) ? -1 : 1;
+ sdy = (dy < 0) ? -1 : 1;
+
+ dx = sdx * dx + 1;
+ dy = sdy * dy + 1;
+
+ x = y = 0;
+
+ px = x1;
+ py = y1;
+
+ if (dx >= dy)
+ {
+ for (x = 0; x < dx; x++)
+ {
+ Callback(Surface, px, py, Color);
+
+ y += dy;
+ if (y >= dx)
+ {
+ y -= dx;
+ py += sdy;
+ }
+
+ px += sdx;
+ }
+ }
+ else
+ {
+ for (y = 0; y < dy; y++)
+ {
+ Callback(Surface, px, py, Color);
+
+ x += dx;
+ if (x >= dy)
+ {
+ x -= dy;
+ px += sdx;
+ }
+
+ py += sdy;
+ }
+ }
+}
+
+void sge_DoLineRGB(SDL_Surface *Surface, Sint16 X1, Sint16 Y1,
+ Sint16 X2, Sint16 Y2, Uint8 R, Uint8 G, Uint8 B,
+ void Callback(SDL_Surface *Surf, Sint16 X, Sint16 Y,
+ Uint32 Color))
+{
+ sge_DoLine(Surface, X1, Y1, X2, Y2,
+ SDL_MapRGB(Surface->format, R, G, B), Callback);
+}
+
+void sge_Line(SDL_Surface *Surface, Sint16 x1, Sint16 y1, Sint16 x2, Sint16 y2,
+ Uint32 Color)
+{
+ if (SDL_MUSTLOCK(Surface))
+ {
+ if (SDL_LockSurface(Surface) < 0)
+ return;
+ }
+
+ /* Draw the line */
+ sge_DoLine(Surface, x1, y1, x2, y2, Color, _PutPixel);
+
+ /* unlock the display */
+ if (SDL_MUSTLOCK(Surface))
+ {
+ SDL_UnlockSurface(Surface);
+ }
+}
+
+void sge_LineRGB(SDL_Surface *Surface, Sint16 x1, Sint16 y1, Sint16 x2,
+ Sint16 y2, Uint8 R, Uint8 G, Uint8 B)
+{
+ sge_Line(Surface, x1, y1, x2, y2, SDL_MapRGB(Surface->format, R, G, B));
+}
+
+
+/*
+ -----------------------------------------------------------------------------
+ quick (no, it's slow) and dirty hack to "invert" rectangle inside SDL surface
+ -----------------------------------------------------------------------------
+*/
+
+inline void SDLInvertArea(Bitmap *bitmap, int src_x, int src_y,
+ int width, int height, Uint32 color)
+{
+ SDL_Surface *surface = bitmap->surface;
+ int x, y;
+
+ for (y=src_y; y < src_y + height; y++)
+ {
+ for (x=src_x; x < src_x + width; x++)
+ {
+ Uint32 pixel = SDLGetPixel(bitmap, x, y);
+
+ sge_PutPixel(surface, x, y, pixel == BLACK_PIXEL ? color : BLACK_PIXEL);
+ }
+ }
+}
+
+
+/* ========================================================================= */
+/* The following functions were taken from the SDL_gfx library version 2.0.3 */
+/* (Rotozoomer) by Andreas Schiffler */
+/* http://www.ferzkopp.net/Software/SDL_gfx-2.0/index.html */
+/* ========================================================================= */
+
+/*
+ -----------------------------------------------------------------------------
+ 32 bit zoomer
+
+ zoomes 32bit RGBA/ABGR 'src' surface to 'dst' surface.
+ -----------------------------------------------------------------------------
+*/
+
+typedef struct
+{
+ Uint8 r;
+ Uint8 g;
+ Uint8 b;
+ Uint8 a;
+} tColorRGBA;
+
+int zoomSurfaceRGBA(SDL_Surface *src, SDL_Surface *dst)
+{
+ int x, y, sx, sy, *sax, *say, *csax, *csay, csx, csy;
+ tColorRGBA *sp, *csp, *dp;
+ int sgap, dgap;
+
+ /* variable setup */
+ sx = (int) (65536.0 * (float) src->w / (float) dst->w);
+ sy = (int) (65536.0 * (float) src->h / (float) dst->h);
+
+ /* allocate memory for row increments */
+ sax = (int *)checked_malloc((dst->w + 1) * sizeof(Uint32));
+ say = (int *)checked_malloc((dst->h + 1) * sizeof(Uint32));
+
+ /* precalculate row increments */
+ csx = 0;
+ csax = sax;
+ for (x = 0; x <= dst->w; x++)
+ {
+ *csax = csx;
+ csax++;
+ csx &= 0xffff;
+ csx += sx;
+ }
+
+ csy = 0;
+ csay = say;
+ for (y = 0; y <= dst->h; y++)
+ {
+ *csay = csy;
+ csay++;
+ csy &= 0xffff;
+ csy += sy;
+ }
+
+ /* pointer setup */
+ sp = csp = (tColorRGBA *) src->pixels;
+ dp = (tColorRGBA *) dst->pixels;
+ sgap = src->pitch - src->w * 4;
+ dgap = dst->pitch - dst->w * 4;
+
+ csay = say;
+ for (y = 0; y < dst->h; y++)
+ {
+ sp = csp;
+ csax = sax;
+
+ for (x = 0; x < dst->w; x++)
+ {
+ /* draw */
+ *dp = *sp;
+
+ /* advance source pointers */
+ csax++;
+ sp += (*csax >> 16);
+
+ /* advance destination pointer */
+ dp++;
+ }
+
+ /* advance source pointer */
+ csay++;
+ csp = (tColorRGBA *) ((Uint8 *) csp + (*csay >> 16) * src->pitch);
+
+ /* advance destination pointers */
+ dp = (tColorRGBA *) ((Uint8 *) dp + dgap);
+ }
+
+ free(sax);
+ free(say);
+
+ return 0;
+}
+
+/*
+ -----------------------------------------------------------------------------
+ 8 bit zoomer
+
+ zoomes 8 bit palette/Y 'src' surface to 'dst' surface
+ -----------------------------------------------------------------------------
+*/
+
+int zoomSurfaceY(SDL_Surface * src, SDL_Surface * dst)
+{
+ Uint32 x, y, sx, sy, *sax, *say, *csax, *csay, csx, csy;
+ Uint8 *sp, *dp, *csp;
+ int dgap;
+
+ /* variable setup */
+ sx = (Uint32) (65536.0 * (float) src->w / (float) dst->w);
+ sy = (Uint32) (65536.0 * (float) src->h / (float) dst->h);
+
+ /* allocate memory for row increments */
+ sax = (Uint32 *)checked_malloc(dst->w * sizeof(Uint32));
+ say = (Uint32 *)checked_malloc(dst->h * sizeof(Uint32));
+
+ /* precalculate row increments */
+ csx = 0;
+ csax = sax;
+ for (x = 0; x < dst->w; x++)
+ {
+ csx += sx;
+ *csax = (csx >> 16);
+ csx &= 0xffff;
+ csax++;
+ }
+
+ csy = 0;
+ csay = say;
+ for (y = 0; y < dst->h; y++)
+ {
+ csy += sy;
+ *csay = (csy >> 16);
+ csy &= 0xffff;
+ csay++;
+ }
+
+ csx = 0;
+ csax = sax;
+ for (x = 0; x < dst->w; x++)
+ {
+ csx += (*csax);
+ csax++;
+ }
+
+ csy = 0;
+ csay = say;
+ for (y = 0; y < dst->h; y++)
+ {
+ csy += (*csay);
+ csay++;
+ }
+
+ /* pointer setup */
+ sp = csp = (Uint8 *) src->pixels;
+ dp = (Uint8 *) dst->pixels;
+ dgap = dst->pitch - dst->w;
+
+ /* draw */
+ csay = say;
+ for (y = 0; y < dst->h; y++)
+ {
+ csax = sax;
+ sp = csp;
+ for (x = 0; x < dst->w; x++)
+ {
+ /* draw */
+ *dp = *sp;
+
+ /* advance source pointers */
+ sp += (*csax);
+ csax++;
+
+ /* advance destination pointer */
+ dp++;
+ }
+
+ /* advance source pointer (for row) */
+ csp += ((*csay) * src->pitch);
+ csay++;
+
+ /* advance destination pointers */
+ dp += dgap;
+ }
+
+ free(sax);
+ free(say);
+
+ return 0;
+}
+
+/*
+ -----------------------------------------------------------------------------
+ zoomSurface()
+
+ Zoomes a 32bit or 8bit 'src' surface to newly created 'dst' surface.
+ 'zoomx' and 'zoomy' are scaling factors for width and height.
+ If 'smooth' is 1 then the destination 32bit surface is anti-aliased.
+ If the surface is not 8bit or 32bit RGBA/ABGR it will be converted
+ into a 32bit RGBA format on the fly.
+ -----------------------------------------------------------------------------
+*/
+
+SDL_Surface *zoomSurface(SDL_Surface *src, int dst_width, int dst_height)
+{
+ SDL_Surface *zoom_src = NULL;
+ SDL_Surface *zoom_dst = NULL;
+ boolean is_converted = FALSE;
+ boolean is_32bit;
+ int i;
+
+ if (src == NULL)
+ return NULL;
+
+ /* determine if source surface is 32 bit or 8 bit */
+ is_32bit = (src->format->BitsPerPixel == 32);
+
+ if (is_32bit || src->format->BitsPerPixel == 8)
+ {
+ /* use source surface 'as is' */
+ zoom_src = src;
+ }
+ else
+ {
+ /* new source surface is 32 bit with a defined RGB ordering */
+ zoom_src = SDL_CreateRGBSurface(SDL_SWSURFACE, src->w, src->h, 32,
+ 0x000000ff, 0x0000ff00, 0x00ff0000, 0);
+ SDL_BlitSurface(src, NULL, zoom_src, NULL);
+ is_32bit = TRUE;
+ is_converted = TRUE;
+ }
+
+ /* allocate surface to completely contain the zoomed surface */
+ if (is_32bit)
+ {
+ /* target surface is 32 bit with source RGBA/ABGR ordering */
+ zoom_dst = SDL_CreateRGBSurface(SDL_SWSURFACE, dst_width, dst_height, 32,
+ zoom_src->format->Rmask,
+ zoom_src->format->Gmask,
+ zoom_src->format->Bmask, 0);
+ }
+ else
+ {
+ /* target surface is 8 bit */
+ zoom_dst = SDL_CreateRGBSurface(SDL_SWSURFACE, dst_width, dst_height, 8,
+ 0, 0, 0, 0);
+ }
+
+ /* lock source surface */
+ SDL_LockSurface(zoom_src);
+
+ /* check which kind of surface we have */
+ if (is_32bit)
+ {
+ /* call the 32 bit transformation routine to do the zooming */
+ zoomSurfaceRGBA(zoom_src, zoom_dst);
+ }
+ else
+ {
+ /* copy palette */
+ for (i=0; i < zoom_src->format->palette->ncolors; i++)
+ zoom_dst->format->palette->colors[i] =
+ zoom_src->format->palette->colors[i];
+ zoom_dst->format->palette->ncolors = zoom_src->format->palette->ncolors;
+
+ /* call the 8 bit transformation routine to do the zooming */
+ zoomSurfaceY(zoom_src, zoom_dst);
+ }
+
+ /* unlock source surface */
+ SDL_UnlockSurface(zoom_src);
+
+ /* free temporary surface */
+ if (is_converted)
+ SDL_FreeSurface(zoom_src);
+
+ /* return destination surface */
+ return zoom_dst;
+}
+
+void SDLZoomBitmap(Bitmap *src_bitmap, Bitmap *dst_bitmap)
+{
+ SDL_Surface *sdl_surface_tmp;
+ int dst_width = dst_bitmap->width;
+ int dst_height = dst_bitmap->height;
+
+ /* throw away old destination surface */
+ SDL_FreeSurface(dst_bitmap->surface);
+
+ /* create zoomed temporary surface from source surface */
+ sdl_surface_tmp = zoomSurface(src_bitmap->surface, dst_width, dst_height);
+
+ /* create native format destination surface from zoomed temporary surface */
+ dst_bitmap->surface = SDL_DisplayFormat(sdl_surface_tmp);
+
+ /* free temporary surface */
+ SDL_FreeSurface(sdl_surface_tmp);
+}
+
+
+/* ========================================================================= */
+/* load image to bitmap */
+/* ========================================================================= */
+
+Bitmap *SDLLoadImage(char *filename)
+{
+ Bitmap *new_bitmap = CreateBitmapStruct();
+ SDL_Surface *sdl_image_tmp;
+
+ /* load image to temporary surface */
+ if ((sdl_image_tmp = IMG_Load(filename)) == NULL)
+ {
+ SetError("IMG_Load(): %s", SDL_GetError());
+ return NULL;
+ }
+
+ /* create native non-transparent surface for current image */
+ if ((new_bitmap->surface = SDL_DisplayFormat(sdl_image_tmp)) == NULL)
+ {
+ SetError("SDL_DisplayFormat(): %s", SDL_GetError());
+ return NULL;
+ }
+
+ /* create native transparent surface for current image */
+ SDL_SetColorKey(sdl_image_tmp, SDL_SRCCOLORKEY,
+ SDL_MapRGB(sdl_image_tmp->format, 0x00, 0x00, 0x00));
+ if ((new_bitmap->surface_masked = SDL_DisplayFormat(sdl_image_tmp)) == NULL)
+ {
+ SetError("SDL_DisplayFormat(): %s", SDL_GetError());
+ return NULL;
+ }
+
+ /* free temporary surface */
+ SDL_FreeSurface(sdl_image_tmp);
+
+ new_bitmap->width = new_bitmap->surface->w;
+ new_bitmap->height = new_bitmap->surface->h;
+
+ return new_bitmap;
+}
+
+
+/* ------------------------------------------------------------------------- */
+/* custom cursor fuctions */
+/* ------------------------------------------------------------------------- */
+
+static SDL_Cursor *create_cursor(const char **image)
+{
+ int i, row, col;
+ Uint8 data[4*32];
+ Uint8 mask[4*32];
+ int hot_x, hot_y;
+
+ i = -1;
+ for (row=0; row<32; ++row)
+ {
+ for (col=0; col<32; ++col)
+ {
+ if (col % 8)
+ {
+ data[i] <<= 1;
+ mask[i] <<= 1;
+ }
+ else
+ {
+ i++;
+ data[i] = mask[i] = 0;
+ }
+
+ switch (image[4+row][col])
+ {
+ case 'X':
+ data[i] |= 0x01;
+ mask[i] |= 0x01;
+ break;
+ case '.':
+ mask[i] |= 0x01;
+ break;
+ case ' ':
+ break;
+ }
+ }
+ }
+
+ sscanf(image[4+row], "%d,%d", &hot_x, &hot_y);
+
+ return SDL_CreateCursor(data, mask, 32, 32, hot_x, hot_y);
+}
+
+void SDLSetMouseCursor(const char **cursor_image)
+{
+ static const char **last_cursor_image = NULL;
+ static SDL_Cursor *cursor_default = NULL;
+ static SDL_Cursor *cursor_current = NULL;
+
+ if (cursor_default == NULL)
+ cursor_default = SDL_GetCursor();
+
+ if (cursor_image != NULL && cursor_image != last_cursor_image)
+ {
+ cursor_current = create_cursor(cursor_image);
+ last_cursor_image = cursor_image;
+ }
+
+ SDL_SetCursor(cursor_image ? cursor_current : cursor_default);
+}
+
+
+/* ========================================================================= */
+/* audio functions */
+/* ========================================================================= */
+
+inline void SDLOpenAudio(void)
+{
+ if (strcmp(setup.system.sdl_audiodriver, ARG_DEFAULT) != 0)
+ putenv(getStringCat2("SDL_AUDIODRIVER=", setup.system.sdl_audiodriver));
+
+ if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0)
+ {
+ Error(ERR_WARN, "SDL_InitSubSystem() failed: %s", SDL_GetError());
+ return;
+ }
+
+ if (Mix_OpenAudio(DEFAULT_AUDIO_SAMPLE_RATE, MIX_DEFAULT_FORMAT,
+ AUDIO_NUM_CHANNELS_STEREO,
+ setup.system.audio_fragment_size) < 0)