void render_screen(short ticks_elapsed)
{
// Make whatever changes are necessary to the world_view structure based on whichever player is frontmost
world_view->ticks_elapsed = ticks_elapsed;
world_view->tick_count = dynamic_world->tick_count;
world_view->yaw = current_player->facing;
world_view->pitch = current_player->elevation;
world_view->maximum_depth_intensity = current_player->weapon_intensity;
world_view->shading_mode = current_player->infravision_duration ? _shading_infravision : _shading_normal;
// Suppress the overhead map if desired
if (PLAYER_HAS_MAP_OPEN(current_player) && View_MapActive()) {
if (!world_view->overhead_map_active)
set_overhead_map_status(true);
} else {
if (world_view->overhead_map_active)
set_overhead_map_status(false);
}
if(player_in_terminal_mode(current_player_index)) {
if (!world_view->terminal_mode_active)
set_terminal_status(true);
} else {
if (world_view->terminal_mode_active)
set_terminal_status(false);
}
// Set rendering-window bounds for the current sort of display to render
screen_mode_data *mode = &screen_mode;
bool HighResolution;
SDL_Rect ScreenRect = {0, 0, main_surface->w, main_surface->h};
int msize = mode->size;
assert(msize >= 0 && msize < NUMBER_OF_VIEW_SIZES);
const ViewSizeData &VS = ViewSizes[msize];
// Rectangle where the view is to go (must not overlap the HUD)
int OverallWidth = VS.OverallWidth;
#ifdef PSP
int OverallHeight = VS.OverallHeight - (TEST_FLAG(VS.flags, _view_show_HUD) ? 240 : 0);
#else
int OverallHeight = VS.OverallHeight - (TEST_FLAG(VS.flags, _view_show_HUD) ? 160 : 0);
#endif
int BufferWidth, BufferHeight;
// Offsets for placement in the screen
int ScreenOffsetWidth = ((ScreenRect.w - VS.OverallWidth) / 2) + ScreenRect.x;
int ScreenOffsetHeight = ((ScreenRect.h - VS.OverallHeight) / 2) + ScreenRect.y;
// HUD location
#ifdef PSP
int HUD_Offset = 0;
SDL_Rect HUD_DestRect = {ScreenOffsetWidth, OverallHeight + ScreenOffsetHeight, 480, 120};
#else
int HUD_Offset = (OverallWidth - 640) / 2;
SDL_Rect HUD_DestRect = {HUD_Offset + ScreenOffsetWidth, OverallHeight + ScreenOffsetHeight, 640, 160};
#endif
bool ChangedSize = false;
// Switching fullscreen mode requires much the same reinitialization as switching the screen size
if (mode->fullscreen != PrevFullscreen) {
PrevFullscreen = mode->fullscreen;
ChangedSize = true;
}
// Each kind of display needs its own size
if (world_view->terminal_mode_active) {
// Standard terminal size
#ifdef PSP
// MK: We need to scale the terminal
// to the PSP's max size
BufferWidth = 480;
BufferHeight = 272;
#else
BufferWidth = 640;
BufferHeight = 320;
#endif
HighResolution = true;
} else if (world_view->overhead_map_active) {
// Fill the available space
BufferWidth = OverallWidth;
BufferHeight = OverallHeight;
HighResolution = true;
} else {
BufferWidth = VS.MainWidth;
BufferHeight = VS.MainHeight;
HighResolution = mode->high_resolution;
}
if (BufferWidth != PrevBufferWidth) {
ChangedSize = true;
PrevBufferWidth = BufferWidth;
}
if (BufferHeight != PrevBufferHeight) {
ChangedSize = true;
PrevBufferHeight = BufferHeight;
}
// Do the buffer/viewport rectangle setup:
// First, the destination rectangle (viewport to be drawn in)
int OffsetWidth = (OverallWidth - BufferWidth) / 2;
int OffsetHeight = (OverallHeight - BufferHeight) / 2;
SDL_Rect ViewRect = {OffsetWidth + ScreenOffsetWidth, OffsetHeight + ScreenOffsetHeight, BufferWidth, BufferHeight};
if (OffsetWidth != PrevOffsetWidth) {
ChangedSize = true;
PrevOffsetWidth = OffsetWidth;
}
if (OffsetHeight != PrevOffsetHeight) {
ChangedSize = true;
PrevOffsetHeight = OffsetHeight;
}
// Now the buffer rectangle; be sure to shrink it as appropriate
if (!HighResolution && screen_mode.acceleration == _no_acceleration) {
BufferWidth >>= 1;
BufferHeight >>= 1;
}
uint32 parse_keymap(void)
{
uint32 flags = 0;
if(get_keyboard_controller_status())
{
Uint8 *key_map;
if (Console::instance()->input_active()) {
static Uint8 chat_input_mode_keymap[SDLK_LAST];
memset(&chat_input_mode_keymap, 0, sizeof(chat_input_mode_keymap));
key_map = chat_input_mode_keymap;
} else {
key_map = SDL_GetKeyState(NULL);
}
// ZZZ: let mouse code simulate keypresses
mouse_buttons_become_keypresses(key_map);
joystick_buttons_become_keypresses(key_map);
// Parse the keymap
key_definition *key = current_key_definitions;
for (unsigned i=0; i<NUMBER_OF_STANDARD_KEY_DEFINITIONS; i++, key++)
if (key_map[key->offset])
flags |= key->action_flag;
// Post-process the keymap
struct special_flag_data *special = special_flags;
for (unsigned i=0; i<NUMBER_OF_SPECIAL_FLAGS; i++, special++) {
if (flags & special->flag) {
switch (special->type) {
case _double_flag:
// If this flag has a double-click flag and has been hit within
// DOUBLE_CLICK_PERSISTENCE (but not at MAXIMUM_FLAG_PERSISTENCE),
// mask on the double-click flag */
if (special->persistence < MAXIMUM_FLAG_PERSISTENCE
&& special->persistence > MAXIMUM_FLAG_PERSISTENCE - DOUBLE_CLICK_PERSISTENCE)
flags |= special->alternate_flag;
break;
case _latched_flag:
// If this flag is latched and still being held down, mask it out
if (special->persistence == MAXIMUM_FLAG_PERSISTENCE)
flags &= ~special->flag;
break;
default:
assert(false);
break;
}
special->persistence = MAXIMUM_FLAG_PERSISTENCE;
} else
special->persistence = FLOOR(special->persistence-1, 0);
}
bool do_interchange =
(local_player->variables.flags & _HEAD_BELOW_MEDIA_BIT) ?
(input_preferences->modifiers & _inputmod_interchange_swim_sink) != 0:
(input_preferences->modifiers & _inputmod_interchange_run_walk) != 0;
// Handle the selected input controller
if (input_preferences->input_device != _keyboard_or_game_pad) {
_fixed delta_yaw, delta_pitch, delta_velocity;
test_mouse(input_preferences->input_device, &flags, &delta_yaw, &delta_pitch, &delta_velocity);
flags = mask_in_absolute_positioning_information(flags, delta_yaw, delta_pitch, delta_velocity);
if (do_interchange)
flags ^= _run_dont_walk;
} else {
int joyflags = process_joystick_axes(flags, heartbeat_count);
if (joyflags != flags) {
flags = joyflags;
} else {
// Modify flags with run/walk and swim/sink if we're using the keyboard
if (do_interchange)
flags ^= _run_dont_walk;
}
}
if (player_in_terminal_mode(local_player_index))
flags = build_terminal_action_flags((char *)key_map);
} // if(get_keyboard_controller_status())
return flags;
}
