#include "init.h"
#include "game.h"
#include "events.h"
-#include "cartoons.h"
+#include "anim.h"
#include "network.h"
#include "tape.h"
#include "screens.h"
{
{
DOOR_1,
- IMG_DOOR_1_GFX_PART_1,
+ IMG_GFX_DOOR_1_PART_1,
&door_1.part_1
},
{
DOOR_1,
- IMG_DOOR_1_GFX_PART_2,
+ IMG_GFX_DOOR_1_PART_2,
&door_1.part_2
},
{
DOOR_1,
- IMG_DOOR_1_GFX_PART_3,
+ IMG_GFX_DOOR_1_PART_3,
&door_1.part_3
},
{
DOOR_1,
- IMG_DOOR_1_GFX_PART_4,
+ IMG_GFX_DOOR_1_PART_4,
&door_1.part_4
},
{
DOOR_1,
- IMG_DOOR_1_GFX_PART_5,
+ IMG_GFX_DOOR_1_PART_5,
&door_1.part_5
},
{
DOOR_1,
- IMG_DOOR_1_GFX_PART_6,
+ IMG_GFX_DOOR_1_PART_6,
&door_1.part_6
},
{
DOOR_1,
- IMG_DOOR_1_GFX_PART_7,
+ IMG_GFX_DOOR_1_PART_7,
&door_1.part_7
},
{
DOOR_1,
- IMG_DOOR_1_GFX_PART_8,
+ IMG_GFX_DOOR_1_PART_8,
&door_1.part_8
},
{
DOOR_2,
- IMG_DOOR_2_GFX_PART_1,
+ IMG_GFX_DOOR_2_PART_1,
&door_2.part_1
},
{
DOOR_2,
- IMG_DOOR_2_GFX_PART_2,
+ IMG_GFX_DOOR_2_PART_2,
&door_2.part_2
},
{
DOOR_2,
- IMG_DOOR_2_GFX_PART_3,
+ IMG_GFX_DOOR_2_PART_3,
&door_2.part_3
},
{
DOOR_2,
- IMG_DOOR_2_GFX_PART_4,
+ IMG_GFX_DOOR_2_PART_4,
&door_2.part_4
},
{
DOOR_2,
- IMG_DOOR_2_GFX_PART_5,
+ IMG_GFX_DOOR_2_PART_5,
&door_2.part_5
},
{
DOOR_2,
- IMG_DOOR_2_GFX_PART_6,
+ IMG_GFX_DOOR_2_PART_6,
&door_2.part_6
},
{
DOOR_2,
- IMG_DOOR_2_GFX_PART_7,
+ IMG_GFX_DOOR_2_PART_7,
&door_2.part_7
},
{
DOOR_2,
- IMG_DOOR_2_GFX_PART_8,
+ IMG_GFX_DOOR_2_PART_8,
&door_2.part_8
},
static struct GadgetInfo *tool_gadget[NUM_TOOL_BUTTONS];
static int request_gadget_id = -1;
-static unsigned int sync_frame_delay = 0;
-static unsigned int sync_frame_delay_value = GAME_FRAME_DELAY;
-
static char *print_if_not_empty(int element)
{
static char *s = NULL;
void SetDrawtoField(int mode)
{
- if (mode == DRAW_FIELDBUFFER)
+ if (mode == DRAW_TO_FIELDBUFFER)
{
FX = 2 * TILEX_VAR;
FY = 2 * TILEY_VAR;
drawto_field = fieldbuffer;
}
- else /* DRAW_BACKBUFFER */
+ else /* DRAW_TO_BACKBUFFER */
{
FX = SX;
FY = SY;
if (x == -1 && y == -1)
return;
- if (draw_target == DRAW_BORDER_TO_SCREEN)
+ if (draw_target == DRAW_TO_SCREEN)
BlitToScreenMasked(src_bitmap, x, y, width, height, x, y);
else
BlitBitmapMasked(src_bitmap, dst_bitmap, x, y, width, height, x, y);
static void DrawMaskedBorderExt_DOOR_1(int draw_target)
{
// when drawing to backbuffer, never draw border over open doors
- if (draw_target == DRAW_BORDER_TO_BACKBUFFER &&
+ if (draw_target == DRAW_TO_BACKBUFFER &&
(GetDoorState() & DOOR_OPEN_1))
return;
static void DrawMaskedBorderExt_DOOR_2(int draw_target)
{
// when drawing to backbuffer, never draw border over open doors
- if (draw_target == DRAW_BORDER_TO_BACKBUFFER &&
+ if (draw_target == DRAW_TO_BACKBUFFER &&
(GetDoorState() & DOOR_OPEN_2))
return;
void DrawMaskedBorder_FIELD()
{
- DrawMaskedBorderExt_FIELD(DRAW_BORDER_TO_BACKBUFFER);
+ DrawMaskedBorderExt_FIELD(DRAW_TO_BACKBUFFER);
}
void DrawMaskedBorder(int redraw_mask)
{
- DrawMaskedBorderExt(redraw_mask, DRAW_BORDER_TO_BACKBUFFER);
+ DrawMaskedBorderExt(redraw_mask, DRAW_TO_BACKBUFFER);
}
void DrawMaskedBorderToTarget(int draw_target)
{
- if (draw_target == DRAW_BORDER_TO_BACKBUFFER ||
- draw_target == DRAW_BORDER_TO_SCREEN)
+ if (draw_target == DRAW_TO_BACKBUFFER ||
+ draw_target == DRAW_TO_SCREEN)
{
DrawMaskedBorderExt(REDRAW_ALL, draw_target);
}
{
int last_border_status = global.border_status;
- if (draw_target == DRAW_BORDER_TO_FADE_SOURCE)
+ if (draw_target == DRAW_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)
+ else if (draw_target == DRAW_TO_FADE_TARGET)
{
global.border_status = gfx.fade_border_target_status;
gfx.masked_border_bitmap_ptr = gfx.fade_bitmap_target;
}
#endif
+static int unifiedRedrawMask(int mask)
+{
+ if (mask & REDRAW_ALL)
+ return REDRAW_ALL;
+
+ if (mask & REDRAW_FIELD && mask & REDRAW_DOORS)
+ return REDRAW_ALL;
+
+ return mask;
+}
+
+static boolean equalRedrawMasks(int mask_1, int mask_2)
+{
+ return unifiedRedrawMask(mask_1) == unifiedRedrawMask(mask_2);
+}
+
void BackToFront()
{
static int last_redraw_mask = REDRAW_NONE;
if (redraw_mask & REDRAW_FPS)
DrawFramesPerSecond();
+ // remove playfield redraw before potentially merging with doors redraw
+ if (DrawingDeactivated(REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE))
+ redraw_mask &= ~REDRAW_FIELD;
+
// redraw complete window if both playfield and (some) doors need redraw
if (redraw_mask & REDRAW_FIELD && redraw_mask & REDRAW_DOORS)
redraw_mask = REDRAW_ALL;
}
else if (redraw_mask & REDRAW_DOORS)
{
+ // merge door areas to prevent calling screen redraw more than once
+ int x1 = WIN_XSIZE;
+ int y1 = WIN_YSIZE;
+ int x2 = 0;
+ int y2 = 0;
+
if (redraw_mask & REDRAW_DOOR_1)
- BlitBitmap(backbuffer, window, DX, DY, DXSIZE, DYSIZE, DX, DY);
+ {
+ x1 = MIN(x1, DX);
+ y1 = MIN(y1, DY);
+ x2 = MAX(x2, DX + DXSIZE);
+ y2 = MAX(y2, DY + DYSIZE);
+ }
if (redraw_mask & REDRAW_DOOR_2)
- BlitBitmap(backbuffer, window, VX, VY, VXSIZE, VYSIZE, VX, VY);
+ {
+ x1 = MIN(x1, VX);
+ y1 = MIN(y1, VY);
+ x2 = MAX(x2, VX + VXSIZE);
+ y2 = MAX(y2, VY + VYSIZE);
+ }
if (redraw_mask & REDRAW_DOOR_3)
- BlitBitmap(backbuffer, window, EX, EY, EXSIZE, EYSIZE, EX, EY);
+ {
+ x1 = MIN(x1, EX);
+ y1 = MIN(y1, EY);
+ x2 = MAX(x2, EX + EXSIZE);
+ y2 = MAX(y2, EY + EYSIZE);
+ }
+
+ BlitBitmap(backbuffer, window, x1, y1, x2 - x1, y2 - y1, x1, y1);
}
redraw_mask = REDRAW_NONE;
#endif
}
-static void FadeCrossSaveBackbuffer()
+void BackToFront_WithFrameDelay(unsigned int frame_delay_value)
{
- BlitBitmap(backbuffer, bitmap_db_cross, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
-}
+ unsigned int frame_delay_value_old = GetVideoFrameDelay();
-static void FadeCrossRestoreBackbuffer()
-{
- int redraw_mask_last = redraw_mask;
+ SetVideoFrameDelay(frame_delay_value);
- BlitBitmap(bitmap_db_cross, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
+ BackToFront();
- // do not change redraw mask when restoring backbuffer after cross-fading
- redraw_mask = redraw_mask_last;
+ SetVideoFrameDelay(frame_delay_value_old);
}
+static int fade_type_skip = FADE_TYPE_NONE;
+
static void FadeExt(int fade_mask, int fade_mode, int fade_type)
{
- static int fade_type_skip = FADE_TYPE_NONE;
void (*draw_border_function)(void) = NULL;
- Bitmap *bitmap = (fade_mode & FADE_TYPE_TRANSFORM ? bitmap_db_cross : NULL);
int x, y, width, height;
int fade_delay, post_delay;
return;
}
-#if 1
- FadeCrossSaveBackbuffer();
-#endif
-
if (fading.fade_mode & FADE_TYPE_TRANSFORM)
- {
-#if 0
- FadeCrossSaveBackbuffer();
-#endif
-
return;
- }
}
redraw_mask |= fade_mask;
return;
}
- FadeRectangle(bitmap, x, y, width, height, fade_mode, fade_delay, post_delay,
+ FadeRectangle(x, y, width, height, fade_mode, fade_delay, post_delay,
draw_border_function);
- if (fade_type == FADE_TYPE_FADE_OUT)
- FadeCrossRestoreBackbuffer();
-
redraw_mask &= ~fade_mask;
}
static void SetScreenStates_BeforeFadingIn()
{
+ // temporarily set screen mode for animations to screen after fading in
+ global.anim_status = global.anim_status_next;
+
+ // store backbuffer with all animations that will be started after fading in
+ if (fade_type_skip != FADE_MODE_SKIP_FADE_IN)
+ PrepareFadeBitmap(DRAW_TO_FADE_TARGET);
+
+ // set screen mode for animations back to fading
+ global.anim_status = GAME_MODE_PSEUDO_FADING;
}
static void SetScreenStates_AfterFadingIn()
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
- redraw_mask = REDRAW_ALL;
- BackToFront();
}
static void SetScreenStates_BeforeFadingOut()
// store new target screen (to use correct masked border for fading)
gfx.fade_border_target_status = game_status;
+ // set screen mode for animations to fading
global.anim_status = GAME_MODE_PSEUDO_FADING;
+
+ // store backbuffer with all animations that will be stopped for fading out
+ if (fade_type_skip != FADE_MODE_SKIP_FADE_OUT)
+ PrepareFadeBitmap(DRAW_TO_FADE_SOURCE);
}
static void SetScreenStates_AfterFadingOut()
FADE_SYSIZE = FULL_SYSIZE;
SetScreenStates_AfterFadingIn();
+
+ // force update of global animation status in case of rapid screen changes
+ redraw_mask = REDRAW_ALL;
+ BackToFront();
}
void FadeOut(int fade_mask)
{
+ // update screen if areas covered by "fade_mask" and "redraw_mask" differ
+ if (!equalRedrawMasks(fade_mask, redraw_mask))
+ BackToFront();
+
SetScreenStates_BeforeFadingOut();
#if 0
// copy current draw buffer to later copy back areas that have not changed
if (game_status_last != GAME_MODE_TITLE)
- BlitBitmap(backbuffer, bitmap_db_store, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
+ BlitBitmap(backbuffer, bitmap_db_store_1, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
if (CheckIfGlobalBorderRedrawIsNeeded())
{
if (real_sx_last != -1 && real_sy_last != -1 &&
REAL_SX != -1 && REAL_SY != -1 &&
full_sxsize_last == FULL_SXSIZE && full_sysize_last == FULL_SYSIZE)
- BlitBitmap(bitmap_db_store, backbuffer,
+ BlitBitmap(bitmap_db_store_1, backbuffer,
real_sx_last, real_sy_last, FULL_SXSIZE, FULL_SYSIZE,
REAL_SX, REAL_SY);
if (dx_last != -1 && dy_last != -1 &&
DX != -1 && DY != -1 &&
dxsize_last == DXSIZE && dysize_last == DYSIZE)
- BlitBitmap(bitmap_db_store, backbuffer,
+ BlitBitmap(bitmap_db_store_1, backbuffer,
dx_last, dy_last, DXSIZE, DYSIZE, DX, DY);
if (vx_last != -1 && vy_last != -1 &&
VX != -1 && VY != -1 &&
vxsize_last == VXSIZE && vysize_last == VYSIZE)
- BlitBitmap(bitmap_db_store, backbuffer,
+ BlitBitmap(bitmap_db_store_1, backbuffer,
vx_last, vy_last, VXSIZE, VYSIZE, VX, VY);
redraw_mask = REDRAW_ALL;
if (game_status == GAME_MODE_PLAYING)
{
ClearRectangle(fieldbuffer, 0, 0, FXSIZE, FYSIZE);
- SetDrawtoField(DRAW_FIELDBUFFER);
+ SetDrawtoField(DRAW_TO_FIELDBUFFER);
}
else
{
- SetDrawtoField(DRAW_BACKBUFFER);
+ SetDrawtoField(DRAW_TO_BACKBUFFER);
}
}
int sy = SY + (SYSIZE - ysize * font_height) / 2;
int xx, yy;
- SetDrawtoField(DRAW_FIELDBUFFER);
+ SetDrawtoField(DRAW_TO_FIELDBUFFER);
BlitScreenToBitmap(backbuffer);
- SetDrawtoField(DRAW_BACKBUFFER);
+ SetDrawtoField(DRAW_TO_BACKBUFFER);
for (yy = 0; yy < ysize; yy++)
for (xx = 0; xx < xsize; xx++)
game.envelope_active = FALSE;
- SetDrawtoField(DRAW_FIELDBUFFER);
+ SetDrawtoField(DRAW_TO_FIELDBUFFER);
redraw_mask |= REDRAW_FIELD;
BackToFront();
RedrawGadget(tool_gadget[i]);
// store readily prepared envelope request for later use when animating
- BlitBitmap(backbuffer, bitmap_db_cross, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
+ BlitBitmap(backbuffer, bitmap_db_store_2, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
if (text_door_style)
free(text_door_style);
setRequestPosition(&src_x, &src_y, FALSE);
setRequestPositionExt(&dst_x, &dst_y, width, height, FALSE);
- BlitBitmap(bitmap_db_store, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
+ BlitBitmap(bitmap_db_store_1, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
for (yy = 0; yy < 2; yy++)
{
int yy_size = (yy ? tile_size : ysize_size_top);
if (draw_masked)
- BlitBitmapMasked(bitmap_db_cross, backbuffer,
+ BlitBitmapMasked(bitmap_db_store_2, backbuffer,
src_xx, src_yy, xx_size, yy_size, dst_xx, dst_yy);
else
- BlitBitmap(bitmap_db_cross, backbuffer,
+ BlitBitmap(bitmap_db_store_2, backbuffer,
src_xx, src_yy, xx_size, yy_size, dst_xx, dst_yy);
}
}
redraw_mask |= REDRAW_FIELD;
- DoAnimation();
BackToFront();
SkipUntilDelayReached(&anim_delay, anim_delay_value, &i, last_frame);
if (game_status == GAME_MODE_PLAYING)
BlitScreenToBitmap(backbuffer);
- SetDrawtoField(DRAW_BACKBUFFER);
+ SetDrawtoField(DRAW_TO_BACKBUFFER);
// SetDrawBackgroundMask(REDRAW_NONE);
if (action == ACTION_OPENING)
{
- BlitBitmap(backbuffer, bitmap_db_store, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
+ BlitBitmap(backbuffer, bitmap_db_store_1, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
if (req_state & REQ_ASK)
{
}
DrawEnvelopeRequest(text);
-
- if (game_status != GAME_MODE_MAIN)
- InitAnimation();
}
game.envelope_active = TRUE; /* needed for RedrawPlayfield() events */
game.envelope_active = FALSE;
if (action == ACTION_CLOSING)
- {
- if (game_status != GAME_MODE_MAIN)
- StopAnimation();
-
- BlitBitmap(bitmap_db_store, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
- }
+ BlitBitmap(bitmap_db_store_1, backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
// SetDrawBackgroundMask(last_draw_background_mask);
redraw_mask |= REDRAW_FIELD;
- if (game_status == GAME_MODE_MAIN)
- DoAnimation();
-
BackToFront();
if (action == ACTION_CLOSING &&
game_status == GAME_MODE_PLAYING &&
level.game_engine_type == GAME_ENGINE_TYPE_RND)
- SetDrawtoField(DRAW_FIELDBUFFER);
+ SetDrawtoField(DRAW_TO_FIELDBUFFER);
}
void DrawPreviewElement(int dst_x, int dst_y, int element, int tilesize)
still_wait = FALSE;
}
- DoAnimation();
-
- WaitUntilDelayReached(&sync_frame_delay, sync_frame_delay_value);
+ BackToFront();
}
}
{
if (level_solved)
{
- SetDrawtoField(DRAW_FIELDBUFFER);
+ SetDrawtoField(DRAW_TO_FIELDBUFFER);
HandleGameActions();
- SetDrawtoField(DRAW_BACKBUFFER);
+ SetDrawtoField(DRAW_TO_BACKBUFFER);
if (global.use_envelope_request)
{
/* copy current state of request area to middle of playfield area */
- BlitBitmap(bitmap_db_cross, drawto, sx, sy, width, height, sx, sy);
+ BlitBitmap(bitmap_db_store_2, drawto, sx, sy, width, height, sx, sy);
}
}
if (global.use_envelope_request)
{
/* copy back current state of pressed buttons inside request area */
- BlitBitmap(drawto, bitmap_db_cross, sx, sy, width, height, sx, sy);
+ BlitBitmap(drawto, bitmap_db_store_2, sx, sy, width, height, sx, sy);
}
}
- else
- {
- DoAnimation();
- }
BackToFront();
-
- WaitUntilDelayReached(&sync_frame_delay, sync_frame_delay_value);
}
return result;
return FALSE;
}
- if (game_status != GAME_MODE_MAIN)
- InitAnimation();
-
SetDrawBackgroundMask(REDRAW_FIELD | REDRAW_DOOR_1);
// ---------- handle request buttons ----------
result = RequestHandleEvents(req_state);
- if (game_status != GAME_MODE_MAIN)
- StopAnimation();
-
UnmapToolButtons();
if (!(req_state & REQ_STAY_OPEN))
// ---------- handle request buttons ----------
result = RequestHandleEvents(req_state);
- if (game_status != GAME_MODE_MAIN)
- StopAnimation();
-
UnmapToolButtons();
ShowEnvelopeRequest(text, req_state, ACTION_CLOSING);
}
doors[] =
{
- { DOOR_1, IMG_DOOR_1_GFX_PART_1, IMG_DOOR_1_GFX_PART_8, &door_1 },
- { DOOR_2, IMG_DOOR_2_GFX_PART_1, IMG_DOOR_2_GFX_PART_8, &door_2 },
+ { DOOR_1, IMG_GFX_DOOR_1_PART_1, IMG_GFX_DOOR_1_PART_8, &door_1 },
+ { DOOR_2, IMG_GFX_DOOR_2_PART_1, IMG_GFX_DOOR_2_PART_8, &door_2 },
{ -1, -1, -1, NULL }
};
{
BackToFront();
- if (game_status == GAME_MODE_MAIN)
- DoAnimation();
-
SkipUntilDelayReached(&door_delay, door_delay_value, &k, last_frame);
current_move_delay += max_step_delay;
} toolbutton_info[NUM_TOOL_BUTTONS] =
{
{
- IMG_REQUEST_BUTTON_GFX_YES, &request.button.yes,
+ IMG_GFX_REQUEST_BUTTON_YES, &request.button.yes,
TOOL_CTRL_ID_YES, "yes"
},
{
- IMG_REQUEST_BUTTON_GFX_NO, &request.button.no,
+ IMG_GFX_REQUEST_BUTTON_NO, &request.button.no,
TOOL_CTRL_ID_NO, "no"
},
{
- IMG_REQUEST_BUTTON_GFX_CONFIRM, &request.button.confirm,
+ IMG_GFX_REQUEST_BUTTON_CONFIRM, &request.button.confirm,
TOOL_CTRL_ID_CONFIRM, "confirm"
},
{
- IMG_REQUEST_BUTTON_GFX_PLAYER_1, &request.button.player_1,
+ IMG_GFX_REQUEST_BUTTON_PLAYER_1, &request.button.player_1,
TOOL_CTRL_ID_PLAYER_1, "player 1"
},
{
- IMG_REQUEST_BUTTON_GFX_PLAYER_2, &request.button.player_2,
+ IMG_GFX_REQUEST_BUTTON_PLAYER_2, &request.button.player_2,
TOOL_CTRL_ID_PLAYER_2, "player 2"
},
{
- IMG_REQUEST_BUTTON_GFX_PLAYER_3, &request.button.player_3,
+ IMG_GFX_REQUEST_BUTTON_PLAYER_3, &request.button.player_3,
TOOL_CTRL_ID_PLAYER_3, "player 3"
},
{
- IMG_REQUEST_BUTTON_GFX_PLAYER_4, &request.button.player_4,
+ IMG_GFX_REQUEST_BUTTON_PLAYER_4, &request.button.player_4,
TOOL_CTRL_ID_PLAYER_4, "player 4"
}
};
void SetAnimStatus(int anim_status_new)
{
+ if (anim_status_new == GAME_MODE_MAIN)
+ anim_status_new = GAME_MODE_PSEUDO_MAINONLY;
+
global.anim_status_next = anim_status_new;
+
+ // directly set screen modes that are entered without fading
+ if ((global.anim_status == GAME_MODE_PSEUDO_MAINONLY &&
+ global.anim_status_next == GAME_MODE_PSEUDO_TYPENAME) ||
+ (global.anim_status == GAME_MODE_PSEUDO_TYPENAME &&
+ global.anim_status_next == GAME_MODE_PSEUDO_MAINONLY))
+ global.anim_status = global.anim_status_next;
}
void SetGameStatus(int game_status_new)
int new_scr_fieldy_buffers = new_sysize / new_tilesize_var;
boolean init_gfx_buffers = FALSE;
boolean init_video_buffer = FALSE;
- boolean init_gadgets_and_toons = FALSE;
+ boolean init_gadgets_and_anims = FALSE;
boolean init_em_graphics = FALSE;
if (new_win_xsize != WIN_XSIZE ||
init_video_buffer = TRUE;
init_gfx_buffers = TRUE;
- init_gadgets_and_toons = TRUE;
+ init_gadgets_and_anims = TRUE;
// printf("::: video: init_video_buffer, init_gfx_buffers\n");
}
TILESIZE_VAR = new_tilesize_var;
init_gfx_buffers = TRUE;
- init_gadgets_and_toons = TRUE;
+ init_gadgets_and_anims = TRUE;
// printf("::: viewports: init_gfx_buffers\n");
- // printf("::: viewports: init_gadgets_and_toons\n");
+ // printf("::: viewports: init_gadgets_and_anims\n");
}
if (init_gfx_buffers)
InitImageTextures();
}
- if (init_gadgets_and_toons)
+ if (init_gadgets_and_anims)
{
- // printf("::: init_gadgets_and_toons\n");
+ // printf("::: init_gadgets_and_anims\n");
InitGadgets();
- InitToons();
InitGlobalAnimations();
}