mirror of
https://github.com/CTCaer/RetroArch.git
synced 2024-12-21 02:08:16 +00:00
Merge pull request #867 from heuripedes/sdl2
SDL2 video, audio, input and joypad drivers
This commit is contained in:
Twinaphex
commit
7b8629c962
8
Makefile
8
Makefile
@ -213,6 +213,14 @@ ifeq ($(HAVE_SDL), 1)
|
||||
LIBS += $(SDL_LIBS)
|
||||
endif
|
||||
|
||||
ifeq ($(HAVE_SDL2), 1)
|
||||
OBJ += gfx/sdl2_gfx.o input/sdl2_input.o input/sdl2_joypad.o audio/sdl_audio.o
|
||||
JOYCONFIG_OBJ += input/sdl2_joypad.o
|
||||
JOYCONFIG_LIBS += $(SDL2_LIBS)
|
||||
DEFINES += $(SDL2_CFLAGS) $(BSD_LOCAL_INC)
|
||||
LIBS += $(SDL2_LIBS)
|
||||
endif
|
||||
|
||||
ifeq ($(HAVE_OMAP), 1)
|
||||
OBJ += gfx/omap_gfx.o
|
||||
endif
|
||||
|
||||
@ -131,6 +131,15 @@ ifeq ($(HAVE_MENU_COMMON), 1)
|
||||
OBJ += frontend/menu/backend/menu_common_backend.o frontend/menu/menu_input_line_cb.o frontend/menu/menu_common.o frontend/menu/menu_navigation.o
|
||||
endif
|
||||
|
||||
ifeq ($(HAVE_SDL2), 1)
|
||||
OBJ += gfx/sdl2_gfx.o input/sdl2_input.o input/sdl2_joypad.o audio/sdl_audio.o
|
||||
JOBJ += input/sdl2_joypad.o
|
||||
LIBS += -lSDL2
|
||||
JLIBS += -lSDL2
|
||||
DEFINES += -ISDL2 -DHAVE_SDL2
|
||||
HAVE_SDL = 0
|
||||
endif
|
||||
|
||||
ifeq ($(HAVE_SDL), 1)
|
||||
OBJ += gfx/sdl_gfx.o input/sdl_input.o input/sdl_joypad.o audio/sdl_audio.o
|
||||
JOBJ += input/sdl_joypad.o
|
||||
|
||||
@ -193,6 +193,10 @@ const audio_driver_t audio_sdl = {
|
||||
sdl_audio_set_nonblock_state,
|
||||
sdl_audio_free,
|
||||
NULL,
|
||||
#ifdef HAVE_SDL2
|
||||
"sdl2"
|
||||
#else
|
||||
"sdl"
|
||||
#endif
|
||||
};
|
||||
|
||||
|
||||
@ -14,6 +14,12 @@ static const bool _sdl_supp = true;
|
||||
static const bool _sdl_supp = false;
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_SDL2
|
||||
static const bool _sdl2_supp = true;
|
||||
#else
|
||||
static const bool _sdl2_supp = false;
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_THREADS
|
||||
static const bool _thread_supp = true;
|
||||
#else
|
||||
|
||||
8
driver.c
8
driver.c
@ -69,7 +69,7 @@ static const audio_driver_t *audio_drivers[] = {
|
||||
#ifdef HAVE_JACK
|
||||
&audio_jack,
|
||||
#endif
|
||||
#ifdef HAVE_SDL
|
||||
#if defined(HAVE_SDL) || defined(HAVE_SDL2)
|
||||
&audio_sdl,
|
||||
#endif
|
||||
#ifdef HAVE_XAUDIO
|
||||
@ -121,6 +121,9 @@ static const video_driver_t *video_drivers[] = {
|
||||
#ifdef HAVE_SDL
|
||||
&video_sdl,
|
||||
#endif
|
||||
#ifdef HAVE_SDL2
|
||||
&video_sdl2,
|
||||
#endif
|
||||
#ifdef HAVE_XVIDEO
|
||||
&video_xvideo,
|
||||
#endif
|
||||
@ -152,6 +155,9 @@ static const input_driver_t *input_drivers[] = {
|
||||
#ifdef HAVE_SDL
|
||||
&input_sdl,
|
||||
#endif
|
||||
#ifdef HAVE_SDL2
|
||||
&input_sdl2,
|
||||
#endif
|
||||
#ifdef HAVE_DINPUT
|
||||
&input_dinput,
|
||||
#endif
|
||||
|
||||
2
driver.h
2
driver.h
@ -620,12 +620,14 @@ extern const video_driver_t video_xenon360;
|
||||
extern const video_driver_t video_xvideo;
|
||||
extern const video_driver_t video_xdk_d3d;
|
||||
extern const video_driver_t video_sdl;
|
||||
extern const video_driver_t video_sdl2;
|
||||
extern const video_driver_t video_vg;
|
||||
extern const video_driver_t video_null;
|
||||
extern const video_driver_t video_omap;
|
||||
extern const video_driver_t video_exynos;
|
||||
extern const input_driver_t input_android;
|
||||
extern const input_driver_t input_sdl;
|
||||
extern const input_driver_t input_sdl2;
|
||||
extern const input_driver_t input_dinput;
|
||||
extern const input_driver_t input_x;
|
||||
extern const input_driver_t input_wayland;
|
||||
|
||||
746
gfx/sdl2_gfx.c
Normal file
746
gfx/sdl2_gfx.c
Normal file
@ -0,0 +1,746 @@
|
||||
/* RetroArch - A frontend for libretro.
|
||||
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
|
||||
*
|
||||
* RetroArch is free software: you can redistribute it and/or modify it under the terms
|
||||
* of the GNU General Public License as published by the Free Software Found-
|
||||
* ation, either version 3 of the License, or (at your option) any later version.
|
||||
*
|
||||
* RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
||||
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||||
* PURPOSE. See the GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along with RetroArch.
|
||||
* If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "SDL.h"
|
||||
#include "SDL_syswm.h"
|
||||
#include "../driver.h"
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include "../general.h"
|
||||
#include "scaler/scaler.h"
|
||||
#include "gfx_common.h"
|
||||
#include "gfx_context.h"
|
||||
#include "fonts/fonts.h"
|
||||
|
||||
#ifdef HAVE_X11
|
||||
#include "context/x11_common.h"
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#include "SDL2/SDL_syswm.h"
|
||||
|
||||
typedef struct sdl2_tex
|
||||
{
|
||||
SDL_Texture *tex;
|
||||
|
||||
int w;
|
||||
int h;
|
||||
int pitch;
|
||||
bool active;
|
||||
bool rgb32;
|
||||
} sdl2_tex_t;
|
||||
|
||||
typedef struct _sdl2_video
|
||||
{
|
||||
SDL_Window *window;
|
||||
SDL_Renderer *renderer;
|
||||
|
||||
sdl2_tex_t frame;
|
||||
sdl2_tex_t menu;
|
||||
sdl2_tex_t font;
|
||||
|
||||
bool gl;
|
||||
bool quitting;
|
||||
|
||||
void *font_data;
|
||||
const font_renderer_driver_t *font_driver;
|
||||
uint8_t font_r;
|
||||
uint8_t font_g;
|
||||
uint8_t font_b;
|
||||
|
||||
struct rarch_viewport vp;
|
||||
|
||||
video_info_t video;
|
||||
|
||||
bool should_resize;
|
||||
double rotation;
|
||||
|
||||
} sdl2_video_t;
|
||||
|
||||
static void sdl2_gfx_free(void *data);
|
||||
|
||||
static inline void sdl_tex_zero(sdl2_tex_t *t)
|
||||
{
|
||||
if (t->tex)
|
||||
{
|
||||
SDL_DestroyTexture(t->tex);
|
||||
}
|
||||
|
||||
t->tex = NULL;
|
||||
t->w = t->h = t->pitch = 0;
|
||||
}
|
||||
|
||||
static void sdl2_init_font(sdl2_video_t *vid, const char *font_path,
|
||||
unsigned font_size)
|
||||
{
|
||||
if (!g_settings.video.font_enable)
|
||||
return;
|
||||
|
||||
if (font_renderer_create_default(&vid->font_driver, &vid->font_data,
|
||||
*font_path ? font_path : NULL, font_size))
|
||||
{
|
||||
int r = g_settings.video.msg_color_r * 255;
|
||||
int g = g_settings.video.msg_color_g * 255;
|
||||
int b = g_settings.video.msg_color_b * 255;
|
||||
|
||||
r = r < 0 ? 0 : (r > 255 ? 255 : r);
|
||||
g = g < 0 ? 0 : (g > 255 ? 255 : g);
|
||||
b = b < 0 ? 0 : (b > 255 ? 255 : b);
|
||||
|
||||
vid->font_r = r;
|
||||
vid->font_g = g;
|
||||
vid->font_b = b;
|
||||
}
|
||||
else
|
||||
{
|
||||
RARCH_WARN("[SDL]: Could not initialize fonts.\n");
|
||||
return;
|
||||
}
|
||||
|
||||
const struct font_atlas *atlas = vid->font_driver->get_atlas(vid->font_data);
|
||||
|
||||
SDL_Surface *tmp = SDL_CreateRGBSurfaceFrom(atlas->buffer, atlas->width,
|
||||
atlas->height, 8, atlas->width,
|
||||
0, 0, 0, 0);
|
||||
SDL_Color colors[256];
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 256; ++i)
|
||||
{
|
||||
colors[i].r = colors[i].g = colors[i].b = i;
|
||||
colors[i].a = 255;
|
||||
}
|
||||
|
||||
SDL_Palette *pal = SDL_AllocPalette(256);
|
||||
SDL_SetPaletteColors(pal, colors, 0, 256);
|
||||
SDL_SetSurfacePalette(tmp, pal);
|
||||
SDL_SetColorKey(tmp, SDL_TRUE, 0);
|
||||
|
||||
vid->font.tex = SDL_CreateTextureFromSurface(vid->renderer, tmp);
|
||||
|
||||
if (vid->font.tex)
|
||||
{
|
||||
vid->font.w = atlas->width;
|
||||
vid->font.h = atlas->height;
|
||||
vid->font.active = true;
|
||||
|
||||
SDL_SetTextureBlendMode(vid->font.tex, SDL_BLENDMODE_ADD);
|
||||
}
|
||||
else
|
||||
RARCH_WARN("[SDL]: Failed to initialize font texture: %s\n", SDL_GetError());
|
||||
|
||||
SDL_FreePalette(pal);
|
||||
SDL_FreeSurface(tmp);
|
||||
}
|
||||
|
||||
static void sdl2_render_msg(sdl2_video_t *vid, const char *msg)
|
||||
{
|
||||
unsigned width = vid->vp.width;
|
||||
unsigned height = vid->vp.height;
|
||||
|
||||
int x, y, delta_x, delta_y;
|
||||
|
||||
if (!vid->font_data)
|
||||
return;
|
||||
|
||||
x = g_settings.video.msg_pos_x * width;
|
||||
y = (1.0f - g_settings.video.msg_pos_y) * height;
|
||||
delta_x = 0;
|
||||
delta_y = 0;
|
||||
|
||||
SDL_SetTextureColorMod(vid->font.tex, vid->font_r, vid->font_g, vid->font_b);
|
||||
|
||||
for (; *msg; msg++)
|
||||
{
|
||||
const struct font_glyph *gly = vid->font_driver->get_glyph(vid->font_data, (uint8_t)*msg);
|
||||
|
||||
if (!gly)
|
||||
gly = vid->font_driver->get_glyph(vid->font_data, '?');
|
||||
|
||||
if (!gly)
|
||||
continue;
|
||||
|
||||
int off_x = gly->draw_offset_x;
|
||||
int off_y = gly->draw_offset_y;
|
||||
int tex_x = gly->atlas_offset_x;
|
||||
int tex_y = gly->atlas_offset_y;
|
||||
|
||||
SDL_Rect srcrect = {
|
||||
tex_x, tex_y,
|
||||
gly->width, gly->height
|
||||
};
|
||||
|
||||
SDL_Rect dstrect = {
|
||||
x + delta_x + off_x, y + delta_y + off_y,
|
||||
gly->width, gly->height
|
||||
};
|
||||
|
||||
SDL_RenderCopyEx(vid->renderer, vid->font.tex, &srcrect, &dstrect, 0, NULL, SDL_FLIP_NONE);
|
||||
|
||||
delta_x += gly->advance_x;
|
||||
delta_y -= gly->advance_y;
|
||||
}
|
||||
}
|
||||
|
||||
static void sdl2_gfx_set_handles(sdl2_video_t *vid)
|
||||
{
|
||||
// SysWMinfo headers are broken on OSX. :(
|
||||
#if defined(_WIN32)
|
||||
SDL_SysWMinfo info;
|
||||
SDL_VERSION(&info.version);
|
||||
|
||||
if (SDL_GetWindowWMInfo(vid->window, &info) == 1)
|
||||
{
|
||||
driver.display_type = RARCH_DISPLAY_WIN32;
|
||||
driver.video_display = 0;
|
||||
driver.video_window = (uintptr_t)info.window;
|
||||
}
|
||||
#elif defined(HAVE_X11)
|
||||
SDL_SysWMinfo info;
|
||||
SDL_VERSION(&info.version);
|
||||
|
||||
if (SDL_GetWindowWMInfo(vid->window, &info) == 1)
|
||||
{
|
||||
driver.display_type = RARCH_DISPLAY_X11;
|
||||
driver.video_display = (uintptr_t)info.info.x11.display;
|
||||
driver.video_window = (uintptr_t)info.info.x11.window;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
static void sdl2_init_renderer(sdl2_video_t *vid)
|
||||
{
|
||||
unsigned flags = SDL_RENDERER_ACCELERATED;
|
||||
|
||||
if (vid->video.vsync)
|
||||
flags |= SDL_RENDERER_PRESENTVSYNC;
|
||||
|
||||
SDL_ClearHints();
|
||||
SDL_SetHintWithPriority(SDL_HINT_RENDER_VSYNC,
|
||||
vid->video.vsync ? "1" : "0", SDL_HINT_OVERRIDE);
|
||||
vid->renderer = SDL_CreateRenderer(vid->window, -1, flags);
|
||||
|
||||
if (!vid->renderer)
|
||||
{
|
||||
RARCH_ERR("[SDL]: Failed to initialize renderer: %s", SDL_GetError());
|
||||
return;
|
||||
}
|
||||
|
||||
SDL_SetRenderDrawColor(vid->renderer, 0, 0, 0, 255);
|
||||
}
|
||||
|
||||
static void sdl_refresh_renderer(sdl2_video_t *vid)
|
||||
{
|
||||
SDL_RenderClear(vid->renderer);
|
||||
SDL_Rect r = { vid->vp.x, vid->vp.y, vid->vp.width, vid->vp.height };
|
||||
SDL_RenderSetViewport(vid->renderer, &r);
|
||||
|
||||
// breaks int scaling
|
||||
// SDL_RenderSetLogicalSize(vid->renderer, vid->vp.width, vid->vp.height);
|
||||
}
|
||||
|
||||
static void sdl_refresh_viewport(sdl2_video_t *vid)
|
||||
{
|
||||
int win_w, win_h;
|
||||
|
||||
SDL_GetWindowSize(vid->window, &win_w, &win_h);
|
||||
|
||||
vid->vp.x = 0;
|
||||
vid->vp.y = 0;
|
||||
vid->vp.width = win_w;
|
||||
vid->vp.height = win_h;
|
||||
vid->vp.full_width = win_w;
|
||||
vid->vp.full_height = win_h;
|
||||
|
||||
if (g_settings.video.scale_integer)
|
||||
gfx_scale_integer(&vid->vp, win_w, win_h, g_extern.system.aspect_ratio,
|
||||
vid->video.force_aspect);
|
||||
else if (g_settings.video.aspect_ratio_idx == ASPECT_RATIO_CUSTOM)
|
||||
{
|
||||
const struct rarch_viewport *custom = &g_extern.console.screen.viewports.custom_vp;
|
||||
|
||||
vid->vp.x = custom->x;
|
||||
vid->vp.y = custom->y;
|
||||
vid->vp.width = custom->width;
|
||||
vid->vp.height = custom->height;
|
||||
}
|
||||
else if (vid->video.force_aspect)
|
||||
{
|
||||
float delta;
|
||||
float device_aspect = (float)win_w / win_h;
|
||||
float desired_aspect = g_extern.system.aspect_ratio;
|
||||
|
||||
if (fabsf(device_aspect - desired_aspect) < 0.0001f)
|
||||
{
|
||||
/* If the aspect ratios of screen and desired aspect ratio are
|
||||
* sufficiently equal (floating point stuff), assume they are
|
||||
* actually equal. */
|
||||
}
|
||||
else if (device_aspect > desired_aspect)
|
||||
{
|
||||
delta = (desired_aspect / device_aspect - 1.0f) / 2.0f + 0.5f;
|
||||
vid->vp.x = (int)roundf(win_w * (0.5f - delta));
|
||||
vid->vp.width = (unsigned)roundf(2.0f * win_w * delta);
|
||||
}
|
||||
else
|
||||
{
|
||||
delta = (device_aspect / desired_aspect - 1.0f) / 2.0f + 0.5f;
|
||||
vid->vp.y = (int)roundf(win_h * (0.5f - delta));
|
||||
vid->vp.height = (unsigned)roundf(2.0f * win_h * delta);
|
||||
}
|
||||
}
|
||||
|
||||
vid->should_resize = false;
|
||||
|
||||
sdl_refresh_renderer(vid);
|
||||
}
|
||||
|
||||
static void sdl_refresh_input_size(sdl2_video_t *vid, bool menu, bool rgb32,
|
||||
unsigned width, unsigned height, unsigned pitch)
|
||||
{
|
||||
sdl2_tex_t *target = menu ? &vid->menu : &vid->frame;
|
||||
|
||||
if (!target->tex || target->w != width || target->h != height
|
||||
|| target->rgb32 != rgb32 || target->pitch != pitch)
|
||||
{
|
||||
unsigned format;
|
||||
|
||||
sdl_tex_zero(target);
|
||||
|
||||
RARCH_PERFORMANCE_INIT(sdl_create_texture);
|
||||
RARCH_PERFORMANCE_START(sdl_create_texture);
|
||||
|
||||
if (menu)
|
||||
format = rgb32 ? SDL_PIXELFORMAT_ARGB8888 : SDL_PIXELFORMAT_RGBA4444;
|
||||
else
|
||||
{
|
||||
switch (g_extern.system.pix_fmt)
|
||||
{
|
||||
case RETRO_PIXEL_FORMAT_0RGB1555:
|
||||
format = SDL_PIXELFORMAT_ARGB1555;
|
||||
break;
|
||||
case RETRO_PIXEL_FORMAT_XRGB8888:
|
||||
format = SDL_PIXELFORMAT_ARGB8888;
|
||||
break;
|
||||
case RETRO_PIXEL_FORMAT_RGB565:
|
||||
format = SDL_PIXELFORMAT_RGB565;
|
||||
break;
|
||||
default:
|
||||
RARCH_ERR("Unknown/unsupported video format.\n");
|
||||
return;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
SDL_SetHintWithPriority(SDL_HINT_RENDER_SCALE_QUALITY,
|
||||
(vid->video.smooth || menu) ? "linear" : "nearest",
|
||||
SDL_HINT_OVERRIDE);
|
||||
|
||||
target->tex = SDL_CreateTexture(vid->renderer, format,
|
||||
SDL_TEXTUREACCESS_STREAMING, width, height);
|
||||
|
||||
RARCH_PERFORMANCE_STOP(sdl_create_texture);
|
||||
|
||||
if (!target->tex)
|
||||
{
|
||||
RARCH_ERR("Failed to create %s texture: %s\n", menu ? "menu" : "main",
|
||||
SDL_GetError());
|
||||
return;
|
||||
}
|
||||
|
||||
if (menu)
|
||||
SDL_SetTextureBlendMode(target->tex, SDL_BLENDMODE_BLEND);
|
||||
|
||||
target->w = width;
|
||||
target->h = height;
|
||||
target->pitch = pitch;
|
||||
target->rgb32 = rgb32;
|
||||
target->active = true;
|
||||
}
|
||||
}
|
||||
|
||||
static void *sdl2_gfx_init(const video_info_t *video, const input_driver_t **input, void **input_data)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
gfx_set_dwm();
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_X11
|
||||
XInitThreads();
|
||||
#endif
|
||||
|
||||
int i;
|
||||
|
||||
SDL_InitSubSystem(SDL_INIT_VIDEO);
|
||||
|
||||
sdl2_video_t *vid = (sdl2_video_t*)calloc(1, sizeof(*vid));
|
||||
if (!vid)
|
||||
return NULL;
|
||||
|
||||
// RARCH_LOG("[SDL]: supported video drivers (change with $SDL_VIDEODRIVER):\n");
|
||||
|
||||
// for (i = 0; i < SDL_GetNumVideoDrivers(); ++i)
|
||||
// {
|
||||
// RARCH_LOG("\t%s\n", SDL_GetVideoDriver(i));
|
||||
// }
|
||||
|
||||
RARCH_LOG("[SDL]: Available displays:\n");
|
||||
for(i = 0; i < SDL_GetNumVideoDisplays(); ++i)
|
||||
{
|
||||
SDL_DisplayMode mode;
|
||||
|
||||
if (SDL_GetCurrentDisplayMode(i, &mode) == 0)
|
||||
RARCH_LOG("\tDisplay #%i mode: unknown.\n", i);
|
||||
else
|
||||
RARCH_LOG("\tDisplay #%i mode: %ix%i@%ihz.\n", i, mode.w, mode.h,
|
||||
mode.refresh_rate);
|
||||
}
|
||||
|
||||
// void *sdl_input = NULL;
|
||||
|
||||
if (!video->fullscreen)
|
||||
RARCH_LOG("[SDL]: Creating window @ %ux%u\n", video->width, video->height);
|
||||
|
||||
unsigned flags;
|
||||
|
||||
if (video->fullscreen)
|
||||
{
|
||||
flags = g_settings.video.windowed_fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : SDL_WINDOW_FULLSCREEN;
|
||||
}
|
||||
else
|
||||
flags = SDL_WINDOW_RESIZABLE;
|
||||
|
||||
vid->window = SDL_CreateWindow("", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
|
||||
video->width, video->height, flags);
|
||||
|
||||
if (!vid->window)
|
||||
{
|
||||
RARCH_ERR("[SDL]: Failed to init SDL window: %s\n", SDL_GetError());
|
||||
goto error;
|
||||
}
|
||||
|
||||
vid->video.smooth = g_settings.video.smooth;
|
||||
vid->should_resize = true;
|
||||
|
||||
sdl_tex_zero(&vid->frame);
|
||||
sdl_tex_zero(&vid->menu);
|
||||
|
||||
if (video->fullscreen)
|
||||
SDL_ShowCursor(SDL_DISABLE);
|
||||
|
||||
sdl2_init_renderer(vid);
|
||||
sdl2_init_font(vid, g_settings.video.font_path, g_settings.video.font_size);
|
||||
|
||||
sdl2_gfx_set_handles(vid);
|
||||
|
||||
if (input && input_data)
|
||||
{
|
||||
void *sdl2_input = input_sdl2.init();
|
||||
if (sdl2_input)
|
||||
{
|
||||
*input = &input_sdl2;
|
||||
*input_data = sdl2_input;
|
||||
}
|
||||
else
|
||||
{
|
||||
*input = NULL;
|
||||
*input_data = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
return vid;
|
||||
|
||||
error:
|
||||
sdl2_gfx_free(vid);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void check_window(sdl2_video_t *vid)
|
||||
{
|
||||
SDL_Event event;
|
||||
|
||||
SDL_PumpEvents();
|
||||
while (SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_QUIT, SDL_WINDOWEVENT) > 0)
|
||||
{
|
||||
switch (event.type)
|
||||
{
|
||||
case SDL_QUIT:
|
||||
vid->quitting = true;
|
||||
break;
|
||||
|
||||
case SDL_WINDOWEVENT:
|
||||
if (event.window.event == SDL_WINDOWEVENT_RESIZED)
|
||||
vid->should_resize = true;
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static bool sdl2_gfx_frame(void *data, const void *frame, unsigned width,
|
||||
unsigned height, unsigned pitch, const char *msg)
|
||||
{
|
||||
sdl2_video_t *vid = (sdl2_video_t*)data;
|
||||
|
||||
if (vid->should_resize)
|
||||
sdl_refresh_viewport(vid);
|
||||
|
||||
if (frame)
|
||||
{
|
||||
sdl_refresh_input_size(vid, false, vid->frame.rgb32/*vid->video.rgb32*/, width, height, pitch);
|
||||
|
||||
RARCH_PERFORMANCE_INIT(sdl_copy_frame);
|
||||
RARCH_PERFORMANCE_START(sdl_copy_frame);
|
||||
|
||||
SDL_UpdateTexture(vid->frame.tex, NULL, frame, pitch);
|
||||
|
||||
RARCH_PERFORMANCE_STOP(sdl_copy_frame);
|
||||
}
|
||||
|
||||
SDL_RenderCopyEx(vid->renderer, vid->frame.tex, NULL, NULL, vid->rotation, NULL, SDL_FLIP_NONE);
|
||||
|
||||
#ifdef HAVE_MENU
|
||||
if (g_extern.lifecycle_state & (1ULL << MODE_MENU) && driver.menu_ctx && driver.menu_ctx->frame)
|
||||
driver.menu_ctx->frame();
|
||||
#endif
|
||||
|
||||
if (vid->menu.active)
|
||||
SDL_RenderCopy(vid->renderer, vid->menu.tex, NULL, NULL);
|
||||
|
||||
if (msg)
|
||||
sdl2_render_msg(vid, msg);
|
||||
|
||||
SDL_RenderPresent(vid->renderer);
|
||||
|
||||
char buf[128];
|
||||
if (gfx_get_fps(buf, sizeof(buf), NULL, 0))
|
||||
SDL_SetWindowTitle(vid->window, buf);
|
||||
|
||||
g_extern.frame_count++;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static void sdl2_gfx_set_nonblock_state(void *data, bool toggle)
|
||||
{
|
||||
sdl2_video_t *vid = (sdl2_video_t*)data;
|
||||
|
||||
vid->video.vsync = !toggle;
|
||||
sdl_refresh_renderer(vid);
|
||||
}
|
||||
|
||||
static bool sdl2_gfx_alive(void *data)
|
||||
{
|
||||
sdl2_video_t *vid = (sdl2_video_t*)data;
|
||||
check_window(vid);
|
||||
return !vid->quitting;
|
||||
}
|
||||
|
||||
static bool sdl2_gfx_focus(void *data)
|
||||
{
|
||||
sdl2_video_t *vid = (sdl2_video_t*)data;
|
||||
unsigned flags = (SDL_WINDOW_INPUT_FOCUS | SDL_WINDOW_MOUSE_FOCUS);
|
||||
return (SDL_GetWindowFlags(vid->window) & flags) == flags;
|
||||
}
|
||||
|
||||
static void sdl2_gfx_free(void *data)
|
||||
{
|
||||
sdl2_video_t *vid = (sdl2_video_t*)data;
|
||||
if (!vid)
|
||||
return;
|
||||
|
||||
SDL_QuitSubSystem(SDL_INIT_VIDEO);
|
||||
|
||||
if (vid->font_data)
|
||||
vid->font_driver->free(vid->font_data);
|
||||
|
||||
free(vid);
|
||||
}
|
||||
|
||||
static void sdl2_gfx_set_rotation(void *data, unsigned rotation)
|
||||
{
|
||||
sdl2_video_t *vid = (sdl2_video_t*)data;
|
||||
vid->rotation = 270 * rotation;
|
||||
}
|
||||
|
||||
static void sdl2_gfx_viewport_info(void *data, struct rarch_viewport *vp)
|
||||
{
|
||||
sdl2_video_t *vid = (sdl2_video_t*)data;
|
||||
*vp = vid->vp;
|
||||
}
|
||||
|
||||
static bool sdl2_gfx_read_viewport(void *data, uint8_t *buffer)
|
||||
{
|
||||
sdl2_video_t *vid = (sdl2_video_t*)data;
|
||||
|
||||
RARCH_PERFORMANCE_INIT(sdl2_gfx_read_viewport);
|
||||
RARCH_PERFORMANCE_START(sdl2_gfx_read_viewport);
|
||||
|
||||
rarch_render_cached_frame();
|
||||
|
||||
SDL_Surface *surf = SDL_GetWindowSurface(vid->window);
|
||||
SDL_Surface *bgr24 = SDL_ConvertSurfaceFormat(surf, SDL_PIXELFORMAT_BGR24, 0);
|
||||
|
||||
if (!bgr24)
|
||||
{
|
||||
RARCH_WARN("Failed to convert viewport data to BGR24: %s", SDL_GetError());
|
||||
return false;
|
||||
}
|
||||
|
||||
memcpy(buffer, bgr24->pixels, bgr24->h * bgr24->pitch);
|
||||
|
||||
RARCH_PERFORMANCE_STOP(sdl2_gfx_read_viewport);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void sdl2_poke_set_filtering(void *data, unsigned index, bool smooth)
|
||||
{
|
||||
sdl2_video_t *vid = (sdl2_video_t*)data;
|
||||
vid->video.smooth = smooth;
|
||||
|
||||
// sdl_refresh_renderer(vid);
|
||||
|
||||
sdl_tex_zero(&vid->frame);
|
||||
}
|
||||
|
||||
static void sdl2_poke_set_aspect_ratio(void *data, unsigned aspectratio_index)
|
||||
{
|
||||
sdl2_video_t *vid = (sdl2_video_t*)data;
|
||||
|
||||
switch (aspectratio_index)
|
||||
{
|
||||
case ASPECT_RATIO_SQUARE:
|
||||
gfx_set_square_pixel_viewport(g_extern.system.av_info.geometry.base_width,
|
||||
g_extern.system.av_info.geometry.base_height);
|
||||
break;
|
||||
|
||||
case ASPECT_RATIO_CORE:
|
||||
gfx_set_core_viewport();
|
||||
break;
|
||||
|
||||
case ASPECT_RATIO_CONFIG:
|
||||
gfx_set_config_viewport();
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
g_extern.system.aspect_ratio = aspectratio_lut[aspectratio_index].value;
|
||||
|
||||
vid->video.force_aspect = true;
|
||||
vid->should_resize = true;
|
||||
}
|
||||
|
||||
void sdl2_poke_apply_state_changes(void *data)
|
||||
{
|
||||
sdl2_video_t *vid = (sdl2_video_t*)data;
|
||||
vid->should_resize = true;
|
||||
}
|
||||
|
||||
void sdl2_poke_set_texture_frame(void *data, const void *frame, bool rgb32,
|
||||
unsigned width, unsigned height, float alpha)
|
||||
{
|
||||
sdl2_video_t *vid = (sdl2_video_t*)data;
|
||||
|
||||
if (frame)
|
||||
{
|
||||
sdl_refresh_input_size(vid, true, rgb32, width, height,
|
||||
width * (rgb32 ? 4 : 2));
|
||||
|
||||
RARCH_PERFORMANCE_INIT(copy_texture_frame);
|
||||
RARCH_PERFORMANCE_START(copy_texture_frame);
|
||||
|
||||
SDL_UpdateTexture(vid->menu.tex, NULL, frame, vid->menu.pitch);
|
||||
|
||||
RARCH_PERFORMANCE_STOP(copy_texture_frame);
|
||||
}
|
||||
}
|
||||
|
||||
void sdl2_poke_texture_enable(void *data, bool enable, bool full_screen)
|
||||
{
|
||||
sdl2_video_t *vid = (sdl2_video_t*)data;
|
||||
|
||||
vid->menu.active = enable;
|
||||
}
|
||||
|
||||
void sdl2_poke_set_osd_msg(void *data, const char *msg, const struct font_params *params)
|
||||
{
|
||||
sdl2_video_t *vid = (sdl2_video_t*)data;
|
||||
sdl2_render_msg(vid, msg);
|
||||
fprintf(stderr, "[SDL]: OSD MSG: %s\n", msg);
|
||||
}
|
||||
|
||||
void sdl2_show_mouse(void *data, bool state)
|
||||
{
|
||||
(void)data;
|
||||
SDL_ShowCursor(state);
|
||||
}
|
||||
|
||||
void sdl2_grab_mouse_toggle(void *data)
|
||||
{
|
||||
sdl2_video_t *vid = (sdl2_video_t*)data;
|
||||
SDL_SetWindowGrab(vid->window, SDL_GetWindowGrab(vid->window));
|
||||
}
|
||||
|
||||
static video_poke_interface_t sdl2_video_poke_interface = {
|
||||
sdl2_poke_set_filtering,
|
||||
#ifdef HAVE_FBO
|
||||
NULL,
|
||||
NULL,
|
||||
#endif
|
||||
sdl2_poke_set_aspect_ratio,
|
||||
sdl2_poke_apply_state_changes,
|
||||
#ifdef HAVE_MENU
|
||||
sdl2_poke_set_texture_frame,
|
||||
sdl2_poke_texture_enable,
|
||||
#endif
|
||||
sdl2_poke_set_osd_msg,
|
||||
sdl2_show_mouse,
|
||||
sdl2_grab_mouse_toggle,
|
||||
NULL,
|
||||
};
|
||||
|
||||
void sdl2_gfx_poke_interface(void *data, const video_poke_interface_t **iface)
|
||||
{
|
||||
(void)data;
|
||||
*iface = &sdl2_video_poke_interface;
|
||||
}
|
||||
|
||||
const video_driver_t video_sdl2 = {
|
||||
sdl2_gfx_init,
|
||||
sdl2_gfx_frame,
|
||||
sdl2_gfx_set_nonblock_state,
|
||||
sdl2_gfx_alive,
|
||||
sdl2_gfx_focus,
|
||||
NULL,
|
||||
sdl2_gfx_free,
|
||||
"sdl2",
|
||||
|
||||
sdl2_gfx_set_rotation,
|
||||
sdl2_gfx_viewport_info,
|
||||
sdl2_gfx_read_viewport,
|
||||
#ifdef HAVE_OVERLAY
|
||||
NULL, //void (*overlay_interface)(void *data, const video_overlay_interface_t **iface);
|
||||
#endif
|
||||
sdl2_gfx_poke_interface
|
||||
};
|
||||
|
||||
@ -30,7 +30,7 @@
|
||||
#include <dinput.h>
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_SDL
|
||||
#if defined(HAVE_SDL) || defined(HAVE_SDL2)
|
||||
#include "SDL.h"
|
||||
#endif
|
||||
|
||||
@ -77,6 +77,9 @@ static const rarch_joypad_driver_t *joypad_drivers[] = {
|
||||
#ifdef HAVE_SDL
|
||||
&sdl_joypad,
|
||||
#endif
|
||||
#ifdef HAVE_SDL2
|
||||
&sdl2_joypad,
|
||||
#endif
|
||||
#ifdef __MACH__
|
||||
&apple_joypad,
|
||||
#endif
|
||||
@ -464,6 +467,96 @@ const struct rarch_key_map rarch_key_map_sdl[] = {
|
||||
};
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_SDL2
|
||||
const struct rarch_key_map rarch_key_map_sdl2[] = {
|
||||
{ SDL_SCANCODE_LEFT, RETROK_LEFT },
|
||||
{ SDL_SCANCODE_RIGHT, RETROK_RIGHT },
|
||||
{ SDL_SCANCODE_UP, RETROK_UP },
|
||||
{ SDL_SCANCODE_DOWN, RETROK_DOWN },
|
||||
{ SDL_SCANCODE_RETURN, RETROK_RETURN },
|
||||
{ SDL_SCANCODE_TAB, RETROK_TAB },
|
||||
{ SDL_SCANCODE_INSERT, RETROK_INSERT },
|
||||
{ SDL_SCANCODE_DELETE, RETROK_DELETE },
|
||||
{ SDL_SCANCODE_RSHIFT, RETROK_RSHIFT },
|
||||
{ SDL_SCANCODE_LSHIFT, RETROK_LSHIFT },
|
||||
{ SDL_SCANCODE_LCTRL, RETROK_LCTRL },
|
||||
{ SDL_SCANCODE_END, RETROK_END },
|
||||
{ SDL_SCANCODE_HOME, RETROK_HOME },
|
||||
{ SDL_SCANCODE_PAGEDOWN, RETROK_PAGEDOWN },
|
||||
{ SDL_SCANCODE_PAGEUP, RETROK_PAGEUP },
|
||||
{ SDL_SCANCODE_LALT, RETROK_LALT },
|
||||
{ SDL_SCANCODE_SPACE, RETROK_SPACE },
|
||||
{ SDL_SCANCODE_ESCAPE, RETROK_ESCAPE },
|
||||
{ SDL_SCANCODE_BACKSPACE, RETROK_BACKSPACE },
|
||||
{ SDL_SCANCODE_KP_ENTER, RETROK_KP_ENTER },
|
||||
{ SDL_SCANCODE_KP_PLUS, RETROK_KP_PLUS },
|
||||
{ SDL_SCANCODE_KP_MINUS, RETROK_KP_MINUS },
|
||||
{ SDL_SCANCODE_KP_MULTIPLY, RETROK_KP_MULTIPLY },
|
||||
{ SDL_SCANCODE_KP_DIVIDE, RETROK_KP_DIVIDE },
|
||||
{ SDL_SCANCODE_GRAVE, RETROK_BACKQUOTE },
|
||||
{ SDL_SCANCODE_PAUSE, RETROK_PAUSE },
|
||||
{ SDL_SCANCODE_KP_0, RETROK_KP0 },
|
||||
{ SDL_SCANCODE_KP_1, RETROK_KP1 },
|
||||
{ SDL_SCANCODE_KP_2, RETROK_KP2 },
|
||||
{ SDL_SCANCODE_KP_3, RETROK_KP3 },
|
||||
{ SDL_SCANCODE_KP_4, RETROK_KP4 },
|
||||
{ SDL_SCANCODE_KP_5, RETROK_KP5 },
|
||||
{ SDL_SCANCODE_KP_6, RETROK_KP6 },
|
||||
{ SDL_SCANCODE_KP_7, RETROK_KP7 },
|
||||
{ SDL_SCANCODE_KP_8, RETROK_KP8 },
|
||||
{ SDL_SCANCODE_KP_9, RETROK_KP9 },
|
||||
{ SDL_SCANCODE_0, RETROK_0 },
|
||||
{ SDL_SCANCODE_1, RETROK_1 },
|
||||
{ SDL_SCANCODE_2, RETROK_2 },
|
||||
{ SDL_SCANCODE_3, RETROK_3 },
|
||||
{ SDL_SCANCODE_4, RETROK_4 },
|
||||
{ SDL_SCANCODE_5, RETROK_5 },
|
||||
{ SDL_SCANCODE_6, RETROK_6 },
|
||||
{ SDL_SCANCODE_7, RETROK_7 },
|
||||
{ SDL_SCANCODE_8, RETROK_8 },
|
||||
{ SDL_SCANCODE_9, RETROK_9 },
|
||||
{ SDL_SCANCODE_F1, RETROK_F1 },
|
||||
{ SDL_SCANCODE_F2, RETROK_F2 },
|
||||
{ SDL_SCANCODE_F3, RETROK_F3 },
|
||||
{ SDL_SCANCODE_F4, RETROK_F4 },
|
||||
{ SDL_SCANCODE_F5, RETROK_F5 },
|
||||
{ SDL_SCANCODE_F6, RETROK_F6 },
|
||||
{ SDL_SCANCODE_F7, RETROK_F7 },
|
||||
{ SDL_SCANCODE_F8, RETROK_F8 },
|
||||
{ SDL_SCANCODE_F9, RETROK_F9 },
|
||||
{ SDL_SCANCODE_F10, RETROK_F10 },
|
||||
{ SDL_SCANCODE_F11, RETROK_F11 },
|
||||
{ SDL_SCANCODE_F12, RETROK_F12 },
|
||||
{ SDL_SCANCODE_A, RETROK_a },
|
||||
{ SDL_SCANCODE_B, RETROK_b },
|
||||
{ SDL_SCANCODE_C, RETROK_c },
|
||||
{ SDL_SCANCODE_D, RETROK_d },
|
||||
{ SDL_SCANCODE_E, RETROK_e },
|
||||
{ SDL_SCANCODE_F, RETROK_f },
|
||||
{ SDL_SCANCODE_G, RETROK_g },
|
||||
{ SDL_SCANCODE_H, RETROK_h },
|
||||
{ SDL_SCANCODE_I, RETROK_i },
|
||||
{ SDL_SCANCODE_J, RETROK_j },
|
||||
{ SDL_SCANCODE_K, RETROK_k },
|
||||
{ SDL_SCANCODE_L, RETROK_l },
|
||||
{ SDL_SCANCODE_M, RETROK_m },
|
||||
{ SDL_SCANCODE_N, RETROK_n },
|
||||
{ SDL_SCANCODE_O, RETROK_o },
|
||||
{ SDL_SCANCODE_P, RETROK_p },
|
||||
{ SDL_SCANCODE_Q, RETROK_q },
|
||||
{ SDL_SCANCODE_R, RETROK_r },
|
||||
{ SDL_SCANCODE_S, RETROK_s },
|
||||
{ SDL_SCANCODE_T, RETROK_t },
|
||||
{ SDL_SCANCODE_U, RETROK_u },
|
||||
{ SDL_SCANCODE_V, RETROK_v },
|
||||
{ SDL_SCANCODE_W, RETROK_w },
|
||||
{ SDL_SCANCODE_X, RETROK_x },
|
||||
{ SDL_SCANCODE_Y, RETROK_y },
|
||||
{ SDL_SCANCODE_Z, RETROK_z },
|
||||
{ 0, RETROK_UNKNOWN },
|
||||
};
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_DINPUT
|
||||
const struct rarch_key_map rarch_key_map_dinput[] = {
|
||||
{ DIK_LEFT, RETROK_LEFT },
|
||||
|
||||
@ -104,6 +104,7 @@ extern const rarch_joypad_driver_t linuxraw_joypad;
|
||||
extern const rarch_joypad_driver_t udev_joypad;
|
||||
extern const rarch_joypad_driver_t winxinput_joypad; // Named as such to avoid confusion with xb1/360 port code
|
||||
extern const rarch_joypad_driver_t sdl_joypad;
|
||||
extern const rarch_joypad_driver_t sdl2_joypad;
|
||||
extern const rarch_joypad_driver_t ps3_joypad;
|
||||
extern const rarch_joypad_driver_t psp_joypad;
|
||||
extern const rarch_joypad_driver_t xdk_joypad;
|
||||
@ -120,6 +121,7 @@ struct rarch_key_map
|
||||
|
||||
extern const struct rarch_key_map rarch_key_map_x11[];
|
||||
extern const struct rarch_key_map rarch_key_map_sdl[];
|
||||
extern const struct rarch_key_map rarch_key_map_sdl2[];
|
||||
extern const struct rarch_key_map rarch_key_map_dinput[];
|
||||
extern const struct rarch_key_map rarch_key_map_rwebinput[];
|
||||
extern const struct rarch_key_map rarch_key_map_linux[];
|
||||
|
||||
324
input/sdl2_input.c
Normal file
324
input/sdl2_input.c
Normal file
@ -0,0 +1,324 @@
|
||||
/* RetroArch - A frontend for libretro.
|
||||
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
|
||||
*
|
||||
* RetroArch is free software: you can redistribute it and/or modify it under the terms
|
||||
* of the GNU General Public License as published by the Free Software Found-
|
||||
* ation, either version 3 of the License, or (at your option) any later version.
|
||||
*
|
||||
* RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
||||
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||||
* PURPOSE. See the GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along with RetroArch.
|
||||
* If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "../driver.h"
|
||||
|
||||
#include "SDL.h"
|
||||
#include "../gfx/gfx_context.h"
|
||||
#include "../boolean.h"
|
||||
#include "../general.h"
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
#include "../libretro.h"
|
||||
#include "input_common.h"
|
||||
|
||||
typedef struct sdl2_input
|
||||
{
|
||||
const rarch_joypad_driver_t *joypad;
|
||||
|
||||
int mouse_x, mouse_y;
|
||||
int mouse_abs_x, mouse_abs_y;
|
||||
int mouse_l, mouse_r, mouse_m, mouse_wu, mouse_wd, mouse_wl, mouse_wr;
|
||||
} sdl2_input_t;
|
||||
|
||||
static void *sdl2_input_init(void)
|
||||
{
|
||||
input_init_keyboard_lut(rarch_key_map_sdl2);
|
||||
sdl2_input_t *sdl = (sdl2_input_t*)calloc(1, sizeof(*sdl));
|
||||
if (!sdl)
|
||||
return NULL;
|
||||
|
||||
sdl->joypad = input_joypad_init_driver(g_settings.input.joypad_driver);
|
||||
return sdl;
|
||||
}
|
||||
|
||||
static bool sdl2_key_pressed(int key)
|
||||
{
|
||||
if (key >= RETROK_LAST)
|
||||
return false;
|
||||
|
||||
int sym = input_translate_rk_to_keysym((enum retro_key)key);
|
||||
|
||||
int num_keys;
|
||||
const uint8_t *keymap = SDL_GetKeyboardState(&num_keys);
|
||||
if (sym < 0 || sym >= num_keys)
|
||||
return false;
|
||||
|
||||
return keymap[sym];
|
||||
}
|
||||
|
||||
static bool sdl2_is_pressed(sdl2_input_t *sdl, unsigned port_num, const struct retro_keybind *binds, unsigned key)
|
||||
{
|
||||
if (sdl2_key_pressed(binds[key].key))
|
||||
return true;
|
||||
|
||||
return input_joypad_pressed(sdl->joypad, port_num, binds, key);
|
||||
}
|
||||
|
||||
static int16_t sdl2_analog_pressed(sdl2_input_t *sdl, const struct retro_keybind *binds,
|
||||
unsigned index, unsigned id)
|
||||
{
|
||||
unsigned id_minus = 0;
|
||||
unsigned id_plus = 0;
|
||||
input_conv_analog_id_to_bind_id(index, id, &id_minus, &id_plus);
|
||||
|
||||
int16_t pressed_minus = sdl2_key_pressed(binds[id_minus].key) ? -0x7fff : 0;
|
||||
int16_t pressed_plus = sdl2_key_pressed(binds[id_plus].key) ? 0x7fff : 0;
|
||||
return pressed_plus + pressed_minus;
|
||||
}
|
||||
|
||||
static bool sdl2_bind_button_pressed(void *data, int key)
|
||||
{
|
||||
const struct retro_keybind *binds = g_settings.input.binds[0];
|
||||
if (key >= 0 && key < RARCH_BIND_LIST_END)
|
||||
return sdl2_is_pressed((sdl2_input_t*)data, 0, binds, key);
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
static int16_t sdl2_joypad_device_state(sdl2_input_t *sdl, const struct retro_keybind **binds_,
|
||||
unsigned port_num, unsigned id)
|
||||
{
|
||||
const struct retro_keybind *binds = binds_[port_num];
|
||||
if (id < RARCH_BIND_LIST_END)
|
||||
return binds[id].valid && sdl2_is_pressed(sdl, port_num, binds, id);
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int16_t sdl2_analog_device_state(sdl2_input_t *sdl, const struct retro_keybind **binds,
|
||||
unsigned port_num, unsigned index, unsigned id)
|
||||
{
|
||||
int16_t ret = sdl2_analog_pressed(sdl, binds[port_num], index, id);
|
||||
if (!ret)
|
||||
ret = input_joypad_analog(sdl->joypad, port_num, index, id, binds[port_num]);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int16_t sdl2_keyboard_device_state(sdl2_input_t *sdl, unsigned id)
|
||||
{
|
||||
return sdl2_key_pressed(id);
|
||||
}
|
||||
|
||||
static int16_t sdl2_mouse_device_state(sdl2_input_t *sdl, unsigned id)
|
||||
{
|
||||
switch (id)
|
||||
{
|
||||
case RETRO_DEVICE_ID_MOUSE_LEFT:
|
||||
return sdl->mouse_l;
|
||||
case RETRO_DEVICE_ID_MOUSE_RIGHT:
|
||||
return sdl->mouse_r;
|
||||
case RETRO_DEVICE_ID_MOUSE_WHEELUP:
|
||||
return sdl->mouse_wu;
|
||||
case RETRO_DEVICE_ID_MOUSE_WHEELDOWN:
|
||||
return sdl->mouse_wd;
|
||||
case RETRO_DEVICE_ID_MOUSE_X:
|
||||
return sdl->mouse_x;
|
||||
case RETRO_DEVICE_ID_MOUSE_Y:
|
||||
return sdl->mouse_y;
|
||||
case RETRO_DEVICE_ID_MOUSE_MIDDLE:
|
||||
return sdl->mouse_m;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
static int16_t sdl2_pointer_device_state(sdl2_input_t *sdl, unsigned index, unsigned id, bool screen)
|
||||
{
|
||||
if (index != 0)
|
||||
return 0;
|
||||
|
||||
int16_t res_x = 0, res_y = 0, res_screen_x = 0, res_screen_y = 0;
|
||||
bool valid = input_translate_coord_viewport(sdl->mouse_abs_x, sdl->mouse_abs_y,
|
||||
&res_x, &res_y, &res_screen_x, &res_screen_y);
|
||||
|
||||
if (!valid)
|
||||
return 0;
|
||||
|
||||
if (screen)
|
||||
{
|
||||
res_x = res_screen_x;
|
||||
res_y = res_screen_y;
|
||||
}
|
||||
|
||||
bool inside = (res_x >= -0x7fff) && (res_y >= -0x7fff);
|
||||
|
||||
if (!inside)
|
||||
return 0;
|
||||
|
||||
switch (id)
|
||||
{
|
||||
case RETRO_DEVICE_ID_POINTER_X:
|
||||
return res_x;
|
||||
case RETRO_DEVICE_ID_POINTER_Y:
|
||||
return res_y;
|
||||
case RETRO_DEVICE_ID_POINTER_PRESSED:
|
||||
return sdl->mouse_l;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
static int16_t sdl2_lightgun_device_state(sdl2_input_t *sdl, unsigned id)
|
||||
{
|
||||
switch (id)
|
||||
{
|
||||
case RETRO_DEVICE_ID_LIGHTGUN_X:
|
||||
return sdl->mouse_x;
|
||||
case RETRO_DEVICE_ID_LIGHTGUN_Y:
|
||||
return sdl->mouse_y;
|
||||
case RETRO_DEVICE_ID_LIGHTGUN_TRIGGER:
|
||||
return sdl->mouse_l;
|
||||
case RETRO_DEVICE_ID_LIGHTGUN_CURSOR:
|
||||
return sdl->mouse_m;
|
||||
case RETRO_DEVICE_ID_LIGHTGUN_TURBO:
|
||||
return sdl->mouse_r;
|
||||
case RETRO_DEVICE_ID_LIGHTGUN_START:
|
||||
return sdl->mouse_m && sdl->mouse_r;
|
||||
case RETRO_DEVICE_ID_LIGHTGUN_PAUSE:
|
||||
return sdl->mouse_m && sdl->mouse_l;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
static int16_t sdl2_input_state(void *data_, const struct retro_keybind **binds, unsigned port, unsigned device, unsigned index, unsigned id)
|
||||
{
|
||||
sdl2_input_t *data = (sdl2_input_t*)data_;
|
||||
switch (device)
|
||||
{
|
||||
case RETRO_DEVICE_JOYPAD:
|
||||
return sdl2_joypad_device_state(data, binds, port, id);
|
||||
case RETRO_DEVICE_ANALOG:
|
||||
return sdl2_analog_device_state(data, binds, port, index, id);
|
||||
case RETRO_DEVICE_MOUSE:
|
||||
return sdl2_mouse_device_state(data, id);
|
||||
case RETRO_DEVICE_POINTER:
|
||||
case RARCH_DEVICE_POINTER_SCREEN:
|
||||
return sdl2_pointer_device_state(data, index, id, device == RARCH_DEVICE_POINTER_SCREEN);
|
||||
case RETRO_DEVICE_KEYBOARD:
|
||||
return sdl2_keyboard_device_state(data, id);
|
||||
case RETRO_DEVICE_LIGHTGUN:
|
||||
return sdl2_lightgun_device_state(data, id);
|
||||
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
static void sdl2_input_free(void *data)
|
||||
{
|
||||
if (!data)
|
||||
return;
|
||||
|
||||
// Flush out all pending events.
|
||||
SDL_FlushEvents(SDL_FIRSTEVENT, SDL_LASTEVENT);
|
||||
|
||||
sdl2_input_t *sdl = (sdl2_input_t*)data;
|
||||
|
||||
if (sdl->joypad)
|
||||
sdl->joypad->destroy();
|
||||
|
||||
free(data);
|
||||
}
|
||||
|
||||
static void sdl2_grab_mouse(void *data, bool state)
|
||||
{
|
||||
sdl2_input_t *sdl = (sdl2_input_t*)data;
|
||||
|
||||
if (driver.video == &video_sdl2)
|
||||
{
|
||||
/* first member of sdl2_video_t is the window */
|
||||
struct temp{
|
||||
SDL_Window *w;
|
||||
};
|
||||
SDL_SetWindowGrab(((struct temp*)driver.video_data)->w,
|
||||
state ? SDL_TRUE : SDL_FALSE);
|
||||
}
|
||||
}
|
||||
|
||||
static bool sdl2_set_rumble(void *data, unsigned port, enum retro_rumble_effect effect, uint16_t strength)
|
||||
{
|
||||
sdl2_input_t *sdl = (sdl2_input_t*)data;
|
||||
return input_joypad_set_rumble(sdl->joypad, port, effect, strength);
|
||||
}
|
||||
|
||||
static const rarch_joypad_driver_t *sdl2_get_joypad_driver(void *data)
|
||||
{
|
||||
sdl2_input_t *sdl = (sdl2_input_t*)data;
|
||||
return sdl->joypad;
|
||||
}
|
||||
|
||||
static void sdl2_input_poll(void *data)
|
||||
{
|
||||
sdl2_input_t *sdl = (sdl2_input_t*)data;
|
||||
|
||||
SDL_Event event;
|
||||
|
||||
SDL_PumpEvents();
|
||||
while (SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_MOUSEWHEEL, SDL_MOUSEWHEEL) > 0)
|
||||
{
|
||||
if (event.type == SDL_MOUSEWHEEL)
|
||||
{
|
||||
sdl->mouse_wu = event.wheel.y < 0;
|
||||
sdl->mouse_wd = event.wheel.y > 0;
|
||||
sdl->mouse_wl = event.wheel.x < 0;
|
||||
sdl->mouse_wr = event.wheel.x > 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (sdl->joypad)
|
||||
sdl->joypad->poll();
|
||||
|
||||
uint8_t btn = SDL_GetRelativeMouseState(&sdl->mouse_x, &sdl->mouse_y);
|
||||
SDL_GetMouseState(&sdl->mouse_abs_x, &sdl->mouse_abs_y);
|
||||
|
||||
sdl->mouse_l = SDL_BUTTON(SDL_BUTTON_LEFT) & btn ? 1 : 0;
|
||||
sdl->mouse_r = SDL_BUTTON(SDL_BUTTON_RIGHT) & btn ? 1 : 0;
|
||||
sdl->mouse_m = SDL_BUTTON(SDL_BUTTON_MIDDLE) & btn ? 1 : 0;
|
||||
}
|
||||
|
||||
static uint64_t sdl2_get_capabilities(void *data)
|
||||
{
|
||||
uint64_t caps = 0;
|
||||
|
||||
caps |= (1 << RETRO_DEVICE_JOYPAD);
|
||||
caps |= (1 << RETRO_DEVICE_MOUSE);
|
||||
caps |= (1 << RETRO_DEVICE_KEYBOARD);
|
||||
caps |= (1 << RETRO_DEVICE_LIGHTGUN);
|
||||
caps |= (1 << RETRO_DEVICE_POINTER);
|
||||
caps |= (1 << RETRO_DEVICE_ANALOG);
|
||||
|
||||
return caps;
|
||||
}
|
||||
|
||||
const input_driver_t input_sdl2 = {
|
||||
sdl2_input_init,
|
||||
sdl2_input_poll,
|
||||
sdl2_input_state,
|
||||
sdl2_bind_button_pressed,
|
||||
sdl2_input_free,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
sdl2_get_capabilities,
|
||||
NULL,
|
||||
"sdl2",
|
||||
sdl2_grab_mouse,
|
||||
sdl2_set_rumble,
|
||||
sdl2_get_joypad_driver,
|
||||
};
|
||||
|
||||
315
input/sdl2_joypad.c
Normal file
315
input/sdl2_joypad.c
Normal file
@ -0,0 +1,315 @@
|
||||
/* RetroArch - A frontend for libretro.
|
||||
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
|
||||
*
|
||||
* RetroArch is free software: you can redistribute it and/or modify it under the terms
|
||||
* of the GNU General Public License as published by the Free Software Found-
|
||||
* ation, either version 3 of the License, or (at your option) any later version.
|
||||
*
|
||||
* RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
||||
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||||
* PURPOSE. See the GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along with RetroArch.
|
||||
* If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "input_common.h"
|
||||
#include "SDL.h"
|
||||
#include "../general.h"
|
||||
|
||||
typedef struct _sdl2_joypad
|
||||
{
|
||||
SDL_Joystick *joypad;
|
||||
SDL_Haptic *haptic;
|
||||
int rumble_effect; // -1 = not initialized, -2 = error/unsupported
|
||||
unsigned num_axes;
|
||||
unsigned num_buttons;
|
||||
unsigned num_hats;
|
||||
unsigned num_balls;
|
||||
} sdl2_joypad_t;
|
||||
|
||||
static sdl2_joypad_t g_pads[MAX_PLAYERS];
|
||||
static bool has_haptic;
|
||||
|
||||
static void sdl2_joypad_destroy(void)
|
||||
{
|
||||
unsigned i;
|
||||
for (i = 0; i < MAX_PLAYERS; i++)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
SDL_QuitSubSystem(SDL_INIT_JOYSTICK);
|
||||
memset(g_pads, 0, sizeof(g_pads));
|
||||
}
|
||||
|
||||
static void sdl2_joypad_connect(int id)
|
||||
{
|
||||
sdl2_joypad_t *pad = &g_pads[id];
|
||||
pad->joypad = SDL_JoystickOpen(id);
|
||||
if (!pad->joypad)
|
||||
{
|
||||
RARCH_ERR("[SDL]: Couldn't open SDL joystick #%u.\n", id);
|
||||
return;
|
||||
}
|
||||
|
||||
RARCH_LOG("[SDL]: Joypad #%u connected: %s.\n",
|
||||
id, SDL_JoystickName(pad->joypad));
|
||||
|
||||
pad->haptic = has_haptic ? SDL_HapticOpenFromJoystick(pad->joypad) : NULL;
|
||||
|
||||
if (has_haptic && !pad->haptic)
|
||||
RARCH_WARN("[SDL]: Couldn't open haptic device of the joypad #%u: %s\n",
|
||||
id, SDL_GetError());
|
||||
|
||||
pad->rumble_effect = -1;
|
||||
|
||||
if (pad->haptic)
|
||||
{
|
||||
SDL_HapticEffect efx;
|
||||
efx.type = SDL_HAPTIC_LEFTRIGHT;
|
||||
efx.leftright.type = SDL_HAPTIC_LEFTRIGHT;
|
||||
efx.leftright.large_magnitude = efx.leftright.small_magnitude = 0x4000;
|
||||
efx.leftright.length = 5000;
|
||||
|
||||
if (SDL_HapticEffectSupported(pad->haptic, &efx) == SDL_FALSE)
|
||||
{
|
||||
pad->rumble_effect = -2;
|
||||
RARCH_WARN("[SDL]: Joypad #%u does not support rumble.\n", id);
|
||||
}
|
||||
}
|
||||
|
||||
pad->num_axes = SDL_JoystickNumAxes(pad->joypad);
|
||||
pad->num_buttons = SDL_JoystickNumButtons(pad->joypad);
|
||||
pad->num_hats = SDL_JoystickNumHats(pad->joypad);
|
||||
pad->num_balls = SDL_JoystickNumBalls(pad->joypad);
|
||||
|
||||
RARCH_LOG("[SDL]: Joypad #%u has: %u axes, %u buttons, %u hats and %u trackballs.\n",
|
||||
id, pad->num_axes, pad->num_buttons, pad->num_hats, pad->num_balls);
|
||||
}
|
||||
|
||||
static void sdl2_joypad_disconnect(int id)
|
||||
{
|
||||
RARCH_LOG("[SDL]: Joypad #%u disconnected.\n", id);
|
||||
|
||||
if (g_pads[id].haptic)
|
||||
SDL_HapticClose(g_pads[id].haptic);
|
||||
|
||||
if (g_pads[id].joypad)
|
||||
SDL_JoystickClose(g_pads[id].joypad);
|
||||
|
||||
memset(&g_pads[id], 0, sizeof(g_pads[id]));
|
||||
}
|
||||
|
||||
static bool sdl2_joypad_init(void)
|
||||
{
|
||||
unsigned i;
|
||||
|
||||
has_haptic = false;
|
||||
if (SDL_Init(SDL_INIT_JOYSTICK) < 0)
|
||||
{
|
||||
RARCH_WARN("[SDL]: Failed to initialize joystick interface: %s\n",
|
||||
SDL_GetError());
|
||||
return false;
|
||||
}
|
||||
|
||||
SDL_JoystickEventState(SDL_ENABLE);
|
||||
|
||||
// TODO: Add SDL_GameController support.
|
||||
// if (SDL_Init(SDL_INIT_GAMECONTROLLER) < 0)
|
||||
// RARCH_LOG("[SDL]: Failed to initialize game controller interface: %s\n",
|
||||
// SDL_GetError());
|
||||
|
||||
if (SDL_Init(SDL_INIT_HAPTIC) < 0)
|
||||
RARCH_WARN("[SDL]: Failed to initialize haptic device support: %s\n",
|
||||
SDL_GetError());
|
||||
else
|
||||
has_haptic = true;
|
||||
|
||||
unsigned num_sticks = SDL_NumJoysticks();
|
||||
if (num_sticks > MAX_PLAYERS)
|
||||
num_sticks = MAX_PLAYERS;
|
||||
|
||||
for (i = 0; i < num_sticks; i++)
|
||||
{
|
||||
sdl2_joypad_connect(i);
|
||||
}
|
||||
|
||||
num_sticks = 0;
|
||||
for (i = 0; i < MAX_PLAYERS; i++)
|
||||
{
|
||||
if (g_pads[i].joypad)
|
||||
num_sticks++;
|
||||
}
|
||||
|
||||
if (num_sticks == 0)
|
||||
goto error;
|
||||
|
||||
return true;
|
||||
|
||||
error:
|
||||
sdl2_joypad_destroy();
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool sdl2_joypad_button(unsigned port, uint16_t joykey)
|
||||
{
|
||||
if (joykey == NO_BTN)
|
||||
return false;
|
||||
|
||||
const sdl2_joypad_t *pad = &g_pads[port];
|
||||
if (!pad->joypad)
|
||||
return false;
|
||||
|
||||
// Check hat.
|
||||
if (GET_HAT_DIR(joykey))
|
||||
{
|
||||
uint16_t hat = GET_HAT(joykey);
|
||||
if (hat >= pad->num_hats)
|
||||
return false;
|
||||
|
||||
Uint8 dir = SDL_JoystickGetHat(pad->joypad, hat);
|
||||
switch (GET_HAT_DIR(joykey))
|
||||
{
|
||||
case HAT_UP_MASK:
|
||||
return dir & SDL_HAT_UP;
|
||||
case HAT_DOWN_MASK:
|
||||
return dir & SDL_HAT_DOWN;
|
||||
case HAT_LEFT_MASK:
|
||||
return dir & SDL_HAT_LEFT;
|
||||
case HAT_RIGHT_MASK:
|
||||
return dir & SDL_HAT_RIGHT;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
else // Check the button
|
||||
{
|
||||
if (joykey < pad->num_buttons && SDL_JoystickGetButton(pad->joypad, joykey))
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
static int16_t sdl2_joypad_axis(unsigned port, uint32_t joyaxis)
|
||||
{
|
||||
if (joyaxis == AXIS_NONE)
|
||||
return 0;
|
||||
|
||||
const sdl2_joypad_t *pad = &g_pads[port];
|
||||
if (!pad->joypad)
|
||||
return false;
|
||||
|
||||
Sint16 val = 0;
|
||||
if (AXIS_NEG_GET(joyaxis) < pad->num_axes)
|
||||
{
|
||||
val = SDL_JoystickGetAxis(pad->joypad, AXIS_NEG_GET(joyaxis));
|
||||
|
||||
if (val > 0)
|
||||
val = 0;
|
||||
else if (val < -0x7fff) // -0x8000 can cause trouble if we later abs() it.
|
||||
val = -0x7fff;
|
||||
}
|
||||
else if (AXIS_POS_GET(joyaxis) < pad->num_axes)
|
||||
{
|
||||
val = SDL_JoystickGetAxis(pad->joypad, AXIS_POS_GET(joyaxis));
|
||||
|
||||
if (val < 0)
|
||||
val = 0;
|
||||
}
|
||||
|
||||
return val;
|
||||
}
|
||||
|
||||
static void sdl2_joypad_poll(void)
|
||||
{
|
||||
SDL_Event event;
|
||||
|
||||
SDL_PumpEvents();
|
||||
while (SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_JOYDEVICEADDED, SDL_JOYDEVICEREMOVED) > 0)
|
||||
{
|
||||
if (event.type == SDL_JOYDEVICEADDED)
|
||||
{
|
||||
sdl2_joypad_connect(event.jdevice.which);
|
||||
}
|
||||
else if (event.type == SDL_JOYDEVICEREMOVED)
|
||||
{
|
||||
sdl2_joypad_disconnect(event.jdevice.which);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static bool sdl2_joypad_set_rumble(unsigned pad, enum retro_rumble_effect effect, uint16_t strength)
|
||||
{
|
||||
SDL_HapticEffect efx;
|
||||
memset(&efx, 0, sizeof(efx));
|
||||
|
||||
sdl2_joypad_t *joypad = &g_pads[pad];
|
||||
|
||||
if (!joypad->joypad || !joypad->haptic)
|
||||
return false;
|
||||
|
||||
efx.type = SDL_HAPTIC_LEFTRIGHT;
|
||||
efx.leftright.type = SDL_HAPTIC_LEFTRIGHT;
|
||||
efx.leftright.length = 5000;
|
||||
|
||||
switch (effect)
|
||||
{
|
||||
case RETRO_RUMBLE_STRONG: efx.leftright.large_magnitude = strength; break;
|
||||
case RETRO_RUMBLE_WEAK: efx.leftright.small_magnitude = strength; break;
|
||||
default: return false;
|
||||
}
|
||||
|
||||
if (joypad->rumble_effect == -1)
|
||||
{
|
||||
joypad->rumble_effect = SDL_HapticNewEffect(g_pads[pad].haptic, &efx);
|
||||
if (joypad->rumble_effect < 0)
|
||||
{
|
||||
RARCH_WARN("[SDL]: Failed to create rumble effect for joypad %u: %s\n",
|
||||
pad, SDL_GetError());
|
||||
joypad->rumble_effect = -2;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
else if (joypad->rumble_effect >= 0)
|
||||
SDL_HapticUpdateEffect(joypad->haptic, joypad->rumble_effect, &efx);
|
||||
|
||||
if (joypad->rumble_effect < 0)
|
||||
return false;
|
||||
|
||||
if (SDL_HapticRunEffect(joypad->haptic, joypad->rumble_effect, 1) < 0)
|
||||
{
|
||||
RARCH_WARN("[SDL]: Failed to set rumble effect on joypad %u: %s\n",
|
||||
pad, SDL_GetError());
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool sdl2_joypad_query_pad(unsigned pad)
|
||||
{
|
||||
return pad < MAX_PLAYERS && g_pads[pad].joypad;
|
||||
}
|
||||
|
||||
static const char *sdl2_joypad_name(unsigned pad)
|
||||
{
|
||||
if (pad >= MAX_PLAYERS)
|
||||
return NULL;
|
||||
|
||||
return SDL_JoystickName(g_pads[pad].joypad);
|
||||
}
|
||||
|
||||
const rarch_joypad_driver_t sdl2_joypad = {
|
||||
sdl2_joypad_init,
|
||||
sdl2_joypad_query_pad,
|
||||
sdl2_joypad_destroy,
|
||||
sdl2_joypad_button,
|
||||
sdl2_joypad_axis,
|
||||
sdl2_joypad_poll,
|
||||
sdl2_joypad_set_rumble,
|
||||
sdl2_joypad_name,
|
||||
"sdl2",
|
||||
};
|
||||
|
||||
@ -160,6 +160,18 @@ check_lib COREAUDIO "-framework AudioUnit" AudioUnitInitialize
|
||||
|
||||
check_pkgconf SDL sdl 1.2.10
|
||||
|
||||
if [ "$HAVE_SDL2" == 'yes' ]; then
|
||||
check_pkgconf SDL2 sdl2 2.0.0
|
||||
|
||||
if [ "$HAVE_SDL2" == 'yes' ] && [ "$HAVE_SDL" == 'yes' ]; then
|
||||
echo "SDL drivers will be replaced by SDL2 ones."
|
||||
HAVE_SDL=no
|
||||
elif [ "$HAVE_SDL2" == 'no' ]; then
|
||||
echo "SDL2 not found, skipping."
|
||||
HAVE_SDL2=no
|
||||
fi
|
||||
fi
|
||||
|
||||
if [ "$HAVE_OPENGL" != 'no' ] && [ "$HAVE_GLES" != 'yes' ]; then
|
||||
if [ "$OS" = 'Darwin' ]; then
|
||||
check_lib CG "-framework Cg" cgCreateContext
|
||||
@ -278,6 +290,6 @@ add_define_make OS "$OS"
|
||||
|
||||
# Creates config.mk and config.h.
|
||||
add_define_make GLOBAL_CONFIG_DIR "$GLOBAL_CONFIG_DIR"
|
||||
VARS="RGUI LAKKA ALSA OSS OSS_BSD OSS_LIB AL RSOUND ROAR JACK COREAUDIO PULSE SDL OPENGL LIMA OMAP GLES GLES3 VG EGL KMS GBM DRM DYLIB GETOPT_LONG THREADS CG LIBXML2 ZLIB DYNAMIC FFMPEG AVCODEC AVFORMAT AVUTIL SWSCALE FREETYPE XKBCOMMON XVIDEO X11 XEXT XF86VM XINERAMA WAYLAND MALI_FBDEV NETPLAY NETWORK_CMD STDIN_CMD COMMAND SOCKET_LEGACY FBO STRL STRCASESTR MMAP PYTHON FFMPEG_ALLOC_CONTEXT3 FFMPEG_AVCODEC_OPEN2 FFMPEG_AVIO_OPEN FFMPEG_AVFORMAT_WRITE_HEADER FFMPEG_AVFORMAT_NEW_STREAM FFMPEG_AVCODEC_ENCODE_AUDIO2 FFMPEG_AVCODEC_ENCODE_VIDEO2 BSV_MOVIE VIDEOCORE NEON FLOATHARD FLOATSOFTFP UDEV V4L2 AV_CHANNEL_LAYOUT"
|
||||
VARS="RGUI LAKKA ALSA OSS OSS_BSD OSS_LIB AL RSOUND ROAR JACK COREAUDIO PULSE SDL SDL2 OPENGL LIMA OMAP GLES GLES3 VG EGL KMS GBM DRM DYLIB GETOPT_LONG THREADS CG LIBXML2 ZLIB DYNAMIC FFMPEG AVCODEC AVFORMAT AVUTIL SWSCALE FREETYPE XKBCOMMON XVIDEO X11 XEXT XF86VM XINERAMA WAYLAND MALI_FBDEV NETPLAY NETWORK_CMD STDIN_CMD COMMAND SOCKET_LEGACY FBO STRL STRCASESTR MMAP PYTHON FFMPEG_ALLOC_CONTEXT3 FFMPEG_AVCODEC_OPEN2 FFMPEG_AVIO_OPEN FFMPEG_AVFORMAT_WRITE_HEADER FFMPEG_AVFORMAT_NEW_STREAM FFMPEG_AVCODEC_ENCODE_AUDIO2 FFMPEG_AVCODEC_ENCODE_VIDEO2 BSV_MOVIE VIDEOCORE NEON FLOATHARD FLOATSOFTFP UDEV V4L2 AV_CHANNEL_LAYOUT"
|
||||
create_config_make config.mk $VARS
|
||||
create_config_header config.h $VARS
|
||||
|
||||
@ -2,6 +2,7 @@ HAVE_RGUI=yes # Disable RGUI
|
||||
HAVE_LAKKA=no # Enable Lakka menu
|
||||
HAVE_DYNAMIC=yes # Disable dynamic loading of libretro library
|
||||
HAVE_SDL=auto # SDL support
|
||||
HAVE_SDL2=no # SDL2 support (disables SDL 1.x)
|
||||
HAVE_UDEV=auto # Udev/Evdev gamepad support
|
||||
HAVE_LIBRETRO= # libretro library used
|
||||
HAVE_MAN_DIR= # Manpage install directory
|
||||
|
||||
@ -823,6 +823,7 @@ static void print_features(void)
|
||||
puts("");
|
||||
puts("Features:");
|
||||
_PSUPP(sdl, "SDL", "SDL drivers");
|
||||
_PSUPP(sdl2, "SDL2", "SDL2 drivers");
|
||||
_PSUPP(x11, "X11", "X11 drivers");
|
||||
_PSUPP(wayland, "wayland", "Wayland drivers");
|
||||
_PSUPP(thread, "Threads", "Threading support");
|
||||
|
||||
Loading…
Reference in New Issue
Block a user