}
static void DrawMaskedBorderExt_Rect(int x, int y, int width, int height,
- boolean blit_to_screen)
+ int draw_target)
{
- Bitmap *bitmap = getGlobalBorderBitmapFromGameStatus();
+ Bitmap *src_bitmap = getGlobalBorderBitmapFromStatus(global.border_status);
+ Bitmap *dst_bitmap = gfx.masked_border_bitmap_ptr;
if (x == -1 && y == -1)
return;
- if (blit_to_screen)
- BlitToScreenMasked(bitmap, x, y, width, height, x, y);
+ if (draw_target == DRAW_BORDER_TO_SCREEN)
+ BlitToScreenMasked(src_bitmap, x, y, width, height, x, y);
else
- BlitBitmapMasked(bitmap, backbuffer, x, y, width, height, x, y);
+ BlitBitmapMasked(src_bitmap, dst_bitmap, x, y, width, height, x, y);
}
-static void DrawMaskedBorderExt_FIELD(boolean blit_to_screen)
+static void DrawMaskedBorderExt_FIELD(int draw_target)
{
- if (global.border_status >= GAME_MODE_TITLE &&
+ if (global.border_status >= GAME_MODE_MAIN &&
global.border_status <= GAME_MODE_PLAYING &&
border.draw_masked[global.border_status])
DrawMaskedBorderExt_Rect(REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE,
- blit_to_screen);
+ draw_target);
}
-static void DrawMaskedBorderExt_DOOR_1(boolean blit_to_screen)
+static void DrawMaskedBorderExt_DOOR_1(int draw_target)
{
- // only draw border over closed doors when drawing to backbuffer
- if (!blit_to_screen && (GetDoorState() & DOOR_OPEN_1))
+ // when drawing to backbuffer, never draw border over open doors
+ if (draw_target == DRAW_BORDER_TO_BACKBUFFER &&
+ (GetDoorState() & DOOR_OPEN_1))
return;
if (border.draw_masked[GFX_SPECIAL_ARG_DOOR] &&
(global.border_status != GAME_MODE_EDITOR ||
border.draw_masked[GFX_SPECIAL_ARG_EDITOR]))
- DrawMaskedBorderExt_Rect(DX, DY, DXSIZE, DYSIZE, blit_to_screen);
+ DrawMaskedBorderExt_Rect(DX, DY, DXSIZE, DYSIZE, draw_target);
}
-static void DrawMaskedBorderExt_DOOR_2(boolean blit_to_screen)
+static void DrawMaskedBorderExt_DOOR_2(int draw_target)
{
- // only draw border over closed doors when drawing to backbuffer
- if (!blit_to_screen && (GetDoorState() & DOOR_OPEN_2))
+ // when drawing to backbuffer, never draw border over open doors
+ if (draw_target == DRAW_BORDER_TO_BACKBUFFER &&
+ (GetDoorState() & DOOR_OPEN_2))
return;
if (border.draw_masked[GFX_SPECIAL_ARG_DOOR] &&
global.border_status != GAME_MODE_EDITOR)
- DrawMaskedBorderExt_Rect(VX, VY, VXSIZE, VYSIZE, blit_to_screen);
+ DrawMaskedBorderExt_Rect(VX, VY, VXSIZE, VYSIZE, draw_target);
}
-static void DrawMaskedBorderExt_DOOR_3(boolean blit_to_screen)
+static void DrawMaskedBorderExt_DOOR_3(int draw_target)
{
/* currently not available */
}
-static void DrawMaskedBorderExt_ALL(boolean blit_to_screen)
+static void DrawMaskedBorderExt_ALL(int draw_target)
{
- DrawMaskedBorderExt_FIELD(blit_to_screen);
- DrawMaskedBorderExt_DOOR_1(blit_to_screen);
- DrawMaskedBorderExt_DOOR_2(blit_to_screen);
- DrawMaskedBorderExt_DOOR_3(blit_to_screen);
+ DrawMaskedBorderExt_FIELD(draw_target);
+ DrawMaskedBorderExt_DOOR_1(draw_target);
+ DrawMaskedBorderExt_DOOR_2(draw_target);
+ DrawMaskedBorderExt_DOOR_3(draw_target);
}
-static void DrawMaskedBorderExt(int redraw_mask, boolean blit_to_screen)
+static void DrawMaskedBorderExt(int redraw_mask, int draw_target)
{
/* never draw masked screen borders on borderless screens */
- if (game_status == GAME_MODE_LOADING ||
- game_status == GAME_MODE_TITLE)
+ if (global.border_status == GAME_MODE_LOADING ||
+ global.border_status == GAME_MODE_TITLE)
return;
if (redraw_mask & REDRAW_ALL)
- DrawMaskedBorderExt_ALL(blit_to_screen);
+ DrawMaskedBorderExt_ALL(draw_target);
else
{
if (redraw_mask & REDRAW_FIELD)
- DrawMaskedBorderExt_FIELD(blit_to_screen);
+ DrawMaskedBorderExt_FIELD(draw_target);
if (redraw_mask & REDRAW_DOOR_1)
- DrawMaskedBorderExt_DOOR_1(blit_to_screen);
+ DrawMaskedBorderExt_DOOR_1(draw_target);
if (redraw_mask & REDRAW_DOOR_2)
- DrawMaskedBorderExt_DOOR_2(blit_to_screen);
+ DrawMaskedBorderExt_DOOR_2(draw_target);
if (redraw_mask & REDRAW_DOOR_3)
- DrawMaskedBorderExt_DOOR_3(blit_to_screen);
+ DrawMaskedBorderExt_DOOR_3(draw_target);
}
}
void DrawMaskedBorder_FIELD()
{
- DrawMaskedBorderExt_FIELD(FALSE);
+ DrawMaskedBorderExt_FIELD(DRAW_BORDER_TO_BACKBUFFER);
}
void DrawMaskedBorder(int redraw_mask)
{
- DrawMaskedBorderExt(redraw_mask, FALSE);
+ DrawMaskedBorderExt(redraw_mask, DRAW_BORDER_TO_BACKBUFFER);
}
-void DrawMaskedBorderToScreen(int redraw_mask)
+void DrawMaskedBorderToTarget(int draw_target)
{
- DrawMaskedBorderExt(redraw_mask, TRUE);
+ if (draw_target == DRAW_BORDER_TO_BACKBUFFER ||
+ draw_target == DRAW_BORDER_TO_SCREEN)
+ {
+ DrawMaskedBorderExt(REDRAW_ALL, draw_target);
+ }
+ else
+ {
+ int last_border_status = global.border_status;
+
+ if (draw_target == DRAW_BORDER_TO_FADE_SOURCE)
+ {
+ global.border_status = gfx.fade_border_source_status;
+ gfx.masked_border_bitmap_ptr = gfx.fade_bitmap_source;
+ }
+ else if (draw_target == DRAW_BORDER_TO_FADE_TARGET)
+ {
+ global.border_status = gfx.fade_border_target_status;
+ gfx.masked_border_bitmap_ptr = gfx.fade_bitmap_target;
+ }
+
+ DrawMaskedBorderExt(REDRAW_ALL, draw_target);
+
+ global.border_status = last_border_status;
+ gfx.masked_border_bitmap_ptr = backbuffer;
+ }
}
void BlitScreenToBitmap_RND(Bitmap *target_bitmap)
void BackToFront()
{
+ static int last_redraw_mask = REDRAW_NONE;
+
+ // force screen redraw in every frame to continue drawing global animations
+ // (but always use the last redraw mask to prevent unwanted side effects)
if (redraw_mask == REDRAW_NONE)
- return;
+ redraw_mask = last_redraw_mask;
+
+ last_redraw_mask = redraw_mask;
#if 1
// masked border now drawn immediately when blitting backbuffer to window
redraw_mask = REDRAW_NONE;
- // force screen redraw in every frame to continue drawing global animations
- redraw_mask = REDRAW_FIELD;
-
#if DEBUG_FRAME_TIME
PrintFrameTimeDebugging();
#endif
redraw_mask &= ~fade_mask;
}
-static void SetAnimStatus_BeforeFadingOut()
+static void SetScreenStates_BeforeFadingIn()
{
- global.anim_status = GAME_MODE_PSEUDO_FADING;
}
-static void SetAnimStatus_AfterFadingIn()
+static void SetScreenStates_AfterFadingIn()
{
+ // store new source screen (to use correct masked border for fading)
+ gfx.fade_border_source_status = global.border_status;
+
global.anim_status = global.anim_status_next;
// force update of global animation status in case of rapid screen changes
BackToFront();
}
+static void SetScreenStates_BeforeFadingOut()
+{
+ // store new target screen (to use correct masked border for fading)
+ gfx.fade_border_target_status = game_status;
+
+ global.anim_status = GAME_MODE_PSEUDO_FADING;
+}
+
+static void SetScreenStates_AfterFadingOut()
+{
+ global.border_status = game_status;
+}
+
void FadeIn(int fade_mask)
{
+ SetScreenStates_BeforeFadingIn();
+
#if 1
DrawMaskedBorder(REDRAW_ALL);
#endif
FADE_SXSIZE = FULL_SXSIZE;
FADE_SYSIZE = FULL_SYSIZE;
- SetAnimStatus_AfterFadingIn();
+ SetScreenStates_AfterFadingIn();
}
void FadeOut(int fade_mask)
{
- SetAnimStatus_BeforeFadingOut();
+ SetScreenStates_BeforeFadingOut();
#if 0
DrawMaskedBorder(REDRAW_ALL);
else
FadeExt(fade_mask, FADE_MODE_FADE_OUT, FADE_TYPE_FADE_OUT);
- global.border_status = game_status;
+ SetScreenStates_AfterFadingOut();
}
static void FadeSetLeaveNext(struct TitleFadingInfo fading_leave, boolean set)
return getBitmapFromGraphicOrDefault(graphic, IMG_GLOBAL_BORDER);
}
-Bitmap *getGlobalBorderBitmapFromGameStatus()
+Bitmap *getGlobalBorderBitmapFromStatus(int status)
{
int graphic =
- (game_status == GAME_MODE_MAIN ||
- game_status == GAME_MODE_PSEUDO_TYPENAME ? IMG_GLOBAL_BORDER_MAIN :
- game_status == GAME_MODE_SCORES ? IMG_GLOBAL_BORDER_SCORES :
- game_status == GAME_MODE_EDITOR ? IMG_GLOBAL_BORDER_EDITOR :
- game_status == GAME_MODE_PLAYING ? IMG_GLOBAL_BORDER_PLAYING :
+ (status == GAME_MODE_MAIN ||
+ status == GAME_MODE_PSEUDO_TYPENAME ? IMG_GLOBAL_BORDER_MAIN :
+ status == GAME_MODE_SCORES ? IMG_GLOBAL_BORDER_SCORES :
+ status == GAME_MODE_EDITOR ? IMG_GLOBAL_BORDER_EDITOR :
+ status == GAME_MODE_PLAYING ? IMG_GLOBAL_BORDER_PLAYING :
IMG_GLOBAL_BORDER);
return getGlobalBorderBitmap(graphic);
return FALSE;
// determine and store new global border bitmap for current game status
- global_border_bitmap = getGlobalBorderBitmapFromGameStatus();
+ global_border_bitmap = getGlobalBorderBitmapFromStatus(game_status);
return (global_border_bitmap_last != global_border_bitmap);
}
void RedrawGlobalBorder()
{
- Bitmap *bitmap = getGlobalBorderBitmapFromGameStatus();
+ Bitmap *bitmap = getGlobalBorderBitmapFromStatus(game_status);
RedrawGlobalBorderFromBitmap(bitmap);
{
boolean change_fullscreen = (setup.fullscreen !=
video.fullscreen_enabled);
- boolean change_fullscreen_mode = (video.fullscreen_enabled &&
- !strEqual(setup.fullscreen_mode,
- video.fullscreen_mode_current));
boolean change_window_scaling_percent = (!video.fullscreen_enabled &&
setup.window_scaling_percent !=
video.window_scaling_percent);
#endif
if (change_fullscreen ||
- change_fullscreen_mode ||
change_window_scaling_percent)
{
Bitmap *tmp_backbuffer = CreateBitmap(WIN_XSIZE, WIN_YSIZE, DEFAULT_DEPTH);
/* save backbuffer content which gets lost when toggling fullscreen mode */
BlitBitmap(backbuffer, tmp_backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
- if (change_fullscreen_mode)
- {
- /* keep fullscreen, but change fullscreen mode (screen resolution) */
- video.fullscreen_enabled = FALSE; /* force new fullscreen mode */
- }
-
if (change_window_scaling_percent)
{
/* keep window mode, but change window scaling */