zdoom/gzdoom-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom-gles.git synced 2024-11-11 07:12:16 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge branch 'SDL2'

Browse source
This commit is contained in:
Braden Obrzut 2014-12-22 15:25:22 -05:00
commit d4bac5776a
12 changed files with 756 additions and 485 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

180
FindSDL2.cmake Normal file
View file

@ -0,0 +1,180 @@
# Locate SDL2 library
# This module defines
# SDL2_LIBRARY, the name of the library to link against
# SDL2_FOUND, if false, do not try to link to SDL2
# SDL2_INCLUDE_DIR, where to find SDL.h
#
# This module responds to the the flag:
# SDL2_BUILDING_LIBRARY
# If this is defined, then no SDL2_main will be linked in because
# only applications need main().
# Otherwise, it is assumed you are building an application and this
# module will attempt to locate and set the the proper link flags
# as part of the returned SDL2_LIBRARY variable.
#
# Don't forget to include SDL2main.h and SDL2main.m your project for the
# OS X framework based version. (Other versions link to -lSDL2main which
# this module will try to find on your behalf.) Also for OS X, this
# module will automatically add the -framework Cocoa on your behalf.
#
#
# Additional Note: If you see an empty SDL2_LIBRARY_TEMP in your configuration
# and no SDL2_LIBRARY, it means CMake did not find your SDL2 library
# (SDL2.dll, libsdl2.so, SDL2.framework, etc).
# Set SDL2_LIBRARY_TEMP to point to your SDL2 library, and configure again.
# Similarly, if you see an empty SDL2MAIN_LIBRARY, you should set this value
# as appropriate. These values are used to generate the final SDL2_LIBRARY
# variable, but when these values are unset, SDL2_LIBRARY does not get created.
#
#
# $SDL2DIR is an environment variable that would
# correspond to the ./configure --prefix=$SDL2DIR
# used in building SDL2.
# l.e.galup 9-20-02
#
# Modified by Eric Wing.
# Added code to assist with automated building by using environmental variables
# and providing a more controlled/consistent search behavior.
# Added new modifications to recognize OS X frameworks and
# additional Unix paths (FreeBSD, etc).
# Also corrected the header search path to follow "proper" SDL2 guidelines.
# Added a search for SDL2main which is needed by some platforms.
# Added a search for threads which is needed by some platforms.
# Added needed compile switches for MinGW.
#
# On OSX, this will prefer the Framework version (if found) over others.
# People will have to manually change the cache values of
# SDL2_LIBRARY to override this selection or set the CMake environment
# CMAKE_INCLUDE_PATH to modify the search paths.
#
# Note that the header path has changed from SDL2/SDL.h to just SDL.h
# This needed to change because "proper" SDL2 convention
# is #include "SDL.h", not <SDL2/SDL.h>. This is done for portability
# reasons because not all systems place things in SDL2/ (see FreeBSD).
#
# Ported by Johnny Patterson. This is a literal port for SDL2 of the FindSDL.cmake
# module with the minor edit of changing "SDL" to "SDL2" where necessary. This
# was not created for redistribution, and exists temporarily pending official
# SDL2 CMake modules.
#=============================================================================
# Copyright 2003-2009 Kitware, Inc.
#
# Distributed under the OSI-approved BSD License (the "License");
# see accompanying file Copyright.txt for details.
#
# This software is distributed WITHOUT ANY WARRANTY; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the License for more information.
#=============================================================================
# (To distribute this file outside of CMake, substitute the full
# License text for the above reference.)
FIND_PATH(SDL2_INCLUDE_DIR SDL.h
HINTS
$ENV{SDL2DIR}
PATH_SUFFIXES include/SDL2 include
PATHS
~/Library/Frameworks
/Library/Frameworks
/usr/local/include/SDL2
/usr/include/SDL2
/sw # Fink
/opt/local # DarwinPorts
/opt/csw # Blastwave
/opt
)
#MESSAGE("SDL2_INCLUDE_DIR is ${SDL2_INCLUDE_DIR}")
FIND_LIBRARY(SDL2_LIBRARY_TEMP
NAMES SDL2
HINTS
$ENV{SDL2DIR}
PATH_SUFFIXES lib64 lib
PATHS
/sw
/opt/local
/opt/csw
/opt
)
#MESSAGE("SDL2_LIBRARY_TEMP is ${SDL2_LIBRARY_TEMP}")
IF(NOT SDL2_BUILDING_LIBRARY)
IF(NOT ${SDL2_INCLUDE_DIR} MATCHES ".framework")
# Non-OS X framework versions expect you to also dynamically link to
# SDL2main. This is mainly for Windows and OS X. Other (Unix) platforms
# seem to provide SDL2main for compatibility even though they don't
# necessarily need it.
FIND_LIBRARY(SDL2MAIN_LIBRARY
NAMES SDL2main
HINTS
$ENV{SDL2DIR}
PATH_SUFFIXES lib64 lib
PATHS
/sw
/opt/local
/opt/csw
/opt
)
ENDIF(NOT ${SDL2_INCLUDE_DIR} MATCHES ".framework")
ENDIF(NOT SDL2_BUILDING_LIBRARY)
# SDL2 may require threads on your system.
# The Apple build may not need an explicit flag because one of the
# frameworks may already provide it.
# But for non-OSX systems, I will use the CMake Threads package.
IF(NOT APPLE)
FIND_PACKAGE(Threads)
ENDIF(NOT APPLE)
# MinGW needs an additional library, mwindows
# It's total link flags should look like -lmingw32 -lSDL2main -lSDL2 -lmwindows
# (Actually on second look, I think it only needs one of the m* libraries.)
IF(MINGW)
SET(MINGW32_LIBRARY mingw32 CACHE STRING "mwindows for MinGW")
ENDIF(MINGW)
SET(SDL2_FOUND "NO")
IF(SDL2_LIBRARY_TEMP)
# For SDL2main
IF(NOT SDL2_BUILDING_LIBRARY)
IF(SDL2MAIN_LIBRARY)
SET(SDL2_LIBRARY_TEMP ${SDL2MAIN_LIBRARY} ${SDL2_LIBRARY_TEMP})
ENDIF(SDL2MAIN_LIBRARY)
ENDIF(NOT SDL2_BUILDING_LIBRARY)
# For OS X, SDL2 uses Cocoa as a backend so it must link to Cocoa.
# CMake doesn't display the -framework Cocoa string in the UI even
# though it actually is there if I modify a pre-used variable.
# I think it has something to do with the CACHE STRING.
# So I use a temporary variable until the end so I can set the
# "real" variable in one-shot.
IF(APPLE)
SET(SDL2_LIBRARY_TEMP ${SDL2_LIBRARY_TEMP} "-framework Cocoa")
ENDIF(APPLE)
# For threads, as mentioned Apple doesn't need this.
# In fact, there seems to be a problem if I used the Threads package
# and try using this line, so I'm just skipping it entirely for OS X.
IF(NOT APPLE)
SET(SDL2_LIBRARY_TEMP ${SDL2_LIBRARY_TEMP} ${CMAKE_THREAD_LIBS_INIT})
ENDIF(NOT APPLE)
# For MinGW library
IF(MINGW)
SET(SDL2_LIBRARY_TEMP ${MINGW32_LIBRARY} ${SDL2_LIBRARY_TEMP})
ENDIF(MINGW)
# Set the final string here so the GUI reflects the final state.
SET(SDL2_LIBRARY ${SDL2_LIBRARY_TEMP} CACHE STRING "Where the SDL2 Library can be found")
# Set the temp variable to INTERNAL so it is not seen in the CMake GUI
SET(SDL2_LIBRARY_TEMP "${SDL2_LIBRARY_TEMP}" CACHE INTERNAL "")
SET(SDL2_FOUND "YES")
ENDIF(SDL2_LIBRARY_TEMP)
INCLUDE(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2
REQUIRED_VARS SDL2_LIBRARY SDL2_INCLUDE_DIR)

29
src/CMakeLists.txt
View file

@ -191,19 +191,6 @@ else( WIN32 )
set( NO_GTK ON ) set( NO_GTK ON )
endif( GTK2_FOUND ) endif( GTK2_FOUND )
endif( NOT NO_GTK ) endif( NOT NO_GTK )
# Check for Xcursor library and header files
find_library( XCURSOR_LIB Xcursor )
if( XCURSOR_LIB )
find_file( XCURSOR_HEADER "X11/Xcursor/Xcursor.h" )
if( XCURSOR_HEADER )
add_definitions( -DUSE_XCURSOR=1 )
message( STATUS "Found Xcursor at ${XCURSOR_LIB}" )
set( ZDOOM_LIBS ${ZDOOM_LIBS} ${XCURSOR_LIB} )
else( XCURSOR_HEADER )
unset( XCURSOR_LIB )
endif( XCURSOR_HEADER )
endif( XCURSOR_LIB )
endif( APPLE ) endif( APPLE )
set( NASM_NAMES nasm ) set( NASM_NAMES nasm )
@ -212,14 +199,11 @@ else( WIN32 )
endif( NO_GTK ) endif( NO_GTK )
# Non-Windows version also needs SDL # Non-Windows version also needs SDL
find_package( SDL ) find_package( SDL2 REQUIRED )
if( NOT SDL_FOUND )
message( SEND_ERROR "SDL is required for building." )
endif( NOT SDL_FOUND )
if( NOT APPLE OR NOT OSX_COCOA_BACKEND ) if( NOT APPLE OR NOT OSX_COCOA_BACKEND )
set( ZDOOM_LIBS ${ZDOOM_LIBS} "${SDL_LIBRARY}" ) set( ZDOOM_LIBS ${ZDOOM_LIBS} "${SDL2_LIBRARY}" )
endif( NOT APPLE OR NOT OSX_COCOA_BACKEND ) endif( NOT APPLE OR NOT OSX_COCOA_BACKEND )
include_directories( "${SDL_INCLUDE_DIR}" ) include_directories( "${SDL2_INCLUDE_DIR}" )
find_path( FPU_CONTROL_DIR fpu_control.h ) find_path( FPU_CONTROL_DIR fpu_control.h )
if( FPU_CONTROL_DIR ) if( FPU_CONTROL_DIR )
@ -579,8 +563,8 @@ set( PLAT_SDL_SPECIAL_SOURCES
sdl/i_joystick.cpp sdl/i_joystick.cpp
sdl/i_timer.cpp ) sdl/i_timer.cpp )
set( PLAT_MAC_SOURCES set( PLAT_MAC_SOURCES
sdl/iwadpicker_cocoa.mm cocoa/iwadpicker_cocoa.mm
sdl/i_system_cocoa.mm ) cocoa/i_system_cocoa.mm )
set( PLAT_COCOA_SOURCES set( PLAT_COCOA_SOURCES
cocoa/HID_Config_Utilities.c cocoa/HID_Config_Utilities.c
cocoa/HID_Error_Handler.c cocoa/HID_Error_Handler.c
@ -600,8 +584,9 @@ if( APPLE )
if( OSX_COCOA_BACKEND ) if( OSX_COCOA_BACKEND )
set( PLAT_MAC_SOURCES ${PLAT_MAC_SOURCES} ${PLAT_COCOA_SOURCES} ) set( PLAT_MAC_SOURCES ${PLAT_MAC_SOURCES} ${PLAT_COCOA_SOURCES} )
add_definitions( -DUSE_NATIVE_COCOA )
else( OSX_COCOA_BACKEND ) else( OSX_COCOA_BACKEND )
set( PLAT_MAC_SOURCES ${PLAT_MAC_SOURCES} ${PLAT_SDL_SPECIAL_SOURCES} sdl/SDLMain.m ) set( PLAT_MAC_SOURCES ${PLAT_MAC_SOURCES} ${PLAT_SDL_SPECIAL_SOURCES} )
endif( OSX_COCOA_BACKEND ) endif( OSX_COCOA_BACKEND )
set_source_files_properties( cocoa/zdoom.icns PROPERTIES MACOSX_PACKAGE_LOCATION Resources ) set_source_files_properties( cocoa/zdoom.icns PROPERTIES MACOSX_PACKAGE_LOCATION Resources )

264
src/cocoa/i_backend_cocoa.mm
View file

@ -1710,102 +1710,26 @@ void SDL_Quit()
} }
char* SDL_GetError() const char* SDL_GetError()
{ {
static char empty[] = {0}; static char empty[] = {0};
return empty; return empty;
} }
char* SDL_VideoDriverName(char* namebuf, int maxlen) const char* SDL_GetCurrentVideoDriver()
{ {
return strncpy(namebuf, "Native OpenGL", maxlen); return "Native OpenGL";
} }
const SDL_VideoInfo* SDL_GetVideoInfo() int SDL_GetDesktopDisplayMode(int displayIndex, SDL_DisplayMode *mode)
{ {
// NOTE: Only required fields are assigned // NOTE: Only required fields are assigned
static SDL_PixelFormat pixelFormat;
memset(&pixelFormat, 0, sizeof(pixelFormat));
pixelFormat.BitsPerPixel = 32;
static SDL_VideoInfo videoInfo;
memset(&videoInfo, 0, sizeof(videoInfo));
const NSRect displayRect = [[NSScreen mainScreen] frame]; const NSRect displayRect = [[NSScreen mainScreen] frame];
videoInfo.current_w = displayRect.size.width; mode->w = displayRect.size.width;
videoInfo.current_h = displayRect.size.height; mode->h = displayRect.size.height;
videoInfo.vfmt = &pixelFormat;
return &videoInfo;
}
SDL_Rect** SDL_ListModes(SDL_PixelFormat* format, Uint32 flags)
{
ZD_UNUSED(format);
ZD_UNUSED(flags);
static std::vector<SDL_Rect*> resolutions;
if (resolutions.empty())
{
#define DEFINE_RESOLUTION(WIDTH, HEIGHT) \
static SDL_Rect resolution_##WIDTH##_##HEIGHT = { 0, 0, WIDTH, HEIGHT }; \
resolutions.push_back(&resolution_##WIDTH##_##HEIGHT);
DEFINE_RESOLUTION( 640, 480);
DEFINE_RESOLUTION( 720, 480);
DEFINE_RESOLUTION( 800, 480);
DEFINE_RESOLUTION( 800, 600);
DEFINE_RESOLUTION(1024, 600);
DEFINE_RESOLUTION(1024, 640);
DEFINE_RESOLUTION(1024, 768);
DEFINE_RESOLUTION(1152, 720);
DEFINE_RESOLUTION(1152, 864);
DEFINE_RESOLUTION(1280, 720);
DEFINE_RESOLUTION(1280, 768);
DEFINE_RESOLUTION(1280, 800);
DEFINE_RESOLUTION(1280, 854);
DEFINE_RESOLUTION(1280, 960);
DEFINE_RESOLUTION(1280, 1024);
DEFINE_RESOLUTION(1366, 768);
DEFINE_RESOLUTION(1400, 1050);
DEFINE_RESOLUTION(1440, 900);
DEFINE_RESOLUTION(1440, 960);
DEFINE_RESOLUTION(1440, 1080);
DEFINE_RESOLUTION(1600, 900);
DEFINE_RESOLUTION(1600, 1200);
DEFINE_RESOLUTION(1680, 1050);
DEFINE_RESOLUTION(1920, 1080);
DEFINE_RESOLUTION(1920, 1200);
DEFINE_RESOLUTION(2048, 1080);
DEFINE_RESOLUTION(2048, 1536);
DEFINE_RESOLUTION(2560, 1080);
DEFINE_RESOLUTION(2560, 1440);
DEFINE_RESOLUTION(2560, 1600);
DEFINE_RESOLUTION(2560, 2048);
DEFINE_RESOLUTION(2880, 1800);
DEFINE_RESOLUTION(3200, 1800);
DEFINE_RESOLUTION(3440, 1440);
DEFINE_RESOLUTION(3840, 2160);
DEFINE_RESOLUTION(3840, 2400);
DEFINE_RESOLUTION(4096, 2160);
DEFINE_RESOLUTION(5120, 2880);
#undef DEFINE_RESOLUTION
resolutions.push_back(NULL);
}
return &resolutions[0];
}
int SDL_ShowCursor(int)
{
// Does nothing
return 0; return 0;
} }
@ -1829,72 +1753,150 @@ static SDL_PixelFormat* GetPixelFormat()
result.Gmask = 0x0000FF00; result.Gmask = 0x0000FF00;
result.Bmask = 0x00FF0000; result.Bmask = 0x00FF0000;
result.Amask = 0xFF000000; result.Amask = 0xFF000000;
result.colorkey = 0;
result.alpha = 0xFF;
return &result; return &result;
} }
SDL_bool SDL_PixelFormatEnumToMasks(Uint32 format, int* bpp, Uint32* Rmask, Uint32* Gmask, Uint32* Bmask, Uint32* Amask)
SDL_Surface* SDL_SetVideoMode(int width, int height, int, Uint32 flags)
{ {
[appCtrl changeVideoResolution:(SDL_FULLSCREEN & flags) assert(format == SDL_PIXELFORMAT_ABGR8888);
*bpp = 32;
*Rmask = 0x000000FF;
*Gmask = 0x0000FF00;
*Bmask = 0x00FF0000;
*Amask = 0xFF000000;
return SDL_TRUE;
}
struct SDL_Window
{
Uint32 flags;
int w, h;
int pitch;
void *pixels;
};
struct SDL_Renderer { SDL_Window *window; };
struct SDL_Texture { SDL_Window *window; };
SDL_Window* SDL_CreateWindow(const char* title, int x, int y, int width, int height, Uint32 flags)
{
[appCtrl changeVideoResolution:(SDL_WINDOW_FULLSCREEN_DESKTOP & flags)
width:width width:width
height:height height:height
useHiDPI:vid_hidpi]; useHiDPI:vid_hidpi];
static SDL_Surface result; static SDL_Window result;
if (!(SDL_OPENGL & flags)) if (!(SDL_WINDOW_OPENGL & flags))
{ {
[appCtrl setupSoftwareRenderingWithWidth:width [appCtrl setupSoftwareRenderingWithWidth:width
height:height]; height:height];
} }
result.flags = flags; result.flags = flags;
result.format = GetPixelFormat();
result.w = width; result.w = width;
result.h = height; result.h = height;
result.pitch = width * BYTES_PER_PIXEL; result.pitch = width * BYTES_PER_PIXEL;
result.pixels = [appCtrl softwareRenderingBuffer]; result.pixels = [appCtrl softwareRenderingBuffer];
result.refcount = 1;
result.clip_rect.x = 0;
result.clip_rect.y = 0;
result.clip_rect.w = width;
result.clip_rect.h = height;
return &result; return &result;
} }
void SDL_DestroyWindow(SDL_Window *window)
void SDL_WM_SetCaption(const char* title, const char* icon)
{ {
ZD_UNUSED(title); ZD_UNUSED(window);
ZD_UNUSED(icon);
// Window title is set in SDL_SetVideoMode()
} }
int SDL_WM_ToggleFullScreen(SDL_Surface* surface) Uint32 SDL_GetWindowFlags(SDL_Window *window)
{ {
if (surface->flags & SDL_FULLSCREEN) return window->flags;
}
SDL_Surface *SDL_GetWindowSurface(SDL_Window *window)
{ {
surface->flags &= ~SDL_FULLSCREEN; ZD_UNUSED(window);
return NULL;
}
void SDL_GetWindowSize(SDL_Window *window, int *w, int *h)
{
*w = window->w;
*h = window->h;
}
void SDL_SetWindowSize(SDL_Window *window, int w, int h)
{
// Currently this is used for handling the fullscreen->windowed transition.
// We can just no-op this for now.
ZD_UNUSED(window);
ZD_UNUSED(w);
ZD_UNUSED(h);
}
int SDL_SetWindowFullscreen(SDL_Window* window, Uint32 flags)
{
if ((window->flags & SDL_WINDOW_FULLSCREEN_DESKTOP) == (flags & SDL_WINDOW_FULLSCREEN_DESKTOP))
return 0;
if (window->flags & SDL_WINDOW_FULLSCREEN_DESKTOP)
{
window->flags &= ~SDL_WINDOW_FULLSCREEN_DESKTOP;
} }
else else
{ {
surface->flags |= SDL_FULLSCREEN; window->flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
} }
[appCtrl changeVideoResolution:(SDL_FULLSCREEN & surface->flags) [appCtrl changeVideoResolution:(SDL_WINDOW_FULLSCREEN_DESKTOP & flags)
width:surface->w width:window->w
height:surface->h height:window->h
useHiDPI:vid_hidpi]; useHiDPI:vid_hidpi];
return 1; return 0;
} }
SDL_Renderer *SDL_CreateRenderer(SDL_Window *window, int index, Uint32 flags)
{
ZD_UNUSED(index);
ZD_UNUSED(flags);
static SDL_Renderer result;
result.window = window;
return &result;
}
void SDL_DestroyRenderer(SDL_Renderer *renderer)
{
ZD_UNUSED(renderer);
}
SDL_Texture *SDL_CreateTexture(SDL_Renderer *renderer, Uint32 format, int access, int w, int h)
{
ZD_UNUSED(format);
ZD_UNUSED(access);
ZD_UNUSED(w);
ZD_UNUSED(h);
static SDL_Texture result;
result.window = renderer->window;
return &result;
}
void SDL_DestroyTexture(SDL_Texture *texture)
{
ZD_UNUSED(texture);
}
int SDL_QueryTexture(SDL_Texture *texture, Uint32* format, int* access, int* w, int* h)
{
if(format) *format = SDL_PIXELFORMAT_ABGR8888;
if(access) *access = SDL_TEXTUREACCESS_STREAMING;
if(w) *w = texture->window->w;
if(h) *h = texture->window->h;
return 0;
}
void SDL_GL_SwapBuffers() void SDL_GL_SwapBuffers()
{ {
@ -1926,18 +1928,22 @@ void SDL_UnlockSurface(SDL_Surface* surface)
ZD_UNUSED(surface); ZD_UNUSED(surface);
} }
int SDL_BlitSurface(SDL_Surface* src, SDL_Rect* srcrect, SDL_Surface* dst, SDL_Rect* dstrect) int SDL_LockTexture(SDL_Texture* texture, const SDL_Rect *rect, void** pixels, int *pitch)
{ {
ZD_UNUSED(src); assert(NULL == rect);
ZD_UNUSED(srcrect);
ZD_UNUSED(dst); *pixels = texture->window->pixels;
ZD_UNUSED(dstrect); *pitch = texture->window->pitch;
return 0; return 0;
} }
void SDL_UnlockTexture(SDL_Texture *texture)
{
ZD_UNUSED(texture);
}
int SDL_Flip(SDL_Surface* screen) int SDL_UpdateWindowSurface(SDL_Window *screen)
{ {
assert(NULL != screen); assert(NULL != screen);
@ -1984,10 +1990,24 @@ int SDL_Flip(SDL_Surface* screen)
return 0; return 0;
} }
int SDL_SetPalette(SDL_Surface* surface, int flags, SDL_Color* colors, int firstcolor, int ncolors) int SDL_RenderCopy(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcrect, const SDL_Rect *dstrect)
{ {
ZD_UNUSED(surface); ZD_UNUSED(renderer);
ZD_UNUSED(flags); ZD_UNUSED(texture);
ZD_UNUSED(srcrect);
ZD_UNUSED(dstrect);
return 0;
}
void SDL_RenderPresent(SDL_Renderer *renderer)
{
SDL_UpdateWindowSurface(renderer->window);
}
int SDL_SetPaletteColors(SDL_Palette* palette, const SDL_Color* colors, int firstcolor, int ncolors)
{
ZD_UNUSED(palette);
ZD_UNUSED(colors); ZD_UNUSED(colors);
ZD_UNUSED(firstcolor); ZD_UNUSED(firstcolor);
ZD_UNUSED(ncolors); ZD_UNUSED(ncolors);
@ -2127,10 +2147,6 @@ DarwinVersion GetDarwinVersion()
const DarwinVersion darwinVersion = GetDarwinVersion(); const DarwinVersion darwinVersion = GetDarwinVersion();
#ifdef main
#undef main
#endif // main
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
gettimeofday(&s_startTicks, NULL); gettimeofday(&s_startTicks, NULL);

0
src/sdl/i_system_cocoa.mm → src/cocoa/i_system_cocoa.mm
View file

0
src/sdl/iwadpicker_cocoa.mm → src/cocoa/iwadpicker_cocoa.mm
View file

6
src/menu/videomenu.cpp
View file

@ -247,8 +247,12 @@ static void BuildModesList (int hiwidth, int hiheight, int hi_bits)
if (Video != NULL) if (Video != NULL)
{ {
while ((haveMode = Video->NextMode (&width, &height, &letterbox)) && while ((haveMode = Video->NextMode (&width, &height, &letterbox)) &&
(ratiomatch >= 0 && CheckRatio (width, height) != ratiomatch)) ratiomatch >= 0)
{ {
int ratio;
CheckRatio (width, height, &ratio);
if (ratio == ratiomatch)
break;
} }
} }

93
src/sdl/i_gui.cpp
View file

@ -9,61 +9,11 @@
#include "v_palette.h" #include "v_palette.h"
#include "textures.h" #include "textures.h"
extern SDL_Surface *cursorSurface;
extern SDL_Rect cursorBlit;
#ifdef USE_XCURSOR
// Xlib has its own GC, so don't let it interfere.
#define GC XGC
#include <X11/Xcursor/Xcursor.h>
#undef GC
bool UseXCursor;
SDL_Cursor *X11Cursor;
SDL_Cursor *FirstCursor;
// Hack! Hack! SDL does not provide a clean way to get the XDisplay.
// On the other hand, there are no more planned updates for SDL 1.2,
// so we should be fine making assumptions.
struct SDL_PrivateVideoData
{
int local_X11;
Display *X11_Display;
};
struct SDL_VideoDevice
{
const char *name;
int (*functions[9])();
SDL_VideoInfo info;
SDL_PixelFormat *displayformatalphapixel;
int (*morefuncs[9])();
Uint16 *gamma;
int (*somefuncs[9])();
unsigned int texture; // Only here if SDL was compiled with OpenGL support. Ack!
int is_32bit;
int (*itsafuncs[13])();
SDL_Surface *surfaces[3];
SDL_Palette *physpal;
SDL_Color *gammacols;
char *wm_strings[2];
int offsets[2];
SDL_GrabMode input_grab;
int handles_any_size;
SDL_PrivateVideoData *hidden; // Why did they have to bury this so far in?
};
extern SDL_VideoDevice *current_video;
#define SDL_Display (current_video->hidden->X11_Display)
SDL_Cursor *CreateColorCursor(FTexture *cursorpic)
{
return NULL;
}
#endif
bool I_SetCursor(FTexture *cursorpic) bool I_SetCursor(FTexture *cursorpic)
{ {
static SDL_Cursor *cursor;
static SDL_Surface *cursorSurface;
if (cursorpic != NULL && cursorpic->UseType != FTexture::TEX_Null) if (cursorpic != NULL && cursorpic->UseType != FTexture::TEX_Null)
{ {
// Must be no larger than 32x32. // Must be no larger than 32x32.
@ -72,25 +22,9 @@ bool I_SetCursor(FTexture *cursorpic)
return false; return false;
} }
#ifdef USE_XCURSOR
if (UseXCursor)
{
if (FirstCursor == NULL)
{
FirstCursor = SDL_GetCursor();
}
X11Cursor = CreateColorCursor(cursorpic);
if (X11Cursor != NULL)
{
SDL_SetCursor(X11Cursor);
return true;
}
}
#endif
if (cursorSurface == NULL) if (cursorSurface == NULL)
cursorSurface = SDL_CreateRGBSurface (0, 32, 32, 32, MAKEARGB(0,255,0,0), MAKEARGB(0,0,255,0), MAKEARGB(0,0,0,255), MAKEARGB(255,0,0,0)); cursorSurface = SDL_CreateRGBSurface (0, 32, 32, 32, MAKEARGB(0,255,0,0), MAKEARGB(0,0,255,0), MAKEARGB(0,0,0,255), MAKEARGB(255,0,0,0));
SDL_ShowCursor(0);
SDL_LockSurface(cursorSurface); SDL_LockSurface(cursorSurface);
BYTE buffer[32*32*4]; BYTE buffer[32*32*4];
memset(buffer, 0, 32*32*4); memset(buffer, 0, 32*32*4);
@ -98,24 +32,25 @@ bool I_SetCursor(FTexture *cursorpic)
cursorpic->CopyTrueColorPixels(&bmp, 0, 0); cursorpic->CopyTrueColorPixels(&bmp, 0, 0);
memcpy(cursorSurface->pixels, bmp.GetPixels(), 32*32*4); memcpy(cursorSurface->pixels, bmp.GetPixels(), 32*32*4);
SDL_UnlockSurface(cursorSurface); SDL_UnlockSurface(cursorSurface);
if (cursor)
SDL_FreeCursor (cursor);
cursor = SDL_CreateColorCursor (cursorSurface, 0, 0);
SDL_SetCursor (cursor);
} }
else else
{ {
SDL_ShowCursor(1); if (cursor)
{
SDL_SetCursor (NULL);
SDL_FreeCursor (cursor);
cursor = NULL;
}
if (cursorSurface != NULL) if (cursorSurface != NULL)
{ {
SDL_FreeSurface(cursorSurface); SDL_FreeSurface(cursorSurface);
cursorSurface = NULL; cursorSurface = NULL;
} }
#ifdef USE_XCURSOR
if (X11Cursor != NULL)
{
SDL_SetCursor(FirstCursor);
SDL_FreeCursor(X11Cursor);
X11Cursor = NULL;
}
#endif
} }
return true; return true;
} }

317
src/sdl/i_input.cpp
View file

@ -18,6 +18,8 @@
#include "templates.h" #include "templates.h"
#include "s_sound.h" #include "s_sound.h"
void ScaleWithAspect (int &w, int &h, int Width, int Height);
static void I_CheckGUICapture (); static void I_CheckGUICapture ();
static void I_CheckNativeMouse (); static void I_CheckNativeMouse ();
@ -29,31 +31,27 @@ extern int paused;
CVAR (Bool, use_mouse, true, CVAR_ARCHIVE|CVAR_GLOBALCONFIG) CVAR (Bool, use_mouse, true, CVAR_ARCHIVE|CVAR_GLOBALCONFIG)
CVAR (Bool, m_noprescale, false, CVAR_ARCHIVE|CVAR_GLOBALCONFIG) CVAR (Bool, m_noprescale, false, CVAR_ARCHIVE|CVAR_GLOBALCONFIG)
CVAR (Bool, m_filter, false, CVAR_ARCHIVE|CVAR_GLOBALCONFIG) CVAR (Bool, m_filter, false, CVAR_ARCHIVE|CVAR_GLOBALCONFIG)
CVAR (Bool, sdl_nokeyrepeat, false, CVAR_ARCHIVE|CVAR_GLOBALCONFIG)
EXTERN_CVAR (Bool, fullscreen) EXTERN_CVAR (Bool, fullscreen)
extern int WaitingForKey, chatmodeon; extern int WaitingForKey, chatmodeon;
extern constate_e ConsoleState; extern constate_e ConsoleState;
extern SDL_Surface *cursorSurface; static bool DownState[SDL_NUM_SCANCODES];
extern SDL_Rect cursorBlit;
static BYTE KeySymToDIK[SDLK_LAST], DownState[SDLK_LAST]; static const SDL_Keycode DIKToKeySym[256] =
static WORD DIKToKeySym[256] =
{ {
0, SDLK_ESCAPE, '1', '2', '3', '4', '5', '6', 0, SDLK_ESCAPE, SDLK_1, SDLK_2, SDLK_3, SDLK_4, SDLK_5, SDLK_6,
'7', '8', '9', '0', '-', '=', SDLK_BACKSPACE, SDLK_TAB, SDLK_7, SDLK_8, SDLK_9, SDLK_0,SDLK_MINUS, SDLK_EQUALS, SDLK_BACKSPACE, SDLK_TAB,
'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', SDLK_q, SDLK_w, SDLK_e, SDLK_r, SDLK_t, SDLK_y, SDLK_u, SDLK_i,
'o', 'p', '[', ']', SDLK_RETURN, SDLK_LCTRL, 'a', 's', SDLK_o, SDLK_p, SDLK_LEFTBRACKET, SDLK_RIGHTBRACKET, SDLK_RETURN, SDLK_LCTRL, SDLK_a, SDLK_s,
'd', 'f', 'g', 'h', 'j', 'k', 'l', SDLK_SEMICOLON, SDLK_d, SDLK_f, SDLK_g, SDLK_h, SDLK_j, SDLK_k, SDLK_l, SDLK_SEMICOLON,
'\'', '`', SDLK_LSHIFT, '\\', 'z', 'x', 'c', 'v', SDLK_QUOTE, SDLK_BACKQUOTE, SDLK_LSHIFT, SDLK_BACKSLASH, SDLK_z, SDLK_x, SDLK_c, SDLK_v,
'b', 'n', 'm', ',', '.', '/', SDLK_RSHIFT, SDLK_KP_MULTIPLY, SDLK_b, SDLK_n, SDLK_m, SDLK_COMMA, SDLK_PERIOD, SDLK_SLASH, SDLK_RSHIFT, SDLK_KP_MULTIPLY,
SDLK_LALT, ' ', SDLK_CAPSLOCK, SDLK_F1, SDLK_F2, SDLK_F3, SDLK_F4, SDLK_F5, SDLK_LALT, SDLK_SPACE, SDLK_CAPSLOCK, SDLK_F1, SDLK_F2, SDLK_F3, SDLK_F4, SDLK_F5,
SDLK_F6, SDLK_F7, SDLK_F8, SDLK_F9, SDLK_F10, SDLK_NUMLOCK, SDLK_SCROLLOCK, SDLK_KP7, SDLK_F6, SDLK_F7, SDLK_F8, SDLK_F9, SDLK_F10, SDLK_NUMLOCKCLEAR, SDLK_SCROLLLOCK, SDLK_KP_7,
SDLK_KP8, SDLK_KP9, SDLK_KP_MINUS, SDLK_KP4, SDLK_KP5, SDLK_KP6, SDLK_KP_PLUS, SDLK_KP1, SDLK_KP_8, SDLK_KP_9, SDLK_KP_MINUS, SDLK_KP_4, SDLK_KP_5, SDLK_KP_6, SDLK_KP_PLUS, SDLK_KP_1,
SDLK_KP2, SDLK_KP3, SDLK_KP0, SDLK_KP_PERIOD, 0, 0, 0, SDLK_F11, SDLK_KP_2, SDLK_KP_3, SDLK_KP_0, SDLK_KP_PERIOD, 0, 0, 0, SDLK_F11,
SDLK_F12, 0, 0, 0, 0, 0, 0, 0, SDLK_F12, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, SDLK_F13, SDLK_F14, SDLK_F15, 0, 0, 0, 0, 0, SDLK_F13, SDLK_F14, SDLK_F15, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@ -65,24 +63,58 @@ static WORD DIKToKeySym[256] =
0, 0, 0, 0, SDLK_KP_ENTER, SDLK_RCTRL, 0, 0, 0, 0, 0, 0, SDLK_KP_ENTER, SDLK_RCTRL, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, SDLK_KP_DIVIDE, 0, SDLK_SYSREQ, 0, 0, 0, SDLK_KP_COMMA, 0, SDLK_KP_DIVIDE, 0, SDLK_SYSREQ,
SDLK_RALT, 0, 0, 0, 0, 0, 0, 0, SDLK_RALT, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, SDLK_PAUSE, 0, SDLK_HOME, 0, 0, 0, 0, 0, SDLK_PAUSE, 0, SDLK_HOME,
SDLK_UP, SDLK_PAGEUP, 0, SDLK_LEFT, 0, SDLK_RIGHT, 0, SDLK_END, SDLK_UP, SDLK_PAGEUP, 0, SDLK_LEFT, 0, SDLK_RIGHT, 0, SDLK_END,
SDLK_DOWN, SDLK_PAGEDOWN, SDLK_INSERT, SDLK_DELETE, 0, 0, 0, 0, SDLK_DOWN, SDLK_PAGEDOWN, SDLK_INSERT, SDLK_DELETE, 0, 0, 0, 0,
0, 0, 0, SDLK_LSUPER, SDLK_RSUPER, SDLK_MENU, SDLK_POWER, 0, 0, 0, 0, SDLK_LGUI, SDLK_RGUI, SDLK_MENU, SDLK_POWER, SDLK_SLEEP,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SDLK_AC_SEARCH, SDLK_AC_BOOKMARKS, SDLK_AC_REFRESH,
0, 0, 0, 0, 0, 0, 0, 0, SDLK_AC_STOP, SDLK_AC_FORWARD, SDLK_AC_BACK, SDLK_COMPUTER, SDLK_MAIL, SDLK_MEDIASELECT, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0 0, 0, 0, 0, 0, 0, 0, 0
}; };
static void FlushDIKState (int low=0, int high=NUM_KEYS-1) static const SDL_Scancode DIKToKeyScan[256] =
{ {
} SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_ESCAPE, SDL_SCANCODE_1, SDL_SCANCODE_2, SDL_SCANCODE_3, SDL_SCANCODE_4, SDL_SCANCODE_5, SDL_SCANCODE_6,
SDL_SCANCODE_7, SDL_SCANCODE_8, SDL_SCANCODE_9, SDL_SCANCODE_0 ,SDL_SCANCODE_MINUS, SDL_SCANCODE_EQUALS, SDL_SCANCODE_BACKSPACE, SDL_SCANCODE_TAB,
SDL_SCANCODE_Q, SDL_SCANCODE_W, SDL_SCANCODE_E, SDL_SCANCODE_R, SDL_SCANCODE_T, SDL_SCANCODE_Y, SDL_SCANCODE_U, SDL_SCANCODE_I,
SDL_SCANCODE_O, SDL_SCANCODE_P, SDL_SCANCODE_LEFTBRACKET, SDL_SCANCODE_RIGHTBRACKET, SDL_SCANCODE_RETURN, SDL_SCANCODE_LCTRL, SDL_SCANCODE_A, SDL_SCANCODE_S,
SDL_SCANCODE_D, SDL_SCANCODE_F, SDL_SCANCODE_G, SDL_SCANCODE_H, SDL_SCANCODE_J, SDL_SCANCODE_K, SDL_SCANCODE_L, SDL_SCANCODE_SEMICOLON,
SDL_SCANCODE_APOSTROPHE, SDL_SCANCODE_GRAVE, SDL_SCANCODE_LSHIFT, SDL_SCANCODE_BACKSLASH, SDL_SCANCODE_Z, SDL_SCANCODE_X, SDL_SCANCODE_C, SDL_SCANCODE_V,
SDL_SCANCODE_B, SDL_SCANCODE_N, SDL_SCANCODE_M, SDL_SCANCODE_COMMA, SDL_SCANCODE_PERIOD, SDL_SCANCODE_SLASH, SDL_SCANCODE_RSHIFT, SDL_SCANCODE_KP_MULTIPLY,
SDL_SCANCODE_LALT, SDL_SCANCODE_SPACE, SDL_SCANCODE_CAPSLOCK, SDL_SCANCODE_F1, SDL_SCANCODE_F2, SDL_SCANCODE_F3, SDL_SCANCODE_F4, SDL_SCANCODE_F5,
SDL_SCANCODE_F6, SDL_SCANCODE_F7, SDL_SCANCODE_F8, SDL_SCANCODE_F9, SDL_SCANCODE_F10, SDL_SCANCODE_NUMLOCKCLEAR, SDL_SCANCODE_SCROLLLOCK, SDL_SCANCODE_KP_7,
SDL_SCANCODE_KP_8, SDL_SCANCODE_KP_9, SDL_SCANCODE_KP_MINUS, SDL_SCANCODE_KP_4, SDL_SCANCODE_KP_5, SDL_SCANCODE_KP_6, SDL_SCANCODE_KP_PLUS, SDL_SCANCODE_KP_1,
SDL_SCANCODE_KP_2, SDL_SCANCODE_KP_3, SDL_SCANCODE_KP_0, SDL_SCANCODE_KP_PERIOD, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_F11,
SDL_SCANCODE_F12, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_F13, SDL_SCANCODE_F14, SDL_SCANCODE_F15, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_KP_EQUALS, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_KP_ENTER, SDL_SCANCODE_RCTRL, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_KP_COMMA, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_KP_DIVIDE, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_SYSREQ,
SDL_SCANCODE_RALT, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_PAUSE, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_HOME,
SDL_SCANCODE_UP, SDL_SCANCODE_PAGEUP, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_LEFT, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_RIGHT, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_END,
SDL_SCANCODE_DOWN, SDL_SCANCODE_PAGEDOWN, SDL_SCANCODE_INSERT, SDL_SCANCODE_DELETE, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_LGUI, SDL_SCANCODE_RGUI, SDL_SCANCODE_MENU, SDL_SCANCODE_POWER, SDL_SCANCODE_SLEEP,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_AC_SEARCH, SDL_SCANCODE_AC_BOOKMARKS, SDL_SCANCODE_AC_REFRESH,
SDL_SCANCODE_AC_STOP, SDL_SCANCODE_AC_FORWARD, SDL_SCANCODE_AC_BACK, SDL_SCANCODE_COMPUTER, SDL_SCANCODE_MAIL, SDL_SCANCODE_MEDIASELECT, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN
};
static void InitKeySymMap () static TMap<SDL_Keycode, BYTE> InitKeySymMap ()
{ {
TMap<SDL_Keycode, BYTE> KeySymToDIK;
for (int i = 0; i < 256; ++i) for (int i = 0; i < 256; ++i)
{ {
KeySymToDIK[DIKToKeySym[i]] = i; KeySymToDIK[DIKToKeySym[i]] = i;
@ -92,16 +124,28 @@ static void InitKeySymMap ()
KeySymToDIK[SDLK_RCTRL] = DIK_LCONTROL; KeySymToDIK[SDLK_RCTRL] = DIK_LCONTROL;
KeySymToDIK[SDLK_RALT] = DIK_LMENU; KeySymToDIK[SDLK_RALT] = DIK_LMENU;
// Depending on your Linux flavor, you may get SDLK_PRINT or SDLK_SYSREQ // Depending on your Linux flavor, you may get SDLK_PRINT or SDLK_SYSREQ
KeySymToDIK[SDLK_PRINT] = DIK_SYSRQ; KeySymToDIK[SDLK_PRINTSCREEN] = DIK_SYSRQ;
return KeySymToDIK;
} }
static const TMap<SDL_Keycode, BYTE> KeySymToDIK(InitKeySymMap());
static TMap<SDL_Scancode, BYTE> InitKeyScanMap ()
{
TMap<SDL_Scancode, BYTE> KeyScanToDIK;
for (int i = 0; i < 256; ++i)
{
KeyScanToDIK[DIKToKeyScan[i]] = i;
}
return KeyScanToDIK;
}
static const TMap<SDL_Scancode, BYTE> KeyScanToDIK(InitKeyScanMap());
static void I_CheckGUICapture () static void I_CheckGUICapture ()
{ {
bool wantCapt; bool wantCapt;
bool repeat;
int oldrepeat, interval;
SDL_GetKeyRepeat(&oldrepeat, &interval);
if (menuactive == MENU_Off) if (menuactive == MENU_Off)
{ {
@ -117,56 +161,21 @@ static void I_CheckGUICapture ()
GUICapture = wantCapt; GUICapture = wantCapt;
if (wantCapt) if (wantCapt)
{ {
int x, y;
SDL_GetMouseState (&x, &y);
cursorBlit.x = x;
cursorBlit.y = y;
FlushDIKState ();
memset (DownState, 0, sizeof(DownState)); memset (DownState, 0, sizeof(DownState));
repeat = !sdl_nokeyrepeat;
SDL_EnableUNICODE (1);
}
else
{
repeat = false;
SDL_EnableUNICODE (0);
}
}
if (wantCapt)
{
repeat = !sdl_nokeyrepeat;
}
else
{
repeat = false;
}
if (repeat != (oldrepeat != 0))
{
if (repeat)
{
SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
}
else
{
SDL_EnableKeyRepeat (0, 0);
} }
} }
} }
void I_SetMouseCapture() void I_SetMouseCapture()
{ {
// Clear out any mouse movement.
SDL_GetRelativeMouseState (NULL, NULL);
SDL_SetRelativeMouseMode (SDL_TRUE);
} }
void I_ReleaseMouseCapture() void I_ReleaseMouseCapture()
{ {
} SDL_SetRelativeMouseMode (SDL_FALSE);
static void CenterMouse ()
{
SDL_WarpMouse (screen->GetWidth()/2, screen->GetHeight()/2);
SDL_PumpEvents ();
SDL_GetRelativeMouseState (NULL, NULL);
} }
static void PostMouseMove (int x, int y) static void PostMouseMove (int x, int y)
@ -210,33 +219,10 @@ static void MouseRead ()
} }
if (x | y) if (x | y)
{ {
CenterMouse ();
PostMouseMove (x, -y); PostMouseMove (x, -y);
} }
} }
static void WheelMoved(event_t *event)
{
if (GUICapture)
{
if (event->type != EV_KeyUp)
{
SDLMod mod = SDL_GetModState();
event->type = EV_GUI_Event;
event->subtype = event->data1 == KEY_MWHEELUP ? EV_GUI_WheelUp : EV_GUI_WheelDown;
event->data1 = 0;
event->data3 = ((mod & KMOD_SHIFT) ? GKM_SHIFT : 0) |
((mod & KMOD_CTRL) ? GKM_CTRL : 0) |
((mod & KMOD_ALT) ? GKM_ALT : 0);
D_PostEvent(event);
}
}
else
{
D_PostEvent(event);
}
}
CUSTOM_CVAR(Int, mouse_capturemode, 1, CVAR_GLOBALCONFIG|CVAR_ARCHIVE) CUSTOM_CVAR(Int, mouse_capturemode, 1, CVAR_GLOBALCONFIG|CVAR_ARCHIVE)
{ {
if (self < 0) self = 0; if (self < 0) self = 0;
@ -259,26 +245,19 @@ static bool inGame()
static void I_CheckNativeMouse () static void I_CheckNativeMouse ()
{ {
bool focus = (SDL_GetAppState() & (SDL_APPINPUTFOCUS|SDL_APPACTIVE)) bool focus = SDL_GetKeyboardFocus() != NULL;
== (SDL_APPINPUTFOCUS|SDL_APPACTIVE); bool fs = screen->IsFullscreen();
bool fs = (SDL_GetVideoSurface ()->flags & SDL_FULLSCREEN) != 0;
bool wantNative = !focus || (!use_mouse || GUICapture || paused || demoplayback || !inGame()); bool wantNative = !focus || (!use_mouse || GUICapture || paused || demoplayback || !inGame());
if (wantNative != NativeMouse) if (wantNative != NativeMouse)
{ {
NativeMouse = wantNative; NativeMouse = wantNative;
SDL_ShowCursor (wantNative ? cursorSurface == NULL : 0); SDL_ShowCursor (wantNative);
if (wantNative) if (wantNative)
{ I_ReleaseMouseCapture ();
SDL_WM_GrabInput (SDL_GRAB_OFF);
FlushDIKState (KEY_MOUSE1, KEY_MOUSE8);
}
else else
{ I_SetMouseCapture ();
SDL_WM_GrabInput (SDL_GRAB_ON);
CenterMouse ();
}
} }
} }
@ -293,14 +272,13 @@ void MessagePump (const SDL_Event &sev)
case SDL_QUIT: case SDL_QUIT:
exit (0); exit (0);
case SDL_ACTIVEEVENT: case SDL_WINDOWEVENT:
if (sev.active.state == SDL_APPINPUTFOCUS) switch (sev.window.event)
{ {
if (sev.active.gain == 0) case SDL_WINDOWEVENT_FOCUS_GAINED:
{ // kill focus case SDL_WINDOWEVENT_FOCUS_LOST:
FlushDIKState (); S_SetSoundPaused(sev.window.event == SDL_WINDOWEVENT_FOCUS_GAINED);
} break;
S_SetSoundPaused(sev.active.gain);
} }
break; break;
@ -320,42 +298,57 @@ void MessagePump (const SDL_Event &sev)
*/ */
switch (sev.button.button) switch (sev.button.button)
{ {
case 1: event.data1 = KEY_MOUSE1; break; case SDL_BUTTON_LEFT: event.data1 = KEY_MOUSE1; break;
case 2: event.data1 = KEY_MOUSE3; break; case SDL_BUTTON_MIDDLE: event.data1 = KEY_MOUSE3; break;
case 3: event.data1 = KEY_MOUSE2; break; case SDL_BUTTON_RIGHT: event.data1 = KEY_MOUSE2; break;
case 4: event.data1 = KEY_MWHEELUP; break; case 8: event.data1 = KEY_MOUSE4; break; // For whatever reason my side mouse buttons are here.
case 5: event.data1 = KEY_MWHEELDOWN; break;
case 6: event.data1 = KEY_MOUSE4; break; /* dunno; not generated by my mouse */
case 7: event.data1 = KEY_MOUSE5; break; /* ditto */
case 8: event.data1 = KEY_MOUSE4; break;
case 9: event.data1 = KEY_MOUSE5; break; case 9: event.data1 = KEY_MOUSE5; break;
case 10: event.data1 = KEY_MOUSE6; break; case SDL_BUTTON_X1: event.data1 = KEY_MOUSE6; break; // And these don't exist
case 11: event.data1 = KEY_MOUSE7; break; case SDL_BUTTON_X2: event.data1 = KEY_MOUSE7; break;
case 12: event.data1 = KEY_MOUSE8; break; case 6: event.data1 = KEY_MOUSE8; break;
default: printf("SDL mouse button %s %d\n", default: printf("SDL mouse button %s %d\n",
sev.type == SDL_MOUSEBUTTONDOWN ? "down" : "up", sev.button.button); break; sev.type == SDL_MOUSEBUTTONDOWN ? "down" : "up", sev.button.button); break;
} }
if (event.data1 != 0) if (event.data1 != 0)
{
//DIKState[ActiveDIKState][event.data1] = (event.type == EV_KeyDown);
if (event.data1 == KEY_MWHEELUP || event.data1 == KEY_MWHEELDOWN)
{
WheelMoved(&event);
}
else
{ {
D_PostEvent(&event); D_PostEvent(&event);
} }
} }
} }
}
else if (sev.type == SDL_MOUSEMOTION || (sev.button.button >= 1 && sev.button.button <= 3)) else if (sev.type == SDL_MOUSEMOTION || (sev.button.button >= 1 && sev.button.button <= 3))
{ {
int x, y; int x, y;
SDL_GetMouseState (&x, &y); SDL_GetMouseState (&x, &y);
cursorBlit.x = event.data1 = x; // Detect if we're doing scaling in the Window and adjust the mouse
cursorBlit.y = event.data2 = y; // coordinates accordingly. This could be more efficent, but I
// don't think performance is an issue in the menus.
SDL_Window *focus;
if (screen->IsFullscreen() && (focus = SDL_GetMouseFocus ()))
{
int w, h;
SDL_GetWindowSize (focus, &w, &h);
int realw = w, realh = h;
ScaleWithAspect (realw, realh, SCREENWIDTH, SCREENHEIGHT);
if (realw != SCREENWIDTH || realh != SCREENHEIGHT)
{
double xratio = (double)SCREENWIDTH/realw;
double yratio = (double)SCREENHEIGHT/realh;
if (realw < w)
{
x = (x - (w - realw)/2)*xratio;
y *= yratio;
}
else
{
y = (y - (h - realh)/2)*yratio;
x *= xratio;
}
}
}
event.data1 = x;
event.data2 = y;
event.type = EV_GUI_Event; event.type = EV_GUI_Event;
if(sev.type == SDL_MOUSEMOTION) if(sev.type == SDL_MOUSEMOTION)
event.subtype = EV_GUI_MouseMove; event.subtype = EV_GUI_MouseMove;
@ -368,15 +361,38 @@ void MessagePump (const SDL_Event &sev)
} }
break; break;
case SDL_KEYDOWN: case SDL_MOUSEWHEEL:
case SDL_KEYUP: if (GUICapture)
if (sev.key.keysym.sym >= SDLK_LAST) {
event.type = EV_GUI_Event;
event.subtype = sev.wheel.y > 0 ? EV_GUI_WheelUp : EV_GUI_WheelDown;
D_PostEvent (&event);
}
else
{
event.type = EV_KeyDown;
event.data1 = sev.wheel.y > 0 ? KEY_MWHEELUP : KEY_MWHEELDOWN;
D_PostEvent (&event);
event.type = EV_KeyUp;
D_PostEvent (&event);
}
break; break;
case SDL_KEYDOWN:
case SDL_KEYUP:
if (!GUICapture) if (!GUICapture)
{ {
event.type = sev.type == SDL_KEYDOWN ? EV_KeyDown : EV_KeyUp; event.type = sev.type == SDL_KEYDOWN ? EV_KeyDown : EV_KeyUp;
event.data1 = KeySymToDIK[sev.key.keysym.sym];
// Try to look up our key mapped key for conversion to DirectInput.
// If that fails, then we'll do a lookup against the scan code,
// which may not return the right key, but at least the key should
// work in the game.
if (const BYTE *dik = KeySymToDIK.CheckKey (sev.key.keysym.sym))
event.data1 = *dik;
else if (const BYTE *dik = KeyScanToDIK.CheckKey (sev.key.keysym.scancode))
event.data1 = *dik;
if (event.data1) if (event.data1)
{ {
if (sev.key.keysym.sym < 256) if (sev.key.keysym.sym < 256)
@ -394,20 +410,17 @@ void MessagePump (const SDL_Event &sev)
((sev.key.keysym.mod & KMOD_CTRL) ? GKM_CTRL : 0) | ((sev.key.keysym.mod & KMOD_CTRL) ? GKM_CTRL : 0) |
((sev.key.keysym.mod & KMOD_ALT) ? GKM_ALT : 0); ((sev.key.keysym.mod & KMOD_ALT) ? GKM_ALT : 0);
if (sev.key.keysym.sym < SDLK_LAST)
{
if (event.subtype == EV_GUI_KeyDown) if (event.subtype == EV_GUI_KeyDown)
{ {
if (DownState[sev.key.keysym.sym]) if (DownState[sev.key.keysym.scancode])
{ {
event.subtype = EV_GUI_KeyRepeat; event.subtype = EV_GUI_KeyRepeat;
} }
DownState[sev.key.keysym.sym] = 1; DownState[sev.key.keysym.scancode] = 1;
} }
else else
{ {
DownState[sev.key.keysym.sym] = 0; DownState[sev.key.keysym.scancode] = 0;
}
} }
switch (sev.key.keysym.sym) switch (sev.key.keysym.sym)
@ -442,20 +455,21 @@ void MessagePump (const SDL_Event &sev)
} }
break; break;
} }
event.data2 = sev.key.keysym.unicode & 0xff;
if (event.data1 < 128) if (event.data1 < 128)
{ {
event.data1 = toupper(event.data1); event.data1 = toupper(event.data1);
D_PostEvent (&event); D_PostEvent (&event);
} }
if (!iscntrl(event.data2) && event.subtype != EV_GUI_KeyUp)
{
event.subtype = EV_GUI_Char;
event.data1 = event.data2;
event.data2 = sev.key.keysym.mod & KMOD_ALT;
event.data3 = 0;
D_PostEvent (&event);
} }
break;
case SDL_TEXTINPUT:
if (GUICapture)
{
event.type = EV_GUI_Event;
event.subtype = EV_GUI_Char;
event.data1 = sev.text.text[0];
D_PostEvent (&event);
} }
break; break;
@ -496,10 +510,5 @@ void I_StartTic ()
void I_ProcessJoysticks (); void I_ProcessJoysticks ();
void I_StartFrame () void I_StartFrame ()
{ {
if (KeySymToDIK[SDLK_BACKSPACE] == 0)
{
InitKeySymMap ();
}
I_ProcessJoysticks(); I_ProcessJoysticks();
} }

2
src/sdl/i_joystick.cpp
View file

@ -35,7 +35,7 @@ public:
FString GetName() FString GetName()
{ {
return SDL_JoystickName(DeviceIndex); return SDL_JoystickName(Device);
} }
float GetSensitivity() float GetSensitivity()
{ {

36
src/sdl/i_main.cpp
View file

@ -85,10 +85,6 @@ void Mac_I_FatalError(const char* errortext);
// EXTERNAL DATA DECLARATIONS ---------------------------------------------- // EXTERNAL DATA DECLARATIONS ----------------------------------------------
#ifdef USE_XCURSOR
extern bool UseXCursor;
#endif
// PUBLIC DATA DEFINITIONS ------------------------------------------------- // PUBLIC DATA DEFINITIONS -------------------------------------------------
#ifndef NO_GTK #ifndef NO_GTK
@ -241,7 +237,11 @@ void I_ShutdownJoysticks();
const char* I_GetBackEndName(); const char* I_GetBackEndName();
#ifdef USE_NATIVE_COCOA
int SDL_main (int argc, char **argv)
#else
int main (int argc, char **argv) int main (int argc, char **argv)
#endif
{ {
#if !defined (__APPLE__) #if !defined (__APPLE__)
{ {
@ -278,27 +278,13 @@ int main (int argc, char **argv)
} }
atterm (SDL_Quit); atterm (SDL_Quit);
{ printf("Using video driver %s\n", SDL_GetCurrentVideoDriver());
char viddriver[80];
if (SDL_VideoDriverName(viddriver, sizeof(viddriver)) != NULL)
{
printf("Using video driver %s\n", viddriver);
#ifdef USE_XCURSOR
UseXCursor = (strcmp(viddriver, "x11") == 0);
#endif
}
printf("\n"); printf("\n");
}
char caption[100];
mysnprintf(caption, countof(caption), GAMESIG " %s (%s)", GetVersionString(), GetGitTime());
SDL_WM_SetCaption(caption, caption);
#ifdef __APPLE__ #ifdef __APPLE__
EXTERN_CVAR( Int, vid_adapter )
const SDL_VideoInfo* videoInfo = SDL_GetVideoInfo(); SDL_DisplayMode videoInfo = {};
if ( NULL != videoInfo ) if ( SDL_GetDesktopDisplayMode (vid_adapter, &videoInfo) == 0 )
{ {
EXTERN_CVAR( Int, vid_defwidth ) EXTERN_CVAR( Int, vid_defwidth )
EXTERN_CVAR( Int, vid_defheight ) EXTERN_CVAR( Int, vid_defheight )
@ -306,13 +292,11 @@ int main (int argc, char **argv)
EXTERN_CVAR( Bool, vid_vsync ) EXTERN_CVAR( Bool, vid_vsync )
EXTERN_CVAR( Bool, fullscreen ) EXTERN_CVAR( Bool, fullscreen )
vid_defwidth = videoInfo->current_w; vid_defwidth = videoInfo.w;
vid_defheight = videoInfo->current_h; vid_defheight = videoInfo.h;
vid_defbits = videoInfo->vfmt->BitsPerPixel;
vid_vsync = true; vid_vsync = true;
fullscreen = true; fullscreen = true;
} }
#endif // __APPLE__ #endif // __APPLE__
try try

263
src/sdl/sdlvideo.cpp
View file

@ -12,6 +12,7 @@
#include "v_palette.h" #include "v_palette.h"
#include "sdlvideo.h" #include "sdlvideo.h"
#include "r_swrenderer.h" #include "r_swrenderer.h"
#include "version.h"
#include <SDL.h> #include <SDL.h>
@ -42,6 +43,7 @@ public:
bool SetGamma (float gamma); bool SetGamma (float gamma);
bool SetFlash (PalEntry rgb, int amount); bool SetFlash (PalEntry rgb, int amount);
void GetFlash (PalEntry &rgb, int &amount); void GetFlash (PalEntry &rgb, int &amount);
void SetFullscreen (bool fullscreen);
int GetPageCount (); int GetPageCount ();
bool IsFullscreen (); bool IsFullscreen ();
@ -57,13 +59,22 @@ private:
float Gamma; float Gamma;
bool UpdatePending; bool UpdatePending;
SDL_Surface *Screen; SDL_Window *Screen;
SDL_Renderer *Renderer;
union
{
SDL_Texture *Texture;
SDL_Surface *Surface;
};
SDL_Rect UpdateRect;
bool UsingRenderer;
bool NeedPalUpdate; bool NeedPalUpdate;
bool NeedGammaUpdate; bool NeedGammaUpdate;
bool NotPaletted; bool NotPaletted;
void UpdateColors (); void UpdateColors ();
void ResetSDLRenderer ();
SDLFB () {} SDLFB () {}
}; };
@ -83,9 +94,6 @@ struct MiniModeInfo
extern IVideo *Video; extern IVideo *Video;
extern bool GUICapture; extern bool GUICapture;
SDL_Surface *cursorSurface = NULL;
SDL_Rect cursorBlit = {0, 0, 32, 32};
EXTERN_CVAR (Float, Gamma) EXTERN_CVAR (Float, Gamma)
EXTERN_CVAR (Int, vid_maxfps) EXTERN_CVAR (Int, vid_maxfps)
EXTERN_CVAR (Bool, cl_capfps) EXTERN_CVAR (Bool, cl_capfps)
@ -93,11 +101,11 @@ EXTERN_CVAR (Bool, vid_vsync)
// PUBLIC DATA DEFINITIONS ------------------------------------------------- // PUBLIC DATA DEFINITIONS -------------------------------------------------
CVAR (Int, vid_displaybits, 8, CVAR_ARCHIVE|CVAR_GLOBALCONFIG) CVAR (Int, vid_adapter, 0, CVAR_ARCHIVE|CVAR_GLOBALCONFIG)
// vid_asyncblit needs a restart to work. SDL doesn't seem to change if the CVAR (Int, vid_displaybits, 32, CVAR_ARCHIVE|CVAR_GLOBALCONFIG)
// frame buffer is changed at run time.
CVAR (Bool, vid_asyncblit, 1, CVAR_NOINITCALL|CVAR_ARCHIVE|CVAR_GLOBALCONFIG) CVAR (Bool, vid_forcesurface, false, CVAR_ARCHIVE|CVAR_GLOBALCONFIG)
CUSTOM_CVAR (Float, rgamma, 1.f, CVAR_ARCHIVE|CVAR_GLOBALCONFIG) CUSTOM_CVAR (Float, rgamma, 1.f, CVAR_ARCHIVE|CVAR_GLOBALCONFIG)
{ {
@ -140,12 +148,14 @@ static MiniModeInfo WinModes[] =
{ 720, 480 }, // 16:10 { 720, 480 }, // 16:10
{ 720, 540 }, { 720, 540 },
{ 800, 450 }, // 16:9 { 800, 450 }, // 16:9
{ 800, 480 },
{ 800, 500 }, // 16:10 { 800, 500 }, // 16:10
{ 800, 600 }, { 800, 600 },
{ 848, 480 }, // 16:9 { 848, 480 }, // 16:9
{ 960, 600 }, // 16:10 { 960, 600 }, // 16:10
{ 960, 720 }, { 960, 720 },
{ 1024, 576 }, // 16:9 { 1024, 576 }, // 16:9
{ 1024, 600 }, // 17:10
{ 1024, 640 }, // 16:10 { 1024, 640 }, // 16:10
{ 1024, 768 }, { 1024, 768 },
{ 1088, 612 }, // 16:9 { 1088, 612 }, // 16:9
@ -153,16 +163,33 @@ static MiniModeInfo WinModes[] =
{ 1152, 720 }, // 16:10 { 1152, 720 }, // 16:10
{ 1152, 864 }, { 1152, 864 },
{ 1280, 720 }, // 16:9 { 1280, 720 }, // 16:9
{ 1280, 854 },
{ 1280, 800 }, // 16:10 { 1280, 800 }, // 16:10
{ 1280, 960 }, { 1280, 960 },
{ 1280, 1024 }, // 5:4
{ 1360, 768 }, // 16:9 { 1360, 768 }, // 16:9
{ 1366, 768 },
{ 1400, 787 }, // 16:9 { 1400, 787 }, // 16:9
{ 1400, 875 }, // 16:10 { 1400, 875 }, // 16:10
{ 1400, 1050 }, { 1400, 1050 },
{ 1440, 900 },
{ 1440, 960 },
{ 1440, 1080 },
{ 1600, 900 }, // 16:9 { 1600, 900 }, // 16:9
{ 1600, 1000 }, // 16:10 { 1600, 1000 }, // 16:10
{ 1600, 1200 }, { 1600, 1200 },
{ 1920, 1080 }, { 1920, 1080 },
{ 1920, 1200 },
{ 2048, 1536 },
{ 2560, 1440 },
{ 2560, 1600 },
{ 2560, 2048 },
{ 2880, 1800 },
{ 3200, 1800 },
{ 3840, 2160 },
{ 3840, 2400 },
{ 4096, 2160 },
{ 5120, 2880 }
}; };
static cycle_t BlitCycles; static cycle_t BlitCycles;
@ -170,10 +197,34 @@ static cycle_t SDLFlipCycles;
// CODE -------------------------------------------------------------------- // CODE --------------------------------------------------------------------
void ScaleWithAspect (int &w, int &h, int Width, int Height)
{
int resRatio = CheckRatio (Width, Height);
int screenRatio;
CheckRatio (w, h, &screenRatio);
if (resRatio == screenRatio)
return;
double yratio;
switch(resRatio)
{
case 0: yratio = 4./3.; break;
case 1: yratio = 16./9.; break;
case 2: yratio = 16./10.; break;
case 3: yratio = 17./10.; break;
case 4: yratio = 5./4.; break;
default: return;
}
double y = w/yratio;
if (y > h)
w = h*yratio;
else
h = y;
}
SDLVideo::SDLVideo (int parm) SDLVideo::SDLVideo (int parm)
{ {
IteratorBits = 0; IteratorBits = 0;
IteratorFS = false;
} }
SDLVideo::~SDLVideo () SDLVideo::~SDLVideo ()
@ -184,7 +235,6 @@ void SDLVideo::StartModeIterator (int bits, bool fs)
{ {
IteratorMode = 0; IteratorMode = 0;
IteratorBits = bits; IteratorBits = bits;
IteratorFS = fs;
} }
bool SDLVideo::NextMode (int *width, int *height, bool *letterbox) bool SDLVideo::NextMode (int *width, int *height, bool *letterbox)
@ -192,8 +242,6 @@ bool SDLVideo::NextMode (int *width, int *height, bool *letterbox)
if (IteratorBits != 8) if (IteratorBits != 8)
return false; return false;
if (!IteratorFS)
{
if ((unsigned)IteratorMode < sizeof(WinModes)/sizeof(WinModes[0])) if ((unsigned)IteratorMode < sizeof(WinModes)/sizeof(WinModes[0]))
{ {
*width = WinModes[IteratorMode].Width; *width = WinModes[IteratorMode].Width;
@ -201,18 +249,6 @@ bool SDLVideo::NextMode (int *width, int *height, bool *letterbox)
++IteratorMode; ++IteratorMode;
return true; return true;
} }
}
else
{
SDL_Rect **modes = SDL_ListModes (NULL, SDL_FULLSCREEN|SDL_HWSURFACE);
if (modes != NULL && modes[IteratorMode] != NULL)
{
*width = modes[IteratorMode]->w;
*height = modes[IteratorMode]->h;
++IteratorMode;
return true;
}
}
return false; return false;
} }
@ -230,11 +266,11 @@ DFrameBuffer *SDLVideo::CreateFrameBuffer (int width, int height, bool fullscree
if (fb->Width == width && if (fb->Width == width &&
fb->Height == height) fb->Height == height)
{ {
bool fsnow = (fb->Screen->flags & SDL_FULLSCREEN) != 0; bool fsnow = (SDL_GetWindowFlags (fb->Screen) & SDL_WINDOW_FULLSCREEN_DESKTOP) != 0;
if (fsnow != fullscreen) if (fsnow != fullscreen)
{ {
SDL_WM_ToggleFullScreen (fb->Screen); fb->SetFullscreen (fullscreen);
} }
return old; return old;
} }
@ -313,32 +349,48 @@ SDLFB::SDLFB (int width, int height, bool fullscreen)
UpdatePending = false; UpdatePending = false;
NotPaletted = false; NotPaletted = false;
FlashAmount = 0; FlashAmount = 0;
Screen = SDL_SetVideoMode (width, height, vid_displaybits,
(vid_asyncblit ? SDL_ASYNCBLIT : 0)|SDL_HWSURFACE|SDL_HWPALETTE|SDL_DOUBLEBUF|SDL_ANYFORMAT| FString caption;
(fullscreen ? SDL_FULLSCREEN : 0)); caption.Format(GAMESIG " %s (%s)", GetVersionString(), GetGitTime());
Screen = SDL_CreateWindow (caption,
SDL_WINDOWPOS_UNDEFINED_DISPLAY(vid_adapter), SDL_WINDOWPOS_UNDEFINED_DISPLAY(vid_adapter),
width, height, (fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0));
if (Screen == NULL) if (Screen == NULL)
return; return;
Renderer = NULL;
Texture = NULL;
ResetSDLRenderer ();
for (i = 0; i < 256; i++) for (i = 0; i < 256; i++)
{ {
GammaTable[0][i] = GammaTable[1][i] = GammaTable[2][i] = i; GammaTable[0][i] = GammaTable[1][i] = GammaTable[2][i] = i;
} }
if (Screen->format->palette == NULL)
{
NotPaletted = true;
GPfx.SetFormat (Screen->format->BitsPerPixel,
Screen->format->Rmask,
Screen->format->Gmask,
Screen->format->Bmask);
}
memcpy (SourcePalette, GPalette.BaseColors, sizeof(PalEntry)*256); memcpy (SourcePalette, GPalette.BaseColors, sizeof(PalEntry)*256);
UpdateColors (); UpdateColors ();
#ifdef __APPLE__
SetVSync (vid_vsync); SetVSync (vid_vsync);
#endif
} }
SDLFB::~SDLFB () SDLFB::~SDLFB ()
{ {
if(Screen)
{
if (Renderer)
{
if (Texture)
SDL_DestroyTexture (Texture);
SDL_DestroyRenderer (Renderer);
}
SDL_DestroyWindow (Screen);
}
} }
bool SDLFB::IsValid () bool SDLFB::IsValid ()
@ -403,41 +455,60 @@ void SDLFB::Update ()
SDLFlipCycles.Reset(); SDLFlipCycles.Reset();
BlitCycles.Clock(); BlitCycles.Clock();
if (SDL_LockSurface (Screen) == -1) void *pixels;
int pitch;
if (UsingRenderer)
{
if (SDL_LockTexture (Texture, NULL, &pixels, &pitch))
return; return;
}
else
{
if (SDL_LockSurface (Surface))
return;
pixels = Surface->pixels;
pitch = Surface->pitch;
}
if (NotPaletted) if (NotPaletted)
{ {
GPfx.Convert (MemBuffer, Pitch, GPfx.Convert (MemBuffer, Pitch,
Screen->pixels, Screen->pitch, Width, Height, pixels, pitch, Width, Height,
FRACUNIT, FRACUNIT, 0, 0); FRACUNIT, FRACUNIT, 0, 0);
} }
else else
{ {
if (Screen->pitch == Pitch) if (pitch == Pitch)
{ {
memcpy (Screen->pixels, MemBuffer, Width*Height); memcpy (pixels, MemBuffer, Width*Height);
} }
else else
{ {
for (int y = 0; y < Height; ++y) for (int y = 0; y < Height; ++y)
{ {
memcpy ((BYTE *)Screen->pixels+y*Screen->pitch, MemBuffer+y*Pitch, Width); memcpy ((BYTE *)pixels+y*pitch, MemBuffer+y*Pitch, Width);
} }
} }
} }
SDL_UnlockSurface (Screen); if (UsingRenderer)
if (cursorSurface != NULL && GUICapture)
{ {
// SDL requires us to draw a surface to get true color cursors. SDL_UnlockTexture (Texture);
SDL_BlitSurface(cursorSurface, NULL, Screen, &cursorBlit);
}
SDLFlipCycles.Clock(); SDLFlipCycles.Clock();
SDL_Flip (Screen); SDL_RenderCopy(Renderer, Texture, NULL, &UpdateRect);
SDL_RenderPresent(Renderer);
SDLFlipCycles.Unclock(); SDLFlipCycles.Unclock();
}
else
{
SDL_UnlockSurface (Surface);
SDLFlipCycles.Clock();
SDL_UpdateWindowSurface (Screen);
SDLFlipCycles.Unclock();
}
BlitCycles.Unclock(); BlitCycles.Unclock();
@ -494,7 +565,7 @@ void SDLFB::UpdateColors ()
256, GammaTable[2][Flash.b], GammaTable[1][Flash.g], GammaTable[0][Flash.r], 256, GammaTable[2][Flash.b], GammaTable[1][Flash.g], GammaTable[0][Flash.r],
FlashAmount); FlashAmount);
} }
SDL_SetPalette (Screen, SDL_LOGPAL|SDL_PHYSPAL, colors, 0, 256); SDL_SetPaletteColors (Surface->format->palette, colors, 0, 256);
} }
} }
@ -539,9 +610,95 @@ void SDLFB::GetFlashedPalette (PalEntry pal[256])
} }
} }
void SDLFB::SetFullscreen (bool fullscreen)
{
SDL_SetWindowFullscreen (Screen, fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
if (!fullscreen)
{
// Restore proper window size
SDL_SetWindowSize (Screen, Width, Height);
}
ResetSDLRenderer ();
}
bool SDLFB::IsFullscreen () bool SDLFB::IsFullscreen ()
{ {
return (Screen->flags & SDL_FULLSCREEN) != 0; return (SDL_GetWindowFlags (Screen) & SDL_WINDOW_FULLSCREEN_DESKTOP) != 0;
}
void SDLFB::ResetSDLRenderer ()
{
if (Renderer)
{
if (Texture)
SDL_DestroyTexture (Texture);
SDL_DestroyRenderer (Renderer);
}
UsingRenderer = !vid_forcesurface;
if (UsingRenderer)
{
Renderer = SDL_CreateRenderer (Screen, -1,SDL_RENDERER_ACCELERATED|SDL_RENDERER_TARGETTEXTURE|
(vid_vsync ? SDL_RENDERER_PRESENTVSYNC : 0));
if (!Renderer)
return;
Uint32 fmt;
switch(vid_displaybits)
{
default: fmt = SDL_PIXELFORMAT_ARGB8888; break;
case 30: fmt = SDL_PIXELFORMAT_ARGB2101010; break;
case 24: fmt = SDL_PIXELFORMAT_RGB888; break;
case 16: fmt = SDL_PIXELFORMAT_RGB565; break;
case 15: fmt = SDL_PIXELFORMAT_ARGB1555; break;
}
Texture = SDL_CreateTexture (Renderer, fmt, SDL_TEXTUREACCESS_STREAMING, Width, Height);
{
NotPaletted = true;
Uint32 format;
SDL_QueryTexture(Texture, &format, NULL, NULL, NULL);
Uint32 Rmask, Gmask, Bmask, Amask;
int bpp;
SDL_PixelFormatEnumToMasks(format, &bpp, &Rmask, &Gmask, &Bmask, &Amask);
GPfx.SetFormat (bpp, Rmask, Gmask, Bmask);
}
}
else
{
Surface = SDL_GetWindowSurface (Screen);
if (Surface->format->palette == NULL)
{
NotPaletted = true;
GPfx.SetFormat (Surface->format->BitsPerPixel, Surface->format->Rmask, Surface->format->Gmask, Surface->format->Bmask);
}
else
NotPaletted = false;
}
// Calculate update rectangle
if (IsFullscreen ())
{
int w, h;
SDL_GetWindowSize (Screen, &w, &h);
UpdateRect.w = w;
UpdateRect.h = h;
ScaleWithAspect (UpdateRect.w, UpdateRect.h, Width, Height);
UpdateRect.x = (w - UpdateRect.w)/2;
UpdateRect.y = (h - UpdateRect.h)/2;
}
else
{
// In windowed mode we just update the whole window.
UpdateRect.x = 0;
UpdateRect.y = 0;
UpdateRect.w = Width;
UpdateRect.h = Height;
}
} }
void SDLFB::SetVSync (bool vsync) void SDLFB::SetVSync (bool vsync)
@ -561,6 +718,8 @@ void SDLFB::SetVSync (bool vsync)
const GLint value = vsync ? 1 : 0; const GLint value = vsync ? 1 : 0;
CGLSetParameter(context, kCGLCPSwapInterval, &value); CGLSetParameter(context, kCGLCPSwapInterval, &value);
} }
#else
ResetSDLRenderer ();
#endif // __APPLE__ #endif // __APPLE__
} }
@ -568,6 +727,6 @@ ADD_STAT (blit)
{ {
FString out; FString out;
out.Format ("blit=%04.1f ms flip=%04.1f ms", out.Format ("blit=%04.1f ms flip=%04.1f ms",
BlitCycles.Time() * 1e-3, SDLFlipCycles.TimeMS()); BlitCycles.TimeMS(), SDLFlipCycles.TimeMS());
return out; return out;
} }

1
src/sdl/sdlvideo.h
View file

@ -18,5 +18,4 @@ class SDLVideo : public IVideo
private: private:
int IteratorMode; int IteratorMode;
int IteratorBits; int IteratorBits;
bool IteratorFS;
}; };