libretro/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch.git synced 2024-10-07 22:33:27 +00:00
Code Issues Actions 23 Packages Projects Releases Wiki Activity

(Gfx context) Cleanups in gfx context drivers

Browse Source
This commit is contained in:
twinaphex 2015-01-10 17:51:00 +01:00
parent 4bdb26e2a1
commit 2f195b96cd
14 changed files with 530 additions and 337 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

91
gfx/context/androidegl_ctx.c
View File

@ -44,8 +44,10 @@ static void android_gfx_ctx_set_swap_interval(void *data, unsigned interval)
driver.video_context_data;
(void)data;
if (android)
eglSwapInterval(android->g_egl_dpy, interval);
if (!android)
return;
eglSwapInterval(android->g_egl_dpy, interval);
}
static void android_gfx_ctx_destroy_resources(gfx_ctx_android_data_t *android)
@ -98,30 +100,35 @@ static void android_gfx_ctx_destroy(void *data)
static void android_gfx_ctx_get_video_size(void *data,
unsigned *width, unsigned *height)
{
EGLint gl_width, gl_height;
gfx_ctx_android_data_t *android = (gfx_ctx_android_data_t*)
driver.video_context_data;
(void)data;
*width = 0;
*height = 0;
if (android && android->g_egl_dpy)
{
EGLint gl_width, gl_height;
if (!android)
return;
if (!android->g_egl_dpy)
return;
eglQuerySurface(android->g_egl_dpy,
android->g_egl_surf, EGL_WIDTH, &gl_width);
eglQuerySurface(android->g_egl_dpy,
android->g_egl_surf, EGL_HEIGHT, &gl_height);
*width = gl_width;
*height = gl_height;
}
eglQuerySurface(android->g_egl_dpy,
android->g_egl_surf, EGL_WIDTH, &gl_width);
eglQuerySurface(android->g_egl_dpy,
android->g_egl_surf, EGL_HEIGHT, &gl_height);
*width = gl_width;
*height = gl_height;
}
static bool android_gfx_ctx_init(void *data)
{
int var;
struct android_app *android_app = (struct android_app*)g_android;
EGLint num_config, egl_version_major, egl_version_minor;
EGLint format;
EGLint context_attributes[] = {
EGL_CONTEXT_CLIENT_VERSION, g_es3 ? 3 : 2,
EGL_NONE
};
const EGLint attribs[] = {
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
@ -131,16 +138,15 @@ static bool android_gfx_ctx_init(void *data)
EGL_ALPHA_SIZE, 8,
EGL_NONE
};
EGLint num_config;
EGLint egl_version_major, egl_version_minor;
EGLint format;
struct android_app *android_app = NULL;
gfx_ctx_android_data_t *android = NULL;
android_app = (struct android_app*)g_android;
if (!android_app)
return false;
EGLint context_attributes[] = {
EGL_CONTEXT_CLIENT_VERSION, g_es3 ? 3 : 2,
EGL_NONE
};
gfx_ctx_android_data_t *android = (gfx_ctx_android_data_t*)
android = (gfx_ctx_android_data_t*)
calloc(1, sizeof(gfx_ctx_android_data_t));
if (!android)
@ -149,6 +155,7 @@ static bool android_gfx_ctx_init(void *data)
RARCH_LOG("Android EGL: GLES version = %d.\n", g_es3 ? 3 : 2);
android->g_egl_dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (!android->g_egl_dpy)
{
RARCH_ERR("[Android/EGL]: Couldn't get EGL display.\n");
@ -224,7 +231,8 @@ static void android_gfx_ctx_swap_buffers(void *data)
(void)data;
eglSwapBuffers(android->g_egl_dpy, android->g_egl_surf);
if (android)
eglSwapBuffers(android->g_egl_dpy, android->g_egl_surf);
}
static void android_gfx_ctx_check_window(void *data, bool *quit,
@ -237,6 +245,7 @@ static void android_gfx_ctx_check_window(void *data, bool *quit,
*quit = false;
android_gfx_ctx_get_video_size(data, &new_width, &new_height);
if (new_width != *width || new_height != *height)
{
*width = new_width;
@ -264,10 +273,11 @@ static void android_gfx_ctx_update_window_title(void *data)
(void)data;
gfx_get_fps(buf, sizeof(buf), fps_draw ? buf_fps : NULL, sizeof(buf_fps));
if (!fps_draw)
return;
if (fps_draw)
msg_queue_push(g_extern.msg_queue, buf_fps, 1, 1);
gfx_get_fps(buf, sizeof(buf), fps_draw ? buf_fps : NULL, sizeof(buf_fps));
msg_queue_push(g_extern.msg_queue, buf_fps, 1, 1);
}
static bool android_gfx_ctx_set_video_mode(void *data,
@ -284,8 +294,10 @@ static bool android_gfx_ctx_set_video_mode(void *data,
static void android_gfx_ctx_input_driver(void *data,
const input_driver_t **input, void **input_data)
{
(void)data;
void *androidinput = input_android.init();
(void)data;
*input = androidinput ? &input_android : NULL;
*input_data = androidinput;
}
@ -293,10 +305,12 @@ static void android_gfx_ctx_input_driver(void *data,
static gfx_ctx_proc_t android_gfx_ctx_get_proc_address(
const char *symbol)
{
rarch_assert(sizeof(void*) == sizeof(void (*)(void)));
gfx_ctx_proc_t ret;
void *sym__ = NULL;
void *sym__ = eglGetProcAddress(symbol);
rarch_assert(sizeof(void*) == sizeof(void (*)(void)));
sym__ = eglGetProcAddress(symbol);
memcpy(&ret, &sym__, sizeof(void*));
return ret;
@ -305,9 +319,10 @@ static gfx_ctx_proc_t android_gfx_ctx_get_proc_address(
static bool android_gfx_ctx_bind_api(void *data,
enum gfx_ctx_api api, unsigned major, unsigned minor)
{
unsigned version = major * 100 + minor;
(void)data;
unsigned version = major * 100 + minor;
if (version > 300)
return false;
if (version < 300)
@ -341,12 +356,14 @@ static void android_gfx_ctx_bind_hw_render(void *data, bool enable)
android->g_use_hw_ctx = enable;
if (android->g_egl_dpy && android->g_egl_surf)
eglMakeCurrent(
android->g_egl_dpy,
android->g_egl_surf,
android->g_egl_surf,
enable ? android->g_egl_hw_ctx : android->g_egl_ctx);
if (!android->g_egl_dpy)
return;
if (!android->g_egl_surf)
return;
eglMakeCurrent(android->g_egl_dpy, android->g_egl_surf,
android->g_egl_surf, enable ?
android->g_egl_hw_ctx : android->g_egl_ctx);
}
const gfx_ctx_driver_t gfx_ctx_android = {

115
gfx/context/bbqnx_ctx.c
View File

@ -90,24 +90,41 @@ static void gfx_ctx_qnx_destroy(void *data)
static void gfx_ctx_qnx_get_video_size(void *data, unsigned *width, unsigned *height)
{
EGLint gl_width, gl_height;
(void)data;
if (g_egl_dpy)
{
EGLint gl_width, gl_height;
eglQuerySurface(g_egl_dpy, g_egl_surf, EGL_WIDTH, &gl_width);
eglQuerySurface(g_egl_dpy, g_egl_surf, EGL_HEIGHT, &gl_height);
*width = gl_width;
*height = gl_height;
}
else
{
*width = 0;
*height = 0;
}
*width = 0;
*height = 0;
if (!g_egl_dpy)
return;
eglQuerySurface(g_egl_dpy, g_egl_surf, EGL_WIDTH, &gl_width);
eglQuerySurface(g_egl_dpy, g_egl_surf, EGL_HEIGHT, &gl_height);
*width = gl_width;
*height = gl_height;
}
static bool gfx_ctx_qnx_init(void *data)
{
EGLint num_config;
EGLint egl_version_major, egl_version_minor;
EGLint context_attributes[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
const EGLint attribs[] = {
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_BLUE_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_RED_SIZE, 8,
EGL_NONE
};
int angle, size[2];
int usage, format = SCREEN_FORMAT_RGBX8888;
/* Create a screen context that will be used to
* create an EGL surface to receive libscreen events */
@ -135,24 +152,6 @@ static bool gfx_ctx_qnx_init(void *data)
}
}
const EGLint attribs[] = {
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_BLUE_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_RED_SIZE, 8,
EGL_NONE
};
EGLint num_config;
EGLint egl_version_major, egl_version_minor;
int format = SCREEN_FORMAT_RGBX8888;
EGLint context_attributes[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
int usage;
usage = SCREEN_USAGE_OPENGL_ES2 | SCREEN_USAGE_ROTATION;
RARCH_LOG("Initializing context\n");
@ -231,7 +230,7 @@ static bool gfx_ctx_qnx_init(void *data)
}
#ifndef HAVE_BB10
int angle = atoi(getenv("ORIENTATION"));
angle = atoi(getenv("ORIENTATION"));
screen_display_mode_t screen_mode;
if (screen_get_display_property_pv(screen_disp, SCREEN_PROPERTY_MODE, (void**)&screen_mode))
@ -240,7 +239,6 @@ static bool gfx_ctx_qnx_init(void *data)
goto error;
}
int size[2];
if (screen_get_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, size))
{
RARCH_ERR("screen_get_window_property_iv [SCREEN_PROPERTY_BUFFER_SIZE] failed.\n");
@ -249,19 +247,26 @@ static bool gfx_ctx_qnx_init(void *data)
int buffer_size[2] = {size[0], size[1]};
if ((angle == 0) || (angle == 180)) {
if ((angle == 0) || (angle == 180))
{
if (((screen_mode.width > screen_mode.height) && (size[0] < size[1])) ||
((screen_mode.width < screen_mode.height) && (size[0] > size[1]))) {
((screen_mode.width < screen_mode.height) && (size[0] > size[1])))
{
buffer_size[1] = size[0];
buffer_size[0] = size[1];
}
} else if ((angle == 90) || (angle == 270)){
}
else if ((angle == 90) || (angle == 270))
{
if (((screen_mode.width > screen_mode.height) && (size[0] > size[1])) ||
((screen_mode.width < screen_mode.height && size[0] < size[1]))) {
((screen_mode.width < screen_mode.height && size[0] < size[1])))
{
buffer_size[1] = size[0];
buffer_size[0] = size[1];
}
} else {
}
else
{
RARCH_ERR("Navigator returned an unexpected orientation angle.\n");
goto error;
}
@ -318,12 +323,13 @@ static void gfx_ctx_qnx_swap_buffers(void *data)
static void gfx_ctx_qnx_check_window(void *data, bool *quit,
bool *resize, unsigned *width, unsigned *height, unsigned frame_count)
{
unsigned new_width, new_height;
(void)data;
(void)frame_count;
*quit = false;
unsigned new_width, new_height;
gfx_ctx_qnx_get_video_size(data, &new_width, &new_height);
if (new_width != *width || new_height != *height)
{
@ -346,13 +352,16 @@ static void gfx_ctx_qnx_set_resize(void *data, unsigned width, unsigned height)
static void gfx_ctx_qnx_update_window_title(void *data)
{
(void)data;
char buf[128], buf_fps[128];
bool fps_draw = g_settings.fps_show;
gfx_get_fps(buf, sizeof(buf), fps_draw ? buf_fps : NULL, sizeof(buf_fps));
if (fps_draw)
msg_queue_push(g_extern.msg_queue, buf_fps, 1, 1);
(void)data;
if (!fps_draw)
return;
gfx_get_fps(buf, sizeof(buf), fps_draw ? buf_fps : NULL, sizeof(buf_fps));
msg_queue_push(g_extern.msg_queue, buf_fps, 1, 1);
}
static bool gfx_ctx_qnx_set_video_mode(void *data,
@ -377,10 +386,12 @@ static void gfx_ctx_qnx_input_driver(void *data,
static gfx_ctx_proc_t gfx_ctx_qnx_get_proc_address(const char *symbol)
{
rarch_assert(sizeof(void*) == sizeof(void (*)(void)));
gfx_ctx_proc_t ret;
void *sym__;
void *sym__ = eglGetProcAddress(symbol);
rarch_assert(sizeof(void*) == sizeof(void (*)(void)));
sym__ = eglGetProcAddress(symbol);
memcpy(&ret, &sym__, sizeof(void*));
return ret;
@ -392,7 +403,9 @@ static bool gfx_ctx_qnx_bind_api(void *data,
(void)data;
(void)major;
(void)minor;
g_api = api;
return api == GFX_CTX_OPENGL_ES_API;
}
@ -411,10 +424,16 @@ static bool gfx_ctx_qnx_has_windowed(void *data)
static void gfx_qnx_ctx_bind_hw_render(void *data, bool enable)
{
(void)data;
g_use_hw_ctx = enable;
if (g_egl_dpy && g_egl_surf)
eglMakeCurrent(g_egl_dpy, g_egl_surf,
g_egl_surf, enable ? g_egl_hw_ctx : g_egl_ctx);
if (!g_egl_dpy)
return;
if (!g_egl_surf)
return;
eglMakeCurrent(g_egl_dpy, g_egl_surf,
g_egl_surf, enable ? g_egl_hw_ctx : g_egl_ctx);
}
const gfx_ctx_driver_t gfx_ctx_bbqnx = {

35
gfx/context/d3d_ctx.cpp
View File

@ -48,16 +48,17 @@ extern bool d3d_restore(d3d_video_t *data);
static void d3d_resize(void *data, unsigned new_width, unsigned new_height)
{
(void)data;
d3d_video_t *d3d = (d3d_video_t*)curD3D;
d3d_video_t *d3d = (d3d_video_t*)curD3D;
LPDIRECT3DDEVICE d3dr = (LPDIRECT3DDEVICE)d3d->dev;
if (!d3dr)
return;
RARCH_LOG("[D3D]: Resize %ux%u.\n", new_width, new_height);
(void)data;
if (new_width != d3d->video_info.width || new_height != d3d->video_info.height)
{
RARCH_LOG("[D3D]: Resize %ux%u.\n", new_width, new_height);
d3d->video_info.width = d3d->screen_width = new_width;
d3d->video_info.height = d3d->screen_height = new_height;
d3d_restore(d3d);
@ -103,7 +104,7 @@ LRESULT CALLBACK WindowProc(HWND hWnd, UINT message,
static void gfx_ctx_d3d_swap_buffers(void *data)
{
d3d_video_t *d3d = (d3d_video_t*)data;
d3d_video_t *d3d = (d3d_video_t*)data;
LPDIRECT3DDEVICE d3dr = (LPDIRECT3DDEVICE)d3d->dev;
d3d_swap(d3d, d3dr);
@ -143,6 +144,7 @@ static void gfx_ctx_d3d_update_title(void *data)
static void gfx_ctx_d3d_show_mouse(void *data, bool state)
{
(void)data;
#ifdef HAVE_WINDOW
if (state)
while (ShowCursor(TRUE) < 0);
@ -154,6 +156,7 @@ static void gfx_ctx_d3d_show_mouse(void *data, bool state)
void d3d_make_d3dpp(void *data, const video_info_t *info, D3DPRESENT_PARAMETERS *d3dpp)
{
d3d_video_t *d3d = (d3d_video_t*)data;
memset(d3dpp, 0, sizeof(*d3dpp));
#ifdef _XBOX
@ -201,6 +204,7 @@ void d3d_make_d3dpp(void *data, const video_info_t *info, D3DPRESENT_PARAMETERS
{
#ifdef _XBOX
unsigned width, height;
width = 0;
height = 0;
@ -266,8 +270,10 @@ void d3d_make_d3dpp(void *data, const video_info_t *info, D3DPRESENT_PARAMETERS
static void gfx_ctx_d3d_check_window(void *data, bool *quit,
bool *resize, unsigned *width, unsigned *height, unsigned frame_count)
{
(void)data;
d3d_video_t *d3d = (d3d_video_t*)data;
(void)data;
*quit = false;
*resize = false;
@ -297,12 +303,15 @@ static HANDLE GetFocus(void)
static bool gfx_ctx_d3d_has_focus(void *data)
{
d3d_video_t *d3d = (d3d_video_t*)data;
if (!d3d)
return false;
return GetFocus() == d3d->hWnd;
}
static bool gfx_ctx_d3d_has_windowed(void *data)
{
(void)data;
#ifdef _XBOX
return false;
#else
@ -317,6 +326,7 @@ static bool gfx_ctx_d3d_bind_api(void *data,
(void)major;
(void)minor;
(void)api;
#if defined(_XBOX1)
return api == GFX_CTX_DIRECT3D8_API;
#else
@ -328,7 +338,9 @@ static bool gfx_ctx_d3d_bind_api(void *data,
static bool gfx_ctx_d3d_init(void *data)
{
(void)data;
d3d_quit = false;
return true;
}
@ -356,11 +368,13 @@ static void gfx_ctx_d3d_get_video_size(void *data,
unsigned *width, unsigned *height)
{
d3d_video_t *d3d = (d3d_video_t*)data;
#ifdef _XBOX
(void)width;
(void)height;
#if defined(_XBOX360)
XVIDEO_MODE video_mode;
XGetVideoMode(&video_mode);
*width = video_mode.dwDisplayWidth;
@ -387,11 +401,12 @@ static void gfx_ctx_d3d_get_video_size(void *data,
*width = 640;
*height = 480;
// Only valid in PAL mode, not valid for HDTV modes!
widescreen_mode = false;
/* Only valid in PAL mode, not valid for HDTV modes! */
if(XGetVideoStandard() == XC_VIDEO_STANDARD_PAL_I)
{
widescreen_mode = false;
/* Check for 16:9 mode (PAL REGION) */
if(video_mode & XC_VIDEO_FLAGS_WIDESCREEN)
{
@ -406,8 +421,6 @@ static void gfx_ctx_d3d_get_video_size(void *data,
}
else
{
widescreen_mode = false;
/* Check for 16:9 mode (NTSC REGIONS) */
if(video_mode & XC_VIDEO_FLAGS_WIDESCREEN)
{
@ -447,7 +460,7 @@ static void gfx_ctx_d3d_get_video_size(void *data,
static void gfx_ctx_d3d_swap_interval(void *data, unsigned interval)
{
d3d_video_t *d3d = (d3d_video_t*)data;
d3d_video_t *d3d = (d3d_video_t*)data;
#ifdef _XBOX
LPDIRECT3DDEVICE d3dr = (LPDIRECT3DDEVICE)d3d->dev;
unsigned d3d_interval = interval ?

23
gfx/context/drm_egl_ctx.c
View File

@ -264,14 +264,16 @@ static void gfx_ctx_drm_egl_set_resize(void *data,
static void gfx_ctx_drm_egl_update_window_title(void *data)
{
(void)data;
char buf[128], buf_fps[128];
bool fps_draw = g_settings.fps_show;
gfx_get_fps(buf, sizeof(buf), fps_draw ? buf_fps : NULL, sizeof(buf_fps));
(void)data;
if (fps_draw)
msg_queue_push(g_extern.msg_queue, buf_fps, 1, 1);
if (!fps_draw)
return;
gfx_get_fps(buf, sizeof(buf), fps_draw ? buf_fps : NULL, sizeof(buf_fps));
msg_queue_push(g_extern.msg_queue, buf_fps, 1, 1);
}
static void gfx_ctx_drm_egl_get_video_size(void *data, unsigned *width, unsigned *height)
@ -929,10 +931,15 @@ static void gfx_ctx_drm_egl_bind_hw_render(void *data, bool enable)
(void)data;
drm->g_use_hw_ctx = enable;
if (drm->g_egl_dpy && drm->g_egl_surf)
eglMakeCurrent(drm->g_egl_dpy, drm->g_egl_surf,
drm->g_egl_surf,
enable ? drm->g_egl_hw_ctx : drm->g_egl_ctx);
if (!drm->g_egl_dpy)
return;
if (!drm->g_egl_surf)
return;
eglMakeCurrent(drm->g_egl_dpy, drm->g_egl_surf,
drm->g_egl_surf,
enable ? drm->g_egl_hw_ctx : drm->g_egl_ctx);
}
const gfx_ctx_driver_t gfx_ctx_drm_egl = {

61
gfx/context/emscriptenegl_ctx.c
View File

@ -50,9 +50,10 @@ static void gfx_ctx_emscripten_swap_interval(void *data, unsigned interval)
static void gfx_ctx_emscripten_check_window(void *data, bool *quit,
bool *resize, unsigned *width, unsigned *height, unsigned frame_count)
{
int iWidth, iHeight, isFullscreen;
(void)data;
(void)frame_count;
int iWidth, iHeight, isFullscreen;
emscripten_get_canvas_size(&iWidth, &iHeight, &isFullscreen);
*width = (unsigned) iWidth;
@ -84,13 +85,16 @@ static void gfx_ctx_emscripten_set_resize(void *data,
static void gfx_ctx_emscripten_update_window_title(void *data)
{
(void)data;
char buf[128], buf_fps[128];
bool fps_draw = g_settings.fps_show;
gfx_get_fps(buf, sizeof(buf), fps_draw ? buf_fps : NULL, sizeof(buf_fps));
if (fps_draw)
msg_queue_push(g_extern.msg_queue, buf_fps, 1, 1);
(void)data;
if (!fps_draw)
return;
gfx_get_fps(buf, sizeof(buf), fps_draw ? buf_fps : NULL, sizeof(buf_fps));
msg_queue_push(g_extern.msg_queue, buf_fps, 1, 1);
}
static void gfx_ctx_emscripten_get_video_size(void *data,
@ -105,19 +109,7 @@ static void gfx_ctx_emscripten_destroy(void *data);
static bool gfx_ctx_emscripten_init(void *data)
{
(void)data;
EGLint width;
EGLint height;
RARCH_LOG("[EMSCRIPTEN/EGL]: Initializing...\n");
if (g_inited)
{
RARCH_LOG("[EMSCRIPTEN/EGL]: Attempted to re-initialize driver.\n");
return true;
}
EGLint num_config;
EGLint width, height, num_config;
static const EGLint attribute_list[] =
{
EGL_RED_SIZE, 8,
@ -127,13 +119,22 @@ static bool gfx_ctx_emscripten_init(void *data)
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_NONE
};
static const EGLint context_attributes[] =
{
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
(void)data;
RARCH_LOG("[EMSCRIPTEN/EGL]: Initializing...\n");
if (g_inited)
{
RARCH_LOG("[EMSCRIPTEN/EGL]: Attempted to re-initialize driver.\n");
return true;
}
/* Get an EGL display connection. */
g_egl_dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (!g_egl_dpy)
@ -179,6 +180,7 @@ static bool gfx_ctx_emscripten_set_video_mode(void *data,
bool fullscreen)
{
(void)data;
if (g_inited)
return false;
@ -192,6 +194,7 @@ static bool gfx_ctx_emscripten_bind_api(void *data,
(void)data;
(void)major;
(void)minor;
switch (api)
{
case GFX_CTX_OPENGL_ES_API:
@ -204,6 +207,7 @@ static bool gfx_ctx_emscripten_bind_api(void *data,
static void gfx_ctx_emscripten_destroy(void *data)
{
(void)data;
if (g_egl_dpy)
{
eglMakeCurrent(g_egl_dpy, EGL_NO_SURFACE,
@ -228,27 +232,32 @@ static void gfx_ctx_emscripten_destroy(void *data)
static void gfx_ctx_emscripten_input_driver(void *data,
const input_driver_t **input, void **input_data)
{
void *rwebinput = NULL;
(void)data;
*input = NULL;
void *rwebinput = input_rwebinput.init();
rwebinput = input_rwebinput.init();
if (rwebinput)
{
*input = &input_rwebinput;
*input_data = rwebinput;
}
if (!rwebinput)
return;
*input = &input_rwebinput;
*input_data = rwebinput;
}
static bool gfx_ctx_emscripten_has_focus(void *data)
{
(void)data;
return g_inited;
}
static bool gfx_ctx_emscripten_has_windowed(void *data)
{
(void)data;
/* TODO -verify. */
return true;
}
@ -262,6 +271,7 @@ static float gfx_ctx_emscripten_translate_aspect(void *data,
unsigned width, unsigned height)
{
(void)data;
return (float)width / height;
}
@ -269,6 +279,7 @@ static bool gfx_ctx_emscripten_init_egl_image_buffer(void *data,
const video_info_t *video)
{
(void)data;
return false;
}

25
gfx/context/glx_ctx.c
View File

@ -190,16 +190,20 @@ static void gfx_ctx_glx_set_resize(void *data,
static void gfx_ctx_glx_update_window_title(void *data)
{
(void)data;
char buf[128], buf_fps[128];
gfx_ctx_glx_data_t *glx = NULL;
bool fps_draw = g_settings.fps_show;
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)driver.video_context_data;
(void)data;
glx = (gfx_ctx_glx_data_t*)driver.video_context_data;
if (gfx_get_fps(buf, sizeof(buf), fps_draw ? buf_fps : NULL, sizeof(buf_fps)))
XStoreName(glx->g_dpy, glx->g_win, buf);
if (fps_draw)
msg_queue_push(g_extern.msg_queue, buf_fps, 1, 1);
if (!fps_draw)
return;
msg_queue_push(g_extern.msg_queue, buf_fps, 1, 1);
}
static void gfx_ctx_glx_get_video_size(void *data,
@ -705,12 +709,13 @@ static void gfx_ctx_glx_bind_hw_render(void *data, bool enable)
glx->g_use_hw_ctx = enable;
if (glx->g_dpy && glx->g_glx_win)
{
//RARCH_LOG("[GLX]: Binding context (%s): %p\n", enable ? "RetroArch" : "HW render", enable ? (void*)g_hw_ctx : (void*)g_ctx);
glXMakeContextCurrent(glx->g_dpy, glx->g_glx_win,
glx->g_glx_win, enable ? glx->g_hw_ctx : glx->g_ctx);
}
if (!glx->g_dpy)
return;
if (!glx->g_glx_win)
return;
glXMakeContextCurrent(glx->g_dpy, glx->g_glx_win,
glx->g_glx_win, enable ? glx->g_hw_ctx : glx->g_ctx);
}
const gfx_ctx_driver_t gfx_ctx_glx = {

67
gfx/context/mali_fbdev_ctx.c
View File

@ -91,29 +91,23 @@ static void gfx_ctx_mali_fbdev_get_video_size(void *data,
unsigned *width, unsigned *height)
{
(void)data;
*width = 0;
*height = 0;
if (g_egl_dpy != EGL_NO_DISPLAY && g_egl_surf != EGL_NO_SURFACE)
{
*width = g_width;
*height = g_height;
}
else
{
*width = 0;
*height = 0;
}
}
static bool gfx_ctx_mali_fbdev_init(void *data)
{
(void)data;
struct sigaction sa = {{0}};
sa.sa_handler = sighandler;
sa.sa_flags = SA_RESTART;
sigemptyset(&sa.sa_mask);
sigaction(SIGINT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
EGLint num_config;
EGLint egl_version_major, egl_version_minor;
EGLint format;
static const EGLint attribs[] = {
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
@ -123,12 +117,17 @@ static bool gfx_ctx_mali_fbdev_init(void *data)
EGL_ALPHA_SIZE, 8,
EGL_NONE
};
EGLint num_config;
EGLint egl_version_major, egl_version_minor;
EGLint format;
struct sigaction sa = {{0}};
//Disable cursor blinking so it's not visible in RetroArch
sa.sa_handler = sighandler;
sa.sa_flags = SA_RESTART;
sigemptyset(&sa.sa_mask);
sigaction(SIGINT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
(void)data;
/* Disable cursor blinking so it's not visible in RetroArch. */
system("setterm -cursor off");
RARCH_LOG("[Mali fbdev]: Initializing context\n");
@ -165,16 +164,19 @@ error:
static void gfx_ctx_mali_fbdev_swap_buffers(void *data)
{
(void)data;
eglSwapBuffers(g_egl_dpy, g_egl_surf);
}
static void gfx_ctx_mali_fbdev_check_window(void *data, bool *quit,
bool *resize, unsigned *width, unsigned *height, unsigned frame_count)
{
unsigned new_width, new_height;
(void)frame_count;
unsigned new_width, new_height;
gfx_ctx_mali_fbdev_get_video_size(data, &new_width, &new_height);
if (new_width != *width || new_height != *height)
{
*width = new_width;
@ -195,13 +197,16 @@ static void gfx_ctx_mali_fbdev_set_resize(void *data,
static void gfx_ctx_mali_fbdev_update_window_title(void *data)
{
(void)data;
char buf[128], buf_fps[128];
bool fps_draw = g_settings.fps_show;
gfx_get_fps(buf, sizeof(buf), fps_draw ? buf_fps : NULL, sizeof(buf_fps));
if (fps_draw)
msg_queue_push(g_extern.msg_queue, buf_fps, 1, 1);
(void)data;
if (!fps_draw)
return;
gfx_get_fps(buf, sizeof(buf), fps_draw ? buf_fps : NULL, sizeof(buf_fps));
msg_queue_push(g_extern.msg_queue, buf_fps, 1, 1);
}
static bool gfx_ctx_mali_fbdev_set_video_mode(void *data,
@ -209,7 +214,12 @@ static bool gfx_ctx_mali_fbdev_set_video_mode(void *data,
bool fullscreen)
{
struct fb_var_screeninfo vinfo;
static const EGLint attribs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2, /* Use version 2, even for GLES3. */
EGL_NONE
};
int fb = open("/dev/fb0", O_RDWR, 0);
if (ioctl(fb, FBIOGET_VSCREENINFO, &vinfo) < 0)
{
RARCH_ERR("Error obtainig framebuffer info.\n");
@ -226,11 +236,6 @@ static bool gfx_ctx_mali_fbdev_set_video_mode(void *data,
native_window.width = vinfo.xres;
native_window.height = vinfo.yres;
static const EGLint attribs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2, /* Use version 2, even for GLES3. */
EGL_NONE
};
if ((g_egl_surf = eglCreateWindowSurface(g_egl_dpy, g_config, &native_window, 0)) == EGL_NO_SURFACE)
{
RARCH_ERR("eglCreateWindowSurface failed.\n");
@ -267,10 +272,12 @@ static void gfx_ctx_mali_fbdev_input_driver(void *data,
static gfx_ctx_proc_t gfx_ctx_mali_fbdev_get_proc_address(const char *symbol)
{
rarch_assert(sizeof(void*) == sizeof(void (*)(void)));
gfx_ctx_proc_t ret;
void *sym__;
void *sym__ = eglGetProcAddress(symbol);
rarch_assert(sizeof(void*) == sizeof(void (*)(void)));
sym__ = eglGetProcAddress(symbol);
memcpy(&ret, &sym__, sizeof(void*));
return ret;

62
gfx/context/ps3_ctx.c
View File

@ -65,8 +65,10 @@ static unsigned gfx_ctx_ps3_get_resolution_height(unsigned resolution_id)
static float gfx_ctx_ps3_get_aspect_ratio(void *data)
{
(void)data;
CellVideoOutState videoState;
(void)data;
cellVideoOutGetState(CELL_VIDEO_OUT_PRIMARY, 0, &videoState);
switch (videoState.displayMode.aspect)
@ -82,15 +84,10 @@ static float gfx_ctx_ps3_get_aspect_ratio(void *data)
static void gfx_ctx_ps3_get_available_resolutions(void)
{
unsigned i;
bool defaultresolution;
uint32_t resolution_count;
uint16_t num_videomodes;
if (g_extern.console.screen.resolutions.check)
return;
defaultresolution = true;
uint32_t videomode[] = {
CELL_VIDEO_OUT_RESOLUTION_480,
CELL_VIDEO_OUT_RESOLUTION_576,
@ -102,10 +99,16 @@ static void gfx_ctx_ps3_get_available_resolutions(void)
CELL_VIDEO_OUT_RESOLUTION_1080
};
if (g_extern.console.screen.resolutions.check)
return;
defaultresolution = true;
num_videomodes = sizeof(videomode) / sizeof(uint32_t);
resolution_count = 0;
for (unsigned i = 0; i < num_videomodes; i++)
for (i = 0; i < num_videomodes; i++)
{
if (cellVideoOutGetResolutionAvailability(CELL_VIDEO_OUT_PRIMARY, videomode[i],
CELL_VIDEO_OUT_ASPECT_AUTO, 0))
@ -115,7 +118,7 @@ static void gfx_ctx_ps3_get_available_resolutions(void)
g_extern.console.screen.resolutions.list = malloc(resolution_count * sizeof(uint32_t));
g_extern.console.screen.resolutions.count = 0;
for (unsigned i = 0; i < num_videomodes; i++)
for (i = 0; i < num_videomodes; i++)
{
if (cellVideoOutGetResolutionAvailability(CELL_VIDEO_OUT_PRIMARY, videomode[i],
CELL_VIDEO_OUT_ASPECT_AUTO, 0))
@ -142,15 +145,19 @@ static void gfx_ctx_ps3_get_available_resolutions(void)
static void gfx_ctx_ps3_set_swap_interval(void *data, unsigned interval)
{
gfx_ctx_ps3_data_t *ps3 = (gfx_ctx_ps3_data_t*)driver.video_context_data;
(void)data;
#if defined(HAVE_PSGL)
if (ps3 && ps3->gl_context)
{
if (interval)
glEnable(GL_VSYNC_SCE);
else
glDisable(GL_VSYNC_SCE);
}
if (!ps3)
return;
if (!ps3->gl_context)
return;
if (interval)
glEnable(GL_VSYNC_SCE);
else
glDisable(GL_VSYNC_SCE);
#endif
}
@ -158,10 +165,10 @@ static void gfx_ctx_ps3_check_window(void *data, bool *quit,
bool *resize, unsigned *width, unsigned *height, unsigned frame_count)
{
gl_t *gl = data;
*quit = false;
*resize = false;
if (gl->quitting)
*quit = true;
@ -203,18 +210,22 @@ static void gfx_ctx_ps3_update_window_title(void *data)
(void)data;
char buf[128], buf_fps[128];
bool fps_draw = g_settings.fps_show;
if (!fps_draw)
return;
gfx_get_fps(buf, sizeof(buf), fps_draw
? buf_fps : NULL, sizeof(buf_fps));
if (fps_draw)
msg_queue_push(g_extern.msg_queue, buf_fps, 1, 1);
msg_queue_push(g_extern.msg_queue, buf_fps, 1, 1);
}
static void gfx_ctx_ps3_get_video_size(void *data,
unsigned *width, unsigned *height)
{
gfx_ctx_ps3_data_t *ps3 = (gfx_ctx_ps3_data_t*)driver.video_context_data;
(void)data;
#if defined(HAVE_PSGL)
if (ps3)
psglGetDeviceDimensions(ps3->gl_device, width, height);
@ -223,11 +234,11 @@ static void gfx_ctx_ps3_get_video_size(void *data,
static bool gfx_ctx_ps3_init(void *data)
{
(void)data;
gfx_ctx_ps3_data_t *ps3 = (gfx_ctx_ps3_data_t*)
calloc(1, sizeof(gfx_ctx_ps3_data_t));
(void)data;
if (!ps3)
return false;
@ -333,8 +344,12 @@ static void gfx_ctx_ps3_destroy(void *data)
static void gfx_ctx_ps3_input_driver(void *data,
const input_driver_t **input, void **input_data)
{
void *ps3input = NULL;
(void)data;
void *ps3input = input_ps3.init();
ps3input = input_ps3.init();
*input = ps3input ? &input_ps3 : NULL;
*input_data = ps3input;
}
@ -345,6 +360,7 @@ static bool gfx_ctx_ps3_bind_api(void *data,
(void)data;
(void)major;
(void)minor;
return api == GFX_CTX_OPENGL_API || GFX_CTX_OPENGL_ES_API;
}

21
gfx/context/sdl_gl_ctx.c
View File

@ -68,9 +68,11 @@ static void sdl_ctx_destroy_resources(gfx_ctx_sdl_data_t *sdl)
static bool sdl_ctx_init(void *data)
{
gfx_ctx_sdl_data_t *sdl;
(void)data;
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)
sdl = (gfx_ctx_sdl_data_t*)
calloc(1, sizeof(gfx_ctx_sdl_data_t));
if (!sdl)
@ -93,7 +95,6 @@ static bool sdl_ctx_init(void *data)
driver.video_context_data = sdl;
return true;
error:
@ -127,13 +128,15 @@ static void sdl_ctx_destroy(void *data)
static bool sdl_ctx_bind_api(void *data, enum gfx_ctx_api api, unsigned major,
unsigned minor)
{
unsigned profile;
(void)data;
#ifdef HAVE_SDL2
if (api != GFX_CTX_OPENGL_API && api != GFX_CTX_OPENGL_ES_API)
return false;
unsigned profile = SDL_GL_CONTEXT_PROFILE_COMPATIBILITY;
profile = SDL_GL_CONTEXT_PROFILE_COMPATIBILITY;
if (api == GFX_CTX_OPENGL_ES_API)
profile = SDL_GL_CONTEXT_PROFILE_ES;
@ -195,6 +198,7 @@ static bool sdl_ctx_set_video_mode(void *data, unsigned width, unsigned height,
else
{
unsigned display = g_settings.video.monitor_index;
sdl->g_win = SDL_CreateWindow("", SDL_WINDOWPOS_UNDEFINED_DISPLAY(display),
SDL_WINDOWPOS_UNDEFINED_DISPLAY(display),
width, height, SDL_WINDOW_OPENGL | fsflag);
@ -271,8 +275,8 @@ static void sdl_ctx_get_video_size(void *data,
static void sdl_ctx_update_window_title(void *data)
{
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)driver.video_context_data;
char buf[128], buf_fps[128];
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)driver.video_context_data;
bool fps_draw = g_settings.fps_show;
if (!sdl)
@ -289,18 +293,16 @@ static void sdl_ctx_update_window_title(void *data)
if (fps_draw)
msg_queue_push(g_extern.msg_queue, buf_fps, 1, 1);
(void)data;
}
static void sdl_ctx_check_window(void *data, bool *quit, bool *resize,unsigned *width,
unsigned *height, unsigned frame_count)
{
SDL_Event event;
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)driver.video_context_data;
(void)data;
SDL_Event event;
SDL_PumpEvents();
#ifdef HAVE_SDL2
@ -357,14 +359,15 @@ static void sdl_ctx_set_resize(void *data, unsigned width, unsigned height)
static bool sdl_ctx_has_focus(void *data)
{
unsigned flags;
(void)data;
#ifdef HAVE_SDL2
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)driver.video_context_data;
unsigned flags = (SDL_WINDOW_INPUT_FOCUS | SDL_WINDOW_MOUSE_FOCUS);
flags = (SDL_WINDOW_INPUT_FOCUS | SDL_WINDOW_MOUSE_FOCUS);
return (SDL_GetWindowFlags(sdl->g_win) & flags) == flags;
#else
unsigned flags = (SDL_APPINPUTFOCUS | SDL_APPACTIVE);
flags = (SDL_APPINPUTFOCUS | SDL_APPACTIVE);
return (SDL_GetAppState() & flags) == flags;
#endif
}

81
gfx/context/vc_egl_ctx.c
View File

@ -117,25 +117,31 @@ static void gfx_ctx_vc_set_resize(void *data, unsigned width, unsigned height)
static void gfx_ctx_vc_update_window_title(void *data)
{
(void)data;
char buf[128], buf_fps[128];
bool fps_draw = g_settings.fps_show;
gfx_get_fps(buf, sizeof(buf), fps_draw ? buf_fps : NULL, sizeof(buf_fps));
if (fps_draw)
msg_queue_push(g_extern.msg_queue, buf_fps, 1, 1);
(void)data;
if (!fps_draw)
return;
gfx_get_fps(buf, sizeof(buf), fps_draw ? buf_fps : NULL, sizeof(buf_fps));
msg_queue_push(g_extern.msg_queue, buf_fps, 1, 1);
}
static void gfx_ctx_vc_get_video_size(void *data,
unsigned *width, unsigned *height)
{
(void)data;
if (g_settings.video.fullscreen_x != 0 &&
g_settings.video.fullscreen_y != 0) {
g_settings.video.fullscreen_y != 0)
{
*width = g_settings.video.fullscreen_x;
*height = g_settings.video.fullscreen_y;
}
else {
else
{
*width = g_fb_width;
*height = g_fb_height;
}
@ -145,13 +151,6 @@ static void gfx_ctx_vc_destroy(void *data);
static bool gfx_ctx_vc_init(void *data)
{
RARCH_LOG("[VC/EGL]: Initializing...\n");
if (g_inited)
{
RARCH_ERR("[VC/EGL]: Attempted to re-initialize driver.\n");
return false;
}
EGLint num_config;
static EGL_DISPMANX_WINDOW_T nativewindow;
@ -178,6 +177,13 @@ static bool gfx_ctx_vc_init(void *data)
EGL_NONE
};
RARCH_LOG("[VC/EGL]: Initializing...\n");
if (g_inited)
{
RARCH_ERR("[VC/EGL]: Attempted to re-initialize driver.\n");
return false;
}
bcm_host_init();
/* Get an EGL display connection. */
@ -221,15 +227,19 @@ static bool gfx_ctx_vc_init(void *data)
src_rect.x = 0;
src_rect.y = 0;
if (g_settings.video.fullscreen_x != 0 &&
g_settings.video.fullscreen_y != 0) {
g_settings.video.fullscreen_y != 0)
{
src_rect.width = g_settings.video.fullscreen_x << 16;
src_rect.height = g_settings.video.fullscreen_y << 16;
}
else {
else
{
src_rect.width = g_fb_width << 16;
src_rect.height = g_fb_height << 16;
}
dispman_display = vc_dispmanx_display_open(0 /* LCD */);
vc_dispmanx_display_get_info(dispman_display, &dispman_modeinfo);
dispman_update = vc_dispmanx_update_start(0);
@ -245,11 +255,13 @@ static bool gfx_ctx_vc_init(void *data)
nativewindow.element = dispman_element;
if (g_settings.video.fullscreen_x != 0 &&
g_settings.video.fullscreen_y != 0) {
g_settings.video.fullscreen_y != 0)
{
nativewindow.width = g_settings.video.fullscreen_x;
nativewindow.height = g_settings.video.fullscreen_y;
}
else {
else
{
nativewindow.width = g_fb_width;
nativewindow.height = g_fb_height;
}
@ -274,10 +286,11 @@ static bool gfx_ctx_vc_set_video_mode(void *data,
unsigned width, unsigned height,
bool fullscreen)
{
struct sigaction sa = {{0}};
if (g_inited)
return false;
struct sigaction sa = {{0}};
sa.sa_handler = sighandler;
sa.sa_flags = SA_RESTART;
sigemptyset(&sa.sa_mask);
@ -287,6 +300,7 @@ static bool gfx_ctx_vc_set_video_mode(void *data,
gfx_ctx_vc_swap_interval(data, g_interval);
g_inited = true;
return true;
}
@ -296,7 +310,9 @@ static bool gfx_ctx_vc_bind_api(void *data,
(void)data;
(void)major;
(void)minor;
g_api = api;
switch (api)
{
case GFX_CTX_OPENGL_API:
@ -314,6 +330,7 @@ static void gfx_ctx_vc_destroy(void *data)
{
(void)data;
unsigned i;
if (g_egl_dpy)
{
for (i = 0; i < MAX_EGLIMAGE_TEXTURES; i++)
@ -431,6 +448,14 @@ static float gfx_ctx_vc_translate_aspect(void *data,
static bool gfx_ctx_vc_init_egl_image_buffer(void *data,
const video_info_t *video)
{
EGLBoolean result;
EGLint pbufsurface_list[] =
{
EGL_WIDTH, g_egl_res,
EGL_HEIGHT, g_egl_res,
EGL_NONE
};
/* Don't bother, we just use VGImages for our EGLImage anyway. */
if (g_api == GFX_CTX_OPENVG_API)
return false;
@ -446,15 +471,6 @@ static bool gfx_ctx_vc_init_egl_image_buffer(void *data,
g_egl_res = video->input_scale * RARCH_SCALE_BASE;
EGLint pbufsurface_list[] =
{
EGL_WIDTH, g_egl_res,
EGL_HEIGHT, g_egl_res,
EGL_NONE
};
EGLBoolean result;
eglBindAPI(EGL_OPENVG_API);
g_pbuff_surf = eglCreatePbufferSurface(g_egl_dpy, g_config, pbufsurface_list);
if (g_pbuff_surf == EGL_NO_SURFACE)
@ -552,11 +568,16 @@ static bool gfx_ctx_vc_write_egl_image(void *data, const void *frame, unsigned w
static void gfx_ctx_vc_bind_hw_render(void *data, bool enable)
{
(void)data;
g_use_hw_ctx = enable;
if (g_egl_dpy && g_egl_surf)
eglMakeCurrent(g_egl_dpy, g_egl_surf,
g_egl_surf, enable ? g_egl_hw_ctx : g_egl_ctx);
if (!g_egl_dpy)
return;
if (!g_egl_surf)
return;
eglMakeCurrent(g_egl_dpy, g_egl_surf,
g_egl_surf, enable ? g_egl_hw_ctx : g_egl_ctx);
}
const gfx_ctx_driver_t gfx_ctx_videocore = {

75
gfx/context/vivante_fbdev_ctx.c
View File

@ -39,8 +39,11 @@ static void sighandler(int sig)
static void gfx_ctx_vivante_set_swap_interval(void *data, unsigned interval)
{
(void)data;
if (g_egl_dpy)
eglSwapInterval(g_egl_dpy, interval);
if (!g_egl_dpy)
return;
eglSwapInterval(g_egl_dpy, interval);
}
static void gfx_ctx_vivante_destroy(void *data)
@ -75,32 +78,27 @@ static void gfx_ctx_vivante_get_video_size(void *data,
unsigned *width, unsigned *height)
{
(void)data;
*width = 0;
*height = 0;
if (g_egl_dpy != EGL_NO_DISPLAY && g_egl_surf != EGL_NO_SURFACE)
{
EGLint gl_width, gl_height;
eglQuerySurface(g_egl_dpy, g_egl_surf, EGL_WIDTH, &gl_width);
eglQuerySurface(g_egl_dpy, g_egl_surf, EGL_HEIGHT, &gl_height);
*width = gl_width;
*height = gl_height;
}
else
{
*width = 0;
*height = 0;
}
}
static bool gfx_ctx_vivante_init(void *data)
{
(void)data;
EGLint num_config;
EGLint egl_version_major, egl_version_minor;
EGLint format;
struct sigaction sa = {{0}};
sa.sa_handler = sighandler;
sa.sa_flags = SA_RESTART;
sigemptyset(&sa.sa_mask);
sigaction(SIGINT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
static const EGLint attribs[] = {
#if 0
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
@ -113,9 +111,14 @@ static bool gfx_ctx_vivante_init(void *data)
EGL_SAMPLES, 0,
EGL_NONE
};
EGLint num_config;
EGLint egl_version_major, egl_version_minor;
EGLint format;
(void)data;
sa.sa_handler = sighandler;
sa.sa_flags = SA_RESTART;
sigemptyset(&sa.sa_mask);
sigaction(SIGINT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
RARCH_LOG("[Vivante fbdev]: Initializing context\n");
@ -134,7 +137,6 @@ static bool gfx_ctx_vivante_init(void *data)
RARCH_LOG("[Vivante fbdev]: EGL version: %d.%d\n",
egl_version_major, egl_version_minor);
if (!eglChooseConfig(g_egl_dpy, attribs, &g_config, 1, &num_config))
{
RARCH_ERR("[Vivante fbdev]: eglChooseConfig failed.\n");
@ -158,10 +160,12 @@ static void gfx_ctx_vivante_swap_buffers(void *data)
static void gfx_ctx_vivante_check_window(void *data, bool *quit,
bool *resize, unsigned *width, unsigned *height, unsigned frame_count)
{
unsigned new_width, new_height;
(void)frame_count;
unsigned new_width, new_height;
gfx_ctx_vivante_get_video_size(data, &new_width, &new_height);
if (new_width != *width || new_height != *height)
{
*width = new_width;
@ -182,19 +186,28 @@ static void gfx_ctx_vivante_set_resize(void *data,
static void gfx_ctx_vivante_update_window_title(void *data)
{
(void)data;
char buf[128], buf_fps[128];
bool fps_draw = g_settings.fps_show;
gfx_get_fps(buf, sizeof(buf), fps_draw ? buf_fps : NULL, sizeof(buf_fps));
if (fps_draw)
msg_queue_push(g_extern.msg_queue, buf_fps, 1, 1);
(void)data;
if (!fps_draw)
return;
gfx_get_fps(buf, sizeof(buf), fps_draw ? buf_fps : NULL, sizeof(buf_fps));
msg_queue_push(g_extern.msg_queue, buf_fps, 1, 1);
}
static bool gfx_ctx_vivante_set_video_mode(void *data,
unsigned width, unsigned height,
bool fullscreen)
{
EGLNativeWindowType window;
static const EGLint attribs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2, /* Use version 2, even for GLES3. */
EGL_NONE
};
/* Pick some arbitrary default. */
if (!width || !fullscreen)
width = 1280;
@ -204,13 +217,9 @@ static bool gfx_ctx_vivante_set_video_mode(void *data,
g_width = width;
g_height = height;
static const EGLint attribs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2, /* Use version 2, even for GLES3. */
EGL_NONE
};
EGLNativeWindowType window = fbCreateWindow(fbGetDisplayByIndex(0), 0, 0, 0, 0);
window = fbCreateWindow(fbGetDisplayByIndex(0), 0, 0, 0, 0);
g_egl_surf = eglCreateWindowSurface(g_egl_dpy, g_config, window, 0);
if (g_egl_surf == EGL_NO_SURFACE)
{
RARCH_ERR("eglCreateWindowSurface failed.\n");
@ -248,10 +257,12 @@ static void gfx_ctx_vivante_input_driver(void *data,
static gfx_ctx_proc_t gfx_ctx_vivante_get_proc_address(const char *symbol)
{
rarch_assert(sizeof(void*) == sizeof(void (*)(void)));
gfx_ctx_proc_t ret;
void *sym__;
void *sym__ = eglGetProcAddress(symbol);
rarch_assert(sizeof(void*) == sizeof(void (*)(void)));
sym__ = eglGetProcAddress(symbol);
memcpy(&ret, &sym__, sizeof(void*));
return ret;

30
gfx/context/wayland_ctx.c
View File

@ -206,6 +206,7 @@ static void egl_report_error(void)
{
EGLint error = eglGetError();
const char *str = NULL;
switch (error)
{
case EGL_SUCCESS:
@ -286,11 +287,15 @@ static void gfx_ctx_wl_check_window(void *data, bool *quit,
bool *resize, unsigned *width, unsigned *height,
unsigned frame_count)
{
unsigned new_width, new_height;
(void)frame_count;
flush_wayland_fd();
unsigned new_width = *width, new_height = *height;
new_width = *width;
new_height = *height;
gfx_ctx_wl_get_video_size(data, &new_width, &new_height);
if (new_width != *width || new_height != *height)
@ -331,9 +336,11 @@ static void gfx_ctx_wl_update_window_title(void *data)
driver.video_context_data;
(void)data;
if (gfx_get_fps(buf, sizeof(buf),
fps_draw ? buf_fps : NULL, sizeof(buf_fps)))
wl_shell_surface_set_title(wl->g_shell_surf, buf);
if (fps_draw)
msg_queue_push(g_extern.msg_queue, buf_fps, 1, 1);
}
@ -363,8 +370,6 @@ static void gfx_ctx_wl_get_video_size(void *data,
static bool gfx_ctx_wl_init(void *data)
{
(void)data;
static const EGLint egl_attribs_gl[] = {
WL_EGL_ATTRIBS_BASE,
EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
@ -398,6 +403,8 @@ static bool gfx_ctx_wl_init(void *data)
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)
calloc(1, sizeof(gfx_ctx_wayland_data_t));
(void)data;
if (!wl)
return false;
@ -478,7 +485,6 @@ static bool gfx_ctx_wl_init(void *data)
goto error;
}
return true;
error:
@ -556,11 +562,11 @@ static EGLint *egl_fill_attribs(EGLint *attr)
static void gfx_ctx_wl_destroy(void *data)
{
(void)data;
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)
driver.video_context_data;
(void)data;
if (!wl)
return;
@ -673,9 +679,11 @@ static bool gfx_ctx_wl_bind_api(void *data,
enum gfx_ctx_api api, unsigned major, unsigned minor)
{
(void)data;
g_major = major;
g_minor = minor;
g_api = api;
switch (api)
{
case GFX_CTX_OPENGL_API:
@ -706,9 +714,13 @@ static void gfx_ctx_wl_bind_hw_render(void *data, bool enable)
wl->g_use_hw_ctx = enable;
if (wl->g_egl_dpy && wl->g_egl_surf)
eglMakeCurrent(wl->g_egl_dpy, wl->g_egl_surf, wl->g_egl_surf,
enable ? wl->g_egl_hw_ctx : wl->g_egl_ctx);
if (!wl->g_egl_dpy)
return;
if (!wl->g_egl_surf)
return;
eglMakeCurrent(wl->g_egl_dpy, wl->g_egl_surf, wl->g_egl_surf,
enable ? wl->g_egl_hw_ctx : wl->g_egl_ctx);
}
static void keyboard_handle_keymap(void* data,

78
gfx/context/wgl_ctx.c
View File

@ -101,17 +101,23 @@ static void setup_pixel_format(HDC hdc)
static void create_gl_context(HWND hwnd)
{
bool core_context;
bool debug = g_extern.system.hw_render_callback.debug_context;
g_hdc = GetDC(hwnd);
setup_pixel_format(g_hdc);
#ifdef GL_DEBUG
bool debug = true;
#else
bool debug = g_extern.system.hw_render_callback.debug_context;
debug = true;
#endif
bool core_context = (g_major * 1000 + g_minor) >= 3001;
core_context = (g_major * 1000 + g_minor) >= 3001;
if (!g_hrc)
if (g_hrc)
{
RARCH_LOG("[WGL]: Using cached GL context.\n");
driver.video_cache_context_ack = true;
}
else
{
g_hrc = wglCreateContext(g_hdc);
@ -131,11 +137,6 @@ static void create_gl_context(HWND hwnd)
g_quit = true;
}
}
else
{
RARCH_LOG("[WGL]: Using cached GL context.\n");
driver.video_cache_context_ack = true;
}
if (g_hrc)
{
@ -280,21 +281,24 @@ static void gfx_ctx_wgl_swap_interval(void *data, unsigned interval)
(void)data;
g_interval = interval;
if (g_hrc && p_swap_interval)
{
RARCH_LOG("[WGL]: wglSwapInterval(%u)\n", g_interval);
if (!p_swap_interval(g_interval))
RARCH_WARN("[WGL]: wglSwapInterval() failed.\n");
}
if (!g_hrc)
return;
if (!p_swap_interval)
return;
RARCH_LOG("[WGL]: wglSwapInterval(%u)\n", g_interval);
if (!p_swap_interval(g_interval))
RARCH_WARN("[WGL]: wglSwapInterval() failed.\n");
}
static void gfx_ctx_wgl_check_window(void *data, bool *quit,
bool *resize, unsigned *width, unsigned *height, unsigned frame_count)
{
MSG msg;
(void)data;
(void)frame_count;
MSG msg;
while (PeekMessage(&msg, g_hwnd, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
@ -302,6 +306,7 @@ static void gfx_ctx_wgl_check_window(void *data, bool *quit,
}
*quit = g_quit;
if (g_resized)
{
*resize = true;
@ -327,9 +332,11 @@ static void gfx_ctx_wgl_set_resize(void *data,
static void gfx_ctx_wgl_update_window_title(void *data)
{
(void)data;
char buf[128], buf_fps[128];
bool fps_draw = g_settings.fps_show;
(void)data;
if (gfx_get_fps(buf, sizeof(buf), fps_draw ? buf_fps : NULL, sizeof(buf_fps)))
SetWindowText(g_hwnd, buf);
@ -340,6 +347,7 @@ static void gfx_ctx_wgl_update_window_title(void *data)
static void gfx_ctx_wgl_get_video_size(void *data, unsigned *width, unsigned *height)
{
(void)data;
if (!g_hwnd)
{
HMONITOR hm_to_use = NULL;
@ -366,7 +374,10 @@ static BOOL CALLBACK monitor_enum_proc(HMONITOR hMonitor,
static bool gfx_ctx_wgl_init(void *data)
{
WNDCLASSEX wndclass = {0};
(void)data;
if (g_inited)
return false;
@ -376,7 +387,6 @@ static bool gfx_ctx_wgl_init(void *data)
g_num_mons = 0;
EnumDisplayMonitors(NULL, NULL, monitor_enum_proc, 0);
WNDCLASSEX wndclass = {0};
wndclass.cbSize = sizeof(wndclass);
wndclass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wndclass.lpfnWndProc = WndProc;
@ -396,6 +406,7 @@ static bool gfx_ctx_wgl_init(void *data)
static bool set_fullscreen(unsigned width, unsigned height, char *dev_name)
{
DEVMODE devmode;
memset(&devmode, 0, sizeof(devmode));
devmode.dmSize = sizeof(DEVMODE);
devmode.dmPelsWidth = width;
@ -416,11 +427,13 @@ static void show_cursor(bool show)
static void monitor_info(MONITORINFOEX *mon, HMONITOR *hm_to_use)
{
unsigned fs_monitor;
if (!g_last_hm)
g_last_hm = MonitorFromWindow(GetDesktopWindow(), MONITOR_DEFAULTTONEAREST);
*hm_to_use = g_last_hm;
unsigned fs_monitor = g_settings.video.monitor_index;
fs_monitor = g_settings.video.monitor_index;
if (fs_monitor && fs_monitor <= g_num_mons && g_all_hms[fs_monitor - 1])
*hm_to_use = g_all_hms[fs_monitor - 1];
@ -434,18 +447,21 @@ static bool gfx_ctx_wgl_set_video_mode(void *data,
bool fullscreen)
{
DWORD style;
RECT rect = {0};
HMONITOR hm_to_use = NULL;
MSG msg;
RECT mon_rect;
MONITORINFOEX current_mon;
bool windowed_full;
RECT rect = {0};
HMONITOR hm_to_use = NULL;
monitor_info(&current_mon, &hm_to_use);
RECT mon_rect = current_mon.rcMonitor;
mon_rect = current_mon.rcMonitor;
g_resize_width = width;
g_resize_height = height;
bool windowed_full = g_settings.video.windowed_fullscreen;
windowed_full = g_settings.video.windowed_fullscreen;
if (fullscreen)
{
if (windowed_full)
@ -461,7 +477,7 @@ static bool gfx_ctx_wgl_set_video_mode(void *data,
if (!set_fullscreen(width, height, current_mon.szDevice))
goto error;
// display settings might have changed, get new coordinates
/* Display settings might have changed, get new coordinates. */
GetMonitorInfo(hm_to_use, (MONITORINFO*)&current_mon);
mon_rect = current_mon.rcMonitor;
g_restore_desktop = true;
@ -496,8 +512,7 @@ static bool gfx_ctx_wgl_set_video_mode(void *data,
show_cursor(!fullscreen);
// Wait until GL context is created (or failed to do so ...)
MSG msg;
/* Wait until GL context is created (or failed to do so ...) */
while (!g_inited && !g_quit && GetMessage(&msg, g_hwnd, 0, 0))
{
TranslateMessage(&msg);
@ -525,6 +540,7 @@ error:
static void gfx_ctx_wgl_destroy(void *data)
{
(void)data;
if (g_hrc)
{
glFinish();
@ -573,7 +589,9 @@ static void gfx_ctx_wgl_input_driver(void *data,
const input_driver_t **input, void **input_data)
{
(void)data;
dinput_wgl = input_dinput.init();
*input = dinput_wgl ? &input_dinput : NULL;
*input_data = dinput_wgl;
}
@ -581,6 +599,7 @@ static void gfx_ctx_wgl_input_driver(void *data,
static bool gfx_ctx_wgl_has_focus(void *data)
{
(void)data;
if (!g_inited)
return false;
@ -603,8 +622,10 @@ static bool gfx_ctx_wgl_bind_api(void *data,
enum gfx_ctx_api api, unsigned major, unsigned minor)
{
(void)data;
g_major = major;
g_minor = minor;
return api == GFX_CTX_OPENGL_API;
}
@ -617,6 +638,7 @@ static void gfx_ctx_wgl_show_mouse(void *data, bool state)
static void gfx_ctx_wgl_bind_hw_render(void *data, bool enable)
{
g_use_hw_ctx = enable;
if (g_hdc)
wglMakeCurrent(g_hdc, enable ? g_hw_hrc : g_hrc);
}

103
gfx/context/xegl_ctx.c
View File

@ -122,23 +122,29 @@ static void gfx_ctx_xegl_swap_interval(void *data, unsigned interval)
{
(void)data;
g_interval = interval;
if (g_egl_dpy && eglGetCurrentContext())
if (!g_egl_dpy)
return;
if (!(eglGetCurrentContext()))
return;
RARCH_LOG("[X/EGL]: eglSwapInterval(%u)\n", g_interval);
if (!eglSwapInterval(g_egl_dpy, g_interval))
{
RARCH_LOG("[X/EGL]: eglSwapInterval(%u)\n", g_interval);
if (!eglSwapInterval(g_egl_dpy, g_interval))
{
RARCH_ERR("[X/EGL]: eglSwapInterval() failed.\n");
egl_report_error();
}
RARCH_ERR("[X/EGL]: eglSwapInterval() failed.\n");
egl_report_error();
}
}
static void gfx_ctx_xegl_check_window(void *data, bool *quit,
bool *resize, unsigned *width, unsigned *height, unsigned frame_count)
{
XEvent event;
unsigned new_width = *width;
unsigned new_height = *height;
(void)frame_count;
unsigned new_width = *width, new_height = *height;
gfx_ctx_xegl_get_video_size(data, &new_width, &new_height);
if (new_width != *width || new_height != *height)
@ -148,12 +154,13 @@ static void gfx_ctx_xegl_check_window(void *data, bool *quit,
*height = new_height;
}
XEvent event;
while (XPending(g_dpy))
{
bool filter;
/* Can get events from older windows. Check this. */
XNextEvent(g_dpy, &event);
bool filter = XFilterEvent(&event, g_win);
filter = XFilterEvent(&event, g_win);
switch (event.type)
{
@ -204,9 +211,11 @@ static void gfx_ctx_xegl_set_resize(void *data,
static void gfx_ctx_xegl_update_window_title(void *data)
{
(void)data;
char buf[128], buf_fps[128];
bool fps_draw = g_settings.fps_show;
(void)data;
if (gfx_get_fps(buf, sizeof(buf),
fps_draw ? buf_fps : NULL, sizeof(buf_fps)))
XStoreName(g_dpy, g_win, buf);
@ -219,6 +228,7 @@ static void gfx_ctx_xegl_get_video_size(void *data,
unsigned *width, unsigned *height)
{
(void)data;
if (!g_dpy || g_win == None)
{
Display *dpy = XOpenDisplay(NULL);
@ -255,11 +265,6 @@ static void gfx_ctx_xegl_get_video_size(void *data,
static bool gfx_ctx_xegl_init(void *data)
{
if (g_inited)
return false;
XInitThreads();
static const EGLint egl_attribs_gl[] = {
XEGL_ATTRIBS_BASE,
EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
@ -287,6 +292,12 @@ static bool gfx_ctx_xegl_init(void *data)
};
const EGLint *attrib_ptr;
if (g_inited)
return false;
XInitThreads();
switch (g_api)
{
case GFX_CTX_OPENGL_API:
@ -365,10 +376,10 @@ static EGLint *egl_fill_attribs(EGLint *attr)
{
unsigned version = g_major * 1000 + g_minor;
bool core = version >= 3001;
#ifdef GL_DEBUG
bool debug = true;
#else
bool debug = g_extern.system.hw_render_callback.debug_context;
#ifdef GL_DEBUG
debug = true;
#endif
if (core)
@ -424,35 +435,37 @@ static bool gfx_ctx_xegl_set_video_mode(void *data,
unsigned width, unsigned height,
bool fullscreen)
{
EGLint egl_attribs[16];
EGLint *attr;
EGLint vid, num_visuals;
bool windowed_full;
bool true_full = false;
int x_off = 0;
int y_off = 0;
struct sigaction sa = {{0}};
XVisualInfo temp = {0};
XSetWindowAttributes swa = {0};
XVisualInfo *vi = NULL;
sa.sa_handler = sighandler;
sa.sa_flags = SA_RESTART;
sigemptyset(&sa.sa_mask);
sigaction(SIGINT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
XVisualInfo temp = {0};
XSetWindowAttributes swa = {0};
XVisualInfo *vi = NULL;
bool windowed_full = g_settings.video.windowed_fullscreen;
bool true_full = false;
int x_off = 0;
int y_off = 0;
windowed_full = g_settings.video.windowed_fullscreen;
true_full = false;
int (*old_handler)(Display*, XErrorEvent*) = NULL;
EGLint egl_attribs[16];
EGLint *attr = egl_attribs;
attr = egl_attribs;
attr = egl_fill_attribs(attr);
EGLint vid;
if (!eglGetConfigAttrib(g_egl_dpy, g_config, EGL_NATIVE_VISUAL_ID, &vid))
goto error;
temp.visualid = vid;
EGLint num_visuals;
vi = XGetVisualInfo(g_dpy, VisualIDMask, &temp, &num_visuals);
if (!vi)
goto error;
@ -481,6 +494,7 @@ static bool gfx_ctx_xegl_set_video_mode(void *data,
{
unsigned new_width = width;
unsigned new_height = height;
if (x11_get_xinerama_coord(g_dpy, g_screen, &x_off, &y_off, &new_width, &new_height))
RARCH_LOG("[X/EGL]: Using Xinerama on screen #%u.\n", g_screen);
else
@ -507,6 +521,7 @@ static bool gfx_ctx_xegl_set_video_mode(void *data,
attr != egl_attribs ? egl_attribs : NULL);
RARCH_LOG("[X/EGL]: Created context: %p.\n", (void*)g_egl_ctx);
if (g_egl_ctx == EGL_NO_CONTEXT)
goto error;
@ -609,7 +624,9 @@ error:
static void gfx_ctx_xegl_destroy(void *data)
{
(void)data;
x11_destroy_input_context(&g_xim, &g_xic);
if (g_egl_dpy)
{
if (g_egl_ctx)
@ -677,20 +694,25 @@ static void gfx_ctx_xegl_destroy(void *data)
static void gfx_ctx_xegl_input_driver(void *data,
const input_driver_t **input, void **input_data)
{
void *xinput;
(void)data;
void *xinput = input_x.init();
xinput = input_x.init();
*input = xinput ? &input_x : NULL;
*input_data = xinput;
}
static bool gfx_ctx_xegl_has_focus(void *data)
{
Window win;
int rev;
(void)data;
if (!g_inited)
return false;
Window win;
int rev;
XGetInputFocus(g_dpy, &win, &rev);
return (win == g_win && g_has_focus) || g_true_full;
@ -713,9 +735,11 @@ static bool gfx_ctx_xegl_bind_api(void *data,
enum gfx_ctx_api api, unsigned major, unsigned minor)
{
(void)data;
g_major = major;
g_minor = minor;
g_api = api;
switch (api)
{
case GFX_CTX_OPENGL_API:
@ -747,9 +771,14 @@ static void gfx_ctx_xegl_bind_hw_render(void *data, bool enable)
{
(void)data;
g_use_hw_ctx = enable;
if (g_egl_dpy && g_egl_surf)
eglMakeCurrent(g_egl_dpy, g_egl_surf,
g_egl_surf, enable ? g_egl_hw_ctx : g_egl_ctx);
if (!g_egl_dpy)
return;
if (!g_egl_surf)
return;
eglMakeCurrent(g_egl_dpy, g_egl_surf,
g_egl_surf, enable ? g_egl_hw_ctx : g_egl_ctx);
}
const gfx_ctx_driver_t gfx_ctx_x_egl = {