//
// SDLVideoDriver::FinishUpdate
//
// Push the newest frame to the display.
//
void SDLVideoDriver::FinishUpdate()
{
// haleyjd 10/08/05: from Chocolate DOOM:
UpdateGrab(window);
// Don't update the screen if the window isn't visible.
// Not doing this breaks under Windows when we alt-tab away
// while fullscreen.
if(!(SDL_GetWindowFlags(window) & SDL_WINDOW_SHOWN))
return;
if(setpalette)
{
if(primary_surface)
SDL_SetPaletteColors(primary_surface->format->palette, colors, 0, 256);
setpalette = false;
}
// haleyjd 11/12/09: blit *after* palette set improves behavior.
if(primary_surface)
{
// Don't bother checking for errors. It should just cancel itself in that case.
SDL_BlitSurface(primary_surface, nullptr, rgba_surface, nullptr);
SDL_UpdateTexture(sdltexture, nullptr, rgba_surface->pixels, rgba_surface->pitch);
SDL_RenderCopy(renderer, sdltexture, nullptr, destrect);
}
// haleyjd 11/12/09: ALWAYS update. Causes problems with some video surface
// types otherwise.
SDL_RenderPresent(renderer);
}
//
// SDLVideoDriver::FinishUpdate
//
// Push the newest frame to the display.
//
void SDLVideoDriver::FinishUpdate(void)
{
// haleyjd 10/08/05: from Chocolate DOOM:
UpdateGrab();
// Don't update the screen if the window isn't visible.
// Not doing this breaks under Windows when we alt-tab away
// while fullscreen.
if(!(SDL_GetAppState() & SDL_APPACTIVE))
return;
if(setpalette)
{
if(!crossbitdepth)
SDL_SetPalette(sdlscreen, SDL_LOGPAL|SDL_PHYSPAL, colors, 0, 256);
if(primary_surface)
SDL_SetPalette(primary_surface, SDL_LOGPAL|SDL_PHYSPAL, colors, 0, 256);
setpalette = false;
}
// haleyjd 11/12/09: blit *after* palette set improves behavior.
if(primary_surface)
SDL_BlitSurface(primary_surface, NULL, sdlscreen, NULL);
// haleyjd 11/12/09: ALWAYS update. Causes problems with some video surface
// types otherwise.
SDL_Flip(sdlscreen);
}
//
// SDLVideoDriver::ShutdownGraphicsPartway
//
// haleyjd: It was necessary to separate this code from I_ShutdownGraphics
// so that the ENDOOM screen can be displayed during shutdown. Otherwise,
// the SDL_QuitSubSystem call below would cause a nasty crash.
//
void SDLVideoDriver::ShutdownGraphicsPartway()
{
// haleyjd 06/21/06: use UpdateGrab here, not release
UpdateGrab();
sdlscreen = NULL;
UnsetPrimaryBuffer();
}
//
// I_InitInput
//
bool I_InitInput (void)
{
if(Args.CheckParm("-nomouse"))
{
nomouse = true;
}
atterm (I_ShutdownInput);
SDL_EnableUNICODE(true);
I_DisableKeyRepeat();
// Initialize the joystick subsystem and open a joystick if use_joystick is enabled. -- Hyper_Eye
Printf(PRINT_HIGH, "I_InitInput: Initializing SDL's joystick subsystem.\n");
SDL_InitSubSystem(SDL_INIT_JOYSTICK);
if((int)use_joystick && I_GetJoystickCount())
{
I_OpenJoystick();
EnableJoystickPolling();
}
#ifdef WIN32
// denis - in fullscreen, prevent exit on accidental windows key press
// [Russell] - Disabled because it screws with the mouse
//g_hKeyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, LowLevelKeyboardProc, GetModuleHandle(NULL), 0);
#endif
//CreateCursors();
UpdateFocus();
UpdateGrab();
return true;
}
void I_InitGraphics(void)
{
static int firsttime=1;
if (firsttime)
{
firsttime = 0;
atexit(I_ShutdownGraphics);
lprintf(LO_INFO, "I_InitGraphics: %dx%d\n", SCREENWIDTH, SCREENHEIGHT);
/* Set the video mode */
I_UpdateVideoMode();
//e6y: setup the window title
I_SetWindowCaption();
//e6y: set the application icon
I_SetWindowIcon();
/* Initialize the input system */
I_InitInputs();
//e6y: new mouse code
UpdateFocus();
UpdateGrab();
}
}
//
// I_PauseMouse
//
void I_PauseMouse (void)
{
// denis - disable key repeats as they mess with the mouse in XP
//SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
UpdateGrab();
mousepaused = true;
}
//
// I_ResumeMouse
//
void I_ResumeMouse (void)
{
UpdateGrab();
if(havefocus)
// denis - disable key repeats as they mess with the mouse in XP
//SDL_EnableKeyRepeat(0, SDL_DEFAULT_REPEAT_INTERVAL);
mousepaused = false;
}
//
// I_FinishUpdate
//
void I_FinishUpdate (void)
{
static int lasttic;
int tics;
int i;
// UNUSED static unsigned char *bigscreen=0;
if (!initialized)
return;
if (noblit)
return;
UpdateGrab();
// Don't update the screen if the window isn't visible.
// Not doing this breaks under Windows when we alt-tab away
// while fullscreen.
if (!(SDL_GetAppState() & SDL_APPACTIVE))
return;
// draws little dots on the bottom of the screen
if (devparm)
{
i = I_GetTime();
tics = i - lasttic;
lasttic = i;
if (tics > 20) tics = 20;
for (i=0 ; i<tics*2 ; i+=4)
screens[0][ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0xff;
for ( ; i<20*4 ; i+=4)
screens[0][ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0x0;
}
// draw to screen
BlitArea(0, 0, SCREENWIDTH, SCREENHEIGHT);
// If we have a palette to set, the act of setting the palette
// updates the screen
if (palette_to_set)
{
SDL_SetColors(screen, palette, 0, 256);
palette_to_set = false;
}
else
{
SDL_Flip(screen);
}
}
//
// SDLVideoDriver::ShutdownGraphicsPartway
//
// haleyjd: It was necessary to separate this code from I_ShutdownGraphics
// so that the ENDOOM screen can be displayed during shutdown. Otherwise,
// the SDL_QuitSubSystem call below would cause a nasty crash.
//
void SDLVideoDriver::ShutdownGraphicsPartway()
{
// haleyjd 06/21/06: use UpdateGrab here, not release
UpdateGrab(window);
if(sdltexture)
{
SDL_DestroyTexture(sdltexture);
sdltexture = nullptr;
}
SDL_DestroyRenderer(renderer);
renderer = nullptr;
SDL_DestroyWindow(window);
window = nullptr;
UnsetPrimaryBuffer();
}
void I_InitGraphics(void)
{
SDL_Event dummy;
byte *doompal;
char *env;
// Pass through the XSCREENSAVER_WINDOW environment variable to
// SDL_WINDOWID, to embed the SDL window into the Xscreensaver
// window.
env = getenv("XSCREENSAVER_WINDOW");
if (env != NULL)
{
char winenv[30];
int winid;
sscanf(env, "0x%x", &winid);
M_snprintf(winenv, sizeof(winenv), "SDL_WINDOWID=%i", winid);
putenv(winenv);
}
SetSDLVideoDriver();
if (SDL_Init(SDL_INIT_VIDEO) < 0)
{
I_Error("Failed to initialize video: %s", SDL_GetError());
}
// When in screensaver mode, run full screen and auto detect
// screen dimensions (don't change video mode)
if (screensaver_mode)
{
fullscreen = true;
}
if (aspect_ratio_correct == 1)
{
actualheight = SCREENHEIGHT_4_3;
}
else
{
actualheight = SCREENHEIGHT;
}
// Create the game window; this may switch graphic modes depending
// on configuration.
AdjustWindowSize();
SetVideoMode();
// Start with a clear black screen
// (screen will be flipped after we set the palette)
SDL_FillRect(screenbuffer, NULL, 0);
// Set the palette
doompal = W_CacheLumpName(DEH_String("PLAYPAL"), PU_CACHE);
I_SetPalette(doompal);
SDL_SetPaletteColors(screenbuffer->format->palette, palette, 0, 256);
// SDL2-TODO UpdateFocus();
UpdateGrab();
// On some systems, it takes a second or so for the screen to settle
// after changing modes. We include the option to add a delay when
// setting the screen mode, so that the game doesn't start immediately
// with the player unable to see anything.
if (fullscreen && !screensaver_mode)
{
SDL_Delay(startup_delay);
}
// The actual 320x200 canvas that we draw to. This is the pixel buffer of
// the 8-bit paletted screen buffer that gets blit on an intermediate
// 32-bit RGBA screen buffer that gets loaded into a texture that gets
// finally rendered into our window or full screen in I_FinishUpdate().
I_VideoBuffer = screenbuffer->pixels;
V_RestoreBuffer();
// Clear the screen to black.
memset(I_VideoBuffer, 0, SCREENWIDTH * SCREENHEIGHT * sizeof(*I_VideoBuffer));
// clear out any events waiting at the start and center the mouse
while (SDL_PollEvent(&dummy));
initialized = true;
// Call I_ShutdownGraphics on quit
I_AtExit(I_ShutdownGraphics, true);
}
//
// SDLVideoDriver::InitGraphicsMode
//
// killough 11/98: New routine, for setting hires and page flipping
// sf: now returns true if an error occurred
//
bool SDLVideoDriver::InitGraphicsMode()
{
// haleyjd 06/19/11: remember characteristics of last successful modeset
static int fallback_w = 640;
static int fallback_h = 480;
static int fallback_bd = 8;
static int fallback_flags = SDL_SWSURFACE;
bool wantfullscreen = false;
bool wantvsync = false;
bool wanthardware = false;
bool wantframe = true;
int v_w = 640;
int v_h = 480;
int v_bd = 8;
int flags = SDL_SWSURFACE;
// haleyjd 12/03/07: cross-bit-depth support
if(M_CheckParm("-8in32"))
v_bd = 32;
else if(i_softbitdepth > 8)
{
switch(i_softbitdepth)
{
case 16: // Valid screen bitdepth settings
case 24:
case 32:
v_bd = i_softbitdepth;
break;
default:
break;
}
}
if(v_bd != 8)
crossbitdepth = true;
// haleyjd 04/11/03: "vsync" or page-flipping support
if(use_vsync)
wantvsync = true;
// haleyjd 07/15/09: set defaults using geom string from configuration file
I_ParseGeom(i_videomode, &v_w, &v_h, &wantfullscreen, &wantvsync,
&wanthardware, &wantframe);
// haleyjd 06/21/06: allow complete command line overrides but only
// on initial video mode set (setting from menu doesn't support this)
I_CheckVideoCmds(&v_w, &v_h, &wantfullscreen, &wantvsync, &wanthardware,
&wantframe);
if(wanthardware)
flags = SDL_HWSURFACE;
if(wantvsync)
flags = SDL_HWSURFACE | SDL_DOUBLEBUF;
if(wantfullscreen)
flags |= SDL_FULLSCREEN;
// haleyjd 10/27/09
if(!wantframe)
flags |= SDL_NOFRAME;
if(!SDL_VideoModeOK(v_w, v_h, v_bd, flags) ||
!(sdlscreen = SDL_SetVideoMode(v_w, v_h, v_bd, flags)))
{
// try 320x200w safety mode
if(!SDL_VideoModeOK(fallback_w, fallback_h, fallback_bd, fallback_flags) ||
!(sdlscreen = SDL_SetVideoMode(fallback_w, fallback_h, fallback_bd, fallback_flags)))
{
I_FatalError(I_ERR_KILL,
"I_SDLInitGraphicsMode: couldn't set mode %dx%dx%d;\n"
" Also failed to restore fallback mode %dx%dx%d.\n"
" Check your SDL video driver settings.\n",
v_w, v_h, v_bd,
fallback_w, fallback_h, fallback_bd);
}
// reset these for below population of video struct
v_w = fallback_w;
v_h = fallback_h;
v_bd = fallback_bd;
flags = fallback_flags;
}
// Record successful mode set for use as a fallback mode
fallback_w = v_w;
fallback_h = v_h;
fallback_bd = v_bd;
fallback_flags = flags;
// haleyjd 10/14/09: wait for a bit so the screen can settle
if(flags & SDL_FULLSCREEN)
I_Sleep(500);
// haleyjd 10/09/05: keep track of fullscreen state
fullscreen = (sdlscreen->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN;
// haleyjd 12/03/07: if the video surface is not high-color, we
// disable cross-bit-depth drawing for efficiency
if(sdlscreen->format->BitsPerPixel == 8)
crossbitdepth = false;
SDL_WM_SetCaption(ee_wmCaption, ee_wmCaption);
UpdateFocus();
UpdateGrab();
video.width = v_w;
video.height = v_h;
video.bitdepth = 8;
video.pixelsize = 1;
// haleyjd 11/12/09: set surface palettes immediately
I_SDLSetPaletteDirect((byte *)wGlobalDir.cacheLumpName("PLAYPAL", PU_CACHE));
return false;
}
//
// I_FinishUpdate
//
void I_FinishUpdate (void)
{
static int lasttic;
int tics;
int i;
if (!initialized)
return;
if (noblit)
return;
if (need_resize && SDL_GetTicks() > last_resize_time + 500)
{
ApplyWindowResize(resize_w, resize_h);
need_resize = false;
palette_to_set = true;
}
UpdateGrab();
// Don't update the screen if the window isn't visible.
// Not doing this breaks under Windows when we alt-tab away
// while fullscreen.
if (!(SDL_GetAppState() & SDL_APPACTIVE))
return;
// draws little dots on the bottom of the screen
if (display_fps_dots)
{
i = I_GetTime();
tics = i - lasttic;
lasttic = i;
if (tics > 20) tics = 20;
for (i=0 ; i<tics*4 ; i+=4)
I_VideoBuffer[ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0xff;
for ( ; i<20*4 ; i+=4)
I_VideoBuffer[ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0x0;
}
if (show_diskicon && disk_indicator == disk_on)
{
if (diskicon_readbytes >= diskicon_threshold)
{
V_BeginRead();
}
}
else if (disk_indicator == disk_dirty)
{
disk_indicator = disk_off;
}
diskicon_readbytes = 0;
// draw to screen
BlitArea(0, 0, SCREENWIDTH, SCREENHEIGHT);
if (palette_to_set)
{
SDL_SetColors(screenbuffer, palette, 0, 256);
palette_to_set = false;
// In native 8-bit mode, if we have a palette to set, the act
// of setting the palette updates the screen
if (screenbuffer == screen)
{
return;
}
}
// In 8in32 mode, we must blit from the fake 8-bit screen buffer
// to the real screen before doing a screen flip.
if (screenbuffer != screen)
{
SDL_Rect dst_rect;
// Center the buffer within the full screen space.
dst_rect.x = (screen->w - screenbuffer->w) / 2;
dst_rect.y = (screen->h - screenbuffer->h) / 2;
SDL_BlitSurface(screenbuffer, NULL, screen, &dst_rect);
}
SDL_Flip(screen);
}
void I_InitGraphics(void)
{
SDL_Event dummy;
byte *doompal;
char *env;
// Pass through the XSCREENSAVER_WINDOW environment variable to
// SDL_WINDOWID, to embed the SDL window into the Xscreensaver
// window.
env = getenv("XSCREENSAVER_WINDOW");
if (env != NULL)
{
char winenv[30];
int winid;
sscanf(env, "0x%x", &winid);
M_snprintf(winenv, sizeof(winenv), "SDL_WINDOWID=%i", winid);
putenv(winenv);
}
SetSDLVideoDriver();
SetWindowPositionVars();
if (SDL_Init(SDL_INIT_VIDEO) < 0)
{
I_Error("Failed to initialize video: %s", SDL_GetError());
}
// Set up title and icon. Windows cares about the ordering; this
// has to be done before the call to SDL_SetVideoMode.
I_InitWindowTitle();
I_InitWindowIcon();
// Warning to OS X users... though they might never see it :(
#ifdef __MACOSX__
if (fullscreen)
{
printf("Some old versions of OS X might crash in fullscreen mode.\n"
"If this happens to you, switch back to windowed mode.\n");
}
#endif
//
// Enter into graphics mode.
//
// When in screensaver mode, run full screen and auto detect
// screen dimensions (don't change video mode)
//
if (screensaver_mode)
{
SetVideoMode(NULL, 0, 0);
}
else
{
int w, h;
if (autoadjust_video_settings)
{
I_AutoAdjustSettings();
}
w = screen_width;
h = screen_height;
screen_mode = I_FindScreenMode(w, h);
if (screen_mode == NULL)
{
I_Error("I_InitGraphics: Unable to find a screen mode small "
"enough for %ix%i", w, h);
}
if (w != screen_mode->width || h != screen_mode->height)
{
printf("I_InitGraphics: %s (%ix%i within %ix%i)\n",
WindowBoxType(screen_mode, w, h),
screen_mode->width, screen_mode->height, w, h);
}
SetVideoMode(screen_mode, w, h);
}
// Start with a clear black screen
// (screen will be flipped after we set the palette)
SDL_FillRect(screenbuffer, NULL, 0);
// Set the palette
doompal = W_CacheLumpName(DEH_String("PLAYPAL"), PU_CACHE);
I_SetPalette(doompal);
SDL_SetColors(screenbuffer, palette, 0, 256);
CreateCursors();
UpdateFocus();
UpdateGrab();
// On some systems, it takes a second or so for the screen to settle
// after changing modes. We include the option to add a delay when
// setting the screen mode, so that the game doesn't start immediately
// with the player unable to see anything.
if (fullscreen && !screensaver_mode)
{
SDL_Delay(startup_delay);
}
// Check if we have a native surface we can use
// If we have to lock the screen, draw to a buffer and copy
// Likewise if the screen pitch is not the same as the width
// If we have to multiply, drawing is done to a separate 320x200 buf
native_surface = screen == screenbuffer
&& !SDL_MUSTLOCK(screen)
&& screen_mode == &mode_scale_1x
&& screen->pitch == SCREENWIDTH
&& aspect_ratio_correct;
// If not, allocate a buffer and copy from that buffer to the
// screen when we do an update
if (native_surface)
{
I_VideoBuffer = (unsigned char *) screen->pixels;
I_VideoBuffer += (screen->h - SCREENHEIGHT) / 2;
}
else
{
I_VideoBuffer = (unsigned char *) Z_Malloc (SCREENWIDTH * SCREENHEIGHT,
PU_STATIC, NULL);
}
V_RestoreBuffer();
// Clear the screen to black.
memset(I_VideoBuffer, 0, SCREENWIDTH * SCREENHEIGHT);
// We need SDL to give us translated versions of keys as well
SDL_EnableUNICODE(1);
// Repeat key presses - this is what Vanilla Doom does
// Not sure about repeat rate - probably dependent on which DOS
// driver is used. This is good enough though.
SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
// clear out any events waiting at the start and center the mouse
while (SDL_PollEvent(&dummy));
initialized = true;
// Call I_ShutdownGraphics on quit
I_AtExit(I_ShutdownGraphics, true);
}
void I_InitGraphics(void)
{
SDL_Event dummy;
byte *doompal;
int flags = 0;
char *env;
// Pass through the XSCREENSAVER_WINDOW environment variable to
// SDL_WINDOWID, to embed the SDL window into the Xscreensaver
// window.
env = getenv("XSCREENSAVER_WINDOW");
if (env != NULL)
{
char winenv[30];
int winid;
sscanf(env, "0x%x", &winid);
sprintf(winenv, "SDL_WINDOWID=%i", winid);
putenv(winenv);
}
SetSDLVideoDriver();
if (SDL_Init(SDL_INIT_VIDEO) < 0)
{
I_Error("Failed to initialize video: %s", SDL_GetError());
}
// Check for command-line video-related parameters.
CheckCommandLine();
doompal = W_CacheLumpName (DEH_String("PLAYPAL"),PU_CACHE);
if (screensaver_mode)
{
windowwidth = 0;
windowheight = 0;
}
else
{
if (autoadjust_video_settings)
{
I_AutoAdjustSettings();
}
windowwidth = screen_width;
windowheight = screen_height;
screen_mode = I_FindScreenMode(windowwidth, windowheight);
if (screen_mode == NULL)
{
I_Error("I_InitGraphics: Unable to find a screen mode small "
"enough for %ix%i", windowwidth, windowheight);
}
if (windowwidth != screen_mode->width
|| windowheight != screen_mode->height)
{
printf("I_InitGraphics: %s (%ix%i within %ix%i)\n",
WindowBoxType(screen_mode, windowwidth, windowheight),
screen_mode->width, screen_mode->height,
windowwidth, windowheight);
}
// Generate lookup tables before setting the video mode.
if (screen_mode->InitMode != NULL)
{
screen_mode->InitMode(doompal);
}
}
// Set up title and icon. Windows cares about the ordering; this
// has to be done before the call to SDL_SetVideoMode.
I_SetWindowCaption();
#if !SDL_VERSION_ATLEAST(1, 3, 0)
I_SetWindowIcon();
#endif
// Set the video mode.
flags |= SDL_SWSURFACE | SDL_HWPALETTE | SDL_DOUBLEBUF;
if (fullscreen)
{
flags |= SDL_FULLSCREEN;
}
screen = SDL_SetVideoMode(windowwidth, windowheight, 8, flags);
if (screen == NULL)
{
I_Error("Error setting video mode: %s\n", SDL_GetError());
}
// Start with a clear black screen
// (screen will be flipped after we set the palette)
if (SDL_LockSurface(screen) >= 0)
{
byte *screenpixels;
int y;
screenpixels = (byte *) screen->pixels;
for (y=0; y<screen->h; ++y)
memset(screenpixels + screen->pitch * y, 0, screen->w);
SDL_UnlockSurface(screen);
}
// Set the palette
I_SetPalette(doompal);
SDL_SetColors(screen, palette, 0, 256);
CreateCursors();
UpdateFocus();
UpdateGrab();
// In screensaver mode, now find a screen_mode to use.
if (screensaver_mode)
{
screen_mode = I_FindScreenMode(screen->w, screen->h);
if (screen_mode == NULL)
{
I_Error("I_InitGraphics: Unable to find a screen mode small "
"enough for %ix%i", screen->w, screen->h);
}
// Generate lookup tables before setting the video mode.
if (screen_mode->InitMode != NULL)
{
screen_mode->InitMode(doompal);
}
}
// On some systems, it takes a second or so for the screen to settle
// after changing modes. We include the option to add a delay when
// setting the screen mode, so that the game doesn't start immediately
// with the player unable to see anything.
if (fullscreen && !screensaver_mode)
{
SDL_Delay(startup_delay);
}
// Check if we have a native surface we can use
// If we have to lock the screen, draw to a buffer and copy
// Likewise if the screen pitch is not the same as the width
// If we have to multiply, drawing is done to a separate 320x200 buf
native_surface = !SDL_MUSTLOCK(screen)
&& screen_mode == &mode_scale_1x
&& screen->pitch == SCREENWIDTH
&& aspect_ratio_correct;
// If not, allocate a buffer and copy from that buffer to the
// screen when we do an update
if (native_surface)
{
screens[0] = (unsigned char *) screen->pixels;
screens[0] += (screen->h - SCREENHEIGHT) / 2;
}
else
{
screens[0] = (unsigned char *) Z_Malloc (SCREENWIDTH * SCREENHEIGHT,
PU_STATIC, NULL);
}
// "Loading from disk" icon
LoadDiskImage();
// Clear the screen to black.
memset(screens[0], 0, SCREENWIDTH * SCREENHEIGHT);
// We need SDL to give us translated versions of keys as well
SDL_EnableUNICODE(1);
// Repeat key presses - this is what Vanilla Doom does
// Not sure about repeat rate - probably dependent on which DOS
// driver is used. This is good enough though.
SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
// clear out any events waiting at the start and center the mouse
while (SDL_PollEvent(&dummy));
if (usemouse && !nomouse && (fullscreen || grabmouse))
{
CenterMouse();
}
initialized = true;
}
//
// SDLVideoDriver::InitGraphicsMode
//
// killough 11/98: New routine, for setting hires and page flipping
// sf: now returns true if an error occurred
//
bool SDLVideoDriver::InitGraphicsMode()
{
// haleyjd 06/19/11: remember characteristics of last successful modeset
static int fallback_w = 640;
static int fallback_h = 480;
static int fallback_w_flags = SDL_WINDOW_ALLOW_HIGHDPI;
// SDL_RENDERER_SOFTWARE causes failures in creating renderer
static int fallback_r_flags = SDL_RENDERER_TARGETTEXTURE;
bool wantfullscreen = false;
bool wantdesktopfs = false;
bool wantvsync = false;
bool wanthardware = false;
bool wantframe = true;
int v_w = 640;
int v_h = 480;
int v_displaynum = 0;
int window_flags = SDL_WINDOW_ALLOW_HIGHDPI;
// SDL_RENDERER_SOFTWARE causes failures in creating renderer
int renderer_flags = SDL_RENDERER_TARGETTEXTURE;
// haleyjd 04/11/03: "vsync" or page-flipping support
if(use_vsync)
wantvsync = true;
// haleyjd 07/15/09: set defaults using geom string from configuration file
I_ParseGeom(i_videomode, &v_w, &v_h, &wantfullscreen, &wantvsync,
&wanthardware, &wantframe, &wantdesktopfs);
// haleyjd 06/21/06: allow complete command line overrides but only
// on initial video mode set (setting from menu doesn't support this)
I_CheckVideoCmds(&v_w, &v_h, &wantfullscreen, &wantvsync, &wanthardware,
&wantframe, &wantdesktopfs);
// Wanting vsync forces framebuffer acceleration on
if(wantvsync)
{
SDL_SetHint(SDL_HINT_FRAMEBUFFER_ACCELERATION, "1");
renderer_flags |= SDL_RENDERER_PRESENTVSYNC;
}
else if(wanthardware)
SDL_SetHint(SDL_HINT_FRAMEBUFFER_ACCELERATION, "1");
else
SDL_SetHint(SDL_HINT_FRAMEBUFFER_ACCELERATION, "0");
// haleyjd 10/27/09
if(!wantframe)
window_flags |= SDL_WINDOW_BORDERLESS;
if(displaynum < SDL_GetNumVideoDisplays())
v_displaynum = displaynum;
else
displaynum = 0;
if(!(window = SDL_CreateWindow(ee_wmCaption,
SDL_WINDOWPOS_CENTERED_DISPLAY(v_displaynum),
SDL_WINDOWPOS_CENTERED_DISPLAY(v_displaynum),
v_w, v_h, window_flags)))
{
// try 320x200w safety mode
if(!(window = SDL_CreateWindow(ee_wmCaption,
SDL_WINDOWPOS_CENTERED_DISPLAY(v_displaynum),
SDL_WINDOWPOS_CENTERED_DISPLAY(v_displaynum),
fallback_w, fallback_h, fallback_w_flags)))
{
// SDL_TODO: Trim fat from this error message
I_FatalError(I_ERR_KILL,
"I_SDLInitGraphicsMode: couldn't create window for mode %dx%d;\n"
" Also failed to restore fallback mode %dx%d.\n"
" Check your SDL video driver settings.\n",
v_w, v_h, fallback_w, fallback_h);
}
// reset these for below population of video struct
v_w = fallback_w;
v_h = fallback_h;
window_flags = fallback_w_flags;
}
#if EE_CURRENT_PLATFORM == EE_PLATFORM_MACOSX
// this and the below #else block are done here as monitor video mode isn't
// set when SDL_WINDOW_FULLSCREEN (sans desktop) is ORed in during window creation
if(wantfullscreen)
SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
#else
if(wantfullscreen && wantdesktopfs)
SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
else if(wantfullscreen) // && !wantdesktopfs
SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN);
#endif
if(!(renderer = SDL_CreateRenderer(window, -1, renderer_flags)))
{
if(!(renderer = SDL_CreateRenderer(window, -1, fallback_r_flags)))
{
// SDL_TODO: Trim fat from this error message
I_FatalError(I_ERR_KILL,
"I_SDLInitGraphicsMode: couldn't create renderer for mode %dx%d;\n"
" Also failed to restore fallback mode %dx%d.\n"
" Check your SDL video driver settings.\n",
v_w, v_h, fallback_w, fallback_h);
}
fallback_r_flags = renderer_flags;
}
// Record successful mode set for use as a fallback mode
fallback_w = v_w;
fallback_h = v_h;
fallback_w_flags = window_flags;
fallback_r_flags = renderer_flags;
// haleyjd 10/09/05: keep track of fullscreen state
fullscreen = !!(SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN_DESKTOP);
UpdateFocus(window);
UpdateGrab(window);
// check for letterboxing
if(I_VideoShouldLetterbox(v_w, v_h))
{
int hs = I_VideoLetterboxHeight(v_w);
staticDestRect.x = 0;
staticDestRect.y = static_cast<Sint16>(I_VideoLetterboxOffset(v_h, hs));
staticDestRect.w = static_cast<Uint16>(v_w);
staticDestRect.h = static_cast<Uint16>(hs);
video.width = v_w;
video.height = hs;
destrect = &staticDestRect;
}
else
{
video.width = v_w;
video.height = v_h;
destrect = nullptr;
}
video.bitdepth = 8;
video.pixelsize = 1;
UnsetPrimaryBuffer();
SetPrimaryBuffer();
// haleyjd 11/12/09: set surface palettes immediately
I_SDLSetPaletteDirect(static_cast<byte *>(wGlobalDir.cacheLumpName("PLAYPAL", PU_CACHE)));
return false;
}
void I_FinishUpdate (void)
{
//e6y: new mouse code
UpdateGrab();
// The screen wipe following pressing the exit switch on a level
// is noticably jerkier with I_SkipFrame
// if (I_SkipFrame())return;
#ifdef MONITOR_VISIBILITY
if (!(SDL_GetAppState()&SDL_APPACTIVE)) {
return;
}
#endif
#ifdef GL_DOOM
if (V_GetMode() == VID_MODEGL) {
// proff 04/05/2000: swap OpenGL buffers
gld_Finish();
return;
}
#endif
if ((screen_multiply > 1) || SDL_MUSTLOCK(screen)) {
int h;
byte *src;
byte *dest;
if (SDL_LockSurface(screen) < 0) {
lprintf(LO_INFO,"I_FinishUpdate: %s\n", SDL_GetError());
return;
}
// e6y: processing of screen_multiply
if (screen_multiply > 1)
{
R_ProcessScreenMultiply(screens[0].data, screen->pixels,
V_GetPixelDepth(), screens[0].byte_pitch, screen->pitch);
}
else
{
dest=screen->pixels;
src=screens[0].data;
h=screen->h;
for (; h>0; h--)
{
memcpy_fast(dest,src,SCREENWIDTH*V_GetPixelDepth()); //e6y
dest+=screen->pitch;
src+=screens[0].byte_pitch;
}
}
SDL_UnlockSurface(screen);
}
/* Update the display buffer (flipping video pages if supported)
* If we need to change palette, that implicitely does a flip */
if (newpal != NO_PALETTE_CHANGE) {
I_UploadNewPalette(newpal, false);
newpal = NO_PALETTE_CHANGE;
}
#ifdef GL_DOOM
if (vid_8ingl.enabled)
{
gld_Draw8InGL();
}
else
#endif
{
SDL_Flip(screen);
}
}
//
// I_FinishUpdate
//
void I_FinishUpdate (void)
{
static int lasttic;
int tics;
int i;
if (!initialized)
return;
if (noblit)
return;
if (need_resize)
{
if (SDL_GetTicks() > last_resize_time + RESIZE_DELAY)
{
int flags;
// When the window is resized (we're not in fullscreen mode),
// save the new window size.
flags = SDL_GetWindowFlags(screen);
if ((flags & SDL_WINDOW_FULLSCREEN_DESKTOP) == 0)
{
SDL_GetWindowSize(screen, &window_width, &window_height);
// Adjust the window by resizing again so that the window
// is the right aspect ratio.
AdjustWindowSize();
SDL_SetWindowSize(screen, window_width, window_height);
}
CreateUpscaledTexture(false);
need_resize = false;
palette_to_set = true;
}
else
{
return;
}
}
UpdateGrab();
#if 0 // SDL2-TODO
// Don't update the screen if the window isn't visible.
// Not doing this breaks under Windows when we alt-tab away
// while fullscreen.
if (!(SDL_GetAppState() & SDL_APPACTIVE))
return;
#endif
// draws little dots on the bottom of the screen
if (display_fps_dots)
{
i = I_GetTime();
tics = i - lasttic;
lasttic = i;
if (tics > 20) tics = 20;
for (i=0 ; i<tics*4 ; i+=4)
I_VideoBuffer[ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0xff;
for ( ; i<20*4 ; i+=4)
I_VideoBuffer[ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0x0;
}
// Draw disk icon before blit, if necessary.
V_DrawDiskIcon();
if (palette_to_set)
{
SDL_SetPaletteColors(screenbuffer->format->palette, palette, 0, 256);
palette_to_set = false;
if (vga_porch_flash)
{
// "flash" the pillars/letterboxes with palette changes, emulating
// VGA "porch" behaviour (GitHub issue #832)
SDL_SetRenderDrawColor(renderer, palette[0].r, palette[0].g,
palette[0].b, SDL_ALPHA_OPAQUE);
}
}
// Blit from the paletted 8-bit screen buffer to the intermediate
// 32-bit RGBA buffer that we can load into the texture.
SDL_LowerBlit(screenbuffer, &blit_rect, argbbuffer, &blit_rect);
// Update the intermediate texture with the contents of the RGBA buffer.
SDL_UpdateTexture(texture, NULL, argbbuffer->pixels, argbbuffer->pitch);
// Make sure the pillarboxes are kept clear each frame.
SDL_RenderClear(renderer);
// Render this intermediate texture into the upscaled texture
// using "nearest" integer scaling.
SDL_SetRenderTarget(renderer, texture_upscaled);
SDL_RenderCopy(renderer, texture, NULL, NULL);
// Finally, render this upscaled texture to screen using linear scaling.
SDL_SetRenderTarget(renderer, NULL);
SDL_RenderCopy(renderer, texture_upscaled, NULL, NULL);
// Draw!
SDL_RenderPresent(renderer);
// Restore background and undo the disk indicator, if it was drawn.
V_RestoreDiskBackground();
}
static void I_GetEvent(SDL_Window *window)
{
SDL_Event ev;
int sendmouseevent = 0;
int buttons = 0;
event_t d_event = { ev_keydown, 0, 0, 0, false };
event_t mouseevent = { ev_mouse, 0, 0, 0, false };
event_t tempevent = { ev_keydown, 0, 0, 0, false };
// [CG] 01/31/2012: Ensure we have the latest info about focus and mouse grabbing.
UpdateFocus(window);
UpdateGrab(window);
while(SDL_PollEvent(&ev))
{
// haleyjd 10/08/05: from Chocolate DOOM
if(!window_focused &&
(ev.type == SDL_MOUSEMOTION ||
ev.type == SDL_MOUSEBUTTONDOWN ||
ev.type == SDL_MOUSEBUTTONUP))
{
continue;
}
switch(ev.type)
{
case SDL_TEXTINPUT:
for(unsigned int i = 0; i < SDL_strlen(ev.text.text); i++)
{
const char currchar = ev.text.text[i];
if(ectype::isPrint(currchar))
{
event_t textevent = { ev_text, currchar, 0, 0, !!ev.key.repeat };
D_PostEvent(&textevent);
}
}
break;
case SDL_KEYDOWN:
d_event.type = ev_keydown;
d_event.repeat = !!ev.key.repeat;
d_event.data1 = I_TranslateKey(&ev.key.keysym);
#if (EE_CURRENT_PLATFORM != EE_PLATFORM_MACOSX)
// This quick exit code is adapted from PRBoom+
// See PRBoom+'s I_GetEvent for a cross-platform implementation of how to get that input.
if(ev.key.keysym.mod & KMOD_LALT)
{
// Prevent executing action on Alt-Tab
if(ev.key.keysym.scancode == SDL_SCANCODE_TAB)
break;
// Immediately exit on Alt+F4 ("Boss Key")
else if(ev.key.keysym.scancode == SDL_SCANCODE_F4)
{
I_QuitFast();
break;
}
else if(ev.key.keysym.scancode == SDL_SCANCODE_RETURN)
{
I_ToggleFullscreen();
break;
}
}
#else
// Also provide macOS option for quick exit and fullscreen toggle
if(ev.key.keysym.mod & KMOD_GUI)
{
if(ev.key.keysym.scancode == SDL_SCANCODE_Q)
{
I_QuitFast();
break;
}
else if(ev.key.keysym.scancode == SDL_SCANCODE_F)
{
I_ToggleFullscreen();
break;
}
}
#endif
// MaxW: 2017/10/12: Removed deferred event adding for caps lock
// MaxW: 2017/10/18: Removed character input
D_PostEvent(&d_event);
break;
case SDL_KEYUP:
d_event.type = ev_keyup;
d_event.data1 = I_TranslateKey(&ev.key.keysym);
D_PostEvent(&d_event);
break;
case SDL_MOUSEMOTION:
if(!usemouse || ((mouseAccel_type == ACCELTYPE_CHOCO) ||
(mouseAccel_type == ACCELTYPE_CUSTOM)))
continue;
// haleyjd 06/14/10: no mouse motion at startup.
if(gametic == 0)
continue;
// SoM 1-20-04 Ok, use xrel/yrel for mouse movement because most
// people like it the most.
if(mouseAccel_type == ACCELTYPE_NONE)
{
mouseevent.data2 += ev.motion.xrel;
mouseevent.data3 -= ev.motion.yrel;
}
else if(mouseAccel_type == ACCELTYPE_LINEAR)
{
// Simple linear acceleration
// Evaluates to 1.25 * x. So Why don't I just do that? .... shut up
mouseevent.data2 += (ev.motion.xrel + (float)(ev.motion.xrel * 0.25f));
mouseevent.data3 -= (ev.motion.yrel + (float)(ev.motion.yrel * 0.25f));
}
sendmouseevent = 1;
break;
case SDL_MOUSEBUTTONDOWN:
if(!usemouse)
continue;
d_event.type = ev_keydown;
switch(ev.button.button)
{
case SDL_BUTTON_LEFT:
sendmouseevent = 1;
buttons |= 1;
d_event.data1 = KEYD_MOUSE1;
break;
case SDL_BUTTON_MIDDLE:
// haleyjd 05/28/06: swapped MOUSE3/MOUSE2
sendmouseevent = 1;
buttons |= 4;
d_event.data1 = KEYD_MOUSE3;
break;
case SDL_BUTTON_RIGHT:
sendmouseevent = 1;
buttons |= 2;
d_event.data1 = KEYD_MOUSE2;
break;
case SDL_BUTTON_X1:
d_event.data1 = KEYD_MOUSE4;
break;
case SDL_BUTTON_X2:
d_event.data1 = KEYD_MOUSE5;
break;
}
D_PostEvent(&d_event);
break;
case SDL_MOUSEWHEEL:
if(!usemouse)
continue;
d_event.type = ev_keydown;
// SDL_TODO: Allow y to correspond to # of weps scrolled through?
if(ev.wheel.y > 0)
{
d_event.data1 = KEYD_MWHEELUP;
D_PostEvent(&d_event);
// WHEELUP sends a button up event immediately. That won't work;
// we need an input latency gap of at least one gametic.
tempevent.type = ev_keyup;
tempevent.data1 = KEYD_MWHEELUP;
I_AddDeferredEvent(tempevent, gametic + 1);
break;
}
else if(ev.wheel.y < 0)
{
d_event.data1 = KEYD_MWHEELDOWN;
D_PostEvent(&d_event);
// ditto, as above.
tempevent.type = ev_keyup;
tempevent.data1 = KEYD_MWHEELDOWN;
I_AddDeferredEvent(tempevent, gametic + 1);
break;
}
case SDL_MOUSEBUTTONUP:
if(!usemouse)
continue;
d_event.type = ev_keyup;
d_event.data1 = 0;
switch(ev.button.button)
{
case SDL_BUTTON_LEFT:
sendmouseevent = 1;
buttons &= ~1;
d_event.data1 = KEYD_MOUSE1;
break;
case SDL_BUTTON_MIDDLE:
// haleyjd 05/28/06: swapped MOUSE3/MOUSE2
sendmouseevent = 1;
buttons &= ~4;
d_event.data1 = KEYD_MOUSE3;
break;
case SDL_BUTTON_RIGHT:
sendmouseevent = 1;
buttons &= ~2;
d_event.data1 = KEYD_MOUSE2;
break;
case SDL_BUTTON_X1:
d_event.data1 = KEYD_MOUSE4;
break;
case SDL_BUTTON_X2:
d_event.data1 = KEYD_MOUSE5;
break;
}
if(d_event.data1)
D_PostEvent(&d_event);
break;
case SDL_QUIT:
MN_QuitDoom();
break;
case SDL_WINDOWEVENT:
// haleyjd 10/08/05: from Chocolate DOOM:
// need to update our focus state
// 2/14/2011: Update mouse grabbing as well (thanks Catoptromancy)
UpdateFocus(window);
UpdateGrab(window);
break;
default:
break;
}
}
if(sendmouseevent)
{
mouseevent.data1 = buttons;
D_PostEvent(&mouseevent);
}
// SoM: if paused, delay for a short amount of time to allow other threads
// to process on the system. Otherwise Eternity will use almost 100% of the
// CPU even while paused.
if(paused || !window_focused)
SDL_Delay(1);
}
