if (gfx.draw_global_anim_function != NULL)
gfx.draw_global_anim_function(draw_target, DRAW_GLOBAL_ANIM_STAGE_2);
- // copy tile selection cursor to render target buffer, if defined (above all)
+ // copy tile selection cursor to render target buffer, if defined (part 1)
if (gfx.draw_tile_cursor_function != NULL)
- gfx.draw_tile_cursor_function(draw_target);
+ gfx.draw_tile_cursor_function(draw_target, TRUE);
+
+ // copy envelope request to render target buffer, if needed (above all)
+ if (gfx.draw_envelope_request_function != NULL)
+ gfx.draw_envelope_request_function(draw_target);
+
+ // copy tile selection cursor to render target buffer, if defined (part 2)
+ if (gfx.draw_tile_cursor_function != NULL)
+ gfx.draw_tile_cursor_function(draw_target, FALSE);
// copy global animations to render target buffer, if defined (mouse pointer)
if (gfx.draw_global_anim_function != NULL)
return (blend_mode == SDL_BLENDMODE_BLEND);
}
-void SDLSetAlpha(SDL_Surface *surface, boolean set, int alpha)
+static void SDLSetSurfaceAlpha(SDL_Surface *surface, boolean set, int alpha)
{
SDL_BlendMode blend_mode = (set ? SDL_BLENDMODE_BLEND : SDL_BLENDMODE_NONE);
SDL_SetSurfaceAlphaMod(surface, alpha);
}
+static void SDLSetTextureAlpha(SDL_Texture *texture, boolean set, int alpha)
+{
+ SDL_BlendMode blend_mode = (set ? SDL_BLENDMODE_BLEND : SDL_BLENDMODE_NONE);
+
+ SDL_SetTextureBlendMode(texture, blend_mode);
+ SDL_SetTextureAlphaMod(texture, alpha);
+}
+
+static void SDLSetBitmapAlpha(Bitmap *bitmap, boolean is_texture,
+ boolean is_masked)
+{
+ int alpha_next_blit = bitmap->alpha_next_blit;
+
+ // alpha value must be requested every time before blitting, if needed
+ bitmap->alpha_next_blit = -1;
+
+ // nothing to do if requested alpha value is already set
+ if (bitmap->alpha[is_texture][is_masked] == alpha_next_blit)
+ return;
+
+ // store requested alpha value for masked/unmasked surface/texture
+ bitmap->alpha[is_texture][is_masked] = alpha_next_blit;
+
+ // set blend mode if bitmap is masked or if alpha value is defined
+ boolean set_blend_mode = (is_masked || alpha_next_blit != -1);
+
+ // if alpha value is undefined, use default (opaque) alpha value
+ if (alpha_next_blit == -1)
+ alpha_next_blit = SDL_ALPHA_OPAQUE;
+
+ if (is_texture)
+ SDLSetTextureAlpha(is_masked ? bitmap->texture_masked : bitmap->texture,
+ set_blend_mode, alpha_next_blit);
+ else
+ SDLSetSurfaceAlpha(is_masked ? bitmap->surface_masked : bitmap->surface,
+ set_blend_mode, alpha_next_blit);
+}
+
+void SDLSetAlpha(SDL_Surface *surface, boolean set, int alpha)
+{
+ SDLSetSurfaceAlpha(surface, set, alpha);
+}
+
const char *SDLGetRendererName(void)
{
static SDL_RendererInfo renderer_info;
return renderer_info.name;
}
+static SDL_Surface *SDLGetOpaqueSurface(SDL_Surface *surface)
+{
+ SDL_Surface *new_surface;
+
+ if (surface == NULL)
+ return NULL;
+
+ if ((new_surface = SDLGetNativeSurface(surface)) == NULL)
+ Fail("SDLGetNativeSurface() failed");
+
+ // remove alpha channel from native non-transparent surface, if defined
+ SDLSetAlpha(new_surface, FALSE, 0);
+
+ // remove transparent color from native non-transparent surface, if defined
+ SDL_SetColorKey(new_surface, UNSET_TRANSPARENT_PIXEL, 0);
+
+ return new_surface;
+}
+
SDL_Surface *SDLGetNativeSurface(SDL_Surface *surface)
{
SDL_PixelFormat format;
return TRUE;
}
+SDL_Surface *SDLCreateNativeSurface(int width, int height, int depth)
+{
+ if (program.headless)
+ return NULL;
+
+ SDL_Surface *surface = SDL_CreateRGBSurface(SURFACE_FLAGS, width, height, depth, 0,0,0, 0);
+
+ if (surface == NULL)
+ Fail("SDL_CreateRGBSurface() failed: %s", SDL_GetError());
+
+ SDLSetNativeSurface(&surface);
+
+ return surface;
+}
+
+Bitmap *SDLGetBitmapFromSurface_WithMaskedColor(SDL_Surface *surface, int r, int g, int b)
+{
+ int width = surface->w;
+ int height = surface->h;
+ int depth = video.default_depth;
+ Bitmap *bitmap = CreateBitmap(width, height, depth);
+
+ // free default surface (not needed anymore)
+ SDL_FreeSurface(bitmap->surface);
+
+ // get native, non-transparent surface from original surface
+ bitmap->surface = SDLGetOpaqueSurface(surface);
+
+ // get native, potentially transparent surface from original surface
+ bitmap->surface_masked = SDLGetNativeSurface(surface);
+
+ // set black pixel to transparent if no alpha channel / transparent color
+ if (!SDLHasAlpha(bitmap->surface_masked) &&
+ !SDLHasColorKey(bitmap->surface_masked))
+ SDL_SetColorKey(bitmap->surface_masked, SET_TRANSPARENT_PIXEL,
+ SDL_MapRGB(bitmap->surface_masked->format, r, g, b));
+
+ return bitmap;
+}
+
+Bitmap *SDLGetBitmapFromSurface(SDL_Surface *surface)
+{
+ return SDLGetBitmapFromSurface_WithMaskedColor(surface, 0x00, 0x00, 0x00);
+}
+
static SDL_Texture *SDLCreateTextureFromSurface(SDL_Surface *surface)
{
if (program.headless)
UpdateScreen_WithoutFrameDelay(NULL);
}
-void SDLCreateBitmapContent(Bitmap *bitmap, int width, int height,
- int depth)
-{
- if (program.headless)
- return;
-
- SDL_Surface *surface =
- SDL_CreateRGBSurface(SURFACE_FLAGS, width, height, depth, 0,0,0, 0);
-
- if (surface == NULL)
- Fail("SDL_CreateRGBSurface() failed: %s", SDL_GetError());
-
- SDLSetNativeSurface(&surface);
-
- bitmap->surface = surface;
-}
-
void SDLFreeBitmapPointers(Bitmap *bitmap)
{
if (bitmap->surface)
bitmap->texture_masked = NULL;
}
+void SDLBlitSurface(SDL_Surface *src_surface, SDL_Surface *dst_surface,
+ int src_x, int src_y, int width, int height,
+ int dst_x, int dst_y)
+{
+ SDL_Rect src_rect, dst_rect;
+
+ src_rect.x = src_x;
+ src_rect.y = src_y;
+ src_rect.w = width;
+ src_rect.h = height;
+
+ dst_rect.x = dst_x;
+ dst_rect.y = dst_y;
+ dst_rect.w = width;
+ dst_rect.h = height;
+
+ SDL_BlitSurface(src_surface, &src_rect, dst_surface, &dst_rect);
+}
+
void SDLCopyArea(Bitmap *src_bitmap, Bitmap *dst_bitmap,
int src_x, int src_y, int width, int height,
int dst_x, int dst_y, int mask_mode)
dst_rect.w = width;
dst_rect.h = height;
+ SDLSetBitmapAlpha(src_bitmap, FALSE, mask_mode == BLIT_MASKED);
+
// if (src_bitmap != backbuffer || dst_bitmap != window)
if (!(src_bitmap == backbuffer && dst_bitmap == window))
SDL_BlitSurface((mask_mode == BLIT_MASKED ?
dst_rect.w = width;
dst_rect.h = height;
+ SDLSetBitmapAlpha(bitmap, TRUE, mask_mode == BLIT_MASKED);
+
SDL_RenderCopy(sdl_renderer, texture, &src_rect, &dst_rect);
}
continue;
sge_Line(surface, points[i].x + dx, points[i].y + dy,
- points[i+1].x + dx, points[i+1].y + dy, color);
+ points[i + 1].x + dx, points[i + 1].y + dy, color);
}
}
}
}
// ----------------------------------------------------------------------------
-// zoomSurface()
+// SDLZoomSurface()
//
// Zooms a 32bit or 8bit 'src' surface to newly created 'dst' surface.
// 'zoomx' and 'zoomy' are scaling factors for width and height.
// into a 32bit RGBA format on the fly.
// ----------------------------------------------------------------------------
-static SDL_Surface *zoomSurface(SDL_Surface *src, int dst_width, int dst_height)
+SDL_Surface *SDLZoomSurface(SDL_Surface *src, int dst_width, int dst_height)
{
SDL_Surface *zoom_src = NULL;
SDL_Surface *zoom_dst = NULL;
return zoom_dst;
}
-static SDL_Surface *SDLGetOpaqueSurface(SDL_Surface *surface)
-{
- SDL_Surface *new_surface;
-
- if (surface == NULL)
- return NULL;
-
- if ((new_surface = SDLGetNativeSurface(surface)) == NULL)
- Fail("SDLGetNativeSurface() failed");
-
- // remove alpha channel from native non-transparent surface, if defined
- SDLSetAlpha(new_surface, FALSE, 0);
-
- // remove transparent color from native non-transparent surface, if defined
- SDL_SetColorKey(new_surface, UNSET_TRANSPARENT_PIXEL, 0);
-
- return new_surface;
-}
-
Bitmap *SDLZoomBitmap(Bitmap *src_bitmap, int dst_width, int dst_height)
{
Bitmap *dst_bitmap = CreateBitmapStruct();
dst_bitmap->height = dst_height;
// create zoomed temporary surface from source surface
- dst_surface = zoomSurface(src_surface, dst_width, dst_height);
+ dst_surface = SDLZoomSurface(src_surface, dst_width, dst_height);
// create native format destination surface from zoomed temporary surface
SDLSetNativeSurface(&dst_surface);
return;
}
- if (Mix_OpenAudio(DEFAULT_AUDIO_SAMPLE_RATE, MIX_DEFAULT_FORMAT,
- AUDIO_NUM_CHANNELS_STEREO,
+ // set audio sample rate for mixer
+ audio.sample_rate = (setup.audio_sample_rate_44100 ? 44100 : 22050);
+
+ if (Mix_OpenAudio(audio.sample_rate, MIX_DEFAULT_FORMAT, AUDIO_NUM_CHANNELS_STEREO,
setup.system.audio_fragment_size) < 0)
{
Warn("Mix_OpenAudio() failed: %s", SDL_GetError());
SDL_QuitSubSystem(SDL_INIT_AUDIO);
}
+void SDLReopenAudio(void)
+{
+ SDLCloseAudio();
+ SDLOpenAudio();
+}
+
// ============================================================================
// event functions
projects / rocksndiamonds.git / blobdiff