static void gfx_ctx_wgl_set_flags(void *data, uint32_t flags)
{
switch (win32_api)
{
case GFX_CTX_OPENGL_API:
#if defined(HAVE_OPENGL) || defined(HAVE_OPENGL1)
if (BIT32_GET(flags, GFX_CTX_FLAGS_ADAPTIVE_VSYNC))
wgl_adaptive_vsync = true;
if (BIT32_GET(flags, GFX_CTX_FLAGS_GL_CORE_CONTEXT))
win32_core_hw_context_enable = true;
#endif
break;
case GFX_CTX_NONE:
default:
break;
}
}
static void gfx_ctx_x_set_flags(void *data, uint32_t flags)
{
gfx_ctx_x_data_t *x = (gfx_ctx_x_data_t*)data;
switch (x_api)
{
case GFX_CTX_OPENGL_API:
case GFX_CTX_OPENGL_ES_API:
if (BIT32_GET(flags, GFX_CTX_FLAGS_ADAPTIVE_VSYNC))
x_adaptive_vsync = true;
if (BIT32_GET(flags, GFX_CTX_FLAGS_GL_CORE_CONTEXT))
x->core_hw_context_enable = true;
if (BIT32_GET(flags, GFX_CTX_FLAGS_MULTISAMPLING))
x_enable_msaa = true;
break;
case GFX_CTX_NONE:
default:
break;
}
}
static const shader_backend_t *video_shader_set_backend(enum rarch_shader_type type)
{
switch (type)
{
case RARCH_SHADER_CG:
{
#ifdef HAVE_CG
gfx_ctx_flags_t flags;
video_context_driver_get_flags(&flags);
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_GL_CORE_CONTEXT))
{
RARCH_ERR("[Shader driver]: Cg cannot be used with core GL context. Trying to fall back to GLSL...\n");
return video_shader_set_backend(RARCH_SHADER_GLSL);
}
RARCH_LOG("[Shader driver]: Using Cg shader backend.\n");
return &gl_cg_backend;
#else
break;
#endif
}
case RARCH_SHADER_GLSL:
#ifdef HAVE_GLSL
RARCH_LOG("[Shader driver]: Using GLSL shader backend.\n");
return &gl_glsl_backend;
#else
break;
#endif
case RARCH_SHADER_NONE:
default:
break;
}
return NULL;
}
static void gfx_ctx_wgl_set_flags(void *data, uint32_t flags)
{
if (BIT32_GET(flags, GFX_CTX_FLAGS_GL_CORE_CONTEXT))
g_core_hw_context_enable = true;
}
static void gfx_ctx_wl_set_flags(void *data, uint32_t flags)
{
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)data;
if (BIT32_GET(flags, GFX_CTX_FLAGS_GL_CORE_CONTEXT))
wl->core_hw_context_enable = true;
}
static void gfx_ctx_drm_set_flags(void *data, uint32_t flags)
{
gfx_ctx_drm_data_t *drm = (gfx_ctx_drm_data_t*)data;
if (BIT32_GET(flags, GFX_CTX_FLAGS_GL_CORE_CONTEXT))
drm->core_hw_context_enable = true;
}
static void parport_poll_pad(struct parport_joypad *pad)
{
/* RetroArch uses an extended version of the Linux
* Multisystem 2-button joystick protocol for parallel port
* joypads:
*
* | Function | Pin | Register | Bit | Active |
* |-------------|-----|----------|-----|--------|
* | Up | 2 | Data | 0 | Low |
* | Down | 3 | Data | 1 | Low |
* | Left | 4 | Data | 2 | Low |
* | Right | 5 | Data | 3 | Low |
* | A | 6 | Data | 4 | Low |
* | B | 7 | Data | 5 | Low |
* | Start | 8 | Data | 6 | Low |
* | Select | 9 | Data | 7 | Low |
* | Menu toggle | 10 | Status | 6 | Low |
* | X | 11 | Status | 7 | Low* |
* | Y | 12 | Status | 5 | Low |
* | L1 | 13 | Status | 4 | Low |
* | R1 | 15 | Status | 3 | Low |
*
* (*) Pin is hardware inverted, but RetroArch inverts it
* back again so the same pullup scheme may be used for
* all pins.
*
* Pin 1 is set high so it can be used for pullups.
*
* RetroArch does not perform debouncing, and so long as
* the button settling time is less than the frame time
* no bouncing will be observed. This replicates the latching
* behavior common in old games consoles. For optimum latency
* and jitter a high performance debouncing routine should be
* implemented in the controller hardware.
*/
int i;
char data;
char status;
if (ioctl(pad->fd, PPRDATA, &data) < 0)
return;
if (ioctl(pad->fd, PPRSTATUS, &status) < 0)
return;
for (i = 0; i < 8; i++)
{
if (!(data & UINT8_C(1 << i)) && pad->button_enable[i])
BIT32_SET(pad->buttons, i);
else
BIT32_CLEAR(pad->buttons, i);
}
for (i = 3; i < 8; i++)
{
if (!(status & UINT8_C(1 << i)) && pad->button_enable[i + 5])
BIT32_SET(pad->buttons, i + 5);
else
BIT32_CLEAR(pad->buttons, i + 5);
}
if (BIT32_GET(pad->buttons, 12) && pad->button_enable[12])
BIT32_CLEAR(pad->buttons, 12);
else
BIT32_SET(pad->buttons, 12);
}
static bool parport_joypad_button(unsigned port, uint16_t joykey)
{
const struct parport_joypad *pad = (const struct parport_joypad*)&parport_pads[port];
return joykey < PARPORT_NUM_BUTTONS && BIT32_GET(pad->buttons, joykey);
}
static bool parport_joypad_init(void *data)
{
unsigned i, j;
bool found_enabled_button = false;
bool found_disabled_button = false;
char buf[PARPORT_NUM_BUTTONS * 3 + 1] = {0};
char pin[3 + 1] = {0};
(void)data;
memset(buf, 0, PARPORT_NUM_BUTTONS * 3 + 1);
for (i = 0; i < MAX_USERS; i++)
{
char path[PATH_MAX_LENGTH] = {0};
struct parport_joypad *pad = &parport_pads[i];
pad->fd = -1;
pad->ident = input_device_names[i];
snprintf(path, sizeof(path), "/dev/parport%u", i);
if (parport_joypad_init_pad(path, pad))
{
/* If a pin is low on initialization it can either mean
* a button is pressed or that nothing is connected.
* Polling non-connected pins can render the menu unusable
* so assume the user is not holding any button on startup
* and disable any low pins.
*/
parport_poll_pad(pad);
found_enabled_button = false;
found_disabled_button = false;
for (j = 0; j < PARPORT_NUM_BUTTONS; j++)
{
if (!(BIT32_GET(pad->buttons, j)))
{
pad->button_enable[j] = true;
found_enabled_button = true;
}
else
{
pad->button_enable[j] = false;
found_disabled_button = true;
}
}
if (found_enabled_button)
{
if (found_disabled_button)
{
buf[0] = '\0';
for (j = 0; j < PARPORT_NUM_BUTTONS; j++)
{
if (!pad->button_enable[j])
{
snprintf(pin, sizeof(pin), "%d ", j);
strlcat(buf, pin, sizeof(buf));
}
}
RARCH_WARN("[Joypad]: Pin(s) %son %s were low on init, assuming not connected\n", \
buf, path);
}
}
else
{
RARCH_WARN("[Joypad]: All pins low on %s, assuming nothing connected\n", path);
parport_free_pad(pad);
}
}
if (!input_autoconfigure_connect(
"Generic Parallel Port device",
NULL,
"parport",
i,
0,
0
))
input_config_set_device_name(i, "Generic Parallel Port device");
}
return true;
}
