ShuriZma
/
RetroArch
mirror of https://github.com/libretro/RetroArch.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #2 from libretro/master 

Merge #2
This commit is contained in:
Jean-Paul Mari 2017-12-05 12:51:58 -05:00 committed by GitHub
parent 38b899e4d6 db4387bd30
commit 3eb5b757c3
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
72 changed files with 1331 additions and 1566 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
CHANGES.md
View File

@ -1,5 +1,22 @@
# 1.7.0 (future)
- CHEEVOS: Add badges
- CHEEVOS: Add badges for achievements, shows thumbnail images of achievements.
- COMMON: Add 'Automatically Load Content To Playlist' feature, enabled by default.
- COMMON: Fix slowmotion ratio always being reset back to 1.
- COMMON: Optimized NBIO implementations now for Apple, Windows, and Linux. Uses mmap for Linux/Windows/BSD if/when available. File I/O should now be much faster for loading images inside the menu.
- COMMON: Native Blissbox support now for latest firmware as of writing (2.0). Implementation through libusb and/or native Windows HID.
- COMMON: New lightgun API.
- COMMON: Fixed some playlist bugs.
- FREEBSD: Support libusb HID input driver.
- HAIKU: Buildfix.
- LINUX/X11: Add RetroArch logo to window title bar.
- LINUX/X11: Input driver now supports new lightgun code.
- LOCALIZATION: Update Italian translation.
- LOCALIZATION: Update Portuguese-Brazilian translation.
- LOCALIZATION: Update Russian translation.
- OSX/PPC: Fix the GL2 renderchain, had to use EXT versions of framebuffer/renderbuffer functions.
- SCANNER: Fix crash from Windows-incompatible format string.
- WIIU: Disabled the controller patcher for now since it was the source of many stability issues.
- WINDOWS: Raw input driver now supports new lightgun code.
# 1.6.9
- COMMON: Small memory leak.

1
Makefile.common
View File

@ -170,6 +170,7 @@ OBJ += frontend/frontend.o \
tasks/task_audio_mixer.o \
$(LIBRETRO_COMM_DIR)/encodings/encoding_utf.o \
$(LIBRETRO_COMM_DIR)/encodings/encoding_crc32.o \
$(LIBRETRO_COMM_DIR)/compat/fopen_utf8.o \
$(LIBRETRO_COMM_DIR)/lists/file_list.o \
$(LIBRETRO_COMM_DIR)/lists/dir_list.o \
$(LIBRETRO_COMM_DIR)/file/retro_dirent.o \

11
audio/drivers/xaudio.h
View File

@ -324,16 +324,11 @@ STDAPI XAudio2Create(__deref_out IXAudio2** ppXAudio2, UINT32 Flags X2DEFAULT(0)
#else
static INLINE HRESULT XAudio2Create(IXAudio2 **ppXAudio2, UINT32 flags, XAUDIO2_PROCESSOR proc)
{
HRESULT hr;
IXAudio2 *pXAudio2 = NULL;
(void)flags;
(void)proc;
#ifdef __cplusplus
hr = CoCreateInstance(CLSID_XAudio2, NULL, CLSCTX_INPROC_SERVER, IID_IXAudio2, (void**)&pXAudio2);
HRESULT hr = CoCreateInstance(CLSID_XAudio2, NULL, CLSCTX_INPROC_SERVER, IID_IXAudio2, (void**)&pXAudio2);
#else
hr = CoCreateInstance(&CLSID_XAudio2, NULL, CLSCTX_INPROC_SERVER, &IID_IXAudio2, (void**)&pXAudio2);
HRESULT hr = CoCreateInstance(&CLSID_XAudio2, NULL, CLSCTX_INPROC_SERVER, &IID_IXAudio2, (void**)&pXAudio2);
#endif
if (SUCCEEDED(hr))
@ -342,9 +337,7 @@ static INLINE HRESULT XAudio2Create(IXAudio2 **ppXAudio2, UINT32 flags, XAUDIO2_
if (SUCCEEDED(hr))
*ppXAudio2 = pXAudio2;
else
{
IXAudio2_Release(pXAudio2);
}
}
return hr;
}

3
cheevos/badges.c
View File

@ -21,15 +21,16 @@ bool badge_exists(const char* filepath)
void set_badge_menu_texture(badges_ctx_t * badges, int i)
{
char fullpath[PATH_MAX_LENGTH];
const char * locked_suffix = (badges->badge_locked[i] == true) ? "_lock.png" : ".png";
unsigned int bufferSize = 16;
/* TODO/FIXME - variable length forbidden in C89 - rewrite this! */
char badge_file[bufferSize];
snprintf(badge_file, bufferSize, "%s", badges->badge_id_list[i]);
strcat(badge_file, locked_suffix);
char fullpath[PATH_MAX_LENGTH];
fill_pathname_application_special(fullpath,
PATH_MAX_LENGTH * sizeof(char),
APPLICATION_SPECIAL_DIRECTORY_THUMBNAILS_CHEEVOS_BADGES);

29
cheevos/cheevos.c
View File

@ -1796,6 +1796,7 @@ static void cheevos_test_cheevo_set(const cheevoset_t *set)
}
else if (valid)
{
char msg[256];
char url[256];
url[0] = '\0';
@ -1807,7 +1808,6 @@ static void cheevos_test_cheevo_set(const cheevoset_t *set)
RARCH_LOG("[CHEEVOS]: awarding cheevo %u: %s (%s).\n",
cheevo->id, cheevo->title, cheevo->description);
char msg[256];
snprintf(msg, sizeof(msg), "Achievement Unlocked: %s", cheevo->title);
msg[sizeof(msg) - 1] = 0;
runloop_msg_queue_push(msg, 0, 2 * 60, false);
@ -1856,10 +1856,11 @@ static int cheevos_expr_value(cheevos_expr_t* expr)
{
cheevos_term_t* term = expr->terms;
unsigned i;
/* Separate possible values with '$' operator, submit the largest */
unsigned current_value = 0;
/* TODO/FIXME - variable length forbidden in C89 - rewrite this! */
int values[expr->compare_count];
memset(values, 0, sizeof values);
for (i = expr->count; i != 0; i--, term++)
@ -1871,8 +1872,10 @@ static int cheevos_expr_value(cheevos_expr_t* expr)
if (expr->compare_count > 1)
{
unsigned j;
int maximum = values[0];
for (unsigned j = 1; j < expr->compare_count; j++)
for (j = 1; j < expr->compare_count; j++)
maximum = values[j] > maximum ? values[j] : maximum;
return maximum;
@ -1974,12 +1977,13 @@ static void cheevos_test_leaderboards(void)
else
{
char url[256];
char msg[256];
char formatted_value[16];
cheevos_make_lboard_url(lboard, url, sizeof(url));
task_push_http_transfer(url, true, NULL, cheevos_lboard_submit, lboard);
RARCH_LOG("[CHEEVOS]: submit lboard %s\n", lboard->title);
char msg[256];
char formatted_value[16];
cheevos_format_value(value, lboard->format, formatted_value, sizeof(formatted_value));
snprintf(msg, sizeof(msg), "Submitted %s for %s", formatted_value, lboard->title);
msg[sizeof(msg) - 1] = 0;
@ -1998,11 +2002,12 @@ static void cheevos_test_leaderboards(void)
{
if (cheevos_test_lboard_condition(&lboard->start))
{
char msg[256];
RARCH_LOG("[CHEEVOS]: start lboard %s\n", lboard->title);
lboard->active = 1;
lboard->last_value = -1;
char msg[256];
snprintf(msg, sizeof(msg), "Leaderboard Active: %s", lboard->title);
msg[sizeof(msg) - 1] = 0;
runloop_msg_queue_push(msg, 0, 2 * 60, false);
@ -2835,10 +2840,10 @@ static int cheevos_iterate(coro_t* coro)
{
if(cheevos_locals.core.count > 0)
{
int mode;
const cheevo_t* cheevo = cheevos_locals.core.cheevos;
const cheevo_t* end = cheevo + cheevos_locals.core.count;
int number_of_unlocked = cheevos_locals.core.count;
int mode;
char msg[256];
if(CHEEVOS_VAR_SETTINGS->bools.cheevos_hardcore_mode_enable)
@ -3168,10 +3173,12 @@ static int cheevos_iterate(coro_t* coro)
badges_ctx = new_badges_ctx;
settings_t *settings = config_get_ptr();
if (!string_is_equal(settings->arrays.menu_driver, "xmb") ||
!settings->bools.cheevos_badges_enable)
CORO_RET();
{
settings_t *settings = config_get_ptr();
if (!string_is_equal(settings->arrays.menu_driver, "xmb") ||
!settings->bools.cheevos_badges_enable)
CORO_RET();
}
CHEEVOS_VAR_CHEEVO_CURR = cheevos_locals.core.cheevos;
CHEEVOS_VAR_CHEEVO_END = cheevos_locals.core.cheevos + cheevos_locals.core.count;

7
cheevos/var.c
View File

@ -24,10 +24,15 @@
#include "../core.h"
#include "../verbosity.h"
static void STUB_LOG(const char *fmt, ...)
{
(void)fmt;
}
#ifdef CHEEVOS_VERBOSE
#define CHEEVOS_LOG RARCH_LOG
#else
#define CHEEVOS_LOG(...)
#define CHEEVOS_LOG STUB_LOG
#endif
/*****************************************************************************

5
gfx/common/gl_common.c
View File

@ -14,16 +14,13 @@
* If not, see <http://www.gnu.org/licenses/>.
*/
#include <gfx/math/matrix_4x4.h>
#include <gfx/gl_capabilities.h>
#ifdef HAVE_CONFIG_H
#include "../../config.h"
#endif
#include "../drivers/gl_symlinks.h"
#include "../video_coord_array.h"
#include "gl_common.h"
static void gl_size_format(GLint* internalFormat)
{

133
gfx/common/gl_common.h
View File

@ -17,7 +17,9 @@
#ifndef __GL_COMMON_H
#define __GL_COMMON_H
#include <boolean.h>
#include <string.h>
#include <retro_common_api.h>
#ifdef HAVE_CONFIG_H
#include "../../config.h"
@ -32,14 +34,124 @@
#include "../font_driver.h"
#include "../video_coord_array.h"
#include "../video_driver.h"
#include "../drivers/gl_symlinks.h"
#include <glsym/glsym.h>
RETRO_BEGIN_DECLS
#define MAX_FENCES 4
#if defined(HAVE_PSGL)
#define RARCH_GL_FRAMEBUFFER GL_FRAMEBUFFER_OES
#define RARCH_GL_FRAMEBUFFER_COMPLETE GL_FRAMEBUFFER_COMPLETE_OES
#define RARCH_GL_COLOR_ATTACHMENT0 GL_COLOR_ATTACHMENT0_EXT
#elif (defined(__MACH__) && (defined(__ppc__) || defined(__ppc64__)))
#define RARCH_GL_FRAMEBUFFER GL_FRAMEBUFFER_EXT
#define RARCH_GL_FRAMEBUFFER_COMPLETE GL_FRAMEBUFFER_COMPLETE_EXT
#define RARCH_GL_COLOR_ATTACHMENT0 GL_COLOR_ATTACHMENT0_EXT
#else
#define RARCH_GL_FRAMEBUFFER GL_FRAMEBUFFER
#define RARCH_GL_FRAMEBUFFER_COMPLETE GL_FRAMEBUFFER_COMPLETE
#define RARCH_GL_COLOR_ATTACHMENT0 GL_COLOR_ATTACHMENT0
#endif
#ifndef ARB_sync
typedef struct __GLsync *GLsync;
#if defined(HAVE_OPENGLES2) || defined(HAVE_OPENGLES3) || defined(HAVE_OPENGLES_3_1) || defined(HAVE_OPENGLES_3_2)
#define RARCH_GL_RENDERBUFFER GL_RENDERBUFFER
#if defined(HAVE_OPENGLES2)
#define RARCH_GL_DEPTH24_STENCIL8 GL_DEPTH24_STENCIL8_OES
#else
#define RARCH_GL_DEPTH24_STENCIL8 GL_DEPTH24_STENCIL8
#endif
#define RARCH_GL_DEPTH_ATTACHMENT GL_DEPTH_ATTACHMENT
#define RARCH_GL_STENCIL_ATTACHMENT GL_STENCIL_ATTACHMENT
#elif (defined(__MACH__) && (defined(__ppc__) || defined(__ppc64__)))
#define RARCH_GL_RENDERBUFFER GL_RENDERBUFFER_EXT
#define RARCH_GL_DEPTH24_STENCIL8 GL_DEPTH24_STENCIL8_EXT
#define RARCH_GL_DEPTH_ATTACHMENT GL_DEPTH_ATTACHMENT_EXT
#define RARCH_GL_STENCIL_ATTACHMENT GL_STENCIL_ATTACHMENT_EXT
#elif defined(HAVE_PSGL)
#define RARCH_GL_RENDERBUFFER GL_RENDERBUFFER_OES
#define RARCH_GL_DEPTH24_STENCIL8 GL_DEPTH24_STENCIL8_SCE
#define RARCH_GL_DEPTH_ATTACHMENT GL_DEPTH_ATTACHMENT_OES
#define RARCH_GL_STENCIL_ATTACHMENT GL_STENCIL_ATTACHMENT_OES
#else
#define RARCH_GL_RENDERBUFFER GL_RENDERBUFFER
#define RARCH_GL_DEPTH24_STENCIL8 GL_DEPTH24_STENCIL8
#define RARCH_GL_DEPTH_ATTACHMENT GL_DEPTH_ATTACHMENT
#define RARCH_GL_STENCIL_ATTACHMENT GL_STENCIL_ATTACHMENT
#endif
#if (defined(__MACH__) && (defined(__ppc__) || defined(__ppc64__)))
#define RARCH_GL_MAX_RENDERBUFFER_SIZE GL_MAX_RENDERBUFFER_SIZE_EXT
#elif defined(HAVE_PSGL)
#define RARCH_GL_MAX_RENDERBUFFER_SIZE GL_MAX_RENDERBUFFER_SIZE_OES
#else
#define RARCH_GL_MAX_RENDERBUFFER_SIZE GL_MAX_RENDERBUFFER_SIZE
#endif
#if defined(HAVE_PSGL)
#define glGenerateMipmap glGenerateMipmapOES
#endif
#if defined(__APPLE__) || defined(HAVE_PSGL)
#define GL_RGBA32F GL_RGBA32F_ARB
#endif
#if defined(HAVE_PSGL)
#define RARCH_GL_INTERNAL_FORMAT32 GL_ARGB_SCE
#define RARCH_GL_INTERNAL_FORMAT16 GL_RGB5 /* TODO: Verify if this is really 565 or just 555. */
#define RARCH_GL_TEXTURE_TYPE32 GL_BGRA
#define RARCH_GL_TEXTURE_TYPE16 GL_BGRA
#define RARCH_GL_FORMAT32 GL_UNSIGNED_INT_8_8_8_8_REV
#define RARCH_GL_FORMAT16 GL_RGB5
#elif defined(HAVE_OPENGLES)
/* Imgtec/SGX headers have this missing. */
#ifndef GL_BGRA_EXT
#define GL_BGRA_EXT 0x80E1
#endif
#ifndef GL_BGRA8_EXT
#define GL_BGRA8_EXT 0x93A1
#endif
#ifdef IOS
/* Stupid Apple */
#define RARCH_GL_INTERNAL_FORMAT32 GL_RGBA
#else
#define RARCH_GL_INTERNAL_FORMAT32 GL_BGRA_EXT
#endif
#define RARCH_GL_INTERNAL_FORMAT16 GL_RGB
#define RARCH_GL_TEXTURE_TYPE32 GL_BGRA_EXT
#define RARCH_GL_TEXTURE_TYPE16 GL_RGB
#define RARCH_GL_FORMAT32 GL_UNSIGNED_BYTE
#define RARCH_GL_FORMAT16 GL_UNSIGNED_SHORT_5_6_5
#else
/* On desktop, we always use 32-bit. */
#define RARCH_GL_INTERNAL_FORMAT32 GL_RGBA8
#define RARCH_GL_INTERNAL_FORMAT16 GL_RGBA8
#define RARCH_GL_TEXTURE_TYPE32 GL_BGRA
#define RARCH_GL_TEXTURE_TYPE16 GL_BGRA
#define RARCH_GL_FORMAT32 GL_UNSIGNED_INT_8_8_8_8_REV
#define RARCH_GL_FORMAT16 GL_UNSIGNED_INT_8_8_8_8_REV
/* GL_RGB565 internal format isn't in desktop GL
* until 4.1 core (ARB_ES2_compatibility).
* Check for this. */
#ifndef GL_RGB565
#define GL_RGB565 0x8D62
#endif
#define RARCH_GL_INTERNAL_FORMAT16_565 GL_RGB565
#define RARCH_GL_TEXTURE_TYPE16_565 GL_RGB
#define RARCH_GL_FORMAT16_565 GL_UNSIGNED_SHORT_5_6_5
#endif
#if defined(HAVE_OPENGLES2) /* TODO: Figure out exactly what. */
#define NO_GL_CLAMP_TO_BORDER
#endif
#if defined(HAVE_OPENGLES)
#ifndef GL_UNPACK_ROW_LENGTH
#define GL_UNPACK_ROW_LENGTH 0x0CF2
#endif
#ifndef GL_SRGB_ALPHA_EXT
#define GL_SRGB_ALPHA_EXT 0x8C42
#endif
#endif
typedef struct gl
@ -54,11 +166,7 @@ typedef struct gl
bool fbo_inited;
bool fbo_feedback_enable;
bool hw_render_fbo_init;
bool hw_render_depth_init;
bool has_fbo;
bool has_srgb_fbo_gles3;
bool has_fp_fbo;
bool has_srgb_fbo;
bool hw_render_use;
bool core_context_in_use;
@ -71,7 +179,6 @@ typedef struct gl
bool have_full_npot_support;
bool have_mipmap;
bool egl_images;
bool overlay_enable;
bool overlay_full_screen;
bool menu_texture_enable;
@ -82,7 +189,6 @@ typedef struct gl
int version_major;
int version_minor;
int fbo_pass;
GLuint tex_mag_filter;
GLuint tex_min_filter;
@ -91,13 +197,9 @@ typedef struct gl
GLuint pbo;
GLuint *overlay_tex;
GLuint menu_texture;
GLuint vao;
GLuint pbo_readback[4];
GLuint texture[GFX_MAX_TEXTURES];
GLuint fbo[GFX_MAX_SHADERS];
GLuint fbo_texture[GFX_MAX_SHADERS];
GLuint hw_render_fbo[GFX_MAX_TEXTURES];
GLuint hw_render_depth[GFX_MAX_TEXTURES];
unsigned tex_index; /* For use with PREV. */
unsigned textures;
@ -110,7 +212,6 @@ typedef struct gl
unsigned base_size; /* 2 or 4 */
unsigned overlays;
unsigned pbo_readback_index;
unsigned fence_count;
unsigned last_width[GFX_MAX_TEXTURES];
unsigned last_height[GFX_MAX_TEXTURES];
@ -134,9 +235,7 @@ typedef struct gl
video_info_t video_info;
struct video_tex_info prev_info[GFX_MAX_TEXTURES];
struct video_fbo_rect fbo_rect[GFX_MAX_SHADERS];
struct gfx_fbo_scale fbo_scale[GFX_MAX_SHADERS];
GLsync fences[MAX_FENCES];
const gl_renderchain_driver_t *renderchain_driver;
void *renderchain_data;
} gl_t;

4
gfx/common/win32_common.c
View File

@ -53,8 +53,8 @@
#include <encodings/utf.h>
/* Assume W-functions do not work below VC2005 and Xbox platforms */
#if defined(_MSC_VER) && _MSC_VER < 1400 || defined(_XBOX)
/* Assume W-functions do not work below Win2K and Xbox platforms */
#if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0500 || defined(_XBOX)
#ifndef LEGACY_WIN32
#define LEGACY_WIN32

107
gfx/drivers/gl.c
View File

@ -40,6 +40,7 @@
#include <gfx/gl_capabilities.h>
#include <gfx/video_frame.h>
#include <glsym/glsym.h>
#include "../../configuration.h"
#include "../../dynamic.h"
@ -543,11 +544,9 @@ static void gl_init_textures_data(gl_t *gl)
static void gl_init_textures(gl_t *gl, const video_info_t *video)
{
unsigned i;
GLenum internal_fmt, texture_type = 0, texture_fmt = 0;
/* Use regular textures if we use HW render. */
gl->egl_images = !gl->hw_render_use && gl_check_capability(GL_CAPS_EGLIMAGE) &&
video_context_driver_init_image_buffer(video);
GLenum internal_fmt = gl->internal_fmt;
GLenum texture_type = gl->texture_type;
GLenum texture_fmt = gl->texture_fmt;
#ifdef HAVE_PSGL
if (!gl->pbo)
@ -559,10 +558,6 @@ static void gl_init_textures(gl_t *gl, const video_info_t *video)
NULL, GL_STREAM_DRAW);
#endif
internal_fmt = gl->internal_fmt;
texture_type = gl->texture_type;
texture_fmt = gl->texture_fmt;
#if defined(HAVE_OPENGLES) && !defined(HAVE_PSGL)
/* GLES is picky about which format we use here.
* Without extensions, we can *only* render to 16-bit FBOs. */
@ -594,7 +589,7 @@ static void gl_init_textures(gl_t *gl, const video_info_t *video)
if (gl->renderchain_driver->init_texture_reference)
gl->renderchain_driver->init_texture_reference(
gl, i, internal_fmt,
gl, gl->renderchain_data, i, internal_fmt,
texture_fmt, texture_type);
}
@ -893,11 +888,11 @@ static void gl_pbo_async_readback(gl_t *gl)
gl->pbo_readback_valid[gl->pbo_readback_index] = true;
if (gl->renderchain_driver->readback)
gl->renderchain_driver->readback(gl,
gl->renderchain_driver->readback(gl, gl->renderchain_data,
video_pixel_get_alignment(gl->vp.width * sizeof(uint32_t)),
fmt, type, NULL);
if (gl->renderchain_driver->unbind_pbo)
gl->renderchain_driver->unbind_pbo();
gl->renderchain_driver->unbind_pbo(gl, gl->renderchain_data);
}
static INLINE void gl_draw_texture(gl_t *gl, video_frame_info_t *video_info)
@ -982,7 +977,7 @@ static bool gl_frame(void *data, const void *frame,
context_bind_hw_render(false);
if (gl->core_context_in_use && gl->renderchain_driver->bind_vao)
gl->renderchain_driver->bind_vao(gl);
gl->renderchain_driver->bind_vao(gl, gl->renderchain_data);
video_info->cb_shader_use(gl, video_info->shader_data, 1, true);
@ -996,11 +991,12 @@ static bool gl_frame(void *data, const void *frame,
{
if (gl->renderchain_driver->recompute_pass_sizes)
gl->renderchain_driver->recompute_pass_sizes(
gl, frame_width, frame_height,
gl, gl->renderchain_data, frame_width, frame_height,
gl->vp_out_width, gl->vp_out_height);
if (gl->renderchain_driver->start_render)
gl->renderchain_driver->start_render(gl, video_info);
gl->renderchain_driver->start_render(gl, gl->renderchain_data,
video_info);
}
if (gl->should_resize)
@ -1018,12 +1014,14 @@ static bool gl_frame(void *data, const void *frame,
if (gl->fbo_inited)
{
if (gl->renderchain_driver->check_fbo_dimensions)
gl->renderchain_driver->check_fbo_dimensions(gl);
gl->renderchain_driver->check_fbo_dimensions(gl,
gl->renderchain_data);
/* Go back to what we're supposed to do,
* render to FBO #0. */
if (gl->renderchain_driver->start_render)
gl->renderchain_driver->start_render(gl, video_info);
gl->renderchain_driver->start_render(gl, gl->renderchain_data,
video_info);
}
else
gl_set_viewport(gl, video_info, width, height, false, true);
@ -1042,7 +1040,7 @@ static bool gl_frame(void *data, const void *frame,
gl_update_input_size(gl, frame_width, frame_height, pitch, true);
if (gl->renderchain_driver->copy_frame)
gl->renderchain_driver->copy_frame(gl,
gl->renderchain_driver->copy_frame(gl, gl->renderchain_data,
video_info, frame, frame_width, frame_height, pitch);
}
@ -1060,12 +1058,12 @@ static bool gl_frame(void *data, const void *frame,
if (!gl->fbo_inited)
{
if (gl->renderchain_driver->bind_backbuffer)
gl->renderchain_driver->bind_backbuffer();
gl->renderchain_driver->bind_backbuffer(gl, gl->renderchain_data);
gl_set_viewport(gl, video_info, width, height, false, true);
}
if (gl->renderchain_driver->restore_default_state)
gl->renderchain_driver->restore_default_state(gl);
gl->renderchain_driver->restore_default_state(gl, gl->renderchain_data);
glDisable(GL_STENCIL_TEST);
glDisable(GL_BLEND);
@ -1127,12 +1125,14 @@ static bool gl_frame(void *data, const void *frame,
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
if (gl->fbo_inited && gl->renderchain_driver->renderchain_render)
gl->renderchain_driver->renderchain_render(gl, video_info,
gl->renderchain_driver->renderchain_render(gl, gl->renderchain_data,
video_info,
frame_count, &gl->tex_info, &feedback_info);
/* Set prev textures. */
if (gl->renderchain_driver->bind_prev_texture)
gl->renderchain_driver->bind_prev_texture(gl, &gl->tex_info);
gl->renderchain_driver->bind_prev_texture(gl, gl->renderchain_data,
&gl->tex_info);
#if defined(HAVE_MENU)
if (gl->menu_texture_enable)
@ -1167,7 +1167,8 @@ static bool gl_frame(void *data, const void *frame,
glBindTexture(GL_TEXTURE_2D, 0);
if (gl->renderchain_driver->disable_client_arrays)
gl->renderchain_driver->disable_client_arrays();
gl->renderchain_driver->disable_client_arrays(gl,
gl->renderchain_data);
}
/* Screenshots. */
@ -1175,6 +1176,7 @@ static bool gl_frame(void *data, const void *frame,
{
if (gl->renderchain_driver->readback)
gl->renderchain_driver->readback(gl,
gl->renderchain_data,
4, GL_RGBA, GL_UNSIGNED_BYTE,
gl->readback_buffer_screenshot);
}
@ -1207,12 +1209,14 @@ static bool gl_frame(void *data, const void *frame,
if (gl->renderchain_driver->fence_iterate)
gl->renderchain_driver->fence_iterate(gl,
gl->renderchain_data,
video_info->hard_sync_frames);
}
if (gl->core_context_in_use &&
gl->renderchain_driver->unbind_vao)
gl->renderchain_driver->unbind_vao(gl);
gl->renderchain_driver->unbind_vao(gl,
gl->renderchain_data);
context_bind_hw_render(true);
@ -1242,7 +1246,7 @@ static void gl_deinit_chain(gl_t *gl)
return;
if (gl->renderchain_driver->chain_free)
gl->renderchain_driver->chain_free(gl->renderchain_data);
gl->renderchain_driver->chain_free(gl, gl->renderchain_data);
gl->renderchain_driver = NULL;
gl->renderchain_data = NULL;
@ -1259,14 +1263,14 @@ static void gl_free(void *data)
if (gl->have_sync)
{
if (gl->renderchain_driver->fence_free)
gl->renderchain_driver->fence_free(gl);
gl->renderchain_driver->fence_free(gl, gl->renderchain_data);
}
font_driver_free_osd();
video_shader_driver_deinit();
if (gl->renderchain_driver->disable_client_arrays)
gl->renderchain_driver->disable_client_arrays();
gl->renderchain_driver->disable_client_arrays(gl, gl->renderchain_data);
glDeleteTextures(gl->textures, gl->texture);
@ -1295,13 +1299,13 @@ static void gl_free(void *data)
if (gl->core_context_in_use)
{
if (gl->renderchain_driver->unbind_vao)
gl->renderchain_driver->unbind_vao(gl);
gl->renderchain_driver->unbind_vao(gl, gl->renderchain_data);
if (gl->renderchain_driver->free_vao)
gl->renderchain_driver->free_vao(gl);
gl->renderchain_driver->free_vao(gl, gl->renderchain_data);
}
if (gl->renderchain_driver->free)
gl->renderchain_driver->free(gl);
gl->renderchain_driver->free(gl, gl->renderchain_data);
gl_deinit_chain(gl);
video_context_driver_free();
@ -1329,7 +1333,7 @@ static void gl_set_nonblock_state(void *data, bool state)
context_bind_hw_render(true);
}
static bool resolve_extensions(gl_t *gl, const char *context_ident)
static bool resolve_extensions(gl_t *gl, const char *context_ident, const video_info_t *video)
{
settings_t *settings = config_get_ptr();
@ -1342,25 +1346,21 @@ static bool resolve_extensions(gl_t *gl, const char *context_ident)
*
* have_sync - Use ARB_sync to reduce latency.
*/
gl->has_srgb_fbo = false;
gl->has_fbo = gl_check_capability(GL_CAPS_FBO);
gl->have_full_npot_support = gl_check_capability(GL_CAPS_FULL_NPOT_SUPPORT);
gl->have_mipmap = gl_check_capability(GL_CAPS_MIPMAP);
gl->have_es2_compat = gl_check_capability(GL_CAPS_ES2_COMPAT);
gl->has_fp_fbo = gl_check_capability(GL_CAPS_FP_FBO);
gl->support_unpack_row_length = gl_check_capability(GL_CAPS_UNPACK_ROW_LENGTH);
gl->have_sync = gl_check_capability(GL_CAPS_SYNC);
/* GLES3 has unpack_subimage and sRGB in core. */
gl->has_srgb_fbo_gles3 = gl_check_capability(GL_CAPS_SRGB_FBO_ES3);
if (!settings->bools.video_force_srgb_disable)
gl->has_srgb_fbo = gl_check_capability(GL_CAPS_SRGB_FBO);
if (gl->have_sync && settings->bools.video_hard_sync)
RARCH_LOG("[GL]: Using ARB_sync to reduce latency.\n");
video_driver_unset_rgba();
if (gl->renderchain_driver->resolve_extensions)
gl->renderchain_driver->resolve_extensions(gl, gl->renderchain_data, context_ident, video);
#if defined(HAVE_OPENGLES) && !defined(HAVE_PSGL)
if (!gl_check_capability(GL_CAPS_BGRA8888))
{
@ -1463,7 +1463,7 @@ static bool gl_init_pbo_readback(gl_t *gl)
gl->vp.height * sizeof(uint32_t), NULL);
}
if (gl->renderchain_driver->unbind_pbo)
gl->renderchain_driver->unbind_pbo();
gl->renderchain_driver->unbind_pbo(gl, gl->renderchain_data);
#ifndef HAVE_OPENGLES3
{
@ -1775,16 +1775,16 @@ static void *gl_init(const video_info_t *video, const input_driver_t **input, vo
}
if (gl->renderchain_driver->restore_default_state)
gl->renderchain_driver->restore_default_state(gl);
gl->renderchain_driver->restore_default_state(gl, gl->renderchain_data);
if (hwr->context_type == RETRO_HW_CONTEXT_OPENGL_CORE)
if (gl->renderchain_driver->new_vao)
gl->renderchain_driver->new_vao(gl);
gl->renderchain_driver->new_vao(gl, gl->renderchain_data);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBlendEquation(GL_FUNC_ADD);
if (!resolve_extensions(gl, ctx_driver->ident))
if (!resolve_extensions(gl, ctx_driver->ident, video))
goto error;
#ifdef GL_DEBUG
@ -1927,13 +1927,13 @@ static void *gl_init(const video_info_t *video, const input_driver_t **input, vo
gl_init_textures_data(gl);
if (gl->renderchain_driver->init)
gl->renderchain_driver->init(gl, gl->tex_w, gl->tex_h);
gl->renderchain_driver->init(gl, gl->renderchain_data, gl->tex_w, gl->tex_h);
if (gl->has_fbo)
{
if (gl->hw_render_use &&
gl->renderchain_driver->init_hw_render &&
!gl->renderchain_driver->init_hw_render(gl, gl->tex_w, gl->tex_h))
!gl->renderchain_driver->init_hw_render(gl, gl->renderchain_data, gl->tex_w, gl->tex_h))
{
RARCH_ERR("[GL]: Hardware rendering context initialization failed.\n");
goto error;
@ -2111,7 +2111,7 @@ static bool gl_set_shader(void *data,
if (gl->fbo_inited)
{
if (gl->renderchain_driver->deinit_fbo)
gl->renderchain_driver->deinit_fbo(gl);
gl->renderchain_driver->deinit_fbo(gl, gl->renderchain_data);
glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
}
@ -2143,7 +2143,7 @@ static bool gl_set_shader(void *data,
{
if (gl->hw_render_use && gl->fbo_inited &&
gl->renderchain_driver->deinit_hw_render)
gl->renderchain_driver->deinit_hw_render(gl);
gl->renderchain_driver->deinit_hw_render(gl, gl->renderchain_data);
glDeleteTextures(gl->textures, gl->texture);
#if defined(HAVE_PSGL)
@ -2157,11 +2157,13 @@ static bool gl_set_shader(void *data,
gl_init_textures_data(gl);
if (gl->hw_render_use && gl->renderchain_driver->init_hw_render)
gl->renderchain_driver->init_hw_render(gl, gl->tex_w, gl->tex_h);
gl->renderchain_driver->init_hw_render(gl, gl->renderchain_data,
gl->tex_w, gl->tex_h);
}
if (gl->renderchain_driver->init)
gl->renderchain_driver->init(gl, gl->tex_w, gl->tex_h);
gl->renderchain_driver->init(gl, gl->renderchain_data,
gl->tex_w, gl->tex_h);
/* Apparently need to set viewport for passes when we aren't using FBOs. */
gl_set_shader_viewports(gl);
@ -2185,7 +2187,7 @@ static void gl_viewport_info(void *data, struct video_viewport *vp)
gl_t *gl = (gl_t*)data;
if (!gl->renderchain_driver || !gl->renderchain_driver->viewport_info)
return;
gl->renderchain_driver->viewport_info(data, vp);
gl->renderchain_driver->viewport_info(gl, gl->renderchain_data, vp);
}
static bool gl_read_viewport(void *data, uint8_t *buffer, bool is_idle)
@ -2193,7 +2195,8 @@ static bool gl_read_viewport(void *data, uint8_t *buffer, bool is_idle)
gl_t *gl = (gl_t*)data;
if (!gl->renderchain_driver || !gl->renderchain_driver->read_viewport)
return false;
return gl->renderchain_driver->read_viewport(data, buffer, is_idle);
return gl->renderchain_driver->read_viewport(gl, gl->renderchain_data,
buffer, is_idle);
}
#if 0
@ -2524,7 +2527,7 @@ static void gl_set_coords(void *handle_data, void *shader_data,
{
gl_t *gl = (gl_t*)handle_data;
if (gl && gl->renderchain_driver->set_coords)
gl->renderchain_driver->set_coords(handle_data,
gl->renderchain_driver->set_coords(gl, gl->renderchain_data,
shader_data, coords);
}
@ -2533,7 +2536,7 @@ static void gl_set_mvp(void *data, void *shader_data,
{
gl_t *gl = (gl_t*)data;
if (gl && gl->renderchain_driver->set_mvp)
gl->renderchain_driver->set_mvp(data,
gl->renderchain_driver->set_mvp(gl, gl->renderchain_data,
shader_data, mat_data);
}

159
gfx/drivers/gl_symlinks.h
View File

@ -1,159 +0,0 @@
/* RetroArch - A frontend for libretro.
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
* Copyright (C) 2011-2017 - Daniel De Matteis
* Copyright (C) 2012-2015 - Michael Lelli
*
* 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/>.
*/
#ifndef _GL_SYMLINKS_H
#define _GL_SYMLINKS_H
#include <boolean.h>
#include <retro_common_api.h>
#include <glsym/glsym.h>
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#if defined(HAVE_PSGL)
#define glGenFramebuffers glGenFramebuffersOES
#define glBindFramebuffer glBindFramebufferOES
#define glFramebufferTexture2D glFramebufferTexture2DOES
#define glCheckFramebufferStatus glCheckFramebufferStatusOES
#define glDeleteFramebuffers glDeleteFramebuffersOES
#define glGenRenderbuffers glGenRenderbuffersOES
#define glBindRenderbuffer glBindRenderbufferOES
#define glFramebufferRenderbuffer glFramebufferRenderbufferOES
#define glRenderbufferStorage glRenderbufferStorageOES
#define glDeleteRenderbuffers glDeleteRenderbuffersOES
#endif
#if defined(HAVE_PSGL)
#define RARCH_GL_FRAMEBUFFER GL_FRAMEBUFFER_OES
#define RARCH_GL_FRAMEBUFFER_COMPLETE GL_FRAMEBUFFER_COMPLETE_OES
#define RARCH_GL_COLOR_ATTACHMENT0 GL_COLOR_ATTACHMENT0_EXT
#elif (defined(__MACH__) && (defined(__ppc__) || defined(__ppc64__)))
#define RARCH_GL_FRAMEBUFFER GL_FRAMEBUFFER_EXT
#define RARCH_GL_FRAMEBUFFER_COMPLETE GL_FRAMEBUFFER_COMPLETE_EXT
#define RARCH_GL_COLOR_ATTACHMENT0 GL_COLOR_ATTACHMENT0_EXT
#else
#define RARCH_GL_FRAMEBUFFER GL_FRAMEBUFFER
#define RARCH_GL_FRAMEBUFFER_COMPLETE GL_FRAMEBUFFER_COMPLETE
#define RARCH_GL_COLOR_ATTACHMENT0 GL_COLOR_ATTACHMENT0
#endif
#if defined(HAVE_OPENGLES2) || defined(HAVE_OPENGLES3) || defined(HAVE_OPENGLES_3_1) || defined(HAVE_OPENGLES_3_2)
#define RARCH_GL_RENDERBUFFER GL_RENDERBUFFER
#if defined(HAVE_OPENGLES2)
#define RARCH_GL_DEPTH24_STENCIL8 GL_DEPTH24_STENCIL8_OES
#else
#define RARCH_GL_DEPTH24_STENCIL8 GL_DEPTH24_STENCIL8
#endif
#define RARCH_GL_DEPTH_ATTACHMENT GL_DEPTH_ATTACHMENT
#define RARCH_GL_STENCIL_ATTACHMENT GL_STENCIL_ATTACHMENT
#elif (defined(__MACH__) && (defined(__ppc__) || defined(__ppc64__)))
#define RARCH_GL_RENDERBUFFER GL_RENDERBUFFER_EXT
#define RARCH_GL_DEPTH24_STENCIL8 GL_DEPTH24_STENCIL8_EXT
#define RARCH_GL_DEPTH_ATTACHMENT GL_DEPTH_ATTACHMENT_EXT
#define RARCH_GL_STENCIL_ATTACHMENT GL_STENCIL_ATTACHMENT_EXT
#elif defined(HAVE_PSGL)
#define RARCH_GL_RENDERBUFFER GL_RENDERBUFFER_OES
#define RARCH_GL_DEPTH24_STENCIL8 GL_DEPTH24_STENCIL8_SCE
#define RARCH_GL_DEPTH_ATTACHMENT GL_DEPTH_ATTACHMENT_OES
#define RARCH_GL_STENCIL_ATTACHMENT GL_STENCIL_ATTACHMENT_OES
#else
#define RARCH_GL_RENDERBUFFER GL_RENDERBUFFER
#define RARCH_GL_DEPTH24_STENCIL8 GL_DEPTH24_STENCIL8
#define RARCH_GL_DEPTH_ATTACHMENT GL_DEPTH_ATTACHMENT
#define RARCH_GL_STENCIL_ATTACHMENT GL_STENCIL_ATTACHMENT
#endif
#if (defined(__MACH__) && (defined(__ppc__) || defined(__ppc64__)))
#define RARCH_GL_MAX_RENDERBUFFER_SIZE GL_MAX_RENDERBUFFER_SIZE_EXT
#elif defined(HAVE_PSGL)
#define RARCH_GL_MAX_RENDERBUFFER_SIZE GL_MAX_RENDERBUFFER_SIZE_OES
#else
#define RARCH_GL_MAX_RENDERBUFFER_SIZE GL_MAX_RENDERBUFFER_SIZE
#endif
#if defined(HAVE_PSGL)
#define glGenerateMipmap glGenerateMipmapOES
#endif
#if defined(__APPLE__) || defined(HAVE_PSGL)
#define GL_RGBA32F GL_RGBA32F_ARB
#endif
#if defined(HAVE_PSGL)
#define RARCH_GL_INTERNAL_FORMAT32 GL_ARGB_SCE
#define RARCH_GL_INTERNAL_FORMAT16 GL_RGB5 /* TODO: Verify if this is really 565 or just 555. */
#define RARCH_GL_TEXTURE_TYPE32 GL_BGRA
#define RARCH_GL_TEXTURE_TYPE16 GL_BGRA
#define RARCH_GL_FORMAT32 GL_UNSIGNED_INT_8_8_8_8_REV
#define RARCH_GL_FORMAT16 GL_RGB5
#elif defined(HAVE_OPENGLES)
/* Imgtec/SGX headers have this missing. */
#ifndef GL_BGRA_EXT
#define GL_BGRA_EXT 0x80E1
#endif
#ifndef GL_BGRA8_EXT
#define GL_BGRA8_EXT 0x93A1
#endif
#ifdef IOS
/* Stupid Apple */
#define RARCH_GL_INTERNAL_FORMAT32 GL_RGBA
#else
#define RARCH_GL_INTERNAL_FORMAT32 GL_BGRA_EXT
#endif
#define RARCH_GL_INTERNAL_FORMAT16 GL_RGB
#define RARCH_GL_TEXTURE_TYPE32 GL_BGRA_EXT
#define RARCH_GL_TEXTURE_TYPE16 GL_RGB
#define RARCH_GL_FORMAT32 GL_UNSIGNED_BYTE
#define RARCH_GL_FORMAT16 GL_UNSIGNED_SHORT_5_6_5
#else
/* On desktop, we always use 32-bit. */
#define RARCH_GL_INTERNAL_FORMAT32 GL_RGBA8
#define RARCH_GL_INTERNAL_FORMAT16 GL_RGBA8
#define RARCH_GL_TEXTURE_TYPE32 GL_BGRA
#define RARCH_GL_TEXTURE_TYPE16 GL_BGRA
#define RARCH_GL_FORMAT32 GL_UNSIGNED_INT_8_8_8_8_REV
#define RARCH_GL_FORMAT16 GL_UNSIGNED_INT_8_8_8_8_REV
/* GL_RGB565 internal format isn't in desktop GL
* until 4.1 core (ARB_ES2_compatibility).
* Check for this. */
#ifndef GL_RGB565
#define GL_RGB565 0x8D62
#endif
#define RARCH_GL_INTERNAL_FORMAT16_565 GL_RGB565
#define RARCH_GL_TEXTURE_TYPE16_565 GL_RGB
#define RARCH_GL_FORMAT16_565 GL_UNSIGNED_SHORT_5_6_5
#endif
#if defined(HAVE_OPENGLES2) /* TODO: Figure out exactly what. */
#define NO_GL_CLAMP_TO_BORDER
#endif
#if defined(HAVE_OPENGLES)
#ifndef GL_UNPACK_ROW_LENGTH
#define GL_UNPACK_ROW_LENGTH 0x0CF2
#endif
#ifndef GL_SRGB_ALPHA_EXT
#define GL_SRGB_ALPHA_EXT 0x8C42
#endif
#endif
#endif

40
gfx/drivers_renderchain/gl1_renderchain.c
View File

@ -57,14 +57,15 @@ typedef struct gl1_renderchain
GLenum min_filter_to_mag(GLenum type);
void gl1_renderchain_free(void *data)
void gl1_renderchain_free(void *data, void *chain_data)
{
gl_t *gl = (gl_t*)data;
(void)gl;
(void)chain_data;
(void)data;
}
static void gl1_renderchain_bind_prev_texture(
void *data,
void *chain_data,
const struct video_tex_info *tex_info)
{
gl_t *gl = (gl_t*)data;
@ -76,7 +77,8 @@ static void gl1_renderchain_bind_prev_texture(
}
static void gl1_renderchain_viewport_info(
void *data, struct video_viewport *vp)
void *data, void *chain_data,
struct video_viewport *vp)
{
unsigned width, height;
unsigned top_y, top_dist;
@ -95,7 +97,8 @@ static void gl1_renderchain_viewport_info(
}
static bool gl1_renderchain_read_viewport(
void *data, uint8_t *buffer, bool is_idle)
void *data, void *chain_data,
uint8_t *buffer, bool is_idle)
{
unsigned num_pixels = 0;
gl_t *gl = (gl_t*)data;
@ -108,14 +111,12 @@ static bool gl1_renderchain_read_viewport(
/* Use slow synchronous readbacks. Use this with plain screenshots
as we don't really care about performance in this case. */
/* GLES2 only guarantees GL_RGBA/GL_UNSIGNED_BYTE
/* GL1 only guarantees GL_RGBA/GL_UNSIGNED_BYTE
* readbacks so do just that.
* GLES2 also doesn't support reading back data
* GL1 also doesn't support reading back data
* from front buffer, so render a cached frame
* and have gl_frame() do the readback while it's
* in the back buffer.
*
* Keep codepath similar for GLES and desktop GL.
*/
gl->readback_buffer_screenshot = malloc(num_pixels * sizeof(uint32_t));
@ -136,9 +137,9 @@ static bool gl1_renderchain_read_viewport(
return true;
}
void gl1_renderchain_free_internal(void *data)
void gl1_renderchain_free_internal(void *data, void *chain_data)
{
gl1_renderchain_t *cg_data = (gl1_renderchain_t*)data;
gl1_renderchain_t *cg_data = (gl1_renderchain_t*)chain_data;
if (!cg_data)
return;
@ -185,7 +186,8 @@ static void gl1_renderchain_ff_matrix(const void *data)
glLoadMatrixf(ident.data);
}
static void gl1_renderchain_disable_client_arrays(void)
static void gl1_renderchain_disable_client_arrays(void *data,
void *chain_data)
{
if (gl_query_core_context_in_use())
return;
@ -198,7 +200,8 @@ static void gl1_renderchain_disable_client_arrays(void)
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
static void gl1_renderchain_restore_default_state(void *data)
static void gl1_renderchain_restore_default_state(void *data,
void *chain_data)
{
gl_t *gl = (gl_t*)data;
if (!gl)
@ -211,6 +214,7 @@ static void gl1_renderchain_restore_default_state(void *data)
static void gl1_renderchain_copy_frame(
void *data,
void *chain_data,
video_frame_info_t *video_info,
const void *frame,
unsigned width, unsigned height, unsigned pitch)
@ -246,6 +250,7 @@ static void gl1_renderchain_copy_frame(
}
static void gl1_renderchain_readback(void *data,
void *chain_data,
unsigned alignment,
unsigned fmt, unsigned type,
void *src)
@ -262,6 +267,7 @@ static void gl1_renderchain_readback(void *data,
}
static void gl1_renderchain_set_mvp(void *data,
void *chain_data,
void *shader_data, const void *mat_data)
{
math_matrix_4x4 ident;
@ -276,6 +282,7 @@ static void gl1_renderchain_set_mvp(void *data,
}
static void gl1_renderchain_set_coords(void *handle_data,
void *chain_data,
void *shader_data, const struct video_coords *coords)
{
/* Fall back to fixed function-style if needed and possible. */
@ -320,10 +327,11 @@ gl_renderchain_driver_t gl2_renderchain = {
NULL, /* renderchain_init */
NULL, /* init_hw_render */
gl1_renderchain_free,
NULL, /* deinit_hw_render */
NULL, /* start_render */
NULL, /* deinit_hw_render */
NULL, /* start_render */
NULL, /* check_fbo_dimensions */
NULL, /* recompute_pass_sizes */
NULL, /* renderchain_render */
NULL, /* renderchain_render */
NULL, /* resolve_extensions */
"gl1",
};

446
gfx/drivers_renderchain/gl2_renderchain.c
View File

@ -41,6 +41,7 @@
#include <gfx/gl_capabilities.h>
#include <gfx/video_frame.h>
#include <glsym/glsym.h>
#include "../video_driver.h"
#include "../video_shader_parse.h"
@ -50,9 +51,28 @@
#include "../../configuration.h"
#include "../../verbosity.h"
#define MAX_FENCES 4
typedef struct gl2_renderchain
{
void *empty;
bool egl_images;
bool has_fp_fbo;
bool has_srgb_fbo_gles3;
bool has_srgb_fbo;
bool hw_render_depth_init;
int fbo_pass;
GLuint vao;
GLuint fbo[GFX_MAX_SHADERS];
GLuint fbo_texture[GFX_MAX_SHADERS];
GLuint hw_render_depth[GFX_MAX_TEXTURES];
unsigned fence_count;
GLsync fences[MAX_FENCES];
struct gfx_fbo_scale fbo_scale[GFX_MAX_SHADERS];
} gl2_renderchain_t;
#if (!defined(HAVE_OPENGLES) || defined(HAVE_OPENGLES3))
@ -67,7 +87,45 @@ typedef struct gl2_renderchain
coords[5] = yamt; \
coords[7] = yamt
#define gl2_bind_fb(id) glBindFramebuffer(RARCH_GL_FRAMEBUFFER, id)
#if defined(HAVE_PSGL)
#define gl2_fb_texture_2d(a, b, c, d, e) glFramebufferTexture2DOES(a, b, c, d, e)
#define gl2_check_fb_status(target) glCheckFramebufferStatusOES(target)
#define gl2_gen_fb(n, ids) glGenFramebuffersOES(n, ids)
#define gl2_delete_fb(n, fb) glDeleteFramebuffersOES(n, fb)
#define gl2_bind_fb(id) glBindFramebufferOES(RARCH_GL_FRAMEBUFFER, id)
#define gl2_gen_rb glGenRenderbuffersOES
#define gl2_bind_rb glBindRenderbufferOES
#define gl2_fb_rb glFramebufferRenderbufferOES
#define gl2_rb_storage glRenderbufferStorageOES
#define gl2_delete_rb glDeleteRenderbuffersOES
#elif (defined(__MACH__) && (defined(__ppc__) || defined(__ppc64__)))
#define gl2_fb_texture_2d(a, b, c, d, e) glFramebufferTexture2DEXT(a, b, c, d, e)
#define gl2_check_fb_status(target) glCheckFramebufferStatusEXT(target)
#define gl2_gen_fb(n, ids) glGenFramebuffersEXT(n, ids)
#define gl2_delete_fb(n, fb) glDeleteFramebuffersEXT(n, fb)
#define gl2_bind_fb(id) glBindFramebufferEXT(RARCH_GL_FRAMEBUFFER, id)
#define gl2_gen_rb glGenRenderbuffersEXT
#define gl2_bind_rb glBindRenderbufferEXT
#define gl2_fb_rb glFramebufferRenderbufferEXT
#define gl2_rb_storage glRenderbufferStorageEXT
#define gl2_delete_rb glDeleteRenderbuffersEXT
#else
#define gl2_fb_texture_2d(a, b, c, d, e) glFramebufferTexture2D(a, b, c, d, e)
#define gl2_check_fb_status(target) glCheckFramebufferStatus(target)
#define gl2_gen_fb(n, ids) glGenFramebuffers(n, ids)
#define gl2_delete_fb(n, fb) glDeleteFramebuffers(n, fb)
#define gl2_bind_fb(id) glBindFramebuffer(RARCH_GL_FRAMEBUFFER, id)
#define gl2_gen_rb glGenRenderbuffers
#define gl2_bind_rb glBindRenderbuffer
#define gl2_fb_rb glFramebufferRenderbuffer
#define gl2_rb_storage glRenderbufferStorage
#define gl2_delete_rb glDeleteRenderbuffers
#endif
#ifndef GL_SYNC_GPU_COMMANDS_COMPLETE
#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117
@ -78,7 +136,8 @@ typedef struct gl2_renderchain
#endif
/* Prototypes */
static void gl2_renderchain_bind_backbuffer(void)
static void gl2_renderchain_bind_backbuffer(void *data,
void *chain_data)
{
#ifdef IOS
/* There is no default frame buffer on iOS. */
@ -169,11 +228,11 @@ static bool gl_recreate_fbo(
0, RARCH_GL_TEXTURE_TYPE32,
RARCH_GL_FORMAT32, NULL);
glFramebufferTexture2D(RARCH_GL_FRAMEBUFFER,
gl2_fb_texture_2d(RARCH_GL_FRAMEBUFFER,
RARCH_GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
*texture, 0);
if (glCheckFramebufferStatus(RARCH_GL_FRAMEBUFFER)
if (gl2_check_fb_status(RARCH_GL_FRAMEBUFFER)
== RARCH_GL_FRAMEBUFFER_COMPLETE)
return true;
@ -181,12 +240,15 @@ static bool gl_recreate_fbo(
return false;
}
static void gl_check_fbo_dimension(gl_t *gl, unsigned i,
static void gl_check_fbo_dimension(gl_t *gl,
void *chain_data,
unsigned i,
bool update_feedback)
{
struct video_fbo_rect *fbo_rect = &gl->fbo_rect[i];
/* Check proactively since we might suddently
* get sizes of tex_w width or tex_h height. */
gl2_renderchain_t *chain = (gl2_renderchain_t*)chain_data;
unsigned img_width = fbo_rect->max_img_width;
unsigned img_height = fbo_rect->max_img_height;
unsigned max = img_width > img_height ? img_width : img_height;
@ -195,7 +257,7 @@ static void gl_check_fbo_dimension(gl_t *gl, unsigned i,
fbo_rect->width = pow2_size;
fbo_rect->height = pow2_size;
gl_recreate_fbo(fbo_rect, gl->fbo[i], &gl->fbo_texture[i]);
gl_recreate_fbo(fbo_rect, chain->fbo[i], &chain->fbo_texture[i]);
/* Update feedback texture in-place so we avoid having to
* juggle two different fbo_rect structs since they get updated here. */
@ -218,13 +280,15 @@ static void gl_check_fbo_dimension(gl_t *gl, unsigned i,
/* On resize, we might have to recreate our FBOs
* due to "Viewport" scale, and set a new viewport. */
static void gl2_renderchain_check_fbo_dimensions(void *data)
static void gl2_renderchain_check_fbo_dimensions(void *data,
void *chain_data)
{
int i;
gl_t *gl = (gl_t*)data;
gl_t *gl = (gl_t*)data;
gl2_renderchain_t *chain = (gl2_renderchain_t*)chain_data;
/* Check if we have to recreate our FBO textures. */
for (i = 0; i < gl->fbo_pass; i++)
for (i = 0; i < chain->fbo_pass; i++)
{
struct video_fbo_rect *fbo_rect = &gl->fbo_rect[i];
if (fbo_rect)
@ -234,13 +298,14 @@ static void gl2_renderchain_check_fbo_dimensions(void *data)
if ((fbo_rect->max_img_width > fbo_rect->width) ||
(fbo_rect->max_img_height > fbo_rect->height))
gl_check_fbo_dimension(gl, i, update_feedback);
gl_check_fbo_dimension(gl, chain_data, i, update_feedback);
}
}
}
static void gl2_renderchain_render(
void *data,
void *chain_data,
video_frame_info_t *video_info,
uint64_t frame_count,
const struct video_tex_info *tex_info,
@ -251,6 +316,7 @@ static void gl2_renderchain_render(
video_shader_ctx_params_t params;
video_shader_ctx_info_t shader_info;
gl_t *gl = (gl_t*)data;
gl2_renderchain_t *chain = (gl2_renderchain_t*)chain_data;
static GLfloat fbo_tex_coords[8] = {0.0f};
struct video_tex_info fbo_tex_info[GFX_MAX_SHADERS];
struct video_tex_info *fbo_info = NULL;
@ -267,7 +333,7 @@ static void gl2_renderchain_render(
/* Calculate viewports, texture coordinates etc,
* and render all passes from FBOs, to another FBO. */
for (i = 1; i < gl->fbo_pass; i++)
for (i = 1; i < chain->fbo_pass; i++)
{
video_shader_ctx_coords_t coords;
video_shader_ctx_params_t params;
@ -281,7 +347,7 @@ static void gl2_renderchain_render(
set_texture_coords(fbo_tex_coords, xamt, yamt);
fbo_info->tex = gl->fbo_texture[i - 1];
fbo_info->tex = chain->fbo_texture[i - 1];
fbo_info->input_size[0] = prev_rect->img_width;
fbo_info->input_size[1] = prev_rect->img_height;
fbo_info->tex_size[0] = prev_rect->width;
@ -289,14 +355,14 @@ static void gl2_renderchain_render(
memcpy(fbo_info->coord, fbo_tex_coords, sizeof(fbo_tex_coords));
fbo_tex_info_cnt++;
gl2_bind_fb(gl->fbo[i]);
gl2_bind_fb(chain->fbo[i]);
shader_info.data = gl;
shader_info.idx = i + 1;
shader_info.set_active = true;
video_shader_driver_use(shader_info);
glBindTexture(GL_TEXTURE_2D, gl->fbo_texture[i - 1]);
glBindTexture(GL_TEXTURE_2D, chain->fbo_texture[i - 1]);
mip_level = i + 1;
@ -340,21 +406,21 @@ static void gl2_renderchain_render(
}
#if defined(GL_FRAMEBUFFER_SRGB) && !defined(HAVE_OPENGLES)
if (gl->has_srgb_fbo)
if (chain->has_srgb_fbo)
glDisable(GL_FRAMEBUFFER_SRGB);
#endif
/* Render our last FBO texture directly to screen. */
prev_rect = &gl->fbo_rect[gl->fbo_pass - 1];
prev_rect = &gl->fbo_rect[chain->fbo_pass - 1];
xamt = (GLfloat)prev_rect->img_width / prev_rect->width;
yamt = (GLfloat)prev_rect->img_height / prev_rect->height;
set_texture_coords(fbo_tex_coords, xamt, yamt);
/* Push final FBO to list. */
fbo_info = &fbo_tex_info[gl->fbo_pass - 1];
fbo_info = &fbo_tex_info[chain->fbo_pass - 1];
fbo_info->tex = gl->fbo_texture[gl->fbo_pass - 1];
fbo_info->tex = chain->fbo_texture[chain->fbo_pass - 1];
fbo_info->input_size[0] = prev_rect->img_width;
fbo_info->input_size[1] = prev_rect->img_height;
fbo_info->tex_size[0] = prev_rect->width;
@ -363,17 +429,17 @@ static void gl2_renderchain_render(
fbo_tex_info_cnt++;
/* Render our FBO texture to back buffer. */
gl2_renderchain_bind_backbuffer();
gl2_renderchain_bind_backbuffer(gl, chain_data);
shader_info.data = gl;
shader_info.idx = gl->fbo_pass + 1;
shader_info.idx = chain->fbo_pass + 1;
shader_info.set_active = true;
video_shader_driver_use(shader_info);
glBindTexture(GL_TEXTURE_2D, gl->fbo_texture[gl->fbo_pass - 1]);
glBindTexture(GL_TEXTURE_2D, chain->fbo_texture[chain->fbo_pass - 1]);
mip_level = gl->fbo_pass + 1;
mip_level = chain->fbo_pass + 1;
if (video_shader_driver_mipmap_input(&mip_level)
&& gl->have_mipmap)
@ -416,69 +482,80 @@ static void gl2_renderchain_render(
gl->coords.tex_coord = gl->tex_info.coord;
}
static void gl2_renderchain_deinit_fbo(void *data)
static void gl2_renderchain_deinit_fbo(void *data,
void *chain_data)
{
gl_t *gl = (gl_t*)data;
gl_t *gl = (gl_t*)data;
gl2_renderchain_t *chain = (gl2_renderchain_t*)chain_data;
glDeleteTextures(gl->fbo_pass, gl->fbo_texture);
glDeleteFramebuffers(gl->fbo_pass, gl->fbo);
memset(gl->fbo_texture, 0, sizeof(gl->fbo_texture));
memset(gl->fbo, 0, sizeof(gl->fbo));
gl->fbo_inited = false;
gl->fbo_pass = 0;
if (!gl)
return;
glDeleteTextures(chain->fbo_pass, chain->fbo_texture);
gl2_delete_fb(chain->fbo_pass, chain->fbo);
memset(chain->fbo_texture, 0, sizeof(chain->fbo_texture));
memset(chain->fbo, 0, sizeof(chain->fbo));
if (gl->fbo_feedback)
glDeleteFramebuffers(1, &gl->fbo_feedback);
gl2_delete_fb(1, &gl->fbo_feedback);
if (gl->fbo_feedback_texture)
glDeleteTextures(1, &gl->fbo_feedback_texture);
chain->fbo_pass = 0;
gl->fbo_inited = false;
gl->fbo_feedback_enable = false;
gl->fbo_feedback_pass = 0;
gl->fbo_feedback_texture = 0;
gl->fbo_feedback = 0;
}
static void gl2_renderchain_deinit_hw_render(void *data)
static void gl2_renderchain_deinit_hw_render(
void *data,
void *chain_data)
{
gl_t *gl = (gl_t*)data;
gl_t *gl = (gl_t*)data;
gl2_renderchain_t *chain = (gl2_renderchain_t*)chain_data;
if (!gl)
return;
context_bind_hw_render(true);
if (gl->hw_render_fbo_init)
glDeleteFramebuffers(gl->textures, gl->hw_render_fbo);
if (gl->hw_render_depth_init)
glDeleteRenderbuffers(gl->textures, gl->hw_render_depth);
gl2_delete_fb(gl->textures, gl->hw_render_fbo);
if (chain->hw_render_depth_init)
gl2_delete_rb(gl->textures, chain->hw_render_depth);
gl->hw_render_fbo_init = false;
context_bind_hw_render(false);
}
void gl2_renderchain_free(void *data)
static void gl2_renderchain_free(void *data, void *chain_data)
{
gl_t *gl = (gl_t*)data;
gl2_renderchain_deinit_fbo(gl);
gl2_renderchain_deinit_hw_render(gl);
gl2_renderchain_deinit_fbo(gl, chain_data);
gl2_renderchain_deinit_hw_render(gl, chain_data);
}
static bool gl_create_fbo_targets(gl_t *gl)
static bool gl_create_fbo_targets(gl_t *gl, void *chain_data)
{
int i;
gl2_renderchain_t *chain = (gl2_renderchain_t*)chain_data;
glBindTexture(GL_TEXTURE_2D, 0);
glGenFramebuffers(gl->fbo_pass, gl->fbo);
gl2_gen_fb(chain->fbo_pass, chain->fbo);
for (i = 0; i < gl->fbo_pass; i++)
for (i = 0; i < chain->fbo_pass; i++)
{
GLenum status;
gl2_bind_fb(gl->fbo[i]);
glFramebufferTexture2D(RARCH_GL_FRAMEBUFFER,
RARCH_GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, gl->fbo_texture[i], 0);
gl2_bind_fb(chain->fbo[i]);
gl2_fb_texture_2d(RARCH_GL_FRAMEBUFFER,
RARCH_GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, chain->fbo_texture[i], 0);
status = glCheckFramebufferStatus(RARCH_GL_FRAMEBUFFER);
status = gl2_check_fb_status(RARCH_GL_FRAMEBUFFER);
if (status != RARCH_GL_FRAMEBUFFER_COMPLETE)
goto error;
}
@ -487,13 +564,13 @@ static bool gl_create_fbo_targets(gl_t *gl)
{
GLenum status;
glGenFramebuffers(1, &gl->fbo_feedback);
gl2_gen_fb(1, &gl->fbo_feedback);
gl2_bind_fb(gl->fbo_feedback);
glFramebufferTexture2D(RARCH_GL_FRAMEBUFFER,
gl2_fb_texture_2d(RARCH_GL_FRAMEBUFFER,
RARCH_GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
gl->fbo_feedback_texture, 0);
status = glCheckFramebufferStatus(RARCH_GL_FRAMEBUFFER);
status = gl2_check_fb_status(RARCH_GL_FRAMEBUFFER);
if (status != RARCH_GL_FRAMEBUFFER_COMPLETE)
goto error;
@ -506,20 +583,22 @@ static bool gl_create_fbo_targets(gl_t *gl)
return true;
error:
glDeleteFramebuffers(gl->fbo_pass, gl->fbo);
gl2_delete_fb(chain->fbo_pass, chain->fbo);
if (gl->fbo_feedback)
glDeleteFramebuffers(1, &gl->fbo_feedback);
gl2_delete_fb(1, &gl->fbo_feedback);
RARCH_ERR("[GL]: Failed to set up frame buffer objects. Multi-pass shading will not work.\n");
return false;
}
static void gl_create_fbo_texture(gl_t *gl, unsigned i, GLuint texture)
static void gl_create_fbo_texture(gl_t *gl,
void *chain_data, unsigned i, GLuint texture)
{
GLenum mag_filter, wrap_enum;
video_shader_ctx_filter_t filter_type;
video_shader_ctx_wrap_t wrap = {0};
bool fp_fbo = false;
bool smooth = false;
gl2_renderchain_t *chain = (gl2_renderchain_t*)chain_data;
settings_t *settings = config_get_ptr();
GLuint base_filt = settings->bools.video_smooth ? GL_LINEAR : GL_NEAREST;
GLuint base_mip_filt = settings->bools.video_smooth ?
@ -547,16 +626,16 @@ static void gl_create_fbo_texture(gl_t *gl, unsigned i, GLuint texture)
gl_bind_texture(texture, wrap_enum, mag_filter, min_filter);
fp_fbo = gl->fbo_scale[i].fp_fbo;
fp_fbo = chain->fbo_scale[i].fp_fbo;
if (fp_fbo)
{
if (!gl->has_fp_fbo)
if (!chain->has_fp_fbo)
RARCH_ERR("[GL]: Floating-point FBO was requested, but is not supported. Falling back to UNORM. Result may band/clip/etc.!\n");
}
#if !defined(HAVE_OPENGLES2)
if (fp_fbo && gl->has_fp_fbo)
if (fp_fbo && chain->has_fp_fbo)
{
RARCH_LOG("[GL]: FBO pass #%d is floating-point.\n", i);
gl_load_texture_image(GL_TEXTURE_2D, 0, GL_RGBA32F,
@ -567,18 +646,18 @@ static void gl_create_fbo_texture(gl_t *gl, unsigned i, GLuint texture)
#endif
{
#ifndef HAVE_OPENGLES
bool srgb_fbo = gl->fbo_scale[i].srgb_fbo;
bool srgb_fbo = chain->fbo_scale[i].srgb_fbo;
if (!fp_fbo && srgb_fbo)
{
if (!gl->has_srgb_fbo)
if (!chain->has_srgb_fbo)
RARCH_ERR("[GL]: sRGB FBO was requested, but it is not supported. Falling back to UNORM. Result may have banding!\n");
}
if (settings->bools.video_force_srgb_disable)
srgb_fbo = false;
if (srgb_fbo && gl->has_srgb_fbo)
if (srgb_fbo && chain->has_srgb_fbo)
{
RARCH_LOG("[GL]: FBO pass #%d is sRGB.\n", i);
#ifdef HAVE_OPENGLES2
@ -587,7 +666,7 @@ static void gl_create_fbo_texture(gl_t *gl, unsigned i, GLuint texture)
glTexImage2D(GL_TEXTURE_2D,
0, GL_SRGB_ALPHA_EXT,
gl->fbo_rect[i].width, gl->fbo_rect[i].height, 0,
gl->has_srgb_fbo_gles3 ? GL_RGBA : GL_SRGB_ALPHA_EXT,
chain->has_srgb_fbo_gles3 ? GL_RGBA : GL_SRGB_ALPHA_EXT,
GL_UNSIGNED_BYTE, NULL);
#else
gl_load_texture_image(GL_TEXTURE_2D,
@ -616,18 +695,22 @@ static void gl_create_fbo_texture(gl_t *gl, unsigned i, GLuint texture)
}
}
static void gl_create_fbo_textures(gl_t *gl)
static void gl_create_fbo_textures(gl_t *gl, void *chain_data)
{
int i;
glGenTextures(gl->fbo_pass, gl->fbo_texture);
gl2_renderchain_t *chain = (gl2_renderchain_t*)chain_data;
for (i = 0; i < gl->fbo_pass; i++)
gl_create_fbo_texture(gl, i, gl->fbo_texture[i]);
glGenTextures(chain->fbo_pass, chain->fbo_texture);
for (i = 0; i < chain->fbo_pass; i++)
gl_create_fbo_texture(gl, gl->renderchain_data,
i, chain->fbo_texture[i]);
if (gl->fbo_feedback_enable)
{
glGenTextures(1, &gl->fbo_feedback_texture);
gl_create_fbo_texture(gl,
gl->renderchain_data,
gl->fbo_feedback_pass, gl->fbo_feedback_texture);
}
@ -640,11 +723,13 @@ static void gl_create_fbo_textures(gl_t *gl)
static void gl2_renderchain_recompute_pass_sizes(
void *data,
void *chain_data,
unsigned width, unsigned height,
unsigned vp_width, unsigned vp_height)
{
int i;
gl_t *gl = (gl_t*)data;
gl2_renderchain_t *chain = (gl2_renderchain_t*)chain_data;
bool size_modified = false;
GLint max_size = 0;
unsigned last_width = width;
@ -655,10 +740,10 @@ static void gl2_renderchain_recompute_pass_sizes(
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_size);
/* Calculate viewports for FBOs. */
for (i = 0; i < gl->fbo_pass; i++)
for (i = 0; i < chain->fbo_pass; i++)
{
struct video_fbo_rect *fbo_rect = &gl->fbo_rect[i];
struct gfx_fbo_scale *fbo_scale = &gl->fbo_scale[i];
struct gfx_fbo_scale *fbo_scale = &chain->fbo_scale[i];
gl2_renderchain_convert_geometry(
gl, fbo_rect, fbo_scale,
@ -702,6 +787,7 @@ static void gl2_renderchain_recompute_pass_sizes(
}
static void gl2_renderchain_start_render(void *data,
void *chain_data,
video_frame_info_t *video_info)
{
/* Used when rendering to an FBO.
@ -713,10 +799,11 @@ static void gl2_renderchain_start_render(void *data,
0, 1,
1, 1
};
gl_t *gl = (gl_t*)data;
gl_t *gl = (gl_t*)data;
gl2_renderchain_t *chain = (gl2_renderchain_t*)chain_data;
glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
gl2_bind_fb(gl->fbo[0]);
gl2_bind_fb(chain->fbo[0]);
gl_set_viewport(gl,
video_info, gl->fbo_rect[0].img_width,
@ -729,21 +816,23 @@ static void gl2_renderchain_start_render(void *data,
gl->coords.vertex = fbo_vertexes;
#if defined(GL_FRAMEBUFFER_SRGB) && !defined(HAVE_OPENGLES)
if (gl->has_srgb_fbo)
if (chain->has_srgb_fbo)
glEnable(GL_FRAMEBUFFER_SRGB);
#endif
}
/* Set up render to texture. */
void gl2_renderchain_init(
void *data, unsigned fbo_width, unsigned fbo_height)
void *data, void *chain_data,
unsigned fbo_width, unsigned fbo_height)
{
int i;
unsigned width, height;
video_shader_ctx_scale_t scaler;
video_shader_ctx_info_t shader_info;
struct gfx_fbo_scale scale, scale_last;
gl_t *gl = (gl_t*)data;
gl_t *gl = (gl_t*)data;
gl2_renderchain_t *chain = (gl2_renderchain_t*)chain_data;
if (!video_shader_driver_info(&shader_info))
return;
@ -773,9 +862,9 @@ void gl2_renderchain_init(
return;
}
gl->fbo_pass = shader_info.num - 1;
chain->fbo_pass = shader_info.num - 1;
if (scale_last.valid)
gl->fbo_pass++;
chain->fbo_pass++;
if (!scale.valid)
{
@ -785,28 +874,29 @@ void gl2_renderchain_init(
scale.valid = true;
}
gl->fbo_scale[0] = scale;
chain->fbo_scale[0] = scale;
for (i = 1; i < gl->fbo_pass; i++)
for (i = 1; i < chain->fbo_pass; i++)
{
scaler.idx = i + 1;
scaler.scale = &gl->fbo_scale[i];
scaler.scale = &chain->fbo_scale[i];
video_shader_driver_scale(&scaler);
if (!gl->fbo_scale[i].valid)
if (!chain->fbo_scale[i].valid)
{
gl->fbo_scale[i].scale_x = gl->fbo_scale[i].scale_y = 1.0f;
gl->fbo_scale[i].type_x = gl->fbo_scale[i].type_y =
chain->fbo_scale[i].scale_x = chain->fbo_scale[i].scale_y = 1.0f;
chain->fbo_scale[i].type_x = chain->fbo_scale[i].type_y =
RARCH_SCALE_INPUT;
gl->fbo_scale[i].valid = true;
chain->fbo_scale[i].valid = true;
}
}
gl2_renderchain_recompute_pass_sizes(gl,
chain_data,
fbo_width, fbo_height, width, height);
for (i = 0; i < gl->fbo_pass; i++)
for (i = 0; i < chain->fbo_pass; i++)
{
gl->fbo_rect[i].width = next_pow2(gl->fbo_rect[i].img_width);
gl->fbo_rect[i].height = next_pow2(gl->fbo_rect[i].img_height);
@ -818,7 +908,7 @@ void gl2_renderchain_init(
&gl->fbo_feedback_pass);
if (gl->fbo_feedback_enable && gl->fbo_feedback_pass
< (unsigned)gl->fbo_pass)
< (unsigned)chain->fbo_pass)
{
RARCH_LOG("[GL]: Creating feedback FBO %d @ %ux%u\n", i,
gl->fbo_rect[gl->fbo_feedback_pass].width,
@ -827,14 +917,14 @@ void gl2_renderchain_init(
else if (gl->fbo_feedback_enable)
{
RARCH_WARN("[GL]: Tried to create feedback FBO of pass #%u, but there are only %d FBO passes. Will use input texture as feedback texture.\n",
gl->fbo_feedback_pass, gl->fbo_pass);
gl->fbo_feedback_pass, chain->fbo_pass);
gl->fbo_feedback_enable = false;
}
gl_create_fbo_textures(gl);
if (!gl || !gl_create_fbo_targets(gl))
gl_create_fbo_textures(gl, chain);
if (!gl || !gl_create_fbo_targets(gl, chain))
{
glDeleteTextures(gl->fbo_pass, gl->fbo_texture);
glDeleteTextures(chain->fbo_pass, chain->fbo_texture);
RARCH_ERR("[GL]: Failed to create FBO targets. Will continue without FBO.\n");
return;
}
@ -844,6 +934,7 @@ void gl2_renderchain_init(
static bool gl2_renderchain_init_hw_render(
void *data,
void *chain_data,
unsigned width, unsigned height)
{
GLenum status;
@ -855,6 +946,7 @@ static bool gl2_renderchain_init_hw_render(
struct retro_hw_render_callback *hwr =
video_driver_get_hw_context();
gl_t *gl = (gl_t*)data;
gl2_renderchain_t *chain = (gl2_renderchain_t*)chain_data;
/* We can only share texture objects through contexts.
* FBOs are "abstract" objects and are not shared. */
@ -872,58 +964,62 @@ static bool gl2_renderchain_init_hw_render(
RARCH_LOG("[GL]: Supports FBO (render-to-texture).\n");
glBindTexture(GL_TEXTURE_2D, 0);
glGenFramebuffers(gl->textures, gl->hw_render_fbo);
gl2_gen_fb(gl->textures, gl->hw_render_fbo);
depth = hwr->depth;
stencil = hwr->stencil;
if (depth)
{
glGenRenderbuffers(gl->textures, gl->hw_render_depth);
gl->hw_render_depth_init = true;
gl2_gen_rb(gl->textures, chain->hw_render_depth);
chain->hw_render_depth_init = true;
}
for (i = 0; i < gl->textures; i++)
{
gl2_bind_fb(gl->hw_render_fbo[i]);
glFramebufferTexture2D(RARCH_GL_FRAMEBUFFER,
gl2_fb_texture_2d(RARCH_GL_FRAMEBUFFER,
RARCH_GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, gl->texture[i], 0);
if (depth)
{
glBindRenderbuffer(RARCH_GL_RENDERBUFFER, gl->hw_render_depth[i]);
glRenderbufferStorage(RARCH_GL_RENDERBUFFER,
gl2_bind_rb(RARCH_GL_RENDERBUFFER, chain->hw_render_depth[i]);
gl2_rb_storage(RARCH_GL_RENDERBUFFER,
stencil ? RARCH_GL_DEPTH24_STENCIL8 : GL_DEPTH_COMPONENT16,
width, height);
glBindRenderbuffer(RARCH_GL_RENDERBUFFER, 0);
gl2_bind_rb(RARCH_GL_RENDERBUFFER, 0);
if (stencil)
{
#if defined(HAVE_OPENGLES2) || defined(HAVE_OPENGLES1) || ((defined(__MACH__) && (defined(__ppc__) || defined(__ppc64__))))
/* GLES2 is a bit weird, as always.
* There's no GL_DEPTH_STENCIL_ATTACHMENT like in desktop GL. */
glFramebufferRenderbuffer(RARCH_GL_FRAMEBUFFER,
gl2_fb_rb(RARCH_GL_FRAMEBUFFER,
RARCH_GL_DEPTH_ATTACHMENT,
RARCH_GL_RENDERBUFFER, gl->hw_render_depth[i]);
glFramebufferRenderbuffer(RARCH_GL_FRAMEBUFFER,
RARCH_GL_RENDERBUFFER,
chain->hw_render_depth[i]);
gl2_fb_rb(RARCH_GL_FRAMEBUFFER,
RARCH_GL_STENCIL_ATTACHMENT,
RARCH_GL_RENDERBUFFER, gl->hw_render_depth[i]);
RARCH_GL_RENDERBUFFER,
chain->hw_render_depth[i]);
#else
/* We use ARB FBO extensions, no need to check. */
glFramebufferRenderbuffer(RARCH_GL_FRAMEBUFFER,
gl2_fb_rb(RARCH_GL_FRAMEBUFFER,
GL_DEPTH_STENCIL_ATTACHMENT,
RARCH_GL_RENDERBUFFER, gl->hw_render_depth[i]);
RARCH_GL_RENDERBUFFER,
chain->hw_render_depth[i]);
#endif
}
else
{
glFramebufferRenderbuffer(RARCH_GL_FRAMEBUFFER,
gl2_fb_rb(RARCH_GL_FRAMEBUFFER,
RARCH_GL_DEPTH_ATTACHMENT,
RARCH_GL_RENDERBUFFER, gl->hw_render_depth[i]);
RARCH_GL_RENDERBUFFER,
chain->hw_render_depth[i]);
}
}
status = glCheckFramebufferStatus(RARCH_GL_FRAMEBUFFER);
status = gl2_check_fb_status(RARCH_GL_FRAMEBUFFER);
if (status != RARCH_GL_FRAMEBUFFER_COMPLETE)
{
RARCH_ERR("[GL]: Failed to create HW render FBO #%u, error: 0x%u.\n",
@ -932,7 +1028,7 @@ static bool gl2_renderchain_init_hw_render(
}
}
gl2_renderchain_bind_backbuffer();
gl2_renderchain_bind_backbuffer(gl, chain_data);
gl->hw_render_fbo_init = true;
context_bind_hw_render(false);
@ -941,9 +1037,11 @@ static bool gl2_renderchain_init_hw_render(
static void gl2_renderchain_bind_prev_texture(
void *data,
void *chain_data,
const struct video_tex_info *tex_info)
{
gl_t *gl = (gl_t*)data;
gl_t *gl = (gl_t*)data;
gl2_renderchain_t *chain = (gl2_renderchain_t*)chain_data;
memmove(gl->prev_info + 1, gl->prev_info,
sizeof(*tex_info) * (gl->textures - 1));
@ -956,15 +1054,16 @@ static void gl2_renderchain_bind_prev_texture(
{
GLuint tmp_fbo = gl->fbo_feedback;
GLuint tmp_tex = gl->fbo_feedback_texture;
gl->fbo_feedback = gl->fbo[gl->fbo_feedback_pass];
gl->fbo_feedback_texture = gl->fbo_texture[gl->fbo_feedback_pass];
gl->fbo[gl->fbo_feedback_pass] = tmp_fbo;
gl->fbo_texture[gl->fbo_feedback_pass] = tmp_tex;
gl->fbo_feedback = chain->fbo[gl->fbo_feedback_pass];
gl->fbo_feedback_texture = chain->fbo_texture[gl->fbo_feedback_pass];
chain->fbo[gl->fbo_feedback_pass] = tmp_fbo;
chain->fbo_texture[gl->fbo_feedback_pass] = tmp_tex;
}
}
static void gl2_renderchain_viewport_info(
void *data, struct video_viewport *vp)
void *data, void *chain_data,
struct video_viewport *vp)
{
unsigned width, height;
unsigned top_y, top_dist;
@ -983,7 +1082,9 @@ static void gl2_renderchain_viewport_info(
}
static bool gl2_renderchain_read_viewport(
void *data, uint8_t *buffer, bool is_idle)
void *data,
void *chain_data,
uint8_t *buffer, bool is_idle)
{
unsigned num_pixels = 0;
gl_t *gl = (gl_t*)data;
@ -1084,14 +1185,14 @@ error:
return false;
}
void gl2_renderchain_free_internal(void *data)
void gl2_renderchain_free_internal(void *data, void *chain_data)
{
gl2_renderchain_t *cg_data = (gl2_renderchain_t*)data;
gl2_renderchain_t *chain = (gl2_renderchain_t*)chain_data;
if (!cg_data)
if (!chain)
return;
free(cg_data);
free(chain);
}
static void *gl2_renderchain_new(void)
@ -1104,40 +1205,43 @@ static void *gl2_renderchain_new(void)
}
#ifndef HAVE_OPENGLES
static void gl2_renderchain_bind_vao(void *data)
static void gl2_renderchain_bind_vao(void *data,
void *chain_data)
{
gl_t *gl = (gl_t*)data;
if (!gl)
gl2_renderchain_t *chain = (gl2_renderchain_t*)chain_data;
if (!chain)
return;
glBindVertexArray(gl->vao);
glBindVertexArray(chain->vao);
}
static void gl2_renderchain_unbind_vao(void *data)
static void gl2_renderchain_unbind_vao(void *data,
void *chain_data)
{
gl_t *gl = (gl_t*)data;
if (!gl)
return;
glBindVertexArray(0);
}
static void gl2_renderchain_new_vao(void *data)
static void gl2_renderchain_new_vao(void *data,
void *chain_data)
{
gl_t *gl = (gl_t*)data;
if (!gl)
gl2_renderchain_t *chain = (gl2_renderchain_t*)chain_data;
if (!chain)
return;
glGenVertexArrays(1, &gl->vao);
glGenVertexArrays(1, &chain->vao);
}
static void gl2_renderchain_free_vao(void *data)
static void gl2_renderchain_free_vao(void *data,
void *chain_data)
{
gl_t *gl = (gl_t*)data;
if (!gl)
gl2_renderchain_t *chain = (gl2_renderchain_t*)chain_data;
if (!chain)
return;
glDeleteVertexArrays(1, &gl->vao);
glDeleteVertexArrays(1, &chain->vao);
}
#endif
static void gl2_renderchain_restore_default_state(void *data)
static void gl2_renderchain_restore_default_state(
void *data,
void *chain_data)
{
gl_t *gl = (gl_t*)data;
if (!gl)
@ -1153,11 +1257,16 @@ static void gl2_renderchain_restore_default_state(void *data)
static void gl2_renderchain_copy_frame(
void *data,
void *chain_data,
video_frame_info_t *video_info,
const void *frame,
unsigned width, unsigned height, unsigned pitch)
{
gl_t *gl = (gl_t*)data;
gl_t *gl = (gl_t*)data;
gl2_renderchain_t *chain = (gl2_renderchain_t*)chain_data;
(void)chain;
#if defined(HAVE_PSGL)
{
unsigned h;
@ -1176,7 +1285,7 @@ static void gl2_renderchain_copy_frame(
}
#elif defined(HAVE_OPENGLES)
#if defined(HAVE_EGL)
if (gl->egl_images)
if (chain->egl_images)
{
gfx_ctx_image_t img_info;
bool new_egl = false;
@ -1295,7 +1404,8 @@ static void gl2_renderchain_bind_pbo(unsigned idx)
glBindBuffer(GL_PIXEL_PACK_BUFFER, (GLuint)idx);
}
static void gl2_renderchain_unbind_pbo(void)
static void gl2_renderchain_unbind_pbo(void *data,
void *chain_data)
{
glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
}
@ -1309,6 +1419,7 @@ static void gl2_renderchain_init_pbo(unsigned size,
#endif
static void gl2_renderchain_readback(void *data,
void *chain_data,
unsigned alignment,
unsigned fmt, unsigned type,
void *src)
@ -1327,47 +1438,51 @@ static void gl2_renderchain_readback(void *data,
}
#ifndef HAVE_OPENGLES
static void gl2_renderchain_fence_iterate(void *data, unsigned
hard_sync_frames)
static void gl2_renderchain_fence_iterate(
void *data,
void *chain_data,
unsigned hard_sync_frames)
{
gl_t *gl = (gl_t*)data;
gl2_renderchain_t *chain = (gl2_renderchain_t*)chain_data;
gl->fences[gl->fence_count++] =
chain->fences[chain->fence_count++] =
glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
while (gl->fence_count > hard_sync_frames)
while (chain->fence_count > hard_sync_frames)
{
glClientWaitSync(gl->fences[0],
glClientWaitSync(chain->fences[0],
GL_SYNC_FLUSH_COMMANDS_BIT, 1000000000);
glDeleteSync(gl->fences[0]);
glDeleteSync(chain->fences[0]);
gl->fence_count--;
memmove(gl->fences, gl->fences + 1,
gl->fence_count * sizeof(GLsync));
chain->fence_count--;
memmove(chain->fences, chain->fences + 1,
chain->fence_count * sizeof(void*));
}
}
static void gl2_renderchain_fence_free(void *data)
static void gl2_renderchain_fence_free(void *data,
void *chain_data)
{
unsigned i;
gl_t *gl = (gl_t*)data;
gl2_renderchain_t *chain = (gl2_renderchain_t*)chain_data;
for (i = 0; i < gl->fence_count; i++)
for (i = 0; i < chain->fence_count; i++)
{
glClientWaitSync(gl->fences[i],
glClientWaitSync(chain->fences[i],
GL_SYNC_FLUSH_COMMANDS_BIT, 1000000000);
glDeleteSync(gl->fences[i]);
glDeleteSync(chain->fences[i]);
}
gl->fence_count = 0;
chain->fence_count = 0;
}
#endif
static void gl2_renderchain_init_textures_reference(
void *data, unsigned i,
void *data, void *chain_data, unsigned i,
unsigned internal_fmt, unsigned texture_fmt,
unsigned texture_type)
{
gl_t *gl = (gl_t*)data;
gl_t *gl = (gl_t*)data;
gl2_renderchain_t *chain = (gl2_renderchain_t*)chain_data;
#ifdef HAVE_PSGL
glTextureReferenceSCE(GL_TEXTURE_2D, 1,
gl->tex_w, gl->tex_h, 0,
@ -1375,7 +1490,7 @@ static void gl2_renderchain_init_textures_reference(
gl->tex_w * gl->base_size,
gl->tex_w * gl->tex_h * i * gl->base_size);
#else
if (gl->egl_images)
if (chain->egl_images)
return;
gl_load_texture_image(GL_TEXTURE_2D,
@ -1388,6 +1503,30 @@ static void gl2_renderchain_init_textures_reference(
#endif
}
static void gl2_renderchain_resolve_extensions(void *data,
void *chain_data, const char *context_ident,
const video_info_t *video)
{
gl_t *gl = (gl_t*)data;
gl2_renderchain_t *chain = (gl2_renderchain_t*)chain_data;
settings_t *settings = config_get_ptr();
if (!chain)
return;
chain->has_srgb_fbo = false;
chain->has_fp_fbo = gl_check_capability(GL_CAPS_FP_FBO);
/* GLES3 has unpack_subimage and sRGB in core. */
chain->has_srgb_fbo_gles3 = gl_check_capability(GL_CAPS_SRGB_FBO_ES3);
if (!settings->bools.video_force_srgb_disable)
chain->has_srgb_fbo = gl_check_capability(GL_CAPS_SRGB_FBO);
/* Use regular textures if we use HW render. */
chain->egl_images = !gl->hw_render_use && gl_check_capability(GL_CAPS_EGLIMAGE) &&
video_context_driver_init_image_buffer(video);
}
gl_renderchain_driver_t gl2_renderchain = {
NULL, /* set_coords */
NULL, /* set_mvp */
@ -1440,5 +1579,6 @@ gl_renderchain_driver_t gl2_renderchain = {
gl2_renderchain_check_fbo_dimensions,
gl2_renderchain_recompute_pass_sizes,
gl2_renderchain_render,
gl2_renderchain_resolve_extensions,
"gl2",
};

2
gfx/include/GL/glext.h
View File

@ -6220,8 +6220,8 @@ typedef uint64_t GLuint64EXT;
#ifndef GL_ARB_sync
typedef int64_t GLint64;
typedef uint64_t GLuint64;
typedef struct __GLsync *GLsync;
#endif
typedef struct __GLsync *GLsync;
#ifndef GL_ARB_cl_event
/* These incomplete types let us declare types compatible with OpenCL's cl_context and cl_event */

2
gfx/include/d3d9/d3dx9shader.h
View File

@ -643,4 +643,4 @@ typedef struct _D3DXSHADER_STRUCTMEMBERINFO
#endif //__D3DX9SHADER_H__
#endif /* __D3DX9SHADER_H__ */

204
gfx/include/d3d9caps.h
View File

@ -12,9 +12,9 @@
#ifndef DIRECT3D_VERSION
#define DIRECT3D_VERSION 0x0900
#endif //DIRECT3D_VERSION
#endif /* DIRECT3D_VERSION */
// include this file content only if compiling for DX9 interfaces
/* include this file content only if compiling for DX9 interfaces */
#if(DIRECT3D_VERSION >= 0x0900)
@ -117,7 +117,7 @@ DEFINE_GUID(D3DKEYEXCHANGE_RSAES_OAEP,
DEFINE_GUID(D3DKEYEXCHANGE_DXVA,
0x43d3775c, 0x38e5, 0x4924, 0x8d, 0x86, 0xd3, 0xfc, 0xcf, 0x15, 0x3e, 0x9b);
#endif // !D3D_DISABLE_9EX
#endif /* !D3D_DISABLE_9EX */
/* -- D3D9Ex only */
typedef struct _D3DCAPS9
@ -146,13 +146,13 @@ typedef struct _D3DCAPS9
DWORD AlphaCmpCaps;
DWORD ShadeCaps;
DWORD TextureCaps;
DWORD TextureFilterCaps; // D3DPTFILTERCAPS for IDirect3DTexture9's
DWORD CubeTextureFilterCaps; // D3DPTFILTERCAPS for IDirect3DCubeTexture9's
DWORD VolumeTextureFilterCaps; // D3DPTFILTERCAPS for IDirect3DVolumeTexture9's
DWORD TextureAddressCaps; // D3DPTADDRESSCAPS for IDirect3DTexture9's
DWORD VolumeTextureAddressCaps; // D3DPTADDRESSCAPS for IDirect3DVolumeTexture9's
DWORD TextureFilterCaps; /* D3DPTFILTERCAPS for IDirect3DTexture9's */
DWORD CubeTextureFilterCaps; /* D3DPTFILTERCAPS for IDirect3DCubeTexture9's */
DWORD VolumeTextureFilterCaps; /* D3DPTFILTERCAPS for IDirect3DVolumeTexture9's */
DWORD TextureAddressCaps; /* D3DPTADDRESSCAPS for IDirect3DTexture9's */
DWORD VolumeTextureAddressCaps; /* D3DPTADDRESSCAPS for IDirect3DVolumeTexture9's */
DWORD LineCaps; // D3DLINECAPS
DWORD LineCaps; /* D3DLINECAPS */
DWORD MaxTextureWidth, MaxTextureHeight;
DWORD MaxVolumeExtent;
@ -183,51 +183,49 @@ typedef struct _D3DCAPS9
float MaxPointSize;
DWORD MaxPrimitiveCount; // max number of primitives per DrawPrimitive call
DWORD MaxPrimitiveCount; /* max number of primitives per DrawPrimitive call */
DWORD MaxVertexIndex;
DWORD MaxStreams;
DWORD MaxStreamStride; // max stride for SetStreamSource
DWORD MaxStreamStride; /* max stride for SetStreamSource */
DWORD VertexShaderVersion;
DWORD MaxVertexShaderConst; // number of vertex shader constant registers
DWORD MaxVertexShaderConst; /* number of vertex shader constant registers */
DWORD PixelShaderVersion;
float PixelShader1xMaxValue; // max value storable in registers of ps.1.x shaders
float PixelShader1xMaxValue; /* max value storable in registers of ps.1.x shaders */
// Here are the DX9 specific ones
/* Here are the DX9 specific ones */
DWORD DevCaps2;
float MaxNpatchTessellationLevel;
DWORD Reserved5;
UINT MasterAdapterOrdinal; // ordinal of master adaptor for adapter group
UINT AdapterOrdinalInGroup; // ordinal inside the adapter group
UINT NumberOfAdaptersInGroup; // number of adapters in this adapter group (only if master)
DWORD DeclTypes; // Data types, supported in vertex declarations
DWORD NumSimultaneousRTs; // Will be at least 1
DWORD StretchRectFilterCaps; // Filter caps supported by StretchRect
UINT MasterAdapterOrdinal; /* ordinal of master adaptor for adapter group */
UINT AdapterOrdinalInGroup; /* ordinal inside the adapter group */
UINT NumberOfAdaptersInGroup; /* number of adapters in this adapter group (only if master) */
DWORD DeclTypes; /* Data types, supported in vertex declarations */
DWORD NumSimultaneousRTs; /* Will be at least 1 */
DWORD StretchRectFilterCaps; /* Filter caps supported by StretchRect */
D3DVSHADERCAPS2_0 VS20Caps;
D3DPSHADERCAPS2_0 PS20Caps;
DWORD VertexTextureFilterCaps; // D3DPTFILTERCAPS for IDirect3DTexture9's for texture, used in vertex shaders
DWORD MaxVShaderInstructionsExecuted; // maximum number of vertex shader instructions that can be executed
DWORD MaxPShaderInstructionsExecuted; // maximum number of pixel shader instructions that can be executed
DWORD VertexTextureFilterCaps; /* D3DPTFILTERCAPS for IDirect3DTexture9's for texture, used in vertex shaders */
DWORD MaxVShaderInstructionsExecuted; /* maximum number of vertex shader instructions that can be executed */
DWORD MaxPShaderInstructionsExecuted; /* maximum number of pixel shader instructions that can be executed */
DWORD MaxVertexShader30InstructionSlots;
DWORD MaxPixelShader30InstructionSlots;
} D3DCAPS9;
//
// BIT DEFINES FOR D3DCAPS9 DWORD MEMBERS
//
/*
* BIT DEFINES FOR D3DCAPS9 DWORD MEMBERS
*/
//
// Caps
//
/*
* Caps
*/
#define D3DCAPS_OVERLAY 0x00000800L
#define D3DCAPS_READ_SCANLINE 0x00020000L
//
// Caps2
//
/* Caps2 */
#define D3DCAPS2_FULLSCREENGAMMA 0x00020000L
#define D3DCAPS2_CANCALIBRATEGAMMA 0x00100000L
#define D3DCAPS2_RESERVED 0x02000000L
@ -240,21 +238,21 @@ typedef struct _D3DCAPS9
#define D3DCAPS2_CANSHARERESOURCE 0x80000000L
#endif // !D3D_DISABLE_9EX
#endif /* !D3D_DISABLE_9EX */
/* -- D3D9Ex only */
//
// Caps3
//
/* Caps3 */
#define D3DCAPS3_RESERVED 0x8000001fL
// Indicates that the device can respect the ALPHABLENDENABLE render state
// when fullscreen while using the FLIP or DISCARD swap effect.
// COPY and COPYVSYNC swap effects work whether or not this flag is set.
/* Indicates that the device can respect the ALPHABLENDENABLE render state
* when fullscreen while using the FLIP or DISCARD swap effect.
* COPY and COPYVSYNC swap effects work whether or not this flag is set.
*/
#define D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD 0x00000020L
// Indicates that the device can perform a gamma correction from
// a windowed back buffer containing linear content to the sRGB desktop.
/* Indicates that the device can perform a gamma correction from
* a windowed back buffer containing linear content to the sRGB desktop.
*/
#define D3DCAPS3_LINEAR_TO_SRGB_PRESENTATION 0x00000080L
#define D3DCAPS3_COPY_TO_VIDMEM 0x00000100L /* Device can acclerate copies from sysmem to local vidmem */
@ -262,10 +260,7 @@ typedef struct _D3DCAPS9
#define D3DCAPS3_DXVAHD 0x00000400L
#define D3DCAPS3_DXVAHD_LIMITED 0x00000800L
//
// PresentationIntervals
//
/* PresentationIntervals */
#define D3DPRESENT_INTERVAL_DEFAULT 0x00000000L
#define D3DPRESENT_INTERVAL_ONE 0x00000001L
#define D3DPRESENT_INTERVAL_TWO 0x00000002L
@ -273,17 +268,13 @@ typedef struct _D3DCAPS9
#define D3DPRESENT_INTERVAL_FOUR 0x00000008L
#define D3DPRESENT_INTERVAL_IMMEDIATE 0x80000000L
//
// CursorCaps
//
// Driver supports HW color cursor in at least hi-res modes(height >=400)
/* CursorCaps */
/* Driver supports HW color cursor in at least hi-res modes(height >=400) */
#define D3DCURSORCAPS_COLOR 0x00000001L
// Driver supports HW cursor also in low-res modes(height < 400)
/* Driver supports HW cursor also in low-res modes(height < 400) */
#define D3DCURSORCAPS_LOWRES 0x00000002L
//
// DevCaps
//
/* DevCaps */
#define D3DDEVCAPS_EXECUTESYSTEMMEMORY 0x00000010L /* Device can use execute buffers from system memory */
#define D3DDEVCAPS_EXECUTEVIDEOMEMORY 0x00000020L /* Device can use execute buffers from video memory */
#define D3DDEVCAPS_TLVERTEXSYSTEMMEMORY 0x00000040L /* Device can use TL buffers from system memory */
@ -305,9 +296,9 @@ typedef struct _D3DCAPS9
#define D3DDEVCAPS_RTPATCHHANDLEZERO 0x00800000L /* Indicates that RT Patches may be drawn efficiently using handle 0 */
#define D3DDEVCAPS_NPATCHES 0x01000000L /* Device supports N-Patches */
//
// PrimitiveMiscCaps
//
/*
* PrimitiveMiscCaps
*/
#define D3DPMISCCAPS_MASKZ 0x00000002L
#define D3DPMISCCAPS_CULLNONE 0x00000010L
#define D3DPMISCCAPS_CULLCW 0x00000020L
@ -332,13 +323,13 @@ typedef struct _D3DCAPS9
#define D3DPMISCCAPS_POSTBLENDSRGBCONVERT 0x00200000L /* Indicates device can perform conversion to sRGB after blending. */
#endif // !D3D_DISABLE_9EX
#endif /* !D3D_DISABLE_9EX */
/* -- D3D9Ex only */
//
// LineCaps
//
/*
* LineCaps
*/
#define D3DLINECAPS_TEXTURE 0x00000001L
#define D3DLINECAPS_ZTEST 0x00000002L
#define D3DLINECAPS_BLEND 0x00000004L
@ -346,9 +337,9 @@ typedef struct _D3DCAPS9
#define D3DLINECAPS_FOG 0x00000010L
#define D3DLINECAPS_ANTIALIAS 0x00000020L
//
// RasterCaps
//
/*
* RasterCaps
*/
#define D3DPRASTERCAPS_DITHER 0x00000001L
#define D3DPRASTERCAPS_ZTEST 0x00000010L
#define D3DPRASTERCAPS_FOGVERTEX 0x00000080L
@ -366,9 +357,9 @@ typedef struct _D3DCAPS9
#define D3DPRASTERCAPS_DEPTHBIAS 0x04000000L
#define D3DPRASTERCAPS_MULTISAMPLE_TOGGLE 0x08000000L
//
// ZCmpCaps, AlphaCmpCaps
//
/*
* ZCmpCaps, AlphaCmpCaps
*/
#define D3DPCMPCAPS_NEVER 0x00000001L
#define D3DPCMPCAPS_LESS 0x00000002L
#define D3DPCMPCAPS_EQUAL 0x00000004L
@ -378,9 +369,9 @@ typedef struct _D3DCAPS9
#define D3DPCMPCAPS_GREATEREQUAL 0x00000040L
#define D3DPCMPCAPS_ALWAYS 0x00000080L
//
// SourceBlendCaps, DestBlendCaps
//
/*
* SourceBlendCaps, DestBlendCaps
*/
#define D3DPBLENDCAPS_ZERO 0x00000001L
#define D3DPBLENDCAPS_ONE 0x00000002L
#define D3DPBLENDCAPS_SRCCOLOR 0x00000004L
@ -402,31 +393,32 @@ typedef struct _D3DCAPS9
#define D3DPBLENDCAPS_SRCCOLOR2 0x00004000L
#define D3DPBLENDCAPS_INVSRCCOLOR2 0x00008000L
#endif // !D3D_DISABLE_9EX
#endif /* !D3D_DISABLE_9EX */
/* -- D3D9Ex only */
//
// ShadeCaps
//
/*
* ShadeCaps
*/
#define D3DPSHADECAPS_COLORGOURAUDRGB 0x00000008L
#define D3DPSHADECAPS_SPECULARGOURAUDRGB 0x00000200L
#define D3DPSHADECAPS_ALPHAGOURAUDBLEND 0x00004000L
#define D3DPSHADECAPS_FOGGOURAUD 0x00080000L
//
// TextureCaps
//
/*
* TextureCaps
*/
#define D3DPTEXTURECAPS_PERSPECTIVE 0x00000001L /* Perspective-correct texturing is supported */
#define D3DPTEXTURECAPS_POW2 0x00000002L /* Power-of-2 texture dimensions are required - applies to non-Cube/Volume textures only. */
#define D3DPTEXTURECAPS_ALPHA 0x00000004L /* Alpha in texture pixels is supported */
#define D3DPTEXTURECAPS_SQUAREONLY 0x00000020L /* Only square textures are supported */
#define D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE 0x00000040L /* Texture indices are not scaled by the texture size prior to interpolation */
#define D3DPTEXTURECAPS_ALPHAPALETTE 0x00000080L /* Device can draw alpha from texture palettes */
// Device can use non-POW2 textures if:
// 1) D3DTEXTURE_ADDRESS is set to CLAMP for this texture's stage
// 2) D3DRS_WRAP(N) is zero for this texture's coordinates
// 3) mip mapping is not enabled (use magnification filter only)
/* Device can use non-POW2 textures if:
* 1) D3DTEXTURE_ADDRESS is set to CLAMP for this texture's stage
* 2) D3DRS_WRAP(N) is zero for this texture's coordinates
* 3) mip mapping is not enabled (use magnification filter only)
*/
#define D3DPTEXTURECAPS_NONPOW2CONDITIONAL 0x00000100L
#define D3DPTEXTURECAPS_PROJECTED 0x00000400L /* Device can do D3DTTFF_PROJECTED */
#define D3DPTEXTURECAPS_CUBEMAP 0x00000800L /* Device can do cubemap textures */
@ -439,9 +431,9 @@ typedef struct _D3DCAPS9
#define D3DPTEXTURECAPS_NOPROJECTEDBUMPENV 0x00200000L /* Device does not support projected bump env lookup operation
in programmable and fixed function pixel shaders */
//
// TextureFilterCaps, StretchRectFilterCaps
//
/*
* TextureFilterCaps, StretchRectFilterCaps
*/
#define D3DPTFILTERCAPS_MINFPOINT 0x00000100L /* Min Filter */
#define D3DPTFILTERCAPS_MINFLINEAR 0x00000200L
#define D3DPTFILTERCAPS_MINFANISOTROPIC 0x00000400L
@ -455,7 +447,7 @@ typedef struct _D3DCAPS9
#define D3DPTFILTERCAPS_CONVOLUTIONMONO 0x00040000L /* Min and Mag for the convolution mono filter */
#endif // !D3D_DISABLE_9EX
#endif /* !D3D_DISABLE_9EX */
/* -- D3D9Ex only */
#define D3DPTFILTERCAPS_MAGFPOINT 0x01000000L /* Mag Filter */
@ -464,9 +456,9 @@ typedef struct _D3DCAPS9
#define D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD 0x08000000L
#define D3DPTFILTERCAPS_MAGFGAUSSIANQUAD 0x10000000L
//
// TextureAddressCaps
//
/*
* TextureAddressCaps
*/
#define D3DPTADDRESSCAPS_WRAP 0x00000001L
#define D3DPTADDRESSCAPS_MIRROR 0x00000002L
#define D3DPTADDRESSCAPS_CLAMP 0x00000004L
@ -474,9 +466,9 @@ typedef struct _D3DCAPS9
#define D3DPTADDRESSCAPS_INDEPENDENTUV 0x00000010L
#define D3DPTADDRESSCAPS_MIRRORONCE 0x00000020L
//
// StencilCaps
//
/*
* StencilCaps
*/
#define D3DSTENCILCAPS_KEEP 0x00000001L
#define D3DSTENCILCAPS_ZERO 0x00000002L
#define D3DSTENCILCAPS_REPLACE 0x00000004L
@ -487,9 +479,9 @@ typedef struct _D3DCAPS9
#define D3DSTENCILCAPS_DECR 0x00000080L
#define D3DSTENCILCAPS_TWOSIDED 0x00000100L
//
// TextureOpCaps
//
/*
* TextureOpCaps
*/
#define D3DTEXOPCAPS_DISABLE 0x00000001L
#define D3DTEXOPCAPS_SELECTARG1 0x00000002L
#define D3DTEXOPCAPS_SELECTARG2 0x00000004L
@ -517,16 +509,16 @@ typedef struct _D3DCAPS9
#define D3DTEXOPCAPS_MULTIPLYADD 0x01000000L
#define D3DTEXOPCAPS_LERP 0x02000000L
//
// FVFCaps
//
/*
* FVFCaps
*/
#define D3DFVFCAPS_TEXCOORDCOUNTMASK 0x0000ffffL /* mask for texture coordinate count field */
#define D3DFVFCAPS_DONOTSTRIPELEMENTS 0x00080000L /* Device prefers that vertex elements not be stripped */
#define D3DFVFCAPS_PSIZE 0x00100000L /* Device can receive point size */
//
// VertexProcessingCaps
//
/*
* VertexProcessingCaps
*/
#define D3DVTXPCAPS_TEXGEN 0x00000001L /* device can do texgen */
#define D3DVTXPCAPS_MATERIALSOURCE7 0x00000002L /* device can do DX7-level colormaterialsource ops */
#define D3DVTXPCAPS_DIRECTIONALLIGHTS 0x00000008L /* device can do directional lights */
@ -537,9 +529,9 @@ typedef struct _D3DCAPS9
#define D3DVTXPCAPS_NO_TEXGEN_NONLOCALVIEWER 0x00000200L /* device does not support TexGen in non-local
viewer mode */
//
// DevCaps2
//
/*
* DevCaps2
*/
#define D3DDEVCAPS2_STREAMOFFSET 0x00000001L /* Device supports offsets in streams. Must be set by DX9 drivers */
#define D3DDEVCAPS2_DMAPNPATCH 0x00000002L /* Device supports displacement maps for N-Patches*/
#define D3DDEVCAPS2_ADAPTIVETESSRTPATCH 0x00000004L /* Device supports adaptive tesselation of RT-patches*/
@ -548,9 +540,9 @@ typedef struct _D3DCAPS9
#define D3DDEVCAPS2_PRESAMPLEDDMAPNPATCH 0x00000020L /* Device supports presampled displacement maps for N-Patches */
#define D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET 0x00000040L /* Vertex elements in a vertex declaration can share the same stream offset */
//
// DeclTypes
//
/*
* DeclTypes
*/
#define D3DDTCAPS_UBYTE4 0x00000001L
#define D3DDTCAPS_UBYTE4N 0x00000002L
#define D3DDTCAPS_SHORT2N 0x00000004L

41
gfx/include/d3d9types.h
View File

@ -565,25 +565,25 @@ typedef enum _D3DTEXTUREOP
D3DTOP_MODULATE4X = 6, /* multiply and 2 bits */
/* Add */
D3DTOP_ADD = 7, // add arguments together
D3DTOP_ADDSIGNED = 8, // add with -0.5 bias
D3DTOP_ADDSIGNED2X = 9, // as above but left 1 bit
D3DTOP_SUBTRACT = 10, // Arg1 - Arg2, with no saturation
D3DTOP_ADDSMOOTH = 11, // add 2 args, subtract product
// Arg1 + Arg2 - Arg1*Arg2
// = Arg1 + (1-Arg1)*Arg2
D3DTOP_ADD = 7, /* add arguments together */
D3DTOP_ADDSIGNED = 8, /* add with -0.5 bias */
D3DTOP_ADDSIGNED2X = 9, /* as above but left 1 bit */
D3DTOP_SUBTRACT = 10, /* Arg1 - Arg2, with no saturation */
D3DTOP_ADDSMOOTH = 11, /* add 2 args, subtract product */
/* Arg1 + Arg2 - Arg1*Arg2 */
/* = Arg1 + (1-Arg1)*Arg2 */
// Linear alpha blend: Arg1*(Alpha) + Arg2*(1-Alpha)
D3DTOP_BLENDDIFFUSEALPHA = 12, // iterated alpha
D3DTOP_BLENDTEXTUREALPHA = 13, // texture alpha
D3DTOP_BLENDFACTORALPHA = 14, // alpha from D3DRS_TEXTUREFACTOR
/* Linear alpha blend: Arg1*(Alpha) + Arg2*(1-Alpha) */
D3DTOP_BLENDDIFFUSEALPHA = 12, /* iterated alpha */
D3DTOP_BLENDTEXTUREALPHA = 13, /* texture alpha */
D3DTOP_BLENDFACTORALPHA = 14, /* alpha from D3DRS_TEXTUREFACTOR */
// Linear alpha blend with pre-multiplied arg1 input: Arg1 + Arg2*(1-Alpha)
D3DTOP_BLENDTEXTUREALPHAPM = 15, // texture alpha
D3DTOP_BLENDCURRENTALPHA = 16, // by alpha of current color
/* Linear alpha blend with pre-multiplied arg1 input: Arg1 + Arg2*(1-Alpha) */
D3DTOP_BLENDTEXTUREALPHAPM = 15, /* texture alpha */
D3DTOP_BLENDCURRENTALPHA = 16, /* by alpha of current color */
// Specular mapping
D3DTOP_PREMODULATE = 17, // modulate with next texture before use
/* Specular mapping */
D3DTOP_PREMODULATE = 17, /* modulate with next texture before use */
D3DTOP_MODULATEALPHA_ADDCOLOR = 18, // Arg1.RGB + Arg1.A*Arg2.RGB
// COLOROP only
D3DTOP_MODULATECOLOR_ADDALPHA = 19, // Arg1.RGB*Arg2.RGB + Arg1.A
@ -1601,10 +1601,11 @@ typedef enum _D3DRESOURCETYPE {
#endif /* !D3D_DISABLE_9EX */
/* -- D3D9Ex only */
// When passed to CheckDeviceFormat, D3DUSAGE_AUTOGENMIPMAP may return
// D3DOK_NOAUTOGEN if the device doesn't support autogeneration for that format.
// D3DOK_NOAUTOGEN is a success code, not a failure code... the SUCCEEDED and FAILED macros
// will return true and false respectively for this code.
/* When passed to CheckDeviceFormat, D3DUSAGE_AUTOGENMIPMAP may return
* D3DOK_NOAUTOGEN if the device doesn't support autogeneration for that format.
* D3DOK_NOAUTOGEN is a success code, not a failure code... the SUCCEEDED and FAILED macros
* will return true and false respectively for this code.
*/
#define D3DUSAGE_AUTOGENMIPMAP (0x00000400L)
#define D3DUSAGE_DMAP (0x00004000L)

4
gfx/video_driver.c
View File

@ -46,10 +46,6 @@
#include "../menu/menu_setting.h"
#endif
#ifdef HAVE_OPENGL
#include "common/gl_common.h"
#endif
#include "video_thread_wrapper.h"
#include "video_driver.h"

61
gfx/video_driver.h
View File

@ -838,60 +838,77 @@ typedef struct d3d_renderchain_driver
typedef struct gl_renderchain_driver
{
void (*set_coords)(void *handle_data,
void *chain_data,
void *shader_data, const struct video_coords *coords);
void (*set_mvp)(void *data, void *shader_data,
void (*set_mvp)(void *data,
void *chain_data,
void *shader_data,
const void *mat_data);
void (*init_texture_reference)(
void *data, unsigned i,
void *data, void *chain_data, unsigned i,
unsigned internal_fmt, unsigned texture_fmt,
unsigned texture_type);
void (*fence_iterate)(void *data, unsigned hard_sync_frames);
void (*fence_free)(void *data);
void (*fence_iterate)(void *data, void *chain_data,
unsigned hard_sync_frames);
void (*fence_free)(void *data, void *chain_data);
void (*readback)(void *data,
void *chain_data,
unsigned alignment,
unsigned fmt, unsigned type,
void *src);
void (*init_pbo)(unsigned size, const void *data);
void (*bind_pbo)(unsigned idx);
void (*unbind_pbo)(void);
void (*unbind_pbo)(void *data, void *chain_data);
void (*copy_frame)(
void *data,
void *chain_data,
video_frame_info_t *video_info,
const void *frame,
unsigned width, unsigned height, unsigned pitch);
void (*restore_default_state)(void *data);
void (*new_vao)(void *data);
void (*free_vao)(void *data);
void (*bind_vao)(void *data);
void (*unbind_vao)(void *data);
void (*disable_client_arrays)(void);
void (*restore_default_state)(void *data, void *chain_data);
void (*new_vao)(void *data, void *chain_data);
void (*free_vao)(void *data, void *chain_data);
void (*bind_vao)(void *data, void *chain_data);
void (*unbind_vao)(void *data, void *chain_data);
void (*disable_client_arrays)(void *data, void *chain_data);
void (*ff_vertex)(const void *data);
void (*ff_matrix)(const void *data);
void (*bind_backbuffer)(void);
void (*deinit_fbo)(void *data);
void (*bind_backbuffer)(void *data, void *chain_data);
void (*deinit_fbo)(void *data, void *chain_data);
void (*viewport_info)(
void *data, struct video_viewport *vp);
void *data, void *chain_data, struct video_viewport *vp);
bool (*read_viewport)(
void *data, uint8_t *buffer, bool is_idle);
void *data, void *chain_data, uint8_t *buffer, bool is_idle);
void (*bind_prev_texture)(
void *data,
void *chain_data,
const struct video_tex_info *tex_info);
void (*chain_free)(void *data);
void (*chain_free)(void *data, void *chain_data);
void *(*chain_new)(void);
void (*init)(void *data, unsigned fbo_width, unsigned fbo_height);
bool (*init_hw_render)(void *data, unsigned width, unsigned height);
void (*free)(void *data);
void (*deinit_hw_render)(void *data);
void (*start_render)(void *data, video_frame_info_t *video_info);
void (*check_fbo_dimensions)(void *data);
void (*init)(void *data, void *chain_data,
unsigned fbo_width, unsigned fbo_height);
bool (*init_hw_render)(void *data, void *chain_data,
unsigned width, unsigned height);
void (*free)(void *data, void *chain_data);
void (*deinit_hw_render)(void *data, void *chain_data);
void (*start_render)(void *data, void *chain_data,
video_frame_info_t *video_info);
void (*check_fbo_dimensions)(void *data, void *chain_data);
void (*recompute_pass_sizes)(void *data,
void *chain_data,
unsigned width, unsigned height,
unsigned vp_width, unsigned vp_height);
void (*renderchain_render)(void *data,
void *chain_data,
video_frame_info_t *video_info,
uint64_t frame_count,
const struct video_tex_info *tex_info,
const struct video_tex_info *feedback_info);
void (*resolve_extensions)(
void *data,
void *chain_data,
const char *context_ident,
const video_info_t *video);
const char *ident;
} gl_renderchain_driver_t;

1
griffin/griffin.c
View File

@ -58,6 +58,7 @@ COMPATIBILITY
#endif
#include "../libretro-common/compat/compat_fnmatch.c"
#include "../libretro-common/compat/fopen_utf8.c"
#include "../libretro-common/memmap/memalign.c"
/*============================================================

9
input/connect/connect_nesusb.c
View File

@ -62,11 +62,12 @@ static void hidpad_nesusb_deinit(void *data)
static void hidpad_nesusb_get_buttons(void *data, retro_bits_t* state)
{
struct hidpad_nesusb_data *device = (struct hidpad_nesusb_data*)data;
if (device) {
RARCH_INPUT_STATE_COPY16_PTR(state, device->buttons);
} else {
RARCH_INPUT_STATE_CLEAR_PTR(state);
if (device)
{
BITS_COPY16_PTR(state, device->buttons);
}
else
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t hidpad_nesusb_get_axis(void *data, unsigned axis)

9
input/connect/connect_ps2adapter.c
View File

@ -62,11 +62,12 @@ static void hidpad_ps2adapter_deinit(void *data)
static void hidpad_ps2adapter_get_buttons(void *data, retro_bits_t *state)
{
struct hidpad_ps2adapter_data *device = (struct hidpad_ps2adapter_data*)data;
if ( device ) {
RARCH_INPUT_STATE_COPY16_PTR(state, device->buttons);
} else {
RARCH_INPUT_STATE_CLEAR_PTR(state);
if (device)
{
BITS_COPY16_PTR(state, device->buttons);
}
else
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t hidpad_ps2adapter_get_axis(void *data, unsigned axis)

11
input/connect/connect_ps3.c
View File

@ -111,17 +111,14 @@ static void hidpad_ps3_get_buttons(void *data, retro_bits_t *state)
if ( device )
{
/*copy first 16 bits - standard RetroPad controls*/
RARCH_INPUT_STATE_COPY16_PTR(state, device->buttons);
BITS_COPY16_PTR(state, device->buttons);
/*PS button?*/
if ( device->buttons & 0x10000 ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RARCH_MENU_TOGGLE );
}
if (device->buttons & 0x10000)
BIT256_SET_PTR(state, RARCH_MENU_TOGGLE);
}
else
{
RARCH_INPUT_STATE_CLEAR_PTR( state );
}
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t hidpad_ps3_get_axis(void *data, unsigned axis)

91
input/connect/connect_ps4.c
View File

@ -20,6 +20,7 @@
#include <boolean.h>
#include <retro_environment.h>
#include <retro_miscellaneous.h>
#include "joypad_connection.h"
#include "../input_defines.h"
@ -187,64 +188,48 @@ static bool hidpad_ps4_check_dpad(struct ps4 *rpt, unsigned id)
static void hidpad_ps4_get_buttons(void *data, retro_bits_t* state)
{
struct hidpad_ps4_data *device = (struct hidpad_ps4_data*)data;
struct ps4 *rpt = device ? (struct ps4*)&device->data : NULL;
struct ps4 *rpt = device ?
(struct ps4*)&device->data : NULL;
if (!device || !rpt)
return;
RARCH_INPUT_STATE_CLEAR_PTR( state );
BIT256_CLEAR_ALL_PTR( state );
if ( rpt->btn.r3 ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_R3 );
}
if ( rpt->btn.l3 ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_L3 );
}
if ( rpt->btn.options ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_START );
}
if ( rpt->btn.share ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_SELECT );
}
if ( rpt->btn.r2 ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_R2 );
}
if ( rpt->btn.l2 ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_L2 );
}
if ( rpt->btn.r1 ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_R );
}
if ( rpt->btn.l1 ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_L );
}
if ( rpt->btn.triangle ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_X );
}
if ( rpt->btn.circle ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_A );
}
if ( rpt->btn.cross ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_B );
}
if ( rpt->btn.square ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_Y );
}
if ( (hidpad_ps4_check_dpad(rpt, RETRO_DEVICE_ID_JOYPAD_LEFT)) ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_LEFT );
}
if ( (hidpad_ps4_check_dpad(rpt, RETRO_DEVICE_ID_JOYPAD_DOWN)) ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_DOWN );
}
if ( (hidpad_ps4_check_dpad(rpt, RETRO_DEVICE_ID_JOYPAD_RIGHT)) ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_RIGHT );
}
if ( (hidpad_ps4_check_dpad(rpt, RETRO_DEVICE_ID_JOYPAD_UP)) ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_UP );
}
if ( rpt->btn.ps ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RARCH_MENU_TOGGLE );
}
if (rpt->btn.r3)
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_R3 );
if (rpt->btn.l3)
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_L3 );
if (rpt->btn.options)
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_START );
if ( rpt->btn.share)
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_SELECT );
if ( rpt->btn.r2)
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_R2 );
if (rpt->btn.l2)
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_L2 );
if (rpt->btn.r1)
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_R );
if (rpt->btn.l1)
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_L );
if (rpt->btn.triangle)
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_X );
if (rpt->btn.circle)
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_A );
if (rpt->btn.cross)
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_B );
if (rpt->btn.square)
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_Y );
if ((hidpad_ps4_check_dpad(rpt, RETRO_DEVICE_ID_JOYPAD_LEFT)))
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_LEFT );
if ((hidpad_ps4_check_dpad(rpt, RETRO_DEVICE_ID_JOYPAD_DOWN)))
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_DOWN );
if ((hidpad_ps4_check_dpad(rpt, RETRO_DEVICE_ID_JOYPAD_RIGHT)))
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_RIGHT );
if ((hidpad_ps4_check_dpad(rpt, RETRO_DEVICE_ID_JOYPAD_UP)))
BIT256_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_UP );
if (rpt->btn.ps)
BIT256_SET_PTR( state, RARCH_MENU_TOGGLE );
}
static int16_t hidpad_ps4_get_axis(void *data, unsigned axis)

9
input/connect/connect_psxadapter.c
View File

@ -62,11 +62,12 @@ static void hidpad_psxadapter_deinit(void *data)
static void hidpad_psxadapter_get_buttons(void *data, retro_bits_t *state)
{
struct hidpad_psxadapter_data *device = (struct hidpad_psxadapter_data*)data;
if ( device ) {
RARCH_INPUT_STATE_COPY16_PTR(state, device->buttons);
} else {
RARCH_INPUT_STATE_CLEAR_PTR(state);
if (device)
{
BITS_COPY16_PTR(state, device->buttons);
}
else
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t hidpad_psxadapter_get_axis(void *data, unsigned axis)

9
input/connect/connect_snesusb.c
View File

@ -63,11 +63,12 @@ static void hidpad_snesusb_deinit(void *data)
static void hidpad_snesusb_get_buttons(void *data, retro_bits_t *state)
{
struct hidpad_snesusb_data *device = (struct hidpad_snesusb_data*)data;
if ( device ) {
RARCH_INPUT_STATE_COPY16_PTR(state, device->buttons);
} else {
RARCH_INPUT_STATE_CLEAR_PTR(state);
if (device)
{
BITS_COPY16_PTR(state, device->buttons);
}
else
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t hidpad_snesusb_get_axis(void *data, unsigned axis)

6
input/connect/connect_wii.c
View File

@ -677,9 +677,9 @@ static void hidpad_wii_get_buttons(void *data, retro_bits_t *state)
struct connect_wii_wiimote_t* device = (struct connect_wii_wiimote_t*)data;
if ( device )
{
uint32_t b;
b = device->btns | (device->exp.cc.classic.btns << 16); /*broken? this doesn't match retropad!!*/
RARCH_INPUT_STATE_COPY32_PTR(state, b);
/* TODO/FIXME - Broken? this doesn't match retropad! */
uint32_t b = device->btns | (device->exp.cc.classic.btns << 16);
BITS_COPY32_PTR(state, b);
}
}

9
input/connect/connect_wiiugca.c
View File

@ -66,11 +66,12 @@ static void hidpad_wiiugca_deinit(void *data)
static void hidpad_wiiugca_get_buttons(void *data, retro_bits_t *state)
{
struct hidpad_wiiugca_data *device = (struct hidpad_wiiugca_data*)data;
if ( device ) {
RARCH_INPUT_STATE_COPY16_PTR(state, device->buttons);
} else {
RARCH_INPUT_STATE_CLEAR_PTR(state);
if (device)
{
BITS_COPY16_PTR(state, device->buttons);
}
else
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t hidpad_wiiugca_get_axis(void *data, unsigned axis)

90
input/connect/connect_wiiupro.c
View File

@ -121,64 +121,48 @@ static void hidpad_wiiupro_deinit(void *data)
static void hidpad_wiiupro_get_buttons(void *data, retro_bits_t *state)
{
struct hidpad_wiiupro_data *device = (struct hidpad_wiiupro_data*)data;
struct wiiupro *rpt = device ? (struct wiiupro*)&device->data : NULL;
struct wiiupro *rpt = device ?
(struct wiiupro*)&device->data : NULL;
if (!device || !rpt)
return;
RARCH_INPUT_STATE_CLEAR_PTR( state );
BIT256_CLEAR_ALL_PTR(state);
if ( rpt->btn.r3 ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_R3 );
}
if ( rpt->btn.l3 ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_L3 );
}
if ( rpt->btn.plus ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_START );
}
if ( rpt->btn.minus ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_SELECT );
}
if ( rpt->btn.zr ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_R2 );
}
if ( rpt->btn.zl ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_L2 );
}
if ( rpt->btn.r ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_R );
}
if ( rpt->btn.l ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_L );
}
if ( rpt->btn.x ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_X );
}
if ( rpt->btn.a ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_A );
}
if ( rpt->btn.b ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_B );
}
if ( rpt->btn.y ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_Y );
}
if ( rpt->btn.left ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_LEFT );
}
if ( rpt->btn.down ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_DOWN );
}
if ( rpt->btn.right ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_RIGHT );
}
if ( rpt->btn.up ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RETRO_DEVICE_ID_JOYPAD_UP );
}
if ( rpt->btn.home ) {
RARCH_INPUT_STATE_BIT_SET_PTR( state, RARCH_MENU_TOGGLE );
}
if (rpt->btn.r3)
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_R3);
if (rpt->btn.l3)
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_L3);
if (rpt->btn.plus)
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_START);
if ( rpt->btn.minus)
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_SELECT);
if ( rpt->btn.zr)
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_R2);
if ( rpt->btn.zl)
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_L2);
if ( rpt->btn.r)
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_R);
if ( rpt->btn.l)
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_L);
if ( rpt->btn.x)
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_X);
if ( rpt->btn.a)
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_A);
if ( rpt->btn.b)
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_B);
if ( rpt->btn.y)
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_Y);
if ( rpt->btn.left)
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_LEFT);
if ( rpt->btn.down)
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_DOWN);
if ( rpt->btn.right)
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_RIGHT);
if ( rpt->btn.up)
BIT256_SET_PTR(state, RETRO_DEVICE_ID_JOYPAD_UP);
if ( rpt->btn.home)
BIT256_SET_PTR(state, RARCH_MENU_TOGGLE);
}
static int16_t hidpad_wiiupro_get_axis(void *data, unsigned axis)

7
input/connect/joypad_connection.c
View File

@ -175,11 +175,10 @@ void pad_connection_packet(joypad_connection_t *joyconn, uint32_t pad,
void pad_connection_get_buttons(joypad_connection_t *joyconn, unsigned pad, retro_bits_t* state)
{
if (joyconn->iface) {
if (joyconn->iface)
joyconn->iface->get_buttons(joyconn->data, state);
} else {
RARCH_INPUT_STATE_CLEAR_PTR( state );
}
else
BIT256_CLEAR_ALL_PTR( state );
}
int16_t pad_connection_get_axis(joypad_connection_t *joyconn,

7
input/drivers/cocoa_input.c
View File

@ -17,14 +17,17 @@
#include <stdint.h>
#include <unistd.h>
#include <retro_miscellaneous.h>
#ifdef HAVE_CONFIG_H
#include "../../config.h"
#endif
#include "../input_driver.h"
#include "../input_keymaps.h"
#include "cocoa_input.h"
#include "../../gfx/video_driver.h"
#include "../../driver.h"
@ -56,7 +59,7 @@ static int cocoa_input_find_any_button_ret(cocoa_input_data_t *apple,
if (state)
for (i = 0; i < 256; i++)
if (RARCH_INPUT_STATE_BIT_GET_PTR(state,i))
if (BIT256_GET_PTR(state,i))
return i;
return -1;
}

4
input/drivers/wiiu_input.c
View File

@ -107,8 +107,8 @@ static int16_t wiiu_pointer_device_state(wiiu_input_t* wiiu, unsigned id)
case RETRO_DEVICE_ID_POINTER_PRESSED:
{
retro_bits_t state;
wiiu->joypad->get_buttons(0,&state);
return RARCH_INPUT_STATE_BIT_GET(state, VPAD_BUTTON_TOUCH) ? 1 : 0;
wiiu->joypad->get_buttons(0, &state);
return BIT256_GET(state, VPAD_BUTTON_TOUCH) ? 1 : 0;
}
case RETRO_DEVICE_ID_POINTER_X:
return wiiu->joypad->axis(0, 0xFFFF0004UL);

3
input/drivers/winraw_input.c
View File

@ -356,9 +356,8 @@ static bool winraw_keyboard_pressed(winraw_input_t *wr, unsigned key)
static bool winraw_mbutton_pressed(winraw_input_t *wr, unsigned port, unsigned key)
{
unsigned i;
bool result;
winraw_mouse_t *mouse = NULL;
settings_t *settings = config_get_ptr();
settings_t *settings = config_get_ptr();
if (port >= MAX_USERS)
return false;

5
input/drivers_hid/btstack_hid.c
View File

@ -27,6 +27,7 @@
#endif
#include <boolean.h>
#include <retro_miscellaneous.h>
#include <rthreads/rthreads.h>
#ifdef HAVE_DYNAMIC
#include <dynamic/dylib.h>
@ -1369,7 +1370,7 @@ static void btstack_hid_joypad_get_buttons(void *data, unsigned port, retro_bits
if (hid)
pad_connection_get_buttons(&hid->slots[port], port, state);
else
RARCH_INPUT_STATE_CLEAR_PTR(state);
BIT256_CLEAR_ALL_PTR(state);
}
static bool btstack_hid_joypad_button(void *data, unsigned port, uint16_t joykey)
@ -1383,7 +1384,7 @@ static bool btstack_hid_joypad_button(void *data, unsigned port, uint16_t joykey
/* Check the button. */
if ((port < MAX_USERS) && (joykey < 32))
return (RARCH_INPUT_STATE_BIT_GET(buttons, joykey) != 0);
return (BIT256_GET(buttons, joykey) != 0);
return false;
}

4
input/drivers_hid/iohidmanager_hid.c
View File

@ -114,7 +114,7 @@ static void iohidmanager_hid_joypad_get_buttons(void *data, unsigned port, retro
if (hid)
return pad_connection_get_buttons(&hid->slots[port], port, state);
else
RARCH_INPUT_STATE_CLEAR_PTR(state);
BIT256_CLEAR_ALL_PTR(state);
}
static bool iohidmanager_hid_joypad_button(void *data,
@ -150,7 +150,7 @@ static bool iohidmanager_hid_joypad_button(void *data,
/* Check the button. */
if ((port < MAX_USERS) && (joykey < 32))
return (RARCH_INPUT_STATE_BIT_GET(buttons, joykey) != 0)
return (BIT256_GET(buttons, joykey) != 0)
|| ((hid->buttons[port] & (1 << joykey)) != 0);
return false;

11
input/drivers_hid/libusb_hid.c
View File

@ -447,9 +447,12 @@ static void libusb_hid_joypad_get_buttons(void *data, unsigned port, retro_bits_
{
libusb_hid_t *hid = (libusb_hid_t*)data;
if (hid)
return pad_connection_get_buttons(&hid->slots[port], port, state);
else
RARCH_INPUT_STATE_CLEAR_PTR(state);
{
pad_connection_get_buttons(&hid->slots[port], port, state);
return;
}
BIT256_CLEAR_ALL_PTR(state);
}
static bool libusb_hid_joypad_button(void *data,
@ -464,7 +467,7 @@ static bool libusb_hid_joypad_button(void *data,
/* Check the button. */
if ((port < MAX_USERS) && (joykey < 32))
return (RARCH_INPUT_STATE_BIT_GET(buttons, joykey) != 0);
return (BIT256_GET(buttons, joykey) != 0);
return false;
}

2
input/drivers_hid/null_hid.c
View File

@ -43,7 +43,7 @@ static void null_hid_joypad_get_buttons(void *data, unsigned port, retro_bits_t
(void)data;
(void)port;
RARCH_INPUT_STATE_CLEAR_PTR(state);
BIT256_CLEAR_ALL_PTR(state);
}
static bool null_hid_joypad_button(void *data, unsigned port, uint16_t joykey)

10
input/drivers_hid/wiiusb_hid.c
View File

@ -482,9 +482,11 @@ static void wiiusb_hid_joypad_get_buttons(void *data, unsigned port, retro_bits_
{
wiiusb_hid_t *hid = (wiiusb_hid_t*)data;
if (hid)
return pad_connection_get_buttons(&hid->connections[port], port, state);
else
RARCH_INPUT_STATE_CLEAR_PTR(state);
{
pad_connection_get_buttons(&hid->connections[port], port, state);
return;
}
BIT256_CLEAR_ALL_PTR(state);
}
static bool wiiusb_hid_joypad_button(void *data, unsigned port, uint16_t joykey)
@ -499,7 +501,7 @@ static bool wiiusb_hid_joypad_button(void *data, unsigned port, uint16_t joykey)
/* Check the button. */
if ((port < MAX_USERS) && (joykey < 32))
return (RARCH_INPUT_STATE_BIT_GET(buttons, joykey) != 0);
return (BIT256_GET(buttons, joykey) != 0);
return false;
}

9
input/drivers_joypad/ctr_joypad.c
View File

@ -72,11 +72,12 @@ static bool ctr_joypad_button(unsigned port_num, uint16_t key)
static void ctr_joypad_get_buttons(unsigned port_num, retro_bits_t *state)
{
if ( port_num < MAX_PADS ) {
RARCH_INPUT_STATE_COPY16_PTR( state, pad_state );
} else {
RARCH_INPUT_STATE_CLEAR_PTR(state);
if ( port_num < MAX_PADS )
{
BITS_COPY16_PTR( state, pad_state );
}
else
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t ctr_joypad_axis(unsigned port_num, uint32_t joyaxis)

9
input/drivers_joypad/gx_joypad.c
View File

@ -164,11 +164,12 @@ static bool gx_joypad_button(unsigned port, uint16_t key)
static void gx_joypad_get_buttons(unsigned port, retro_bits_t *state)
{
if ( port < MAX_PADS ) {
RARCH_INPUT_STATE_COPY16_PTR( state, pad_state[port] );
} else {
RARCH_INPUT_STATE_CLEAR_PTR(state);
if (port < MAX_PADS)
{
BITS_COPY16_PTR( state, pad_state[port] );
}
else
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t gx_joypad_axis(unsigned port, uint32_t joyaxis)

7
input/drivers_joypad/hid_joypad.c
View File

@ -57,11 +57,10 @@ static bool hid_joypad_button(unsigned port, uint16_t joykey)
static void hid_joypad_get_buttons(unsigned port, retro_bits_t *state)
{
if (generic_hid && generic_hid->get_buttons) {
if (generic_hid && generic_hid->get_buttons)
generic_hid->get_buttons((void*)hid_driver_get_data(), port, state);
} else {
RARCH_INPUT_STATE_CLEAR_PTR( state );
}
else
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t hid_joypad_axis(unsigned port, uint32_t joyaxis)

9
input/drivers_joypad/linuxraw_joypad.c
View File

@ -329,11 +329,12 @@ static bool linuxraw_joypad_button(unsigned port, uint16_t joykey)
static void linuxraw_joypad_get_buttons(unsigned port, retro_bits_t *state)
{
const struct linuxraw_joypad *pad = (const struct linuxraw_joypad*)&linuxraw_pads[port];
if ( pad ) {
RARCH_INPUT_STATE_COPY16_PTR(state, pad->buttons);
} else {
RARCH_INPUT_STATE_CLEAR_PTR(state);
if (pad)
{
BITS_COPY16_PTR(state, pad->buttons);
}
else
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t linuxraw_joypad_axis(unsigned port, uint32_t joyaxis)

2
input/drivers_joypad/mfi_joypad.m
View File

@ -223,7 +223,7 @@ static bool apple_gamecontroller_joypad_button(unsigned port, uint16_t joykey)
static void apple_gamecontroller_joypad_get_buttons(unsigned port, retro_bits_t *state)
{
RARCH_INPUT_STATE_COPY16_PTR(state, mfi_buttons[port]);
BITS_COPY16_PTR(state, mfi_buttons[port]);
}
static int16_t apple_gamecontroller_joypad_axis(unsigned port, uint32_t joyaxis)

2
input/drivers_joypad/null_joypad.c
View File

@ -39,7 +39,7 @@ static bool null_joypad_button(unsigned port_num, uint16_t joykey)
static void null_joypad_get_buttons(unsigned port_num, retro_bits_t *state)
{
RARCH_INPUT_STATE_CLEAR_PTR( state );
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t null_joypad_axis(unsigned port_num, uint32_t joyaxis)

9
input/drivers_joypad/parport_joypad.c
View File

@ -343,11 +343,12 @@ static bool parport_joypad_button(unsigned port, uint16_t joykey)
static void parport_joypad_get_buttons(unsigned port, retro_bits_t *state)
{
const struct parport_joypad *pad = (const struct parport_joypad*)&parport_pads[port];
if ( pad ) {
RARCH_INPUT_STATE_COPY16_PTR(state, pad->buttons);
} else {
RARCH_INPUT_STATE_CLEAR_PTR(state);
if (pad)
{
BITS_COPY16_PTR(state, pad->buttons);
}
else
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t parport_joypad_axis(unsigned port, uint32_t joyaxis)

9
input/drivers_joypad/ps3_joypad.c
View File

@ -70,11 +70,12 @@ static bool ps3_joypad_button(unsigned port_num, uint16_t joykey)
static void ps3_joypad_get_buttons(unsigned port_num, retro_bits_t *state)
{
if ( port_num < MAX_PADS ) {
RARCH_INPUT_STATE_COPY16_PTR( state, pad_state[port_num] );
} else {
RARCH_INPUT_STATE_CLEAR_PTR(state);
if (port_num < MAX_PADS)
{
BITS_COPY16_PTR( state, pad_state[port_num] );
}
else
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t ps3_joypad_axis(unsigned port_num, uint32_t joyaxis)

9
input/drivers_joypad/psp_joypad.c
View File

@ -126,11 +126,12 @@ static bool psp_joypad_button(unsigned port_num, uint16_t key)
static void psp_joypad_get_buttons(unsigned port_num, retro_bits_t *state)
{
if ( port_num < PSP_MAX_PADS ) {
RARCH_INPUT_STATE_COPY16_PTR( state, pad_state[port_num] );
} else {
RARCH_INPUT_STATE_CLEAR_PTR(state);
if (port_num < PSP_MAX_PADS)
{
BITS_COPY16_PTR( state, pad_state[port_num] );
}
else
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t psp_joypad_axis(unsigned port_num, uint32_t joyaxis)

9
input/drivers_joypad/udev_joypad.c
View File

@ -607,11 +607,12 @@ static bool udev_joypad_button(unsigned port, uint16_t joykey)
static void udev_joypad_get_buttons(unsigned port, retro_bits_t *state)
{
const struct udev_joypad *pad = (const struct udev_joypad*)&udev_pads[port];
if ( pad ) {
RARCH_INPUT_STATE_COPY16_PTR( state, pad->buttons );
} else {
RARCH_INPUT_STATE_CLEAR_PTR(state);
if (pad)
{
BITS_COPY16_PTR( state, pad->buttons );
}
else
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t udev_joypad_axis(unsigned port, uint32_t joyaxis)

9
input/drivers_joypad/wiiu_joypad.c
View File

@ -137,11 +137,12 @@ static bool wiiu_joypad_button(unsigned port_num, uint16_t key)
static void wiiu_joypad_get_buttons(unsigned port_num, retro_bits_t *state)
{
if ( port_num < MAX_PADS ) {
RARCH_INPUT_STATE_COPY16_PTR( state, pad_state[port_num] );
} else {
RARCH_INPUT_STATE_CLEAR_PTR(state);
if (port_num < MAX_PADS)
{
BITS_COPY16_PTR( state, pad_state[port_num] );
}
else
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t wiiu_joypad_axis(unsigned port_num, uint32_t joyaxis)

9
input/drivers_joypad/xdk_joypad.c
View File

@ -78,11 +78,12 @@ static bool xdk_joypad_button(unsigned port_num, uint16_t joykey)
static void xdk_joypad_get_buttons(unsigned port_num, retro_bits_t *state)
{
if ( port_num < MAX_PADS ) {
RARCH_INPUT_STATE_COPY16_PTR( state, pad_state[port_num] );
} else {
RARCH_INPUT_STATE_CLEAR_PTR(state);
if (port_num < MAX_PADS)
{
BITS_COPY16_PTR( state, pad_state[port_num] );
}
else
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t xdk_joypad_axis(unsigned port_num, uint32_t joyaxis)

24
input/input_defines.h
View File

@ -158,30 +158,6 @@ enum analog_dpad_mode
#define GET_HAT_DIR(x) (x & HAT_MASK)
#define GET_HAT(x) (x & (~HAT_MASK))
#define RARCH_INPUT_STATE_BIT_SET(a,bit) ((a).data [((bit) >> 5)] |= (1 << ((bit) & 31)))
#define RARCH_INPUT_STATE_BIT_SET_PTR(a,bit) ((a)->data[((bit) >> 5)] |= (1 << ((bit) & 31)))
#define RARCH_INPUT_STATE_BIT_GET(a,bit) ((a).data [((bit) >> 5)] & (1 << ((bit) & 31)))
#define RARCH_INPUT_STATE_BIT_GET_PTR(a,bit) ((a)->data[((bit) >> 5)] & (1 << ((bit) & 31)))
#define RARCH_INPUT_STATE_CLEAR(a) memset(&a, 0, sizeof(a));
#define RARCH_INPUT_STATE_CLEAR_PTR(a) memset(a, 0, sizeof(retro_bits_t));
#define RARCH_INPUT_STATE_ANY_SET(a) ( ((a).data[0])||((a).data[1])||((a).data[2])||((a).data[3])|| \
((a).data[4])||((a).data[5])||((a).data[6])||((a).data[7]) )
#define RARCH_INPUT_STATE_ANY_SET_PTR(a) ( ((a)->data[0])||((a)->data[1])||((a)->data[2])||((a)->data[3])|| \
((a)->data[4])||((a)->data[5])||((a)->data[6])||((a)->data[7]) )
#define RARCH_INPUT_STATE_CLEAR_BITS(a,b) \
((a).data[0])&=(~((b).data[0])); \
((a).data[1])&=(~((b).data[1])); \
((a).data[2])&=(~((b).data[2])); \
((a).data[3])&=(~((b).data[3])); \
((a).data[4])&=(~((b).data[4])); \
((a).data[5])&=(~((b).data[5])); \
((a).data[6])&=(~((b).data[6])); \
((a).data[7])&=(~((b).data[7]));
#define RARCH_INPUT_STATE_COPY16_PTR(a,bits) {memset(a, 0, sizeof(retro_bits_t));((a)->data[0] = (bits)&0xffff);}
#define RARCH_INPUT_STATE_COPY32_PTR(a,bits) {memset(a, 0, sizeof(retro_bits_t));((a)->data[0] = (bits));}
RETRO_END_DECLS
#endif

32
input/input_driver.c
View File

@ -806,8 +806,11 @@ void input_menu_keys_pressed(void *data, retro_bits_t* p_new_state)
uint8_t port_max =
settings->bools.input_all_users_control_menu
? max_users : 1;
joypad_info.joy_idx = 0;
joypad_info.auto_binds = NULL;
RARCH_INPUT_STATE_CLEAR_PTR( p_new_state );
BIT256_CLEAR_ALL_PTR(p_new_state);
input_driver_block_libretro_input = false;
input_driver_block_hotkey = false;
@ -909,7 +912,7 @@ void input_menu_keys_pressed(void *data, retro_bits_t* p_new_state)
if (pressed)
{
RARCH_INPUT_STATE_BIT_SET_PTR(p_new_state, i);
BIT256_SET_PTR(p_new_state, i);
continue;
}
}
@ -919,7 +922,7 @@ void input_menu_keys_pressed(void *data, retro_bits_t* p_new_state)
{
if (current_input->meta_key_pressed(current_input_data, i))
{
RARCH_INPUT_STATE_BIT_SET_PTR(p_new_state, i);
BIT256_SET_PTR(p_new_state, i);
continue;
}
}
@ -927,7 +930,7 @@ void input_menu_keys_pressed(void *data, retro_bits_t* p_new_state)
#ifdef HAVE_OVERLAY
if (overlay_ptr && input_overlay_key_pressed(overlay_ptr, i))
{
RARCH_INPUT_STATE_BIT_SET_PTR(p_new_state, i);
BIT256_SET_PTR(p_new_state, i);
continue;
}
#endif
@ -942,7 +945,7 @@ void input_menu_keys_pressed(void *data, retro_bits_t* p_new_state)
if (command_get(&handle))
{
RARCH_INPUT_STATE_BIT_SET_PTR(p_new_state, i);
BIT256_SET_PTR(p_new_state, i);
continue;
}
}
@ -951,7 +954,7 @@ void input_menu_keys_pressed(void *data, retro_bits_t* p_new_state)
#ifdef HAVE_NETWORKGAMEPAD
if (input_driver_remote && input_remote_key_pressed(i, 0))
{
RARCH_INPUT_STATE_BIT_SET_PTR(p_new_state, i);
BIT256_SET_PTR(p_new_state, i);
continue;
}
#endif
@ -1004,9 +1007,10 @@ void input_menu_keys_pressed(void *data, retro_bits_t* p_new_state)
for (i = 0; i < 13; i++)
{
if (current_input->input_state(current_input_data, joypad_info, binds, 0,
if (current_input->input_state(current_input_data,
joypad_info, binds, 0,
RETRO_DEVICE_KEYBOARD, 0, ids[i][0]))
RARCH_INPUT_STATE_BIT_SET_PTR(p_new_state, ids[i][1]);
BIT256_SET_PTR(p_new_state, ids[i][1]);
}
}
}
@ -1033,7 +1037,7 @@ void input_keys_pressed(void *data, retro_bits_t* p_new_state)
const struct retro_keybind *enable_hotkey = &input_config_binds[0][RARCH_ENABLE_HOTKEY];
bool game_focus_toggle_valid = false;
RARCH_INPUT_STATE_CLEAR_PTR( p_new_state );
BIT256_CLEAR_ALL_PTR(p_new_state);
joypad_info.joy_idx = settings->uints.input_joypad_map[0];
joypad_info.auto_binds = input_autoconf_binds[joypad_info.joy_idx];
@ -1079,7 +1083,7 @@ void input_keys_pressed(void *data, retro_bits_t* p_new_state)
0, RETRO_DEVICE_JOYPAD, 0, i)
)
{
RARCH_INPUT_STATE_BIT_SET_PTR(p_new_state, i);
BIT256_SET_PTR(p_new_state, i);
continue;
}
@ -1087,7 +1091,7 @@ void input_keys_pressed(void *data, retro_bits_t* p_new_state)
current_input->meta_key_pressed(current_input_data, i)
)
{
RARCH_INPUT_STATE_BIT_SET_PTR(p_new_state, i);
BIT256_SET_PTR(p_new_state, i);
continue;
}
@ -1095,7 +1099,7 @@ void input_keys_pressed(void *data, retro_bits_t* p_new_state)
if (overlay_ptr &&
input_overlay_key_pressed(overlay_ptr, i))
{
RARCH_INPUT_STATE_BIT_SET_PTR(p_new_state, i);
BIT256_SET_PTR(p_new_state, i);
continue;
}
#endif
@ -1110,7 +1114,7 @@ void input_keys_pressed(void *data, retro_bits_t* p_new_state)
if (command_get(&handle))
{
RARCH_INPUT_STATE_BIT_SET_PTR(p_new_state, i);
BIT256_SET_PTR(p_new_state, i);
continue;
}
}
@ -1120,7 +1124,7 @@ void input_keys_pressed(void *data, retro_bits_t* p_new_state)
if (input_driver_remote &&
input_remote_key_pressed(i, 0))
{
RARCH_INPUT_STATE_BIT_SET_PTR(p_new_state, i);
BIT256_SET_PTR(p_new_state, i);
continue;
}
#endif

65
intl/msg_hash_de.c
View File

@ -904,13 +904,19 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_SCALE_PASS:
snprintf(s, len,
" \n"
);
{
/* Work around C89 limitations */
const char * t =
"Für diesen durchgang skalieren. \n"
" \n"
"Der Skalierungsfaktor wird multipliziert, \n"
"d.h. 2x im ersten durchgang und 2x im \n"
"zweiten durchgang bedeute eine 4x Gesamt- \n"
"Skalierung."
" \n"
" \n";
const char * u =
"Wenn es im letzten durchgang einen \n"
"Skalierungsfaktor gibt, wird das Ergebnis \n"
"mit dem als 'Standardfilter' eingestellten \n"
@ -919,8 +925,10 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
"Wenn 'Ignorieren' eingestellt ist, wird \n"
"entweder einfache Skalierung oder Vollbild- \n"
"Streckung verwendet - abhängig davon, ob \n"
"es der letzte durchgang ist oder nicht."
);
"es der letzte durchgang ist oder nicht.";
strlcpy(s, t, len);
strlcat(s, u, len);
}
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_NUM_PASSES:
snprintf(s, len,
@ -1133,7 +1141,9 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
"Verwendet für Inhalt, der auf mehreren Datenträgern ausgeliefert wird. ");
break;
case MENU_ENUM_LABEL_ENABLE_HOTKEY:
snprintf(s, len,
{
/* Work around C89 limitations */
const char * t =
"Andere Tastenkürzel aktivieren. \n"
" \n"
"Wenn dieses Tastenkürzel entweder einer\n"
@ -1141,14 +1151,18 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
"Controller-Achse zugeordnet ist, werden alle \n"
"anderen Tastenkürzel nur aktiviert, wenn dieses \n"
"Tastenkürzel zur gleichen Zeit gehalten wird. \n"
" \n"
" \n";
const char * u =
"Dies ist hilfreich für Implementierungen, die auf \n"
"RETRO_KEYBOARD ausgelegt sind und eine große \n"
"Fläche auf der Tastatur benötigen, wo es nicht \n"
"gewünscht ist, dass es zu Kollisionen mit Tastenkürzeln kommt \n."
" \n"
"Alternativ können auch alle Tastatur-Kürzel durch \n"
"den Benutzer deaktiviert werden.");
"den Benutzer deaktiviert werden.";
strlcpy(s, t, len);
strlcat(s, u, len);
}
break;
case MENU_ENUM_LABEL_REWIND_ENABLE:
snprintf(s, len,
@ -1165,7 +1179,9 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
"Libretro-Core-Implementierungen gesucht wird.");
break;
case MENU_ENUM_LABEL_VIDEO_REFRESH_RATE_AUTO:
snprintf(s, len,
{
/* Work around C89 limitations */
const char * t =
"Bildwiederholrate.\n"
" \n"
"Die genaue Bildwiederholrate deines Bildschirms (Hz).\n"
@ -1174,14 +1190,19 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
" \n"
"audio_input_rate = Spiel-Eingaberate * Bildschirm- \n"
"Wiederholrate / Spiel-Wiederholrate\n"
" \n"
" \n";
const char * u =
"Wenn die Implementierung keinen Wert liefert, \n"
"werden aus Kompatiblitätsgründen die Werte für NTSC \n"
"angenommen.\n"
" \n"
"Dieser Wert sollte nahe 60Hz liegen, um Tonsprünge zu vermeiden. \n"
"Wenn dein Bildschirm nicht auf 60Hz oder einem ähnlichen Wert läuft, \n"
"deaktiviere VSync und lasse diese Einstellung unverändert. \n");
"deaktiviere VSync und lasse diese Einstellung unverändert. \n";
;
strlcpy(s, t, len);
strlcat(s, u, len);
}
break;
case MENU_ENUM_LABEL_VIDEO_ROTATION:
snprintf(s, len,
@ -1594,20 +1615,26 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
"tritt keine Netplay-Verzögerung auf.\n");
break;
case MENU_ENUM_LABEL_NETPLAY_CHECK_FRAMES:
snprintf(s, len,
{
/* Work around C89 limitations */
const char * t =
"Die Frequenz in Einzelbildern, mit der Netplay \n"
"sicherstellen wird, dass Host und Clients \n"
"synchronisiert sind. \n"
" \n"
"Bei den meisten Cores wird diese Einstellungen \n"
"keine sichtbaren Auswirkungen haben und kann ignoriert werden. \n"
"Bei nichtdeterministischen Cores legt dieser Wert fest, \n"
"wie oft die Netplay-Mitglieder miteinander synchronisiert \n"
"werden. Bei fehlerhaften Cores wird ein \n"
"anderer Wert als 0 für diese Einstellung erhebliche \n"
"Leistungsprobleme verursachen. Auf 0 setzen, um keine \n"
"Überprüfungen durchzuführen. Diese Einstellung wird nur \n"
"auf dem Netplay-Host verwendet. \n");
"Bei den meisten Cores wird diese Einstellungen \n"
"keine sichtbaren Auswirkungen haben und kann ignoriert werden. \n";
const char *u =
"Bei nichtdeterministischen Cores legt dieser Wert fest, \n"
"wie oft die Netplay-Mitglieder miteinander synchronisiert \n"
"werden. Bei fehlerhaften Cores wird ein \n"
"anderer Wert als 0 für diese Einstellung erhebliche \n"
"Leistungsprobleme verursachen. Auf 0 setzen, um keine \n"
"Überprüfungen durchzuführen. Diese Einstellung wird nur \n"
"auf dem Netplay-Host verwendet. \n";
strlcpy(s, t, len);
strlcat(s, u, len);
}
break;
case MENU_ENUM_LABEL_NETPLAY_INPUT_LATENCY_FRAMES_MIN:
snprintf(s, len,

2
intl/msg_hash_nl.h
View File

@ -2313,6 +2313,8 @@ MSG_HASH(
)
MSG_HASH(MENU_ENUM_LABEL_VALUE_SHADER_PIPELINE_BOKEH,
"Bokeh")
MSG_HASH(MENU_ENUM_LABEL_VALUE_SHADER_PIPELINE_SNOWFLAKE,
"Sneeuwvlok")
MSG_HASH(MENU_ENUM_LABEL_VALUE_NETPLAY_REFRESH_ROOMS,
"Refresh Room List")
MSG_HASH(MENU_ENUM_LABEL_VALUE_NETPLAY_ROOM_NICKNAME,

32
libretro-common/compat/fopen_utf8.c Normal file
View File

@ -0,0 +1,32 @@
#include <compat/fopen_utf8.h>
#include <encodings/utf.h>
#include <stdlib.h>
#if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0500 || defined(_XBOX)
#ifndef LEGACY_WIN32
#define LEGACY_WIN32
#endif
#endif
#ifdef _WIN32
#undef fopen
FILE* fopen_utf8(const char * filename, const char * mode)
{
#if defined(_XBOX)
return fopen(filename, mode);
#elif defined(LEGACY_WIN32)
char * filename_local = utf8_to_local_string_alloc(filename);
FILE* ret = fopen(filename_local, mode);
free(filename_local);
return ret;
#else
wchar_t * filename_w = utf8_to_utf16_string_alloc(filename);
wchar_t * mode_w = utf8_to_utf16_string_alloc(mode);
FILE* ret = _wfopen(filename_w, mode_w);
free(filename_w);
free(mode_w);
return ret;
#endif
}
#endif

20
libretro-common/file/config_file.c
View File

@ -38,6 +38,7 @@
#include <retro_miscellaneous.h>
#include <compat/strl.h>
#include <compat/posix_string.h>
#include <compat/fopen_utf8.h>
#include <compat/msvc.h>
#include <file/config_file.h>
#include <file/file_path.h>
@ -912,21 +913,26 @@ void config_set_bool(config_file_t *conf, const char *key, bool val)
bool config_file_write(config_file_t *conf, const char *path)
{
RFILE *file = NULL;
if (!string_is_empty(path))
{
file = filestream_open(path, RFILE_MODE_WRITE, 0x4000);
void* buf = NULL;
FILE *file = fopen_utf8(path, "wb");
if (!file)
return false;
config_file_dump(conf, filestream_get_fp(file));
/* TODO: this is only useful for a few platforms, find which and add ifdef */
buf = calloc(1, 0x4000);
setvbuf(file, (char*)buf, _IOFBF, 0x4000);
config_file_dump(conf, file);
if (file != stdout)
fclose(file);
free(buf);
}
else
config_file_dump(conf, stdout);
if (file)
filestream_close(file);
return true;
}

8
libretro-common/file/file_path.c
View File

@ -84,8 +84,8 @@
#include <unistd.h> /* stat() is defined here */
#endif
/* Assume W-functions do not work below VC2005 and Xbox platforms */
#if defined(_MSC_VER) && _MSC_VER < 1400 || defined(_XBOX)
/* Assume W-functions do not work below Win2K and Xbox platforms */
#if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0500 || defined(_XBOX)
#ifndef LEGACY_WIN32
#define LEGACY_WIN32
@ -936,7 +936,7 @@ bool path_file_remove(const char *path)
(void)path_wide;
#if defined(_WIN32) && !defined(_XBOX)
#if defined(_MSC_VER) && _MSC_VER < 1400
#if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0500
path_local = utf8_to_local_string_alloc(path);
if (path_local)
@ -982,7 +982,7 @@ bool path_file_rename(const char *old_path, const char *new_path)
(void)new_path_wide;
#if defined(_WIN32) && !defined(_XBOX)
#if defined(_MSC_VER) && _MSC_VER < 1400
#if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0500
old_path_local = utf8_to_local_string_alloc(old_path);
new_path_local = utf8_to_local_string_alloc(new_path);

4
libretro-common/file/nbio/nbio_stdio.c
View File

@ -26,8 +26,8 @@
#include <file/nbio.h>
#include <encodings/utf.h>
/* Assume W-functions do not work below VC2005 and Xbox platforms */
#if defined(_MSC_VER) && _MSC_VER < 1400 || defined(_XBOX)
/* Assume W-functions do not work below Win2K and Xbox platforms */
#if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0500 || defined(_XBOX)
#ifndef LEGACY_WIN32
#define LEGACY_WIN32

14
libretro-common/file/nbio/nbio_unixmmap.c
View File

@ -39,6 +39,20 @@
#include <fcntl.h>
#include <sys/mman.h>
#ifdef __APPLE__
#ifndef O_CLOEXEC
#define O_CLOEXEC 0x1000000
#endif
#else
#ifndef O_CLOEXEC
#define O_CLOEXEC 0
#endif
#endif
struct nbio_mmap_unix_t
{
int fd;

4
libretro-common/file/nbio/nbio_windowsmmap.c
View File

@ -31,8 +31,8 @@
#include <windows.h>
/* Assume W-functions do not work below VC2005 and Xbox platforms */
#if defined(_MSC_VER) && _MSC_VER < 1400 || defined(_XBOX)
/* Assume W-functions do not work below Win2K and Xbox platforms */
#if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0500 || defined(_XBOX)
#ifndef LEGACY_WIN32
#define LEGACY_WIN32

2
libretro-common/file/retro_dirent.c
View File

@ -67,7 +67,7 @@
#include <unistd.h> /* stat() is defined here */
#endif
#if defined(_MSC_VER) && _MSC_VER < 1400 || defined(_XBOX)
#if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0500 || defined(_XBOX)
#ifndef LEGACY_WIN32
#define LEGACY_WIN32
#endif

17
libretro-common/gfx/gl_capabilities.c
View File

@ -179,16 +179,13 @@ bool gl_check_capability(enum gl_capability_enum enum_idx)
&& !gl_query_extension("EXT_framebuffer_object"))
return false;
if (glGenFramebuffers
&& glBindFramebuffer
&& glFramebufferTexture2D
&& glCheckFramebufferStatus
&& glDeleteFramebuffers
&& glGenRenderbuffers
&& glBindRenderbuffer
&& glFramebufferRenderbuffer
&& glRenderbufferStorage
&& glDeleteRenderbuffers)
if (gl_query_extension("ARB_framebuffer_object"))
return true;
if (gl_query_extension("EXT_framebuffer_object"))
return true;
if (major >= 3)
return true;
break;
#endif

14
libretro-common/include/compat/fopen_utf8.h Normal file
View File

@ -0,0 +1,14 @@
#ifndef __FOPEN_UTF8_H
#define __FOPEN_UTF8_H
#include <stdio.h>
#ifdef _WIN32
/* defined to error rather than fopen_utf8, to make it clear to everyone reading the code that not worrying about utf16 is fine */
/* TODO: enable */
/* #define fopen (use fopen_utf8 instead) */
FILE* fopen_utf8(const char * filename, const char * mode);
#else
#define fopen_utf8 fopen
#endif
#endif

69
libretro-common/include/retro_miscellaneous.h
View File

@ -24,6 +24,8 @@
#define __RARCH_MISCELLANEOUS_H
#include <stdint.h>
#include <boolean.h>
#include <retro_inline.h>
#if defined(_WIN32) && !defined(_XBOX)
#ifndef WIN32_LEAN_AND_MEAN
@ -40,6 +42,24 @@
#include <compat/msvc.h>
#endif
static INLINE void bits_clear_bits(uint32_t *a, uint32_t *b, uint32_t count)
{
uint32_t i;
for (i = 0; i < count;i++)
a[i] &= ~b[i];
}
static INLINE bool bits_any_set(uint32_t* ptr, uint32_t count)
{
uint32_t i;
for (i = 0; i < count; i++)
{
if (ptr[i] != 0)
return true;
}
return false;
}
#ifndef PATH_MAX_LENGTH
#if defined(_XBOX1) || defined(_3DS) || defined(PSP) || defined(GEKKO)|| defined(WIIU)
#define PATH_MAX_LENGTH 512
@ -56,35 +76,64 @@
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#endif
#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
#define BITS_GET_ELEM(a, i) ((a).data[i])
#define BITS_GET_ELEM_PTR(a, i) ((a)->data[i])
#define BIT_SET(a, bit) ((a)[(bit) >> 3] |= (1 << ((bit) & 7)))
#define BIT_CLEAR(a, bit) ((a)[(bit) >> 3] &= ~(1 << ((bit) & 7)))
#define BIT_GET(a, bit) ((a)[(bit) >> 3] & (1 << ((bit) & 7)))
#define BIT_GET(a, bit) (((a)[(bit) >> 3] >> ((bit) & 7)) & 1)
#define BIT16_SET(a, bit) ((a) |= (1 << ((bit) & 15)))
#define BIT16_CLEAR(a, bit) ((a) &= ~(1 << ((bit) & 15)))
#define BIT16_GET(a, bit) (!!((a) & (1 << ((bit) & 15))))
#define BIT16_GET(a, bit) (((a) >> ((bit) & 15)) & 1)
#define BIT16_CLEAR_ALL(a) ((a) = 0)
#define BIT32_SET(a, bit) ((a) |= (1 << ((bit) & 31)))
#define BIT32_CLEAR(a, bit) ((a) &= ~(1 << ((bit) & 31)))
#define BIT32_GET(a, bit) (!!((a) & (1 << ((bit) & 31))))
#define BIT32_GET(a, bit) (((a) >> ((bit) & 31)) & 1)
#define BIT32_CLEAR_ALL(a) ((a) = 0)
#define BIT64_SET(a, bit) ((a) |= (UINT64_C(1) << ((bit) & 63)))
#define BIT64_CLEAR(a, bit) ((a) &= ~(UINT64_C(1) << ((bit) & 63)))
#define BIT64_GET(a, bit) (!!((a) & (UINT64_C(1) << ((bit) & 63))))
#define BIT64_GET(a, bit) (((a) >> ((bit) & 63)) & 1)
#define BIT64_CLEAR_ALL(a) ((a) = 0)
#define BIT128_SET(a, bit) ((a).data[(bit) >> 5] |= (1 << ((bit) & 31)))
#define BIT128_CLEAR(a, bit) ((a).data[(bit) >> 5] &= ~(1 << ((bit) & 31)))
#define BIT128_GET(a, bit) ((a).data[(bit) >> 5] & (1 << ((bit) & 31)))
#define BIT128_CLEAR_ALL(a) memset(&(a), 0, sizeof(a));
#define BIT128_GET(a, bit) (((a).data[(bit) >> 5] >> ((bit) & 31)) & 1)
#define BIT128_CLEAR_ALL(a) memset(&(a), 0, sizeof(a))
/* Helper macros and struct to keep track of many booleans.
* To check for multiple bits, use &&, not &.
* For OR, | can be used. */
#define BIT128_SET_PTR(a, bit) BIT128_SET(*a, bit)
#define BIT128_CLEAR_PTR(a, bit) BIT128_CLEAR(*a, bit)
#define BIT128_GET_PTR(a, bit) BIT128_GET(*a, bit)
#define BIT128_CLEAR_ALL_PTR(a) BIT128_CLEAR_ALL(*a)
#define BIT256_SET(a, bit) BIT128_SET(a, bit)
#define BIT256_CLEAR(a, bit) BIT128_CLEAR(a, bit)
#define BIT256_GET(a, bit) BIT128_GET(a, bit)
#define BIT256_CLEAR_ALL(a) BIT128_CLEAR_ALL(a)
#define BIT256_SET_PTR(a, bit) BIT256_SET(*a, bit)
#define BIT256_CLEAR_PTR(a, bit) BIT256_CLEAR(*a, bit)
#define BIT256_GET_PTR(a, bit) BIT256_GET(*a, bit)
#define BIT256_CLEAR_ALL_PTR(a) BIT256_CLEAR_ALL(*a)
#define BITS_COPY16_PTR(a,bits) \
{ \
BIT128_CLEAR_ALL_PTR(a); \
BITS_GET_ELEM_PTR(a, 0) = (bits) & 0xffff; \
}
#define BITS_COPY32_PTR(a,bits) \
{ \
BIT128_CLEAR_ALL_PTR(a); \
BITS_GET_ELEM_PTR(a, 0) = (bits); \
}
/* Helper macros and struct to keep track of many booleans. */
/* This struct has 256 bits. */
typedef struct
{
uint32_t data[8];

8
libretro-common/include/streams/file_stream.h
View File

@ -63,10 +63,9 @@ const char *filestream_get_ext(RFILE *stream);
* @bufsize : optional buffer size (-1 or 0 to use default)
*
* Opens a file for reading or writing, depending on the requested mode.
* If bufsize is > 0 for unbuffered modes (like RFILE_MODE_WRITE), file will instead be fully buffered.
* Returns a pointer to an RFILE if opened successfully, otherwise NULL.
**/
RFILE *filestream_open(const char *path, unsigned mode, ssize_t bufsize);
RFILE *filestream_open(const char *path, unsigned mode, ssize_t unused);
ssize_t filestream_seek(RFILE *stream, ssize_t offset, int whence);
@ -100,9 +99,10 @@ int filestream_printf(RFILE *stream, const char* format, ...);
int filestream_error(RFILE *stream);
/* DO NOT put these functions back, unless you want to deal with
the UNAVOIDABLE REGRESSIONS on platforms using unexpected rfile backends
int filestream_get_fd(RFILE *stream);
FILE* filestream_get_fp(RFILE *stream);
FILE* filestream_get_fp(RFILE *stream); */
int filestream_flush(RFILE *stream);

52
libretro-common/streams/file_stream.c
View File

@ -65,8 +65,8 @@
#include <fcntl.h>
#endif
/* Assume W-functions do not work below VC2005 and Xbox platforms */
#if defined(_MSC_VER) && _MSC_VER < 1400 || defined(_XBOX)
/* Assume W-functions do not work below Win2K and Xbox platforms */
#if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0500 || defined(_XBOX)
#ifndef LEGACY_WIN32
#define LEGACY_WIN32
@ -114,24 +114,6 @@ struct RFILE
char *buf;
};
FILE* filestream_get_fp(RFILE *stream)
{
if (!stream)
return NULL;
return stream->fp;
}
int filestream_get_fd(RFILE *stream)
{
if (!stream)
return -1;
#if defined(HAVE_BUFFERED_IO)
if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0)
return fileno(stream->fp);
#endif
return stream->fd;
}
const char *filestream_get_ext(RFILE *stream)
{
if (!stream)
@ -166,12 +148,10 @@ void filestream_set_size(RFILE *stream)
* @bufsize : optional buffer size (-1 or 0 to use default)
*
* Opens a file for reading or writing, depending on the requested mode.
* If bufsize is > 0 for unbuffered modes (like RFILE_MODE_WRITE), file will instead be fully buffered.
* Returns a pointer to an RFILE if opened successfully, otherwise NULL.
**/
RFILE *filestream_open(const char *path, unsigned mode, ssize_t unused)
{
ssize_t bufsize = 0x4000;
int flags = 0;
int mode_int = 0;
#if defined(HAVE_BUFFERED_IO)
@ -271,7 +251,7 @@ RFILE *filestream_open(const char *path, unsigned mode, ssize_t unused)
#if defined(PSP)
stream->fd = sceIoOpen(path, flags, mode_int);
if (stream->fd == -1)
if (stream->fd < 0)
goto error;
#else
#if defined(HAVE_BUFFERED_IO)
@ -298,20 +278,18 @@ RFILE *filestream_open(const char *path, unsigned mode, ssize_t unused)
if (!stream->fp)
goto error;
if (bufsize > 0)
{
/* Regarding setvbuf:
*
* https://www.freebsd.org/cgi/man.cgi?query=setvbuf&apropos=0&sektion=0&manpath=FreeBSD+11.1-RELEASE&arch=default&format=html
*
* If the size argument is not zero but buf is NULL, a buffer of the given size will be allocated immediately, and
* released on close. This is an extension to ANSI C.
*
* Since C89 does not support specifying a null buffer with a non-zero size, we create and track our own buffer for it.
*/
stream->buf = (char*)calloc(1, bufsize);
setvbuf(stream->fp, stream->buf, _IOFBF, bufsize);
}
/* Regarding setvbuf:
*
* https://www.freebsd.org/cgi/man.cgi?query=setvbuf&apropos=0&sektion=0&manpath=FreeBSD+11.1-RELEASE&arch=default&format=html
*
* If the size argument is not zero but buf is NULL, a buffer of the given size will be allocated immediately, and
* released on close. This is an extension to ANSI C.
*
* Since C89 does not support specifying a null buffer with a non-zero size, we create and track our own buffer for it.
*/
/* TODO: this is only useful for a few platforms, find which and add ifdef */
stream->buf = (char*)calloc(1, 0x4000);
setvbuf(stream->fp, stream->buf, _IOFBF, 0x4000);
}
else
#endif

668
menu/cbs/menu_cbs_deferred_push.c
View File

@ -58,227 +58,6 @@ static int deferred_push_dlist(menu_displaylist_info_t *info, enum menu_displayl
return 0;
}
static int deferred_push_core_information(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_CORE_INFO);
}
static int deferred_push_system_information(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_SYSTEM_INFO);
}
static int deferred_push_network_information(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_NETWORK_INFO);
}
static int deferred_push_achievement_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_ACHIEVEMENT_LIST);
}
static int deferred_push_rdb_collection(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_PLAYLIST_COLLECTION);
}
static int deferred_main_menu_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_MAIN_MENU);
}
static int deferred_music_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_MUSIC_LIST);
}
static int deferred_user_binds_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_USER_BINDS_LIST);
}
static int deferred_push_accounts_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_ACCOUNTS_LIST);
}
static int deferred_push_driver_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_DRIVER_SETTINGS_LIST);
}
static int deferred_push_core_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_CORE_SETTINGS_LIST);
}
static int deferred_push_video_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_VIDEO_SETTINGS_LIST);
}
static int deferred_push_configuration_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_CONFIGURATION_SETTINGS_LIST);
}
static int deferred_push_saving_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_SAVING_SETTINGS_LIST);
}
static int deferred_push_logging_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_LOGGING_SETTINGS_LIST);
}
static int deferred_push_frame_throttle_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_FRAME_THROTTLE_SETTINGS_LIST);
}
static int deferred_push_rewind_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_REWIND_SETTINGS_LIST);
}
static int deferred_push_onscreen_display_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_ONSCREEN_DISPLAY_SETTINGS_LIST);
}
static int deferred_push_onscreen_notifications_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_ONSCREEN_NOTIFICATIONS_SETTINGS_LIST);
}
static int deferred_push_onscreen_overlay_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_ONSCREEN_OVERLAY_SETTINGS_LIST);
}
static int deferred_push_menu_file_browser_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_MENU_FILE_BROWSER_SETTINGS_LIST);
}
static int deferred_push_menu_views_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_MENU_VIEWS_SETTINGS_LIST);
}
static int deferred_push_quick_menu_views_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_QUICK_MENU_VIEWS_SETTINGS_LIST);
}
static int deferred_push_menu_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_MENU_SETTINGS_LIST);
}
static int deferred_push_user_interface_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_USER_INTERFACE_SETTINGS_LIST);
}
static int deferred_push_retro_achievements_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_RETRO_ACHIEVEMENTS_SETTINGS_LIST);
}
static int deferred_push_updater_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_UPDATER_SETTINGS_LIST);
}
static int deferred_push_wifi_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_WIFI_SETTINGS_LIST);
}
static int deferred_push_network_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_NETWORK_SETTINGS_LIST);
}
static int deferred_push_lakka_services_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_LAKKA_SERVICES_LIST);
}
static int deferred_push_user_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_USER_SETTINGS_LIST);
}
static int deferred_push_directory_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_DIRECTORY_SETTINGS_LIST);
}
static int deferred_push_privacy_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_PRIVACY_SETTINGS_LIST);
}
static int deferred_push_audio_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_AUDIO_SETTINGS_LIST);
}
static int deferred_push_input_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_INPUT_SETTINGS_LIST);
}
static int deferred_push_recording_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_RECORDING_SETTINGS_LIST);
}
static int deferred_push_playlist_settings_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_PLAYLIST_SETTINGS_LIST);
}
static int deferred_push_input_hotkey_binds_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_INPUT_HOTKEY_BINDS_LIST);
}
static int deferred_push_accounts_cheevos_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_ACCOUNTS_CHEEVOS_LIST);
}
static int deferred_push_help(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_HELP_SCREEN_LIST);
}
static int deferred_push_rdb_entry_detail(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_DATABASE_ENTRY);
}
static int deferred_push_rpl_entry_actions(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_HORIZONTAL_CONTENT_ACTIONS);
}
static int deferred_push_core_list_deferred(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_CORES_SUPPORTED);
}
static int deferred_push_core_collection_list_deferred(
menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_CORES_COLLECTION_SUPPORTED);
}
static int deferred_push_database_manager_list_deferred(
menu_displaylist_info_t *info)
{
@ -293,151 +72,108 @@ static int deferred_push_database_manager_list_deferred(
return deferred_push_dlist(info, DISPLAYLIST_DATABASE_QUERY);
}
static int deferred_push_video_shader_preset_parameters(
menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_SHADER_PARAMETERS_PRESET);
#define generic_deferred_push(name, type) \
static int (name)(menu_displaylist_info_t *info) \
{ \
return deferred_push_dlist(info, type); \
}
static int deferred_push_video_shader_parameters(
menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_SHADER_PARAMETERS);
}
static int deferred_push_settings(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_SETTINGS_ALL);
}
static int deferred_push_shader_options(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_OPTIONS_SHADERS);
}
static int deferred_push_options(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_OPTIONS);
}
static int deferred_push_netplay(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_NETPLAY_ROOM_LIST);
}
static int deferred_push_netplay_sublist(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_NETPLAY);
}
static int deferred_push_content_settings(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_CONTENT_SETTINGS);
}
static int deferred_push_add_content_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_ADD_CONTENT_LIST);
}
static int deferred_push_configurations_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_CONFIGURATIONS_LIST);
}
static int deferred_push_load_content_special(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_LOAD_CONTENT_LIST);
}
static int deferred_push_load_content_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_LOAD_CONTENT_LIST);
}
static int deferred_push_information_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_INFORMATION_LIST);
}
static int deferred_push_management_options(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_OPTIONS_MANAGEMENT);
}
static int deferred_push_core_counters(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_PERFCOUNTERS_CORE);
}
static int deferred_push_frontend_counters(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_PERFCOUNTERS_FRONTEND);
}
static int deferred_push_core_cheat_options(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_OPTIONS_CHEATS);
}
static int deferred_push_core_input_remapping_options(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_OPTIONS_REMAPPINGS);
}
static int deferred_push_core_options(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_CORE_OPTIONS);
}
static int deferred_push_disk_options(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_OPTIONS_DISK);
}
generic_deferred_push(deferred_push_video_shader_preset_parameters, DISPLAYLIST_SHADER_PARAMETERS_PRESET)
generic_deferred_push(deferred_push_video_shader_parameters, DISPLAYLIST_SHADER_PARAMETERS)
generic_deferred_push(deferred_push_settings, DISPLAYLIST_SETTINGS_ALL)
generic_deferred_push(deferred_push_shader_options, DISPLAYLIST_OPTIONS_SHADERS)
generic_deferred_push(deferred_push_options, DISPLAYLIST_OPTIONS)
generic_deferred_push(deferred_push_netplay, DISPLAYLIST_NETPLAY_ROOM_LIST)
generic_deferred_push(deferred_push_netplay_sublist, DISPLAYLIST_NETPLAY)
generic_deferred_push(deferred_push_content_settings, DISPLAYLIST_CONTENT_SETTINGS)
generic_deferred_push(deferred_push_add_content_list, DISPLAYLIST_ADD_CONTENT_LIST)
generic_deferred_push(deferred_push_history_list, DISPLAYLIST_HISTORY)
generic_deferred_push(deferred_push_database_manager_list, DISPLAYLIST_DATABASES)
generic_deferred_push(deferred_push_cursor_manager_list, DISPLAYLIST_DATABASE_CURSORS)
generic_deferred_push(deferred_push_content_collection_list, DISPLAYLIST_DATABASE_PLAYLISTS)
generic_deferred_push(deferred_push_configurations_list, DISPLAYLIST_CONFIGURATIONS_LIST)
generic_deferred_push(deferred_push_load_content_special, DISPLAYLIST_LOAD_CONTENT_LIST)
generic_deferred_push(deferred_push_load_content_list, DISPLAYLIST_LOAD_CONTENT_LIST)
generic_deferred_push(deferred_push_information_list, DISPLAYLIST_INFORMATION_LIST)
generic_deferred_push(deferred_archive_action_detect_core, DISPLAYLIST_ARCHIVE_ACTION_DETECT_CORE)
generic_deferred_push(deferred_archive_action, DISPLAYLIST_ARCHIVE_ACTION)
generic_deferred_push(deferred_push_management_options, DISPLAYLIST_OPTIONS_MANAGEMENT)
generic_deferred_push(deferred_push_core_counters, DISPLAYLIST_PERFCOUNTERS_CORE)
generic_deferred_push(deferred_push_frontend_counters, DISPLAYLIST_PERFCOUNTERS_FRONTEND)
generic_deferred_push(deferred_push_core_cheat_options, DISPLAYLIST_OPTIONS_CHEATS)
generic_deferred_push(deferred_push_core_input_remapping_options, DISPLAYLIST_OPTIONS_REMAPPINGS)
generic_deferred_push(deferred_push_core_options, DISPLAYLIST_CORE_OPTIONS)
generic_deferred_push(deferred_push_disk_options, DISPLAYLIST_OPTIONS_DISK)
generic_deferred_push(deferred_push_browse_url_list, DISPLAYLIST_BROWSE_URL_LIST)
generic_deferred_push(deferred_push_browse_url_start, DISPLAYLIST_BROWSE_URL_START)
generic_deferred_push(deferred_push_core_list, DISPLAYLIST_CORES)
generic_deferred_push(deferred_push_configurations, DISPLAYLIST_CONFIG_FILES)
generic_deferred_push(deferred_push_video_shader_preset, DISPLAYLIST_SHADER_PRESET)
generic_deferred_push(deferred_push_video_shader_pass, DISPLAYLIST_SHADER_PASS)
generic_deferred_push(deferred_push_video_filter, DISPLAYLIST_VIDEO_FILTERS)
generic_deferred_push(deferred_push_images, DISPLAYLIST_IMAGES)
generic_deferred_push(deferred_push_audio_dsp_plugin, DISPLAYLIST_AUDIO_FILTERS)
generic_deferred_push(deferred_push_cheat_file_load, DISPLAYLIST_CHEAT_FILES)
generic_deferred_push(deferred_push_remap_file_load, DISPLAYLIST_REMAP_FILES)
generic_deferred_push(deferred_push_record_configfile, DISPLAYLIST_RECORD_CONFIG_FILES)
generic_deferred_push(deferred_push_input_overlay, DISPLAYLIST_OVERLAYS)
generic_deferred_push(deferred_push_video_font_path, DISPLAYLIST_FONTS)
generic_deferred_push(deferred_push_xmb_font_path, DISPLAYLIST_FONTS)
generic_deferred_push(deferred_push_content_history_path, DISPLAYLIST_CONTENT_HISTORY)
generic_deferred_push(deferred_push_core_information, DISPLAYLIST_CORE_INFO)
generic_deferred_push(deferred_push_system_information, DISPLAYLIST_SYSTEM_INFO)
generic_deferred_push(deferred_push_network_information, DISPLAYLIST_NETWORK_INFO)
generic_deferred_push(deferred_push_achievement_list, DISPLAYLIST_ACHIEVEMENT_LIST)
generic_deferred_push(deferred_push_rdb_collection, DISPLAYLIST_PLAYLIST_COLLECTION)
generic_deferred_push(deferred_main_menu_list, DISPLAYLIST_MAIN_MENU)
generic_deferred_push(deferred_music_list, DISPLAYLIST_MUSIC_LIST)
generic_deferred_push(deferred_user_binds_list, DISPLAYLIST_USER_BINDS_LIST)
generic_deferred_push(deferred_push_accounts_list, DISPLAYLIST_ACCOUNTS_LIST)
generic_deferred_push(deferred_push_driver_settings_list, DISPLAYLIST_DRIVER_SETTINGS_LIST)
generic_deferred_push(deferred_push_core_settings_list, DISPLAYLIST_CORE_SETTINGS_LIST)
generic_deferred_push(deferred_push_video_settings_list, DISPLAYLIST_VIDEO_SETTINGS_LIST)
generic_deferred_push(deferred_push_configuration_settings_list, DISPLAYLIST_CONFIGURATION_SETTINGS_LIST)
generic_deferred_push(deferred_push_saving_settings_list, DISPLAYLIST_SAVING_SETTINGS_LIST)
generic_deferred_push(deferred_push_logging_settings_list, DISPLAYLIST_LOGGING_SETTINGS_LIST)
generic_deferred_push(deferred_push_frame_throttle_settings_list, DISPLAYLIST_FRAME_THROTTLE_SETTINGS_LIST)
generic_deferred_push(deferred_push_rewind_settings_list, DISPLAYLIST_REWIND_SETTINGS_LIST)
generic_deferred_push(deferred_push_onscreen_display_settings_list, DISPLAYLIST_ONSCREEN_DISPLAY_SETTINGS_LIST)
generic_deferred_push(deferred_push_onscreen_notifications_settings_list, DISPLAYLIST_ONSCREEN_NOTIFICATIONS_SETTINGS_LIST)
generic_deferred_push(deferred_push_onscreen_overlay_settings_list, DISPLAYLIST_ONSCREEN_OVERLAY_SETTINGS_LIST)
generic_deferred_push(deferred_push_menu_file_browser_settings_list,DISPLAYLIST_MENU_FILE_BROWSER_SETTINGS_LIST)
generic_deferred_push(deferred_push_menu_views_settings_list, DISPLAYLIST_MENU_VIEWS_SETTINGS_LIST)
generic_deferred_push(deferred_push_quick_menu_views_settings_list, DISPLAYLIST_QUICK_MENU_VIEWS_SETTINGS_LIST)
generic_deferred_push(deferred_push_menu_settings_list, DISPLAYLIST_MENU_SETTINGS_LIST)
generic_deferred_push(deferred_push_user_interface_settings_list, DISPLAYLIST_USER_INTERFACE_SETTINGS_LIST)
generic_deferred_push(deferred_push_retro_achievements_settings_list,DISPLAYLIST_RETRO_ACHIEVEMENTS_SETTINGS_LIST)
generic_deferred_push(deferred_push_updater_settings_list, DISPLAYLIST_UPDATER_SETTINGS_LIST)
generic_deferred_push(deferred_push_wifi_settings_list, DISPLAYLIST_WIFI_SETTINGS_LIST)
generic_deferred_push(deferred_push_network_settings_list, DISPLAYLIST_NETWORK_SETTINGS_LIST)
generic_deferred_push(deferred_push_lakka_services_list, DISPLAYLIST_LAKKA_SERVICES_LIST)
generic_deferred_push(deferred_push_user_settings_list, DISPLAYLIST_USER_SETTINGS_LIST)
generic_deferred_push(deferred_push_directory_settings_list, DISPLAYLIST_DIRECTORY_SETTINGS_LIST)
generic_deferred_push(deferred_push_privacy_settings_list, DISPLAYLIST_PRIVACY_SETTINGS_LIST)
generic_deferred_push(deferred_push_audio_settings_list, DISPLAYLIST_AUDIO_SETTINGS_LIST)
generic_deferred_push(deferred_push_input_settings_list, DISPLAYLIST_INPUT_SETTINGS_LIST)
generic_deferred_push(deferred_push_recording_settings_list, DISPLAYLIST_RECORDING_SETTINGS_LIST)
generic_deferred_push(deferred_push_playlist_settings_list, DISPLAYLIST_PLAYLIST_SETTINGS_LIST)
generic_deferred_push(deferred_push_input_hotkey_binds_list, DISPLAYLIST_INPUT_HOTKEY_BINDS_LIST)
generic_deferred_push(deferred_push_accounts_cheevos_list, DISPLAYLIST_ACCOUNTS_CHEEVOS_LIST)
generic_deferred_push(deferred_push_help, DISPLAYLIST_HELP_SCREEN_LIST)
generic_deferred_push(deferred_push_rdb_entry_detail, DISPLAYLIST_DATABASE_ENTRY)
generic_deferred_push(deferred_push_rpl_entry_actions, DISPLAYLIST_HORIZONTAL_CONTENT_ACTIONS)
generic_deferred_push(deferred_push_core_list_deferred, DISPLAYLIST_CORES_SUPPORTED)
generic_deferred_push(deferred_push_core_collection_list_deferred, DISPLAYLIST_CORES_COLLECTION_SUPPORTED)
#ifdef HAVE_NETWORKING
static int deferred_push_thumbnails_updater_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_THUMBNAILS_UPDATER);
}
static int deferred_push_core_updater_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_CORES_UPDATER);
}
static int deferred_push_core_content_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_CORE_CONTENT);
}
static int deferred_push_core_content_dirs_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_CORE_CONTENT_DIRS);
}
static int deferred_push_core_content_dirs_subdir_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_CORE_CONTENT_DIRS_SUBDIR);
}
static int deferred_push_lakka_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_LAKKA);
}
generic_deferred_push(deferred_push_thumbnails_updater_list, DISPLAYLIST_THUMBNAILS_UPDATER)
generic_deferred_push(deferred_push_core_updater_list, DISPLAYLIST_CORES_UPDATER)
generic_deferred_push(deferred_push_core_content_list, DISPLAYLIST_CORE_CONTENT)
generic_deferred_push(deferred_push_core_content_dirs_list, DISPLAYLIST_CORE_CONTENT_DIRS)
generic_deferred_push(deferred_push_core_content_dirs_subdir_list, DISPLAYLIST_CORE_CONTENT_DIRS_SUBDIR)
generic_deferred_push(deferred_push_lakka_list, DISPLAYLIST_LAKKA)
#endif
static int deferred_archive_action_detect_core(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_ARCHIVE_ACTION_DETECT_CORE);
}
static int deferred_archive_action(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_ARCHIVE_ACTION);
}
static int deferred_push_cursor_manager_list_deferred(
menu_displaylist_info_t *info)
{
@ -523,101 +259,29 @@ end:
return ret;
}
static int deferred_push_cursor_manager_list_deferred_query_rdb_entry_max_users(
menu_displaylist_info_t *info)
{
return deferred_push_cursor_manager_list_generic(info, DATABASE_QUERY_ENTRY_MAX_USERS);
#define generic_deferred_cursor_manager(name, type) \
static int (name)(menu_displaylist_info_t *info) \
{ \
return deferred_push_cursor_manager_list_generic(info, type); \
}
static int deferred_push_cursor_manager_list_deferred_query_rdb_entry_famitsu_magazine_rating(
menu_displaylist_info_t *info)
{
return deferred_push_cursor_manager_list_generic(info, DATABASE_QUERY_ENTRY_FAMITSU_MAGAZINE_RATING);
}
generic_deferred_cursor_manager(deferred_push_cursor_manager_list_deferred_query_rdb_entry_max_users, DATABASE_QUERY_ENTRY_MAX_USERS)
generic_deferred_cursor_manager(deferred_push_cursor_manager_list_deferred_query_rdb_entry_famitsu_magazine_rating, DATABASE_QUERY_ENTRY_FAMITSU_MAGAZINE_RATING)
generic_deferred_cursor_manager(deferred_push_cursor_manager_list_deferred_query_rdb_entry_edge_magazine_rating, DATABASE_QUERY_ENTRY_EDGE_MAGAZINE_RATING)
generic_deferred_cursor_manager(deferred_push_cursor_manager_list_deferred_query_rdb_entry_edge_magazine_issue, DATABASE_QUERY_ENTRY_EDGE_MAGAZINE_ISSUE)
generic_deferred_cursor_manager(deferred_push_cursor_manager_list_deferred_query_rdb_entry_elspa_rating, DATABASE_QUERY_ENTRY_ELSPA_RATING)
generic_deferred_cursor_manager(deferred_push_cursor_manager_list_deferred_query_rdb_entry_cero_rating, DATABASE_QUERY_ENTRY_CERO_RATING)
generic_deferred_cursor_manager(deferred_push_cursor_manager_list_deferred_query_rdb_entry_pegi_rating, DATABASE_QUERY_ENTRY_PEGI_RATING)
generic_deferred_cursor_manager(deferred_push_cursor_manager_list_deferred_query_rdb_entry_bbfc_rating, DATABASE_QUERY_ENTRY_BBFC_RATING)
generic_deferred_cursor_manager(deferred_push_cursor_manager_list_deferred_query_rdb_entry_esrb_rating, DATABASE_QUERY_ENTRY_ESRB_RATING)
generic_deferred_cursor_manager(deferred_push_cursor_manager_list_deferred_query_rdb_entry_enhancement_hw, DATABASE_QUERY_ENTRY_ENHANCEMENT_HW)
generic_deferred_cursor_manager(deferred_push_cursor_manager_list_deferred_query_rdb_entry_franchise, DATABASE_QUERY_ENTRY_FRANCHISE)
generic_deferred_cursor_manager(deferred_push_cursor_manager_list_deferred_query_rdb_entry_publisher, DATABASE_QUERY_ENTRY_PUBLISHER)
generic_deferred_cursor_manager(deferred_push_cursor_manager_list_deferred_query_rdb_entry_developer, DATABASE_QUERY_ENTRY_DEVELOPER)
generic_deferred_cursor_manager(deferred_push_cursor_manager_list_deferred_query_rdb_entry_origin, DATABASE_QUERY_ENTRY_ORIGIN)
generic_deferred_cursor_manager(deferred_push_cursor_manager_list_deferred_query_rdb_entry_releasemonth, DATABASE_QUERY_ENTRY_RELEASEDATE_MONTH)
generic_deferred_cursor_manager(deferred_push_cursor_manager_list_deferred_query_rdb_entry_releaseyear, DATABASE_QUERY_ENTRY_RELEASEDATE_YEAR)
static int deferred_push_cursor_manager_list_deferred_query_rdb_entry_edge_magazine_rating(
menu_displaylist_info_t *info)
{
return deferred_push_cursor_manager_list_generic(info, DATABASE_QUERY_ENTRY_EDGE_MAGAZINE_RATING);
}
static int deferred_push_cursor_manager_list_deferred_query_rdb_entry_edge_magazine_issue(
menu_displaylist_info_t *info)
{
return deferred_push_cursor_manager_list_generic(info, DATABASE_QUERY_ENTRY_EDGE_MAGAZINE_ISSUE);
}
static int deferred_push_cursor_manager_list_deferred_query_rdb_entry_elspa_rating(
menu_displaylist_info_t *info)
{
return deferred_push_cursor_manager_list_generic(info, DATABASE_QUERY_ENTRY_ELSPA_RATING);
}
static int deferred_push_cursor_manager_list_deferred_query_rdb_entry_cero_rating(
menu_displaylist_info_t *info)
{
return deferred_push_cursor_manager_list_generic(info, DATABASE_QUERY_ENTRY_CERO_RATING);
}
static int deferred_push_cursor_manager_list_deferred_query_rdb_entry_pegi_rating(
menu_displaylist_info_t *info)
{
return deferred_push_cursor_manager_list_generic(info, DATABASE_QUERY_ENTRY_PEGI_RATING);
}
static int deferred_push_cursor_manager_list_deferred_query_rdb_entry_bbfc_rating(
menu_displaylist_info_t *info)
{
return deferred_push_cursor_manager_list_generic(info, DATABASE_QUERY_ENTRY_BBFC_RATING);
}
static int deferred_push_cursor_manager_list_deferred_query_rdb_entry_esrb_rating(
menu_displaylist_info_t *info)
{
return deferred_push_cursor_manager_list_generic(info, DATABASE_QUERY_ENTRY_ESRB_RATING);
}
static int deferred_push_cursor_manager_list_deferred_query_rdb_entry_enhancement_hw(
menu_displaylist_info_t *info)
{
return deferred_push_cursor_manager_list_generic(info, DATABASE_QUERY_ENTRY_ENHANCEMENT_HW);
}
static int deferred_push_cursor_manager_list_deferred_query_rdb_entry_franchise(
menu_displaylist_info_t *info)
{
return deferred_push_cursor_manager_list_generic(info, DATABASE_QUERY_ENTRY_FRANCHISE);
}
static int deferred_push_cursor_manager_list_deferred_query_rdb_entry_publisher(
menu_displaylist_info_t *info)
{
return deferred_push_cursor_manager_list_generic(info, DATABASE_QUERY_ENTRY_PUBLISHER);
}
static int deferred_push_cursor_manager_list_deferred_query_rdb_entry_developer(
menu_displaylist_info_t *info)
{
return deferred_push_cursor_manager_list_generic(info, DATABASE_QUERY_ENTRY_DEVELOPER);
}
static int deferred_push_cursor_manager_list_deferred_query_rdb_entry_origin(
menu_displaylist_info_t *info)
{
return deferred_push_cursor_manager_list_generic(info, DATABASE_QUERY_ENTRY_ORIGIN);
}
static int deferred_push_cursor_manager_list_deferred_query_rdb_entry_releasemonth(
menu_displaylist_info_t *info)
{
return deferred_push_cursor_manager_list_generic(info, DATABASE_QUERY_ENTRY_RELEASEDATE_MONTH);
}
static int deferred_push_cursor_manager_list_deferred_query_rdb_entry_releaseyear(
menu_displaylist_info_t *info)
{
return deferred_push_cursor_manager_list_generic(info, DATABASE_QUERY_ENTRY_RELEASEDATE_YEAR);
}
#endif
#if 0
@ -941,111 +605,11 @@ static int deferred_push_default(menu_displaylist_info_t *info)
return general_push(info, PUSH_DEFAULT, DISPLAYLIST_DEFAULT);
}
static int deferred_push_history_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_HISTORY);
}
static int deferred_push_database_manager_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_DATABASES);
}
static int deferred_push_cursor_manager_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_DATABASE_CURSORS);
}
static int deferred_push_content_collection_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_DATABASE_PLAYLISTS);
}
static int deferred_push_favorites_list(menu_displaylist_info_t *info)
{
return general_push(info, PUSH_DEFAULT, DISPLAYLIST_FAVORITES);
}
static int deferred_push_browse_url_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_BROWSE_URL_LIST);
}
static int deferred_push_browse_url_start(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_BROWSE_URL_START);
}
static int deferred_push_core_list(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_CORES);
}
static int deferred_push_configurations(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_CONFIG_FILES);
}
static int deferred_push_video_shader_preset(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_SHADER_PRESET);
}
static int deferred_push_video_shader_pass(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_SHADER_PASS);
}
static int deferred_push_video_filter(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_VIDEO_FILTERS);
}
static int deferred_push_images(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_IMAGES);
}
static int deferred_push_audio_dsp_plugin(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_AUDIO_FILTERS);
}
static int deferred_push_cheat_file_load(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_CHEAT_FILES);
}
static int deferred_push_remap_file_load(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_REMAP_FILES);
}
static int deferred_push_record_configfile(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_RECORD_CONFIG_FILES);
}
static int deferred_push_input_overlay(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_OVERLAYS);
}
static int deferred_push_video_font_path(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_FONTS);
}
static int deferred_push_xmb_font_path(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_FONTS);
}
static int deferred_push_content_history_path(menu_displaylist_info_t *info)
{
return deferred_push_dlist(info, DISPLAYLIST_CONTENT_HISTORY);
}
static int menu_cbs_init_bind_deferred_push_compare_label(
menu_file_list_cbs_t *cbs,
const char *label, uint32_t label_hash)

50
menu/menu_event.c
View File

@ -160,12 +160,12 @@ unsigned menu_event(retro_bits_t* p_input, retro_bits_t* p_trigger_input)
unsigned menu_cancel_btn = (!input_swap_override &&
settings->bools.input_menu_swap_ok_cancel_buttons) ?
RETRO_DEVICE_ID_JOYPAD_A : RETRO_DEVICE_ID_JOYPAD_B;
unsigned ok_current = RARCH_INPUT_STATE_BIT_GET_PTR(p_input, menu_ok_btn );
unsigned ok_current = BIT256_GET_PTR(p_input, menu_ok_btn );
unsigned ok_trigger = ok_current & ~ok_old;
ok_old = ok_current;
if (RARCH_INPUT_STATE_ANY_SET_PTR(p_input))
if (bits_any_set(p_input->data, ARRAY_SIZE(p_input->data)))
{
if (!first_held)
{
@ -221,31 +221,31 @@ unsigned menu_event(retro_bits_t* p_input, retro_bits_t* p_trigger_input)
{
menu_event_osk_iterate();
if (RARCH_INPUT_STATE_BIT_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_DOWN))
if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_DOWN))
{
if (menu_event_get_osk_ptr() < 33)
menu_event_set_osk_ptr(menu_event_get_osk_ptr() + OSK_CHARS_PER_LINE);
}
if (RARCH_INPUT_STATE_BIT_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_UP))
if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_UP))
{
if (menu_event_get_osk_ptr() >= OSK_CHARS_PER_LINE)
menu_event_set_osk_ptr(menu_event_get_osk_ptr() - OSK_CHARS_PER_LINE);
}
if (RARCH_INPUT_STATE_BIT_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_RIGHT))
if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_RIGHT))
{
if (menu_event_get_osk_ptr() < 43)
menu_event_set_osk_ptr(menu_event_get_osk_ptr() + 1);
}
if (RARCH_INPUT_STATE_BIT_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_LEFT))
if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_LEFT))
{
if (menu_event_get_osk_ptr() >= 1)
menu_event_set_osk_ptr(menu_event_get_osk_ptr() - 1);
}
if (RARCH_INPUT_STATE_BIT_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_L))
if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_L))
{
if (menu_event_get_osk_idx() > OSK_TYPE_UNKNOWN + 1)
menu_event_set_osk_idx((enum osk_type)(menu_event_get_osk_idx() - 1));
@ -253,7 +253,7 @@ unsigned menu_event(retro_bits_t* p_input, retro_bits_t* p_trigger_input)
menu_event_set_osk_idx((enum osk_type)(OSK_TYPE_LAST - 1));
}
if (RARCH_INPUT_STATE_BIT_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_R))
if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_R))
{
if (menu_event_get_osk_idx() < OSK_TYPE_LAST - 1)
menu_event_set_osk_idx((enum osk_type)(menu_event_get_osk_idx() + 1));
@ -261,50 +261,50 @@ unsigned menu_event(retro_bits_t* p_input, retro_bits_t* p_trigger_input)
menu_event_set_osk_idx((enum osk_type)(OSK_TYPE_UNKNOWN + 1));
}
if (RARCH_INPUT_STATE_BIT_GET_PTR(p_trigger_input, menu_ok_btn))
if (BIT256_GET_PTR(p_trigger_input, menu_ok_btn))
{
if (menu_event_get_osk_ptr() >= 0)
menu_event_osk_append(menu_event_get_osk_ptr());
}
if (RARCH_INPUT_STATE_BIT_GET_PTR(p_trigger_input, menu_cancel_btn))
if (BIT256_GET_PTR(p_trigger_input, menu_cancel_btn))
{
input_keyboard_event(true, '\x7f', '\x7f', 0, RETRO_DEVICE_KEYBOARD);
}
/* send return key to close keyboard input window */
if (RARCH_INPUT_STATE_BIT_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_START))
if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_START))
input_keyboard_event(true, '\n', '\n', 0, RETRO_DEVICE_KEYBOARD);
RARCH_INPUT_STATE_CLEAR_PTR(p_trigger_input);
BIT256_CLEAR_ALL_PTR(p_trigger_input);
}
else
{
if (RARCH_INPUT_STATE_BIT_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_UP))
if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_UP))
ret = MENU_ACTION_UP;
else if (RARCH_INPUT_STATE_BIT_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_DOWN))
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_DOWN))
ret = MENU_ACTION_DOWN;
else if (RARCH_INPUT_STATE_BIT_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_LEFT))
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_LEFT))
ret = MENU_ACTION_LEFT;
else if (RARCH_INPUT_STATE_BIT_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_RIGHT))
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_RIGHT))
ret = MENU_ACTION_RIGHT;
else if (RARCH_INPUT_STATE_BIT_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_L))
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_L))
ret = MENU_ACTION_SCROLL_UP;
else if (RARCH_INPUT_STATE_BIT_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_R))
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_R))
ret = MENU_ACTION_SCROLL_DOWN;
else if (ok_trigger)
ret = MENU_ACTION_OK;
else if (RARCH_INPUT_STATE_BIT_GET_PTR(p_trigger_input, menu_cancel_btn))
else if (BIT256_GET_PTR(p_trigger_input, menu_cancel_btn))
ret = MENU_ACTION_CANCEL;
else if (RARCH_INPUT_STATE_BIT_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_X))
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_X))
ret = MENU_ACTION_SEARCH;
else if (RARCH_INPUT_STATE_BIT_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_Y))
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_Y))
ret = MENU_ACTION_SCAN;
else if (RARCH_INPUT_STATE_BIT_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_START))
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_START))
ret = MENU_ACTION_START;
else if (RARCH_INPUT_STATE_BIT_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_SELECT))
else if (BIT256_GET_PTR(p_trigger_input, RETRO_DEVICE_ID_JOYPAD_SELECT))
ret = MENU_ACTION_INFO;
else if (RARCH_INPUT_STATE_BIT_GET_PTR(p_trigger_input, RARCH_MENU_TOGGLE))
else if (BIT256_GET_PTR(p_trigger_input, RARCH_MENU_TOGGLE))
ret = MENU_ACTION_TOGGLE;
}
@ -314,7 +314,7 @@ unsigned menu_event(retro_bits_t* p_input, retro_bits_t* p_trigger_input)
menu_event_kb_set_internal(RETROK_F11, 0);
}
if (RARCH_INPUT_STATE_BIT_GET_PTR(p_trigger_input, RARCH_QUIT_KEY))
if (BIT256_GET_PTR(p_trigger_input, RARCH_QUIT_KEY))
return MENU_ACTION_QUIT;
mouse_enabled = settings->bools.menu_mouse_enable;

5
playlist.c
View File

@ -381,7 +381,6 @@ void playlist_write_file(playlist_t *playlist)
{
size_t i;
RFILE *file = NULL;
FILE *fp = NULL;
if (!playlist || !playlist->modified)
return;
@ -394,10 +393,8 @@ void playlist_write_file(playlist_t *playlist)
return;
}
fp = filestream_get_fp(file);
for (i = 0; i < playlist->size; i++)
fprintf(fp, "%s\n%s\n%s\n%s\n%s\n%s\n",
filestream_printf(file, "%s\n%s\n%s\n%s\n%s\n%s\n",
playlist->entries[i].path ? playlist->entries[i].path : "",
playlist->entries[i].label ? playlist->entries[i].label : "",
playlist->entries[i].core_path,

121
retroarch.c
View File

@ -1931,7 +1931,7 @@ bool retroarch_override_setting_is_set(enum rarch_override_setting enum_idx, voi
if (val)
{
unsigned bit = *val;
return BIT128_GET(has_set_libretro_device, bit);
return BIT256_GET(has_set_libretro_device, bit);
}
}
break;
@ -1980,7 +1980,7 @@ void retroarch_override_setting_set(enum rarch_override_setting enum_idx, void *
if (val)
{
unsigned bit = *val;
BIT128_SET(has_set_libretro_device, bit);
BIT256_SET(has_set_libretro_device, bit);
}
}
break;
@ -2039,7 +2039,7 @@ void retroarch_override_setting_unset(enum rarch_override_setting enum_idx, void
if (val)
{
unsigned bit = *val;
BIT128_CLEAR(has_set_libretro_device, bit);
BIT256_CLEAR(has_set_libretro_device, bit);
}
}
break;
@ -2315,35 +2315,35 @@ static bool input_driver_toggle_button_combo(
switch (mode)
{
case INPUT_TOGGLE_DOWN_Y_L_R:
if (!RARCH_INPUT_STATE_BIT_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_DOWN))
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_DOWN))
return false;
if (!RARCH_INPUT_STATE_BIT_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_Y))
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_Y))
return false;
if (!RARCH_INPUT_STATE_BIT_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_L))
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_L))
return false;
if (!RARCH_INPUT_STATE_BIT_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_R))
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_R))
return false;
break;
case INPUT_TOGGLE_L3_R3:
if (!RARCH_INPUT_STATE_BIT_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_L3))
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_L3))
return false;
if (!RARCH_INPUT_STATE_BIT_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_R3))
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_R3))
return false;
break;
case INPUT_TOGGLE_L1_R1_START_SELECT:
if (!RARCH_INPUT_STATE_BIT_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_START))
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_START))
return false;
if (!RARCH_INPUT_STATE_BIT_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_SELECT))
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_SELECT))
return false;
if (!RARCH_INPUT_STATE_BIT_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_L))
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_L))
return false;
if (!RARCH_INPUT_STATE_BIT_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_R))
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_R))
return false;
break;
case INPUT_TOGGLE_START_SELECT:
if (!RARCH_INPUT_STATE_BIT_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_START))
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_START))
return false;
if (!RARCH_INPUT_STATE_BIT_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_SELECT))
if (!BIT256_GET_PTR(p_input, RETRO_DEVICE_ID_JOYPAD_SELECT))
return false;
break;
default:
@ -2375,7 +2375,7 @@ static enum runloop_state runloop_check_state(
retro_bits_t current_input;
if ( menu_is_alive && !(settings->bools.menu_unified_controls && !menu_input_dialog_get_display_kb()) )
if (menu_is_alive && !(settings->bools.menu_unified_controls && !menu_input_dialog_get_display_kb()))
input_menu_keys_pressed(settings, &current_input);
else
input_keys_pressed(settings, &current_input);
@ -2391,19 +2391,17 @@ static enum runloop_state runloop_check_state(
((settings->uints.input_menu_toggle_gamepad_combo != INPUT_TOGGLE_NONE) &&
input_driver_toggle_button_combo(
settings->uints.input_menu_toggle_gamepad_combo, &last_input)))
{
RARCH_INPUT_STATE_BIT_SET(current_input, RARCH_MENU_TOGGLE);
}
BIT256_SET(current_input, RARCH_MENU_TOGGLE);
#endif
if (input_driver_flushing_input)
{
input_driver_flushing_input = false;
if (RARCH_INPUT_STATE_ANY_SET(current_input))
if (bits_any_set(current_input.data, ARRAY_SIZE(current_input.data)))
{
RARCH_INPUT_STATE_CLEAR( current_input );
BIT256_CLEAR_ALL(current_input);
if (runloop_paused)
RARCH_INPUT_STATE_BIT_SET(current_input, RARCH_PAUSE_TOGGLE);
BIT256_SET(current_input, RARCH_PAUSE_TOGGLE);
input_driver_flushing_input = true;
}
}
@ -2412,14 +2410,14 @@ static enum runloop_state runloop_check_state(
#ifdef HAVE_MENU
if (menu_driver_binding_state)
RARCH_INPUT_STATE_CLEAR( current_input );
BIT256_CLEAR_ALL(current_input);
#endif
#ifdef HAVE_OVERLAY
/* Check next overlay */
{
static bool old_should_check_next_overlay = false;
bool should_check_next_overlay = runloop_cmd_press(
bool should_check_next_overlay = BIT256_GET(
current_input, RARCH_OVERLAY_NEXT);
if (should_check_next_overlay && !old_should_check_next_overlay)
@ -2431,7 +2429,7 @@ static enum runloop_state runloop_check_state(
/* Check fullscreen toggle */
{
bool fs_toggle_pressed = runloop_cmd_press(
bool fs_toggle_pressed = BIT256_GET(
current_input, RARCH_FULLSCREEN_TOGGLE_KEY);
fs_toggle_triggered = fs_toggle_pressed && !old_fs_toggle_pressed;
@ -2454,7 +2452,7 @@ static enum runloop_state runloop_check_state(
/* Check mouse grab toggle */
{
static bool old_pressed = false;
bool pressed = runloop_cmd_press(
bool pressed = BIT256_GET(
current_input, RARCH_GRAB_MOUSE_TOGGLE);
if (pressed && !old_pressed)
@ -2489,7 +2487,7 @@ static enum runloop_state runloop_check_state(
/* Check quit key */
{
static bool old_quit_key = false;
bool quit_key = runloop_cmd_press(
bool quit_key = BIT256_GET(
current_input, RARCH_QUIT_KEY);
bool trig_quit_key = quit_key && !old_quit_key;
@ -2539,12 +2537,12 @@ static enum runloop_state runloop_check_state(
retro_ctx.poll_cb();
{
retro_bits_t trigger_input;
enum menu_action action;
bool focused;
bool focused = false;
retro_bits_t trigger_input = current_input;
trigger_input = current_input;
RARCH_INPUT_STATE_CLEAR_BITS( trigger_input, old_input );
bits_clear_bits(trigger_input.data, old_input.data,
ARRAY_SIZE(trigger_input.data));
action = (enum menu_action)menu_event(&current_input, &trigger_input);
focused = pause_nonactive ? is_focused : true;
@ -2583,7 +2581,7 @@ static enum runloop_state runloop_check_state(
/* Check game focus toggle */
{
static bool old_pressed = false;
bool pressed = runloop_cmd_press(
bool pressed = BIT256_GET(
current_input, RARCH_GAME_FOCUS_TOGGLE);
if (pressed && !old_pressed)
@ -2596,7 +2594,7 @@ static enum runloop_state runloop_check_state(
/* Check menu toggle */
{
static bool old_pressed = false;
bool pressed = runloop_cmd_press(
bool pressed = BIT256_GET(
current_input, RARCH_MENU_TOGGLE);
if (menu_event_kb_is_set(RETROK_F1) == 1)
@ -2646,7 +2644,7 @@ static enum runloop_state runloop_check_state(
/* Check screenshot toggle */
{
static bool old_pressed = false;
bool pressed = runloop_cmd_press(
bool pressed = BIT256_GET(
current_input, RARCH_SCREENSHOT);
if (pressed && old_pressed)
@ -2658,7 +2656,7 @@ static enum runloop_state runloop_check_state(
/* Check audio mute toggle */
{
static bool old_pressed = false;
bool pressed = runloop_cmd_press(
bool pressed = BIT256_GET(
current_input, RARCH_MUTE);
if (pressed && !old_pressed)
@ -2670,8 +2668,7 @@ static enum runloop_state runloop_check_state(
/* Check OSK toggle */
{
static bool old_pressed = false;
bool pressed = runloop_cmd_press(
current_input, RARCH_OSK);
bool pressed = BIT256_GET(current_input, RARCH_OSK);
if (pressed && !old_pressed)
{
@ -2687,9 +2684,9 @@ static enum runloop_state runloop_check_state(
old_pressed = pressed;
}
if (runloop_cmd_press(current_input, RARCH_VOLUME_UP))
if (BIT256_GET(current_input, RARCH_VOLUME_UP))
command_event(CMD_EVENT_VOLUME_UP, NULL);
else if (runloop_cmd_press(current_input, RARCH_VOLUME_DOWN))
else if (BIT256_GET(current_input, RARCH_VOLUME_DOWN))
command_event(CMD_EVENT_VOLUME_DOWN, NULL);
#ifdef HAVE_NETWORKING
@ -2697,9 +2694,9 @@ static enum runloop_state runloop_check_state(
{
static bool old_netplay_flip = false;
static bool old_netplay_watch = false;
bool netplay_flip = runloop_cmd_press(
bool netplay_flip = BIT256_GET(
current_input, RARCH_NETPLAY_FLIP);
bool netplay_watch = runloop_cmd_press(
bool netplay_watch = BIT256_GET(
current_input, RARCH_NETPLAY_GAME_WATCH);
if (netplay_flip && !old_netplay_flip)
@ -2718,9 +2715,9 @@ static enum runloop_state runloop_check_state(
static bool old_frameadvance = false;
static bool old_pause_pressed = false;
bool check_is_oneshot = true;
bool frameadvance_pressed = runloop_cmd_press(
bool frameadvance_pressed = BIT256_GET(
current_input, RARCH_FRAMEADVANCE);
bool pause_pressed = runloop_cmd_press(
bool pause_pressed = BIT256_GET(
current_input, RARCH_PAUSE_TOGGLE);
bool trig_frameadvance = frameadvance_pressed && !old_frameadvance;
@ -2744,7 +2741,7 @@ static enum runloop_state runloop_check_state(
if (runloop_paused)
{
check_is_oneshot = trig_frameadvance ||
runloop_cmd_press(current_input, RARCH_REWIND);
BIT256_GET(current_input, RARCH_REWIND);
if (fs_toggle_triggered)
{
@ -2769,9 +2766,9 @@ static enum runloop_state runloop_check_state(
{
static bool old_button_state = false;
static bool old_hold_button_state = false;
bool new_button_state = runloop_cmd_press(
bool new_button_state = BIT256_GET(
current_input, RARCH_FAST_FORWARD_KEY);
bool new_hold_button_state = runloop_cmd_press(
bool new_hold_button_state = BIT256_GET(
current_input, RARCH_FAST_FORWARD_HOLD_KEY);
if (new_button_state && !old_button_state)
@ -2812,9 +2809,9 @@ static enum runloop_state runloop_check_state(
{
static bool old_should_slot_increase = false;
static bool old_should_slot_decrease = false;
bool should_slot_increase = runloop_cmd_press(
bool should_slot_increase = BIT256_GET(
current_input, RARCH_STATE_SLOT_PLUS);
bool should_slot_decrease = runloop_cmd_press(
bool should_slot_decrease = BIT256_GET(
current_input, RARCH_STATE_SLOT_MINUS);
/* Checks if the state increase/decrease keys have been pressed
@ -2865,9 +2862,9 @@ static enum runloop_state runloop_check_state(
{
static bool old_should_savestate = false;
static bool old_should_loadstate = false;
bool should_savestate = runloop_cmd_press(
bool should_savestate = BIT256_GET(
current_input, RARCH_SAVE_STATE_KEY);
bool should_loadstate = runloop_cmd_press(
bool should_loadstate = BIT256_GET(
current_input, RARCH_LOAD_STATE_KEY);
if (should_savestate && !old_should_savestate)
@ -2888,14 +2885,14 @@ static enum runloop_state runloop_check_state(
s[0] = '\0';
if (state_manager_check_rewind(runloop_cmd_press(current_input, RARCH_REWIND),
if (state_manager_check_rewind(BIT256_GET(current_input, RARCH_REWIND),
settings->uints.rewind_granularity, runloop_paused, s, sizeof(s), &t))
runloop_msg_queue_push(s, 0, t, true);
}
/* Checks if slowmotion toggle/hold was being pressed and/or held. */
{
runloop_slowmotion = runloop_cmd_press(current_input, RARCH_SLOWMOTION);
runloop_slowmotion = BIT256_GET(current_input, RARCH_SLOWMOTION);
if (runloop_slowmotion)
{
@ -2917,7 +2914,7 @@ static enum runloop_state runloop_check_state(
/* Check movie record toggle */
{
static bool old_pressed = false;
bool pressed = runloop_cmd_press(
bool pressed = BIT256_GET(
current_input, RARCH_MOVIE_RECORD_TOGGLE);
if (pressed && !old_pressed)
@ -2930,9 +2927,9 @@ static enum runloop_state runloop_check_state(
{
static bool old_shader_next = false;
static bool old_shader_prev = false;
bool shader_next = runloop_cmd_press(
bool shader_next = BIT256_GET(
current_input, RARCH_SHADER_NEXT);
bool shader_prev = runloop_cmd_press(
bool shader_prev = BIT256_GET(
current_input, RARCH_SHADER_PREV);
bool trig_shader_next = shader_next && !old_shader_next;
bool trig_shader_prev = shader_prev && !old_shader_prev;
@ -2949,11 +2946,11 @@ static enum runloop_state runloop_check_state(
static bool old_disk_eject = false;
static bool old_disk_next = false;
static bool old_disk_prev = false;
bool disk_eject = runloop_cmd_press(
bool disk_eject = BIT256_GET(
current_input, RARCH_DISK_EJECT_TOGGLE);
bool disk_next = runloop_cmd_press(
bool disk_next = BIT256_GET(
current_input, RARCH_DISK_NEXT);
bool disk_prev = runloop_cmd_press(
bool disk_prev = BIT256_GET(
current_input, RARCH_DISK_PREV);
if (disk_eject && !old_disk_eject)
@ -2971,7 +2968,7 @@ static enum runloop_state runloop_check_state(
/* Check reset */
{
static bool old_state = false;
bool new_state = runloop_cmd_press(
bool new_state = BIT256_GET(
current_input, RARCH_RESET);
if (new_state && !old_state)
@ -2985,11 +2982,11 @@ static enum runloop_state runloop_check_state(
static bool old_cheat_index_plus = false;
static bool old_cheat_index_minus = false;
static bool old_cheat_index_toggle = false;
bool cheat_index_plus = runloop_cmd_press(
bool cheat_index_plus = BIT256_GET(
current_input, RARCH_CHEAT_INDEX_PLUS);
bool cheat_index_minus = runloop_cmd_press(
bool cheat_index_minus = BIT256_GET(
current_input, RARCH_CHEAT_INDEX_MINUS);
bool cheat_index_toggle = runloop_cmd_press(
bool cheat_index_toggle = BIT256_GET(
current_input, RARCH_CHEAT_TOGGLE);
if (cheat_index_plus && !old_cheat_index_plus)

2
retroarch.h
View File

@ -27,8 +27,6 @@
#include "core_type.h"
#include "core.h"
#define runloop_cmd_press(current_input, id) (RARCH_INPUT_STATE_BIT_GET(current_input, id))
RETRO_BEGIN_DECLS
enum rarch_ctl_state

17
verbosity.c
View File

@ -35,6 +35,7 @@
#include <string/stdstring.h>
#include <streams/file_stream.h>
#include <compat/fopen_utf8.h>
#ifdef HAVE_CONFIG_H
#include "config.h"
@ -49,8 +50,8 @@
/* If this is non-NULL. RARCH_LOG and friends
* will write to this file. */
static RFILE *log_file = NULL;
static FILE *log_file_fp = NULL;
static void* log_file_buf = NULL;
static bool main_verbosity = false;
static bool log_file_initialized = false;
@ -96,17 +97,21 @@ void retro_main_log_file_init(const char *path)
if (path == NULL)
return;
log_file = filestream_open(path, RFILE_MODE_WRITE, -1);
log_file_fp = filestream_get_fp(log_file);
log_file_fp = fopen_utf8(path, "wb");
log_file_initialized = true;
/* TODO: this is only useful for a few platforms, find which and add ifdef */
log_file_buf = calloc(1, 0x4000);
setvbuf(log_file_fp, (char*)log_file_buf, _IOFBF, 0x4000);
}
void retro_main_log_file_deinit(void)
{
if (log_file && log_file_fp != stderr)
filestream_close(log_file);
log_file = NULL;
if (log_file_fp && log_file_fp != stderr)
fclose(log_file_fp);
if (log_file_buf) free(log_file_buf);
log_file_fp = NULL;
log_file_buf = NULL;
}
#if !defined(HAVE_LOGGER)