src/i_video.c

   1 // Emacs style mode select   -*- C++ -*-
   2 //-----------------------------------------------------------------------------
   3 //
   4 // Copyright(C) 1993-1996 Id Software, Inc.
   5 // Copyright(C) 2005 Simon Howard
   6 //
   7 // This program is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU General Public License
   9 // as published by the Free Software Foundation; either version 2
  10 // of the License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License
  18 // along with this program; if not, write to the Free Software
  19 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  20 // 02111-1307, USA.
  21 //
  22 // DESCRIPTION:
  23 //      DOOM graphics stuff for SDL.
  24 //
  25 //-----------------------------------------------------------------------------
  26
  27
  28 #include "SDL.h"
  29 #include <stdlib.h>
  30 #include <ctype.h>
  31 #include <math.h>
  32
  33 #include "icon.c"
  34
  35 #include "config.h"
  36 #include "deh_main.h"
  37 #include "doomdef.h"
  38 #include "doomstat.h"
  39 #include "d_main.h"
  40 #include "i_joystick.h"
  41 #include "i_system.h"
  42 #include "i_swap.h"
  43 #include "i_timer.h"
  44 #include "i_video.h"
  45 #include "i_scale.h"
  46 #include "m_argv.h"
  47 #include "s_sound.h"
  48 #include "sounds.h"
  49 #include "v_video.h"
  50 #include "w_wad.h"
  51 #include "z_zone.h"
  52
  53 #define LOADING_DISK_W 16
  54 #define LOADING_DISK_H 16
  55
  56 // Non aspect ratio-corrected modes (direct multiples of 320x200)
  57
  58 static screen_mode_t *screen_modes[] = {
  59     &mode_scale_1x,
  60     &mode_scale_2x,
  61     &mode_scale_3x,
  62     &mode_scale_4x,
  63     &mode_scale_5x,
  64 };
  65
  66 // Aspect ratio corrected modes (4:3 ratio)
  67
  68 static screen_mode_t *screen_modes_corrected[] = {
  69
  70     // Vertically stretched modes (320x200 -> 320x240 and multiples)
  71
  72     &mode_stretch_1x,
  73     &mode_stretch_2x,
  74     &mode_stretch_3x,
  75     &mode_stretch_4x,
  76     &mode_stretch_5x,
  77
  78     // Horizontally squashed modes (320x200 -> 256x200 and multiples)
  79
  80     &mode_squash_1x,
  81     &mode_squash_2x,
  82     &mode_squash_3x,
  83     &mode_squash_4x,
  84     &mode_squash_5x,
  85 };
  86
  87 extern void M_QuitDOOM();
  88 extern boolean advancedemo;
  89
  90 // SDL video driver name
  91
  92 char *video_driver = "";
  93
  94 static SDL_Surface *screen;
  95
  96 // palette
  97
  98 static SDL_Color palette[256];
  99 static boolean palette_to_set;
 100
 101 // display has been set up?
 102
 103 static boolean initialized = false;
 104
 105 // disable mouse?
 106
 107 static boolean nomouse = false;
 108 extern int usemouse;
 109
 110 // if true, screens[0] is screen->pixel
 111
 112 static boolean native_surface;
 113
 114 // Screen width and height, from configuration file.
 115
 116 int screen_width = SCREENWIDTH;
 117 int screen_height = SCREENHEIGHT;
 118
 119 // Automatically adjust video settings if the selected mode is
 120 // not a valid video mode.
 121
 122 int autoadjust_video_settings = 1;
 123
 124 // Run in full screen mode?  (int type for config code)
 125
 126 int fullscreen = true;
 127
 128 // Aspect ratio correction mode
 129
 130 int aspect_ratio_correct = true;
 131
 132 // Time to wait for the screen to settle on startup before starting the
 133 // game (ms)
 134
 135 int startup_delay = 1000;
 136
 137 // Grab the mouse? (int type for config code)
 138
 139 int grabmouse = true;
 140
 141 // Flag indicating whether the screen is currently visible:
 142 // when the screen isnt visible, don't render the screen
 143
 144 boolean screenvisible;
 145
 146 // disk image data and background overwritten by the disk to be
 147 // restored by EndRead
 148
 149 static byte *disk_image = NULL;
 150 static byte *saved_background;
 151 static boolean window_focused;
 152
 153 // Empty mouse cursor
 154
 155 static SDL_Cursor *cursors[2];
 156
 157 // The screen mode and scale functions being used
 158
 159 static screen_mode_t *screen_mode;
 160
 161 // Window resize state.
 162
 163 static boolean need_resize = false;
 164 static unsigned int resize_w, resize_h;
 165 static unsigned int last_resize_time;
 166
 167 // If true, keyboard mapping is ignored, like in Vanilla Doom.
 168 // The sensible thing to do is to disable this if you have a non-US
 169 // keyboard.
 170
 171 int vanilla_keyboard_mapping = true;
 172
 173 // Mouse acceleration
 174 //
 175 // This emulates some of the behavior of DOS mouse drivers by increasing
 176 // the speed when the mouse is moved fast.
 177 //
 178 // The mouse input values are input directly to the game, but when
 179 // the values exceed the value of mouse_threshold, they are multiplied
 180 // by mouse_acceleration to increase the speed.
 181
 182 float mouse_acceleration = 2.0;
 183 int mouse_threshold = 10;
 184
 185 static void ApplyWindowResize(unsigned int w, unsigned int h);
 186
 187 static boolean MouseShouldBeGrabbed()
 188 {
 189     // never grab the mouse when in screensaver mode
 190
 191     if (screensaver_mode)
 192         return false;
 193
 194     // if the window doesn't have focus, never grab it
 195
 196     if (!window_focused)
 197         return false;
 198
 199     // always grab the mouse when full screen (dont want to
 200     // see the mouse pointer)
 201
 202     if (fullscreen)
 203         return true;
 204
 205 #ifdef _WIN32_WCE
 206
 207     // On Windows CE, always grab input.  This is because hardware
 208     // button events are only acquired by SDL when the input is grabbed.
 209     // Almost all Windows CE devices should have touch screens anyway,
 210     // so this shouldn't affect mouse grabbing behavior.
 211
 212     return true;
 213
 214 #else
 215
 216     // Don't grab the mouse if mouse input is disabled
 217
 218     if (!usemouse || nomouse)
 219         return false;
 220
 221     // Drone players don't need mouse focus
 222
 223     if (drone)
 224         return false;
 225
 226     // if we specify not to grab the mouse, never grab
 227
 228     if (!grabmouse)
 229         return false;
 230
 231     // when menu is active or game is paused, release the mouse
 232
 233     if (menuactive || paused)
 234         return false;
 235
 236     // only grab mouse when playing levels (but not demos)
 237
 238     return (gamestate == GS_LEVEL) && !demoplayback && !advancedemo;
 239
 240 #endif /* #ifndef _WIN32_WCE */
 241 }
 242
 243 // Update the value of window_focused when we get a focus event
 244 //
 245 // We try to make ourselves be well-behaved: the grab on the mouse
 246 // is removed if we lose focus (such as a popup window appearing),
 247 // and we dont move the mouse around if we aren't focused either.
 248
 249 static void UpdateFocus(void)
 250 {
 251     Uint8 state;
 252
 253     state = SDL_GetAppState();
 254
 255     // We should have input (keyboard) focus and be visible
 256     // (not minimized)
 257
 258     window_focused = (state & SDL_APPINPUTFOCUS) && (state & SDL_APPACTIVE);
 259
 260     // Should the screen be grabbed?
 261
 262     screenvisible = (state & SDL_APPACTIVE) != 0;
 263 }
 264
 265 static void LoadDiskImage(void)
 266 {
 267     patch_t *disk;
 268     char *disk_name;
 269     int y;
 270     int xoffset = SCREENWIDTH - LOADING_DISK_W;
 271     int yoffset = SCREENHEIGHT - LOADING_DISK_H;
 272     char buf[20];
 273
 274     SDL_VideoDriverName(buf, 15);
 275
 276     if (!strcmp(buf, "Quartz"))
 277     {
 278         // MacOS Quartz gives us pageflipped graphics that screw up the
 279         // display when we use the loading disk.  Disable it.
 280         // This is a gross hack.
 281
 282         return;
 283     }
 284
 285     if (M_CheckParm("-cdrom") > 0)
 286         disk_name = DEH_String("STCDROM");
 287     else
 288         disk_name = DEH_String("STDISK");
 289
 290     disk = W_CacheLumpName(disk_name, PU_STATIC);
 291
 292     // Draw the disk to the screen:
 293
 294     V_DrawPatch(SCREENWIDTH - LOADING_DISK_W,
 295                 SCREENHEIGHT - LOADING_DISK_H,
 296                 0, disk);
 297
 298     disk_image = Z_Malloc(LOADING_DISK_W * LOADING_DISK_H, PU_STATIC, NULL);
 299     saved_background = Z_Malloc(LOADING_DISK_W * LOADING_DISK_H, PU_STATIC, NULL);
 300
 301     for (y=0; y<LOADING_DISK_H; ++y)
 302     {
 303         memcpy(disk_image + LOADING_DISK_W * y,
 304                screens[0] + SCREENWIDTH * (y + yoffset) + xoffset,
 305                LOADING_DISK_W);
 306     }
 307
 308     W_ReleaseLumpName(disk_name);
 309 }
 310
 311 //
 312 // Translates the SDL key
 313 //
 314
 315 static int TranslateKey(SDL_keysym *sym)
 316 {
 317     switch(sym->sym)
 318     {
 319       case SDLK_LEFT:   return KEY_LEFTARROW;
 320       case SDLK_RIGHT:  return KEY_RIGHTARROW;
 321       case SDLK_DOWN:   return KEY_DOWNARROW;
 322       case SDLK_UP:     return KEY_UPARROW;
 323       case SDLK_ESCAPE: return KEY_ESCAPE;
 324       case SDLK_RETURN: return KEY_ENTER;
 325       case SDLK_TAB:    return KEY_TAB;
 326       case SDLK_F1:     return KEY_F1;
 327       case SDLK_F2:     return KEY_F2;
 328       case SDLK_F3:     return KEY_F3;
 329       case SDLK_F4:     return KEY_F4;
 330       case SDLK_F5:     return KEY_F5;
 331       case SDLK_F6:     return KEY_F6;
 332       case SDLK_F7:     return KEY_F7;
 333       case SDLK_F8:     return KEY_F8;
 334       case SDLK_F9:     return KEY_F9;
 335       case SDLK_F10:    return KEY_F10;
 336       case SDLK_F11:    return KEY_F11;
 337       case SDLK_F12:    return KEY_F12;
 338
 339       case SDLK_BACKSPACE: return KEY_BACKSPACE;
 340       case SDLK_DELETE: return KEY_DEL;
 341
 342       case SDLK_PAUSE:  return KEY_PAUSE;
 343
 344 #if !SDL_VERSION_ATLEAST(1, 3, 0)
 345       case SDLK_EQUALS: return KEY_EQUALS;
 346 #endif
 347
 348       case SDLK_MINUS:          return KEY_MINUS;
 349
 350       case SDLK_LSHIFT:
 351       case SDLK_RSHIFT:
 352         return KEY_RSHIFT;
 353
 354       case SDLK_LCTRL:
 355       case SDLK_RCTRL:
 356         return KEY_RCTRL;
 357
 358       case SDLK_LALT:
 359       case SDLK_RALT:
 360 #if !SDL_VERSION_ATLEAST(1, 3, 0)
 361       case SDLK_LMETA:
 362       case SDLK_RMETA:
 363 #endif
 364         return KEY_RALT;
 365
 366       case SDLK_CAPSLOCK: return KEY_CAPSLOCK;
 367       case SDLK_SCROLLOCK: return KEY_SCRLCK;
 368
 369       case SDLK_KP0: return KEYP_0;
 370       case SDLK_KP1: return KEYP_1;
 371       case SDLK_KP2: return KEYP_2;
 372       case SDLK_KP3: return KEYP_3;
 373       case SDLK_KP4: return KEYP_4;
 374       case SDLK_KP5: return KEYP_5;
 375       case SDLK_KP6: return KEYP_6;
 376       case SDLK_KP7: return KEYP_7;
 377       case SDLK_KP8: return KEYP_8;
 378       case SDLK_KP9: return KEYP_9;
 379
 380       case SDLK_KP_PERIOD:   return KEYP_PERIOD;
 381       case SDLK_KP_MULTIPLY: return KEYP_MULTIPLY;
 382       case SDLK_KP_PLUS:     return KEYP_PLUS;
 383       case SDLK_KP_MINUS:    return KEYP_MINUS;
 384       case SDLK_KP_DIVIDE:   return KEYP_DIVIDE;
 385       case SDLK_KP_EQUALS:   return KEYP_EQUALS;
 386       case SDLK_KP_ENTER:    return KEYP_ENTER;
 387
 388       case SDLK_HOME: return KEY_HOME;
 389       case SDLK_INSERT: return KEY_INS;
 390       case SDLK_END: return KEY_END;
 391       case SDLK_PAGEUP: return KEY_PGUP;
 392       case SDLK_PAGEDOWN: return KEY_PGDN;
 393
 394 #ifdef SDL_HAVE_APP_KEYS
 395         case SDLK_APP1:        return KEY_F1;
 396         case SDLK_APP2:        return KEY_F2;
 397         case SDLK_APP3:        return KEY_F3;
 398         case SDLK_APP4:        return KEY_F4;
 399         case SDLK_APP5:        return KEY_F5;
 400         case SDLK_APP6:        return KEY_F6;
 401 #endif
 402
 403       default:
 404         return tolower(sym->sym);
 405     }
 406 }
 407
 408 void I_ShutdownGraphics(void)
 409 {
 410     if (initialized)
 411     {
 412         SDL_SetCursor(cursors[1]);
 413         SDL_ShowCursor(1);
 414         SDL_WM_GrabInput(SDL_GRAB_OFF);
 415
 416         SDL_QuitSubSystem(SDL_INIT_VIDEO);
 417
 418         initialized = false;
 419     }
 420 }
 421
 422
 423
 424 //
 425 // I_StartFrame
 426 //
 427 void I_StartFrame (void)
 428 {
 429     // er?
 430
 431 }
 432
 433 static int MouseButtonState(void)
 434 {
 435     Uint8 state;
 436     int result = 0;
 437
 438 #if SDL_VERSION_ATLEAST(1, 3, 0)
 439     state = SDL_GetMouseState(0, NULL, NULL);
 440 #else
 441     state = SDL_GetMouseState(NULL, NULL);
 442 #endif
 443
 444     // Note: button "0" is left, button "1" is right,
 445     // button "2" is middle for Doom.  This is different
 446     // to how SDL sees things.
 447
 448     if (state & SDL_BUTTON(1))
 449         result |= 1;
 450     if (state & SDL_BUTTON(3))
 451         result |= 2;
 452     if (state & SDL_BUTTON(2))
 453         result |= 4;
 454
 455     return result;
 456 }
 457
 458 static int AccelerateMouse(int val)
 459 {
 460     if (val < 0)
 461         return -AccelerateMouse(-val);
 462
 463     if (val > mouse_threshold)
 464     {
 465         return (int)((val - mouse_threshold) * mouse_acceleration + mouse_threshold);
 466     }
 467     else
 468     {
 469         return val;
 470     }
 471 }
 472
 473 void I_GetEvent(void)
 474 {
 475     SDL_Event sdlevent;
 476     event_t event;
 477
 478     // possibly not needed
 479
 480     SDL_PumpEvents();
 481
 482     // put event-grabbing stuff in here
 483
 484     while (SDL_PollEvent(&sdlevent))
 485     {
 486         // ignore mouse events when the window is not focused
 487
 488         if (!window_focused
 489          && (sdlevent.type == SDL_MOUSEMOTION
 490           || sdlevent.type == SDL_MOUSEBUTTONDOWN
 491           || sdlevent.type == SDL_MOUSEBUTTONUP))
 492         {
 493             continue;
 494         }
 495
 496         if (screensaver_mode && sdlevent.type == SDL_QUIT)
 497         {
 498             I_Quit();
 499         }
 500
 501         // process event
 502
 503         switch (sdlevent.type)
 504         {
 505             case SDL_KEYDOWN:
 506                 event.type = ev_keydown;
 507                 event.data1 = TranslateKey(&sdlevent.key.keysym);
 508
 509                 // If Vanilla keyboard mapping enabled, the keyboard
 510                 // scan code is used to give the character typed.
 511                 // This does not change depending on keyboard layout.
 512                 // If you have a German keyboard, pressing 'z' will
 513                 // give 'y', for example.  It is desirable to be able
 514                 // to fix this so that people with non-standard
 515                 // keyboard mappings can type properly.  If vanilla
 516                 // mode is disabled, use the properly translated
 517                 // version.
 518
 519                 if (vanilla_keyboard_mapping)
 520                 {
 521                     event.data2 = event.data1;
 522                 }
 523                 else
 524                 {
 525                     event.data2 = sdlevent.key.keysym.unicode;
 526                 }
 527
 528                 if (event.data1 != 0)
 529                 {
 530                     D_PostEvent(&event);
 531                 }
 532                 break;
 533
 534             case SDL_KEYUP:
 535                 event.type = ev_keyup;
 536                 event.data1 = TranslateKey(&sdlevent.key.keysym);
 537
 538                 if (event.data1 != 0)
 539                 {
 540                     D_PostEvent(&event);
 541                 }
 542                 break;
 543
 544                 /*
 545             case SDL_MOUSEMOTION:
 546                 event.type = ev_mouse;
 547                 event.data1 = MouseButtonState();
 548                 event.data2 = AccelerateMouse(sdlevent.motion.xrel);
 549                 event.data3 = -AccelerateMouse(sdlevent.motion.yrel);
 550                 D_PostEvent(&event);
 551                 break;
 552                 */
 553
 554             case SDL_MOUSEBUTTONDOWN:
 555                 if (usemouse && !nomouse)
 556                 {
 557                     event.type = ev_mouse;
 558                     event.data1 = MouseButtonState();
 559                     event.data2 = event.data3 = 0;
 560                     D_PostEvent(&event);
 561                 }
 562                 break;
 563
 564             case SDL_MOUSEBUTTONUP:
 565                 if (usemouse && !nomouse)
 566                 {
 567                     event.type = ev_mouse;
 568                     event.data1 = MouseButtonState();
 569                     event.data2 = event.data3 = 0;
 570                     D_PostEvent(&event);
 571                 }
 572                 break;
 573
 574             case SDL_QUIT:
 575                 // bring up the "quit doom?" prompt
 576                 S_StartSound(NULL,sfx_swtchn);
 577                 M_QuitDOOM(0);
 578                 break;
 579
 580             case SDL_ACTIVEEVENT:
 581                 // need to update our focus state
 582                 UpdateFocus();
 583                 break;
 584
 585             case SDL_VIDEOEXPOSE:
 586                 palette_to_set = true;
 587                 break;
 588
 589             case SDL_RESIZABLE:
 590                 need_resize = true;
 591                 resize_w = sdlevent.resize.w;
 592                 resize_h = sdlevent.resize.h;
 593                 last_resize_time = SDL_GetTicks();
 594                 break;
 595
 596             default:
 597                 break;
 598         }
 599     }
 600 }
 601
 602 // Warp the mouse back to the middle of the screen
 603
 604 static void CenterMouse(void)
 605 {
 606     // Warp the the screen center
 607
 608     SDL_WarpMouse(screen->w / 2, screen->h / 2);
 609
 610     // Clear any relative movement caused by warping
 611
 612     SDL_PumpEvents();
 613 #if SDL_VERSION_ATLEAST(1, 3, 0)
 614     SDL_GetRelativeMouseState(0, NULL, NULL);
 615 #else
 616     SDL_GetRelativeMouseState(NULL, NULL);
 617 #endif
 618 }
 619
 620 //
 621 // Read the change in mouse state to generate mouse motion events
 622 //
 623 // This is to combine all mouse movement for a tic into one mouse
 624 // motion event.
 625
 626 static void I_ReadMouse(void)
 627 {
 628     int x, y;
 629     event_t ev;
 630
 631 #if SDL_VERSION_ATLEAST(1, 3, 0)
 632     SDL_GetRelativeMouseState(0, &x, &y);
 633 #else
 634     SDL_GetRelativeMouseState(&x, &y);
 635 #endif
 636
 637     if (x != 0 || y != 0)
 638     {
 639         ev.type = ev_mouse;
 640         ev.data1 = MouseButtonState();
 641         ev.data2 = AccelerateMouse(x);
 642         ev.data3 = -AccelerateMouse(y);
 643
 644         D_PostEvent(&ev);
 645     }
 646
 647     if (MouseShouldBeGrabbed())
 648     {
 649         CenterMouse();
 650     }
 651 }
 652
 653 //
 654 // I_StartTic
 655 //
 656 void I_StartTic (void)
 657 {
 658     if (!initialized)
 659     {
 660         return;
 661     }
 662
 663     I_GetEvent();
 664
 665     if (usemouse && !nomouse)
 666     {
 667         I_ReadMouse();
 668     }
 669
 670     I_UpdateJoystick();
 671 }
 672
 673
 674 //
 675 // I_UpdateNoBlit
 676 //
 677 void I_UpdateNoBlit (void)
 678 {
 679     // what is this?
 680 }
 681
 682 static void UpdateGrab(void)
 683 {
 684     static boolean currently_grabbed = false;
 685     boolean grab;
 686
 687     grab = MouseShouldBeGrabbed();
 688
 689     if (screensaver_mode)
 690     {
 691         // Hide the cursor in screensaver mode
 692
 693         SDL_SetCursor(cursors[0]);
 694     }
 695     else if (grab && !currently_grabbed)
 696     {
 697         SDL_SetCursor(cursors[0]);
 698         SDL_WM_GrabInput(SDL_GRAB_ON);
 699     }
 700     else if (!grab && currently_grabbed)
 701     {
 702         SDL_SetCursor(cursors[1]);
 703         SDL_WM_GrabInput(SDL_GRAB_OFF);
 704     }
 705
 706     currently_grabbed = grab;
 707
 708 }
 709
 710 // Update a small portion of the screen
 711 //
 712 // Does stretching and buffer blitting if neccessary
 713 //
 714 // Return true if blit was successful.
 715
 716 static boolean BlitArea(int x1, int y1, int x2, int y2)
 717 {
 718     int x_offset, y_offset;
 719     boolean result;
 720
 721     // No blit needed on native surface
 722
 723     if (native_surface)
 724     {
 725         return true;
 726     }
 727
 728     x_offset = (screen->w - screen_mode->width) / 2;
 729     y_offset = (screen->h - screen_mode->height) / 2;
 730
 731     if (SDL_LockSurface(screen) >= 0)
 732     {
 733         I_InitScale(screens[0],
 734                     (byte *) screen->pixels + (y_offset * screen->pitch)
 735                                             + x_offset,
 736                     screen->pitch);
 737         result = screen_mode->DrawScreen(x1, y1, x2, y2);
 738         SDL_UnlockSurface(screen);
 739     }
 740     else
 741     {
 742         result = false;
 743     }
 744
 745     return result;
 746 }
 747
 748 static void UpdateRect(int x1, int y1, int x2, int y2)
 749 {
 750     int x1_scaled, x2_scaled, y1_scaled, y2_scaled;
 751
 752     // Do stretching and blitting
 753
 754     if (BlitArea(x1, y1, x2, y2))
 755     {
 756         // Update the area
 757
 758         x1_scaled = (x1 * screen_mode->width) / SCREENWIDTH;
 759         y1_scaled = (y1 * screen_mode->height) / SCREENHEIGHT;
 760         x2_scaled = (x2 * screen_mode->width) / SCREENWIDTH;
 761         y2_scaled = (y2 * screen_mode->height) / SCREENHEIGHT;
 762
 763         SDL_UpdateRect(screen,
 764                        x1_scaled, y1_scaled,
 765                        x2_scaled - x1_scaled,
 766                        y2_scaled - y1_scaled);
 767     }
 768 }
 769
 770 void I_BeginRead(void)
 771 {
 772     byte *screenloc = screens[0]
 773                     + (SCREENHEIGHT - LOADING_DISK_H) * SCREENWIDTH
 774                     + (SCREENWIDTH - LOADING_DISK_W);
 775     int y;
 776
 777     if (!initialized || disk_image == NULL)
 778         return;
 779
 780     // save background and copy the disk image in
 781
 782     for (y=0; y<LOADING_DISK_H; ++y)
 783     {
 784         memcpy(saved_background + y * LOADING_DISK_W,
 785                screenloc,
 786                LOADING_DISK_W);
 787         memcpy(screenloc,
 788                disk_image + y * LOADING_DISK_W,
 789                LOADING_DISK_W);
 790
 791         screenloc += SCREENWIDTH;
 792     }
 793
 794     UpdateRect(SCREENWIDTH - LOADING_DISK_W, SCREENHEIGHT - LOADING_DISK_H,
 795                SCREENWIDTH, SCREENHEIGHT);
 796 }
 797
 798 void I_EndRead(void)
 799 {
 800     byte *screenloc = screens[0]
 801                     + (SCREENHEIGHT - LOADING_DISK_H) * SCREENWIDTH
 802                     + (SCREENWIDTH - LOADING_DISK_W);
 803     int y;
 804
 805     if (!initialized || disk_image == NULL)
 806         return;
 807
 808     // save background and copy the disk image in
 809
 810     for (y=0; y<LOADING_DISK_H; ++y)
 811     {
 812         memcpy(screenloc,
 813                saved_background + y * LOADING_DISK_W,
 814                LOADING_DISK_W);
 815
 816         screenloc += SCREENWIDTH;
 817     }
 818
 819     UpdateRect(SCREENWIDTH - LOADING_DISK_W, SCREENHEIGHT - LOADING_DISK_H,
 820                SCREENWIDTH, SCREENHEIGHT);
 821 }
 822
 823 //
 824 // I_FinishUpdate
 825 //
 826 void I_FinishUpdate (void)
 827 {
 828     static int  lasttic;
 829     int         tics;
 830     int         i;
 831
 832     if (!initialized)
 833         return;
 834
 835     if (noblit)
 836         return;
 837
 838     if (need_resize && SDL_GetTicks() > last_resize_time + 500)
 839     {
 840         ApplyWindowResize(resize_w, resize_h);
 841         need_resize = false;
 842         palette_to_set = true;
 843     }
 844
 845     UpdateGrab();
 846
 847     // Don't update the screen if the window isn't visible.
 848     // Not doing this breaks under Windows when we alt-tab away
 849     // while fullscreen.
 850
 851     if (!(SDL_GetAppState() & SDL_APPACTIVE))
 852         return;
 853
 854     // draws little dots on the bottom of the screen
 855     if (devparm)
 856     {
 857
 858         i = I_GetTime();
 859         tics = i - lasttic;
 860         lasttic = i;
 861         if (tics > 20) tics = 20;
 862
 863         for (i=0 ; i<tics*2 ; i+=4)
 864             screens[0][ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0xff;
 865         for ( ; i<20*4 ; i+=4)
 866             screens[0][ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0x0;
 867
 868     }
 869
 870     // draw to screen
 871
 872     BlitArea(0, 0, SCREENWIDTH, SCREENHEIGHT);
 873
 874     // If we have a palette to set, the act of setting the palette
 875     // updates the screen
 876
 877     if (palette_to_set)
 878     {
 879         SDL_SetColors(screen, palette, 0, 256);
 880         palette_to_set = false;
 881     }
 882     else
 883     {
 884         SDL_Flip(screen);
 885     }
 886 }
 887
 888
 889 //
 890 // I_ReadScreen
 891 //
 892 void I_ReadScreen (byte* scr)
 893 {
 894     memcpy (scr, screens[0], SCREENWIDTH*SCREENHEIGHT);
 895 }
 896
 897
 898 //
 899 // I_SetPalette
 900 //
 901 void I_SetPalette (byte *doompalette)
 902 {
 903     int i;
 904
 905     for (i=0; i<256; ++i)
 906     {
 907         palette[i].r = gammatable[usegamma][*doompalette++];
 908         palette[i].g = gammatable[usegamma][*doompalette++];
 909         palette[i].b = gammatable[usegamma][*doompalette++];
 910     }
 911
 912     palette_to_set = true;
 913 }
 914
 915 //
 916 // Set the window caption
 917 //
 918
 919 void I_SetWindowCaption(void)
 920 {
 921     char *buf;
 922
 923     buf = Z_Malloc(strlen(gamedescription) + strlen(PACKAGE_STRING) + 10,
 924                    PU_STATIC, NULL);
 925     sprintf(buf, "%s - %s", gamedescription, PACKAGE_STRING);
 926
 927     SDL_WM_SetCaption(buf, NULL);
 928
 929     Z_Free(buf);
 930 }
 931
 932 // Set the application icon
 933
 934 void I_SetWindowIcon(void)
 935 {
 936     SDL_Surface *surface;
 937     Uint8 *mask;
 938     int i;
 939
 940     // Generate the mask
 941
 942     mask = malloc(icon_w * icon_h / 8);
 943     memset(mask, 0, icon_w * icon_h / 8);
 944
 945     for (i=0; i<icon_w * icon_h; ++i)
 946     {
 947         if (icon_data[i * 3] != 0x00
 948          || icon_data[i * 3 + 1] != 0x00
 949          || icon_data[i * 3 + 2] != 0x00)
 950         {
 951             mask[i / 8] |= 1 << (7 - i % 8);
 952         }
 953     }
 954
 955     surface = SDL_CreateRGBSurfaceFrom(icon_data,
 956                                        icon_w,
 957                                        icon_h,
 958                                        24,
 959                                        icon_w * 3,
 960                                        0xff << 0,
 961                                        0xff << 8,
 962                                        0xff << 16,
 963                                        0);
 964
 965     SDL_WM_SetIcon(surface, mask);
 966     SDL_FreeSurface(surface);
 967     free(mask);
 968 }
 969
 970 // Pick the modes list to use:
 971
 972 static void GetScreenModes(screen_mode_t ***modes_list, int *num_modes)
 973 {
 974     if (aspect_ratio_correct)
 975     {
 976         *modes_list = screen_modes_corrected;
 977         *num_modes = arrlen(screen_modes_corrected);
 978     }
 979     else
 980     {
 981         *modes_list = screen_modes;
 982         *num_modes = arrlen(screen_modes);
 983     }
 984 }
 985
 986 // Find which screen_mode_t to use for the given width and height.
 987
 988 static screen_mode_t *I_FindScreenMode(int w, int h)
 989 {
 990     screen_mode_t **modes_list;
 991     screen_mode_t *best_mode;
 992     int modes_list_length;
 993     int num_pixels;
 994     int best_num_pixels;
 995     int i;
 996
 997     // Special case: 320x200 and 640x400 are available even if aspect
 998     // ratio correction is turned on.  These modes have non-square
 999     // pixels.
1000
1001     if (fullscreen)
1002     {
1003         if (w == SCREENWIDTH && h == SCREENHEIGHT)
1004         {
1005             return &mode_scale_1x;
1006         }
1007         else if (w == SCREENWIDTH*2 && h == SCREENHEIGHT*2)
1008         {
1009             return &mode_scale_2x;
1010         }
1011     }
1012
1013     GetScreenModes(&modes_list, &modes_list_length);
1014
1015     // Find the biggest screen_mode_t in the list that fits within these
1016     // dimensions
1017
1018     best_mode = NULL;
1019     best_num_pixels = 0;
1020
1021     for (i=0; i<modes_list_length; ++i)
1022     {
1023         // Will this fit within the dimensions? If not, ignore.
1024
1025         if (modes_list[i]->width > w || modes_list[i]->height > h)
1026         {
1027             continue;
1028         }
1029
1030         num_pixels = modes_list[i]->width * modes_list[i]->height;
1031
1032         if (num_pixels > best_num_pixels)
1033         {
1034             // This is a better mode than the current one
1035
1036             best_mode = modes_list[i];
1037             best_num_pixels = num_pixels;
1038         }
1039     }
1040
1041     return best_mode;
1042 }
1043
1044 // Adjust to an appropriate fullscreen mode.
1045 // Returns true if successful.
1046
1047 static boolean AutoAdjustFullscreen(void)
1048 {
1049     SDL_Rect **modes;
1050     SDL_Rect *best_mode;
1051     screen_mode_t *screen_mode;
1052     int target_pixels, diff, best_diff;
1053     int i;
1054
1055     modes = SDL_ListModes(NULL, SDL_FULLSCREEN);
1056
1057     // No fullscreen modes available at all?
1058
1059     if (modes == NULL || modes == (SDL_Rect **) -1 || *modes == NULL)
1060     {
1061         return false;
1062     }
1063
1064     // Find the best mode that matches the mode specified in the
1065     // configuration file
1066
1067     best_mode = NULL;
1068     best_diff = INT_MAX;
1069     target_pixels = screen_width * screen_height;
1070
1071     for (i=0; modes[i] != NULL; ++i)
1072     {
1073         //printf("%ix%i?\n", modes[i]->w, modes[i]->h);
1074
1075         // What screen_mode_t would be used for this video mode?
1076
1077         screen_mode = I_FindScreenMode(modes[i]->w, modes[i]->h);
1078
1079         // Never choose a screen mode that we cannot run in, or
1080         // is poor quality for fullscreen
1081
1082         if (screen_mode == NULL || screen_mode->poor_quality)
1083         {
1084         //    printf("\tUnsupported / poor quality\n");
1085             continue;
1086         }
1087
1088         // Do we have the exact mode?
1089         // If so, no autoadjust needed
1090
1091         if (screen_width == modes[i]->w && screen_height == modes[i]->h)
1092         {
1093         //    printf("\tExact mode!\n");
1094             return true;
1095         }
1096
1097         // Is this mode better than the current mode?
1098
1099         diff = (screen_width - modes[i]->w) * (screen_width - modes[i]->w)
1100              + (screen_height - modes[i]->h) * (screen_height - modes[i]->h);
1101
1102         if (diff < best_diff)
1103         {
1104         //    printf("\tA valid mode\n");
1105             best_mode = modes[i];
1106             best_diff = diff;
1107         }
1108     }
1109
1110     if (best_mode == NULL)
1111     {
1112         // Unable to find a valid mode!
1113
1114         return false;
1115     }
1116
1117     printf("I_InitGraphics: %ix%i mode not supported on this machine.\n",
1118            screen_width, screen_height);
1119
1120     screen_width = best_mode->w;
1121     screen_height = best_mode->h;
1122
1123     return true;
1124 }
1125
1126 // Auto-adjust to a valid windowed mode.
1127
1128 static void AutoAdjustWindowed(void)
1129 {
1130     screen_mode_t *best_mode;
1131
1132     // Find a screen_mode_t to fit within the current settings
1133
1134     best_mode = I_FindScreenMode(screen_width, screen_height);
1135
1136     if (best_mode == NULL)
1137     {
1138         // Nothing fits within the current settings.
1139         // Pick the closest to 320x200 possible.
1140
1141         best_mode = I_FindScreenMode(SCREENWIDTH, SCREENHEIGHT_4_3);
1142     }
1143
1144     // Switch to the best mode if necessary.
1145
1146     if (best_mode->width != screen_width || best_mode->height != screen_height)
1147     {
1148         printf("I_InitGraphics: Cannot run at specified mode: %ix%i\n",
1149                screen_width, screen_height);
1150
1151         screen_width = best_mode->width;
1152         screen_height = best_mode->height;
1153     }
1154 }
1155
1156 // If the video mode set in the configuration file is not available,
1157 // try to choose a different mode.
1158
1159 static void I_AutoAdjustSettings(void)
1160 {
1161     int old_screen_w, old_screen_h;
1162
1163     old_screen_w = screen_width;
1164     old_screen_h = screen_height;
1165
1166     // If we are running fullscreen, try to autoadjust to a valid fullscreen
1167     // mode.  If this is impossible, switch to windowed.
1168
1169     if (fullscreen && !AutoAdjustFullscreen())
1170     {
1171         fullscreen = 0;
1172     }
1173
1174     // If we are running windowed, pick a valid window size.
1175
1176     if (!fullscreen)
1177     {
1178         AutoAdjustWindowed();
1179     }
1180
1181     // Have the settings changed?  Show a message.
1182
1183     if (screen_width != old_screen_w || screen_height != old_screen_h)
1184     {
1185         printf("I_InitGraphics: Auto-adjusted to %ix%i.\n",
1186                screen_width, screen_height);
1187
1188         printf("NOTE: Your video settings have been adjusted.  "
1189                "To disable this behavior,\n"
1190                "set autoadjust_video_settings to 0 in your "
1191                "configuration file.\n");
1192     }
1193 }
1194
1195 // Set video size to a particular scale factor (1x, 2x, 3x, etc.)
1196
1197 static void SetScaleFactor(int factor)
1198 {
1199     if (fullscreen)
1200     {
1201         // In fullscreen, find a mode that will provide this scale factor
1202
1203         SDL_Rect **modes;
1204         SDL_Rect *best_mode;
1205         screen_mode_t *scrmode;
1206         int best_num_pixels, num_pixels;
1207         int i;
1208
1209         modes = SDL_ListModes(NULL, SDL_FULLSCREEN);
1210
1211         best_mode = NULL;
1212         best_num_pixels = INT_MAX;
1213
1214         for (i=0; modes[i] != NULL; ++i)
1215         {
1216             // What screen_mode_t will this use?
1217
1218             scrmode = I_FindScreenMode(modes[i]->w, modes[i]->h);
1219
1220             if (scrmode == NULL)
1221             {
1222                 continue;
1223             }
1224
1225             // Only choose modes that fit the requested scale factor.
1226             //
1227             // Note that this allows 320x240 as valid for 1x scale, as
1228             // 240/200 is rounded down to 1 by integer division.
1229
1230             if ((scrmode->width / SCREENWIDTH) != factor
1231              || (scrmode->height / SCREENHEIGHT) != factor)
1232             {
1233                 continue;
1234             }
1235
1236             // Is this a better mode than what we currently have?
1237
1238             num_pixels = modes[i]->w * modes[i]->h;
1239
1240             if (num_pixels < best_num_pixels)
1241             {
1242                 best_num_pixels = num_pixels;
1243                 best_mode = modes[i];
1244             }
1245         }
1246
1247         if (best_mode == NULL)
1248         {
1249             I_Error("No fullscreen graphics mode available to support "
1250                     "%ix scale factor!", factor);
1251         }
1252
1253         screen_width = best_mode->w;
1254         screen_height = best_mode->h;
1255     }
1256     else
1257     {
1258         int w, h;
1259
1260         // Pick 320x200 or 320x240, depending on aspect ratio correct
1261
1262         if (aspect_ratio_correct)
1263         {
1264             w = SCREENWIDTH;
1265             h = SCREENHEIGHT_4_3;
1266         }
1267         else
1268         {
1269             w = SCREENWIDTH;
1270             h = SCREENHEIGHT;
1271         }
1272
1273         screen_width = w * factor;
1274         screen_height = h * factor;
1275     }
1276 }
1277
1278 static void CheckCommandLine(void)
1279 {
1280     int i;
1281
1282     //!
1283     // @category video
1284     //
1285     // Grab the mouse when running in windowed mode.
1286     //
1287
1288     if (M_CheckParm("-grabmouse"))
1289     {
1290         grabmouse = true;
1291     }
1292
1293     //!
1294     // @category video
1295     //
1296     // Don't grab the mouse when running in windowed mode.
1297     //
1298
1299     if (M_CheckParm("-nograbmouse"))
1300     {
1301         grabmouse = false;
1302     }
1303
1304     // default to fullscreen mode, allow override with command line
1305     // nofullscreen because we love prboom
1306
1307     //!
1308     // @category video
1309     //
1310     // Run in a window.
1311     //
1312
1313     if (M_CheckParm("-window") || M_CheckParm("-nofullscreen"))
1314     {
1315         fullscreen = false;
1316     }
1317
1318     //!
1319     // @category video
1320     //
1321     // Run in fullscreen mode.
1322     //
1323
1324     if (M_CheckParm("-fullscreen"))
1325     {
1326         fullscreen = true;
1327     }
1328
1329     //!
1330     // @category video
1331     //
1332     // Disable the mouse.
1333     //
1334
1335     nomouse = M_CheckParm("-nomouse") > 0;
1336
1337     //!
1338     // @category video
1339     // @arg <x>
1340     //
1341     // Specify the screen width, in pixels.
1342     //
1343
1344     i = M_CheckParm("-width");
1345
1346     if (i > 0)
1347     {
1348         screen_width = atoi(myargv[i + 1]);
1349     }
1350
1351     //!
1352     // @category video
1353     // @arg <y>
1354     //
1355     // Specify the screen height, in pixels.
1356     //
1357
1358     i = M_CheckParm("-height");
1359
1360     if (i > 0)
1361     {
1362         screen_height = atoi(myargv[i + 1]);
1363     }
1364
1365     //!
1366     // @category video
1367     // @arg <WxY>
1368     //
1369     // Specify the screen mode (when running fullscreen) or the window
1370     // dimensions (when running in windowed mode).
1371
1372     i = M_CheckParm("-geometry");
1373
1374     if (i > 0)
1375     {
1376         int w, h;
1377
1378         if (sscanf(myargv[i + 1], "%ix%i", &w, &h) == 2)
1379         {
1380             screen_width = w;
1381             screen_height = h;
1382         }
1383     }
1384
1385     //!
1386     // @category video
1387     //
1388     // Don't scale up the screen.
1389     //
1390
1391     if (M_CheckParm("-1"))
1392     {
1393         SetScaleFactor(1);
1394     }
1395
1396     //!
1397     // @category video
1398     //
1399     // Double up the screen to 2x its normal size.
1400     //
1401
1402     if (M_CheckParm("-2"))
1403     {
1404         SetScaleFactor(2);
1405     }
1406
1407     //!
1408     // @category video
1409     //
1410     // Double up the screen to 3x its normal size.
1411     //
1412
1413     if (M_CheckParm("-3"))
1414     {
1415         SetScaleFactor(3);
1416     }
1417 }
1418
1419 // Check if we have been invoked as a screensaver by xscreensaver.
1420
1421 void I_CheckIsScreensaver(void)
1422 {
1423     char *env;
1424
1425     env = getenv("XSCREENSAVER_WINDOW");
1426
1427     if (env != NULL)
1428     {
1429         screensaver_mode = true;
1430     }
1431 }
1432
1433 static void CreateCursors(void)
1434 {
1435     static Uint8 empty_cursor_data = 0;
1436
1437     // Save the default cursor so it can be recalled later
1438
1439     cursors[1] = SDL_GetCursor();
1440
1441     // Create an empty cursor
1442
1443     cursors[0] = SDL_CreateCursor(&empty_cursor_data,
1444                                   &empty_cursor_data,
1445                                   1, 1, 0, 0);
1446 }
1447
1448 static void SetSDLVideoDriver(void)
1449 {
1450     // Allow a default value for the SDL video driver to be specified
1451     // in the configuration file.
1452
1453     if (strcmp(video_driver, "") != 0)
1454     {
1455         char *env_string;
1456
1457         env_string = malloc(strlen(video_driver) + 30);
1458         sprintf(env_string, "SDL_VIDEODRIVER=%s", video_driver);
1459         putenv(env_string);
1460         free(env_string);
1461     }
1462
1463 #if defined(_WIN32) && !defined(_WIN32_WCE)
1464
1465     // Allow -gdi as a shortcut for using the windib driver.
1466
1467     //!
1468     // @category video
1469     // @platform windows
1470     //
1471     // Use the Windows GDI driver instead of DirectX.
1472     //
1473
1474     if (M_CheckParm("-gdi") > 0)
1475     {
1476         putenv("SDL_VIDEODRIVER=windib");
1477     }
1478
1479     // From the SDL 1.2.10 release notes:
1480     //
1481     // > The "windib" video driver is the default now, to prevent
1482     // > problems with certain laptops, 64-bit Windows, and Windows
1483     // > Vista.
1484     //
1485     // The hell with that.
1486
1487     if (getenv("SDL_VIDEODRIVER") == NULL)
1488     {
1489         putenv("SDL_VIDEODRIVER=directx");
1490     }
1491 #endif
1492 }
1493
1494 static char *WindowBoxType(screen_mode_t *mode, int w, int h)
1495 {
1496     if (mode->width != w && mode->height != h)
1497     {
1498         return "Windowboxed";
1499     }
1500     else if (mode->width == w)
1501     {
1502         return "Letterboxed";
1503     }
1504     else if (mode->height == h)
1505     {
1506         return "Pillarboxed";
1507     }
1508     else
1509     {
1510         return "...";
1511     }
1512 }
1513
1514 static void SetVideoMode(screen_mode_t *mode, int w, int h)
1515 {
1516     byte *doompal;
1517     int flags = 0;
1518
1519     doompal = W_CacheLumpName(DEH_String("PLAYPAL"), PU_CACHE);
1520
1521     // Generate lookup tables before setting the video mode.
1522
1523     if (mode != NULL && mode->InitMode != NULL)
1524     {
1525         mode->InitMode(doompal);
1526     }
1527
1528     // Set the video mode.
1529
1530     flags |= SDL_SWSURFACE | SDL_HWPALETTE | SDL_DOUBLEBUF;
1531
1532     if (fullscreen)
1533     {
1534         flags |= SDL_FULLSCREEN;
1535     }
1536     else
1537     {
1538         flags |= SDL_RESIZABLE;
1539     }
1540
1541     screen = SDL_SetVideoMode(w, h, 8, flags);
1542
1543     if (screen == NULL)
1544     {
1545         I_Error("Error setting video mode: %s\n", SDL_GetError());
1546     }
1547
1548     // If mode was not set, it must be set now that we know the
1549     // screen size.
1550
1551     if (mode == NULL)
1552     {
1553         mode = I_FindScreenMode(screen->w, screen->h);
1554
1555         if (mode == NULL)
1556         {
1557             I_Error("I_InitGraphics: Unable to find a screen mode small "
1558                     "enough for %ix%i", screen->w, screen->h);
1559         }
1560
1561         // Generate lookup tables before setting the video mode.
1562
1563         if (mode->InitMode != NULL)
1564         {
1565             mode->InitMode(doompal);
1566         }
1567     }
1568
1569     // Save screen mode.
1570
1571     screen_mode = mode;
1572 }
1573
1574 static void ApplyWindowResize(unsigned int w, unsigned int h)
1575 {
1576     screen_mode_t *mode;
1577
1578     // Find the biggest screen mode that will fall within these
1579     // dimensions, falling back to the smallest mode possible if
1580     // none is found.
1581
1582     mode = I_FindScreenMode(w, h);
1583
1584     if (mode == NULL)
1585     {
1586         mode = I_FindScreenMode(SCREENWIDTH, SCREENHEIGHT);
1587     }
1588
1589     // Reset mode to resize window.
1590
1591     printf("Resize to %ix%i\n", mode->width, mode->height);
1592     SetVideoMode(mode, mode->width, mode->height);
1593
1594     // Save settings.
1595
1596     screen_width = mode->width;
1597     screen_height = mode->height;
1598 }
1599
1600 void I_InitGraphics(void)
1601 {
1602     SDL_Event dummy;
1603     byte *doompal;
1604     char *env;
1605
1606     // Pass through the XSCREENSAVER_WINDOW environment variable to
1607     // SDL_WINDOWID, to embed the SDL window into the Xscreensaver
1608     // window.
1609
1610     env = getenv("XSCREENSAVER_WINDOW");
1611
1612     if (env != NULL)
1613     {
1614         char winenv[30];
1615         int winid;
1616
1617         sscanf(env, "0x%x", &winid);
1618         sprintf(winenv, "SDL_WINDOWID=%i", winid);
1619
1620         putenv(winenv);
1621     }
1622
1623     SetSDLVideoDriver();
1624
1625     if (SDL_Init(SDL_INIT_VIDEO) < 0)
1626     {
1627         I_Error("Failed to initialize video: %s", SDL_GetError());
1628     }
1629
1630     // Check for command-line video-related parameters.
1631
1632     CheckCommandLine();
1633
1634     // Set up title and icon.  Windows cares about the ordering; this
1635     // has to be done before the call to SDL_SetVideoMode.
1636
1637     I_SetWindowCaption();
1638 #if !SDL_VERSION_ATLEAST(1, 3, 0)
1639     I_SetWindowIcon();
1640 #endif
1641
1642     //
1643     // Enter into graphics mode.
1644     //
1645     // When in screensaver mode, run full screen and auto detect
1646     // screen dimensions (don't change video mode)
1647     //
1648
1649     if (screensaver_mode)
1650     {
1651         SetVideoMode(NULL, 0, 0);
1652     }
1653     else
1654     {
1655         int w, h;
1656
1657         if (autoadjust_video_settings)
1658         {
1659             I_AutoAdjustSettings();
1660         }
1661
1662         w = screen_width;
1663         h = screen_height;
1664
1665         screen_mode = I_FindScreenMode(w, h);
1666
1667         if (screen_mode == NULL)
1668         {
1669             I_Error("I_InitGraphics: Unable to find a screen mode small "
1670                     "enough for %ix%i", w, h);
1671         }
1672
1673         if (w != screen_mode->width || h != screen_mode->height)
1674         {
1675             printf("I_InitGraphics: %s (%ix%i within %ix%i)\n",
1676                    WindowBoxType(screen_mode, w, h),
1677                    screen_mode->width, screen_mode->height, w, h);
1678         }
1679
1680         SetVideoMode(screen_mode, w, h);
1681     }
1682
1683     // Start with a clear black screen
1684     // (screen will be flipped after we set the palette)
1685
1686     if (SDL_LockSurface(screen) >= 0)
1687     {
1688         byte *screenpixels;
1689         int y;
1690
1691         screenpixels = (byte *) screen->pixels;
1692
1693         for (y=0; y<screen->h; ++y)
1694             memset(screenpixels + screen->pitch * y, 0, screen->w);
1695
1696         SDL_UnlockSurface(screen);
1697     }
1698
1699     // Set the palette
1700
1701     doompal = W_CacheLumpName(DEH_String("PLAYPAL"), PU_CACHE);
1702     I_SetPalette(doompal);
1703     SDL_SetColors(screen, palette, 0, 256);
1704
1705     CreateCursors();
1706
1707     UpdateFocus();
1708     UpdateGrab();
1709
1710     // On some systems, it takes a second or so for the screen to settle
1711     // after changing modes.  We include the option to add a delay when
1712     // setting the screen mode, so that the game doesn't start immediately
1713     // with the player unable to see anything.
1714
1715     if (fullscreen && !screensaver_mode)
1716     {
1717         SDL_Delay(startup_delay);
1718     }
1719
1720     // Check if we have a native surface we can use
1721     // If we have to lock the screen, draw to a buffer and copy
1722     // Likewise if the screen pitch is not the same as the width
1723     // If we have to multiply, drawing is done to a separate 320x200 buf
1724
1725     native_surface = !SDL_MUSTLOCK(screen)
1726                   && screen_mode == &mode_scale_1x
1727                   && screen->pitch == SCREENWIDTH
1728                   && aspect_ratio_correct;
1729
1730     // If not, allocate a buffer and copy from that buffer to the
1731     // screen when we do an update
1732
1733     if (native_surface)
1734     {
1735         screens[0] = (unsigned char *) screen->pixels;
1736
1737         screens[0] += (screen->h - SCREENHEIGHT) / 2;
1738     }
1739     else
1740     {
1741         screens[0] = (unsigned char *) Z_Malloc (SCREENWIDTH * SCREENHEIGHT,
1742                                                  PU_STATIC, NULL);
1743     }
1744
1745     // "Loading from disk" icon
1746
1747     LoadDiskImage();
1748
1749     // Clear the screen to black.
1750
1751     memset(screens[0], 0, SCREENWIDTH * SCREENHEIGHT);
1752
1753     // We need SDL to give us translated versions of keys as well
1754
1755     SDL_EnableUNICODE(1);
1756
1757     // Repeat key presses - this is what Vanilla Doom does
1758     // Not sure about repeat rate - probably dependent on which DOS
1759     // driver is used.  This is good enough though.
1760
1761     SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
1762
1763     // clear out any events waiting at the start and center the mouse
1764
1765     while (SDL_PollEvent(&dummy));
1766
1767     if (usemouse && !nomouse && (fullscreen || grabmouse))
1768     {
1769         CenterMouse();
1770     }
1771
1772     initialized = true;
1773 }
1774