2012-12-20 11:24:49 +00:00
|
|
|
/* RetroArch - A frontend for libretro.
|
2014-01-01 00:50:59 +00:00
|
|
|
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
|
2015-01-07 16:46:50 +00:00
|
|
|
* Copyright (C) 2011-2015 - Daniel De Matteis
|
2014-01-08 17:14:50 +00:00
|
|
|
*
|
2012-12-20 11:24:49 +00:00
|
|
|
* 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/>.
|
|
|
|
*/
|
|
|
|
|
2015-01-29 19:33:27 +00:00
|
|
|
#include <stdlib.h>
|
2015-06-14 14:53:09 +00:00
|
|
|
#include <stddef.h>
|
2015-01-29 19:33:27 +00:00
|
|
|
#include <string.h>
|
2015-06-14 14:53:09 +00:00
|
|
|
#include <math.h>
|
|
|
|
|
2014-10-21 05:58:58 +00:00
|
|
|
#include <compat/posix_string.h>
|
2014-10-21 22:23:06 +00:00
|
|
|
#include <file/file_path.h>
|
2015-03-19 03:28:40 +00:00
|
|
|
#include <string/string_list.h>
|
2015-07-11 05:51:34 +00:00
|
|
|
#include <file/config_file.h>
|
2015-07-11 06:14:39 +00:00
|
|
|
#include <formats/image.h>
|
2014-10-26 01:18:56 +00:00
|
|
|
#include <clamping.h>
|
2015-06-14 14:53:09 +00:00
|
|
|
#include <rhash.h>
|
|
|
|
|
|
|
|
#include "input_overlay.h"
|
2015-07-08 23:10:30 +00:00
|
|
|
#include "../configuration.h"
|
2015-06-14 14:53:09 +00:00
|
|
|
#include "../driver.h"
|
|
|
|
#include "input_common.h"
|
|
|
|
|
|
|
|
#define BOX_RADIAL 0x18df06d2U
|
|
|
|
#define BOX_RECT 0x7c9d4d93U
|
|
|
|
|
|
|
|
#define KEY_ANALOG_LEFT 0x56b92e81U
|
|
|
|
#define KEY_ANALOG_RIGHT 0x2e4dc654U
|
2012-12-22 12:27:00 +00:00
|
|
|
|
2015-07-11 06:07:14 +00:00
|
|
|
struct overlay
|
|
|
|
{
|
|
|
|
struct overlay_desc *descs;
|
|
|
|
size_t size;
|
|
|
|
size_t pos;
|
|
|
|
unsigned pos_increment;
|
|
|
|
|
|
|
|
struct texture_image image;
|
|
|
|
|
|
|
|
bool block_scale;
|
|
|
|
float mod_x, mod_y, mod_w, mod_h;
|
|
|
|
float x, y, w, h;
|
|
|
|
float scale;
|
|
|
|
float center_x, center_y;
|
|
|
|
|
|
|
|
bool full_screen;
|
|
|
|
|
|
|
|
char name[64];
|
|
|
|
|
|
|
|
struct
|
|
|
|
{
|
|
|
|
struct
|
|
|
|
{
|
|
|
|
char key[64];
|
|
|
|
char path[PATH_MAX_LENGTH];
|
|
|
|
} paths;
|
|
|
|
|
|
|
|
struct
|
|
|
|
{
|
|
|
|
char key[64];
|
|
|
|
} names;
|
|
|
|
|
|
|
|
struct
|
|
|
|
{
|
|
|
|
char array[256];
|
|
|
|
char key[64];
|
|
|
|
} rect;
|
|
|
|
|
|
|
|
struct
|
|
|
|
{
|
|
|
|
char key[64];
|
|
|
|
unsigned size;
|
|
|
|
} descs;
|
|
|
|
|
|
|
|
bool normalized;
|
|
|
|
float alpha_mod;
|
|
|
|
float range_mod;
|
|
|
|
} config;
|
|
|
|
|
|
|
|
struct texture_image *load_images;
|
|
|
|
unsigned load_images_size;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct overlay_desc
|
|
|
|
{
|
|
|
|
float x;
|
|
|
|
float y;
|
|
|
|
|
|
|
|
enum overlay_hitbox hitbox;
|
|
|
|
float range_x, range_y;
|
|
|
|
float range_x_mod, range_y_mod;
|
|
|
|
float mod_x, mod_y, mod_w, mod_h;
|
|
|
|
float delta_x, delta_y;
|
|
|
|
|
|
|
|
enum overlay_type type;
|
|
|
|
uint64_t key_mask;
|
|
|
|
float analog_saturate_pct;
|
|
|
|
|
|
|
|
unsigned next_index;
|
|
|
|
char next_index_name[64];
|
|
|
|
|
|
|
|
struct texture_image image;
|
|
|
|
unsigned image_index;
|
|
|
|
|
|
|
|
float alpha_mod;
|
|
|
|
float range_mod;
|
|
|
|
|
|
|
|
bool updated;
|
|
|
|
bool movable;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct input_overlay
|
|
|
|
{
|
|
|
|
void *iface_data;
|
|
|
|
const video_overlay_interface_t *iface;
|
|
|
|
bool enable;
|
|
|
|
|
|
|
|
enum overlay_image_transfer_status loading_status;
|
|
|
|
bool blocked;
|
2015-07-11 21:45:23 +00:00
|
|
|
bool alive;
|
2015-07-11 06:07:14 +00:00
|
|
|
|
|
|
|
struct overlay *overlays;
|
|
|
|
const struct overlay *active;
|
|
|
|
size_t index;
|
|
|
|
size_t size;
|
|
|
|
unsigned pos;
|
|
|
|
size_t resolve_pos;
|
|
|
|
size_t pos_increment;
|
|
|
|
|
|
|
|
unsigned next_index;
|
|
|
|
char *overlay_path;
|
|
|
|
enum overlay_status state;
|
|
|
|
|
|
|
|
struct
|
|
|
|
{
|
|
|
|
struct
|
|
|
|
{
|
|
|
|
unsigned size;
|
|
|
|
} overlays;
|
|
|
|
} config;
|
|
|
|
|
|
|
|
struct
|
|
|
|
{
|
|
|
|
bool enable;
|
|
|
|
float opacity;
|
|
|
|
float scale_factor;
|
|
|
|
} deferred;
|
|
|
|
};
|
|
|
|
|
2015-07-08 23:10:30 +00:00
|
|
|
static input_overlay_t *overlay_ptr;
|
2015-07-11 20:45:02 +00:00
|
|
|
static input_overlay_state_t overlay_st_ptr;
|
2015-07-08 23:10:30 +00:00
|
|
|
|
2015-07-12 05:22:52 +00:00
|
|
|
static input_overlay_t *input_overlay_get_ptr(void)
|
2015-07-08 23:10:30 +00:00
|
|
|
{
|
|
|
|
return overlay_ptr;
|
|
|
|
}
|
|
|
|
|
2015-07-12 05:22:52 +00:00
|
|
|
static input_overlay_state_t *input_overlay_get_state_ptr(void)
|
2015-07-08 23:10:30 +00:00
|
|
|
{
|
2015-07-11 20:45:02 +00:00
|
|
|
return &overlay_st_ptr;
|
2015-07-08 23:10:30 +00:00
|
|
|
}
|
|
|
|
|
2015-07-11 21:45:23 +00:00
|
|
|
bool input_overlay_data_is_active(void)
|
2015-07-08 23:10:30 +00:00
|
|
|
{
|
|
|
|
input_overlay_t *overlay = input_overlay_get_ptr();
|
|
|
|
if (!overlay)
|
|
|
|
return false;
|
|
|
|
|
2015-07-11 21:45:23 +00:00
|
|
|
if (overlay->alive)
|
2015-07-08 23:10:30 +00:00
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-01-18 08:25:48 +00:00
|
|
|
/**
|
|
|
|
* input_overlay_scale:
|
|
|
|
* @ol : Overlay handle.
|
|
|
|
* @scale : Scaling factor.
|
|
|
|
*
|
|
|
|
* Scales overlay and all its associated descriptors
|
|
|
|
* by a given scaling factor (@scale).
|
|
|
|
**/
|
|
|
|
static void input_overlay_scale(struct overlay *ol, float scale)
|
2013-02-03 22:35:55 +00:00
|
|
|
{
|
2013-10-22 13:08:17 +00:00
|
|
|
size_t i;
|
2015-01-14 22:15:24 +00:00
|
|
|
|
2015-02-15 06:01:32 +00:00
|
|
|
if (!ol)
|
|
|
|
return;
|
|
|
|
|
2015-01-18 08:25:48 +00:00
|
|
|
if (ol->block_scale)
|
2013-10-16 14:59:24 +00:00
|
|
|
scale = 1.0f;
|
|
|
|
|
2015-01-18 08:25:48 +00:00
|
|
|
ol->scale = scale;
|
|
|
|
ol->mod_w = ol->w * scale;
|
|
|
|
ol->mod_h = ol->h * scale;
|
|
|
|
ol->mod_x = ol->center_x +
|
|
|
|
(ol->x - ol->center_x) * scale;
|
|
|
|
ol->mod_y = ol->center_y +
|
|
|
|
(ol->y - ol->center_y) * scale;
|
2013-10-16 14:59:24 +00:00
|
|
|
|
2015-01-18 08:25:48 +00:00
|
|
|
for (i = 0; i < ol->size; i++)
|
2013-02-03 22:35:55 +00:00
|
|
|
{
|
2015-01-14 22:15:24 +00:00
|
|
|
float scale_w, scale_h, adj_center_x, adj_center_y;
|
2015-01-18 08:25:48 +00:00
|
|
|
struct overlay_desc *desc = &ol->descs[i];
|
2013-10-21 12:26:42 +00:00
|
|
|
|
2015-01-18 08:25:48 +00:00
|
|
|
if (!desc)
|
|
|
|
continue;
|
|
|
|
|
2015-07-11 23:33:14 +00:00
|
|
|
scale_w = ol->mod_w * desc->range_x;
|
|
|
|
scale_h = ol->mod_h * desc->range_y;
|
2013-10-21 12:26:42 +00:00
|
|
|
|
2015-07-11 23:33:14 +00:00
|
|
|
desc->mod_w = 2.0f * scale_w;
|
|
|
|
desc->mod_h = 2.0f * scale_h;
|
2013-10-21 12:26:42 +00:00
|
|
|
|
2015-01-18 08:25:48 +00:00
|
|
|
adj_center_x = ol->mod_x + desc->x * ol->mod_w;
|
|
|
|
adj_center_y = ol->mod_y + desc->y * ol->mod_h;
|
2015-07-11 23:33:14 +00:00
|
|
|
desc->mod_x = adj_center_x - scale_w;
|
|
|
|
desc->mod_y = adj_center_y - scale_h;
|
2013-02-03 22:35:55 +00:00
|
|
|
}
|
2013-10-16 14:59:24 +00:00
|
|
|
}
|
|
|
|
|
2015-07-12 05:22:52 +00:00
|
|
|
static void input_overlay_set_vertex_geom(void)
|
2013-10-16 14:59:24 +00:00
|
|
|
{
|
2013-10-22 13:08:17 +00:00
|
|
|
size_t i;
|
2015-07-12 05:22:52 +00:00
|
|
|
input_overlay_t *ol = input_overlay_get_ptr();
|
2015-01-09 23:21:27 +00:00
|
|
|
|
2015-02-15 06:01:32 +00:00
|
|
|
if (!ol)
|
|
|
|
return;
|
2013-12-31 18:03:58 +00:00
|
|
|
if (ol->active->image.pixels)
|
2013-10-16 14:59:24 +00:00
|
|
|
ol->iface->vertex_geom(ol->iface_data, 0,
|
2014-09-02 14:50:28 +00:00
|
|
|
ol->active->mod_x, ol->active->mod_y,
|
|
|
|
ol->active->mod_w, ol->active->mod_h);
|
2013-10-16 14:59:24 +00:00
|
|
|
|
2013-10-22 13:08:17 +00:00
|
|
|
for (i = 0; i < ol->active->size; i++)
|
2013-02-03 22:35:55 +00:00
|
|
|
{
|
2013-10-16 14:59:24 +00:00
|
|
|
struct overlay_desc *desc = &ol->active->descs[i];
|
2015-01-09 23:21:27 +00:00
|
|
|
|
|
|
|
if (!desc)
|
|
|
|
continue;
|
|
|
|
|
2015-01-14 22:15:24 +00:00
|
|
|
if (!desc->image.pixels)
|
|
|
|
continue;
|
|
|
|
|
2015-07-11 23:33:14 +00:00
|
|
|
if (ol->iface && ol->iface->vertex_geom)
|
|
|
|
ol->iface->vertex_geom(ol->iface_data, desc->image_index,
|
|
|
|
desc->mod_x, desc->mod_y, desc->mod_w, desc->mod_h);
|
2013-02-03 22:35:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-01-09 23:59:05 +00:00
|
|
|
/**
|
|
|
|
* input_overlay_set_scale_factor:
|
|
|
|
* @ol : Overlay handle.
|
|
|
|
* @scale : Factor of scale to apply.
|
|
|
|
*
|
|
|
|
* Scales the overlay by a factor of scale.
|
|
|
|
**/
|
2015-07-12 05:22:52 +00:00
|
|
|
void input_overlay_set_scale_factor(float scale)
|
2013-02-03 22:35:55 +00:00
|
|
|
{
|
2013-10-22 13:08:17 +00:00
|
|
|
size_t i;
|
2015-07-12 05:22:52 +00:00
|
|
|
input_overlay_t *ol = input_overlay_get_ptr();
|
2014-09-28 15:52:15 +00:00
|
|
|
|
|
|
|
if (!ol)
|
|
|
|
return;
|
|
|
|
|
2013-10-22 13:08:17 +00:00
|
|
|
for (i = 0; i < ol->size; i++)
|
2013-02-03 22:35:55 +00:00
|
|
|
input_overlay_scale(&ol->overlays[i], scale);
|
|
|
|
|
2015-07-12 05:22:52 +00:00
|
|
|
input_overlay_set_vertex_geom();
|
2013-02-03 22:35:55 +00:00
|
|
|
}
|
|
|
|
|
2012-12-22 12:27:00 +00:00
|
|
|
static void input_overlay_free_overlay(struct overlay *overlay)
|
|
|
|
{
|
2013-10-22 13:08:17 +00:00
|
|
|
size_t i;
|
2014-05-10 18:26:58 +00:00
|
|
|
|
2014-09-15 12:17:16 +00:00
|
|
|
if (!overlay)
|
|
|
|
return;
|
|
|
|
|
2014-05-28 19:14:11 +00:00
|
|
|
for (i = 0; i < overlay->size; i++)
|
2014-06-17 15:44:48 +00:00
|
|
|
texture_image_free(&overlay->descs[i].image);
|
2014-05-10 18:26:58 +00:00
|
|
|
|
2015-07-11 20:07:05 +00:00
|
|
|
if (overlay->load_images)
|
|
|
|
free(overlay->load_images);
|
|
|
|
overlay->load_images = NULL;
|
|
|
|
if (overlay->descs)
|
|
|
|
free(overlay->descs);
|
|
|
|
overlay->descs = NULL;
|
2014-06-17 15:44:48 +00:00
|
|
|
texture_image_free(&overlay->image);
|
2012-12-22 12:27:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void input_overlay_free_overlays(input_overlay_t *ol)
|
|
|
|
{
|
2013-10-22 13:08:17 +00:00
|
|
|
size_t i;
|
2014-09-15 12:17:16 +00:00
|
|
|
|
|
|
|
if (!ol)
|
|
|
|
return;
|
|
|
|
|
2013-10-22 13:08:17 +00:00
|
|
|
for (i = 0; i < ol->size; i++)
|
2012-12-22 12:27:00 +00:00
|
|
|
input_overlay_free_overlay(&ol->overlays[i]);
|
2014-09-15 12:17:16 +00:00
|
|
|
|
2015-07-11 23:33:14 +00:00
|
|
|
if (ol->overlays)
|
|
|
|
free(ol->overlays);
|
|
|
|
ol->overlays = NULL;
|
2012-12-22 12:27:00 +00:00
|
|
|
}
|
|
|
|
|
2015-03-20 03:12:17 +00:00
|
|
|
static bool input_overlay_load_texture_image(struct overlay *overlay,
|
|
|
|
struct texture_image *image, const char *path)
|
|
|
|
{
|
2015-07-11 20:03:21 +00:00
|
|
|
if (!image)
|
|
|
|
return false;
|
|
|
|
if (!texture_image_load(image, path))
|
2015-03-20 03:12:17 +00:00
|
|
|
return false;
|
|
|
|
|
|
|
|
overlay->load_images[overlay->load_images_size++] = *image;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-07-12 05:22:52 +00:00
|
|
|
static bool input_overlay_load_desc_image(
|
2015-02-23 08:07:04 +00:00
|
|
|
struct overlay_desc *desc,
|
2015-03-19 22:02:50 +00:00
|
|
|
struct overlay *input_overlay,
|
2015-04-13 18:02:06 +00:00
|
|
|
unsigned ol_idx, unsigned desc_idx)
|
2012-12-22 12:27:00 +00:00
|
|
|
{
|
2015-06-12 21:52:52 +00:00
|
|
|
char overlay_desc_image_key[64] = {0};
|
|
|
|
char image_path[PATH_MAX_LENGTH] = {0};
|
2015-07-12 05:22:52 +00:00
|
|
|
input_overlay_t *ol = input_overlay_get_ptr();
|
|
|
|
config_file_t *conf = ol ? config_file_new(ol->overlay_path) : NULL;
|
2015-07-11 18:49:04 +00:00
|
|
|
|
2015-07-12 05:22:52 +00:00
|
|
|
if (!ol || !conf)
|
2015-07-11 18:49:04 +00:00
|
|
|
return false;
|
2015-06-12 21:52:52 +00:00
|
|
|
|
2013-10-16 14:59:24 +00:00
|
|
|
snprintf(overlay_desc_image_key, sizeof(overlay_desc_image_key),
|
2014-10-20 18:31:00 +00:00
|
|
|
"overlay%u_desc%u_overlay", ol_idx, desc_idx);
|
2013-10-16 14:59:24 +00:00
|
|
|
|
2015-07-11 18:49:04 +00:00
|
|
|
if (config_get_path(conf, overlay_desc_image_key,
|
2014-09-02 14:50:28 +00:00
|
|
|
image_path, sizeof(image_path)))
|
2013-10-16 14:59:24 +00:00
|
|
|
{
|
2015-06-12 21:52:52 +00:00
|
|
|
char path[PATH_MAX_LENGTH] = {0};
|
2014-09-02 14:50:28 +00:00
|
|
|
fill_pathname_resolve_relative(path, ol->overlay_path,
|
|
|
|
image_path, sizeof(path));
|
2013-10-16 14:59:24 +00:00
|
|
|
|
2015-03-20 03:12:17 +00:00
|
|
|
if (input_overlay_load_texture_image(input_overlay, &desc->image, path))
|
|
|
|
desc->image_index = input_overlay->load_images_size - 1;
|
2013-10-16 14:59:24 +00:00
|
|
|
}
|
|
|
|
|
2015-03-19 22:13:25 +00:00
|
|
|
input_overlay->pos ++;
|
|
|
|
|
2015-07-11 18:49:04 +00:00
|
|
|
config_file_free(conf);
|
|
|
|
|
2015-04-13 18:02:06 +00:00
|
|
|
return true;
|
2015-03-19 22:13:25 +00:00
|
|
|
}
|
|
|
|
|
2015-07-12 05:22:52 +00:00
|
|
|
static bool input_overlay_load_desc(
|
2015-03-19 22:13:25 +00:00
|
|
|
struct overlay_desc *desc,
|
|
|
|
struct overlay *input_overlay,
|
|
|
|
unsigned ol_idx, unsigned desc_idx,
|
|
|
|
unsigned width, unsigned height,
|
|
|
|
bool normalized, float alpha_mod, float range_mod)
|
|
|
|
{
|
|
|
|
float width_mod, height_mod;
|
2015-06-14 14:53:09 +00:00
|
|
|
uint32_t box_hash, key_hash;
|
2015-06-12 21:52:52 +00:00
|
|
|
bool ret = true;
|
|
|
|
bool by_pixel = false;
|
|
|
|
char overlay_desc_key[64] = {0};
|
|
|
|
char conf_key[64] = {0};
|
|
|
|
char overlay_desc_normalized_key[64] = {0};
|
|
|
|
char overlay[256] = {0};
|
|
|
|
char *save = NULL;
|
|
|
|
char *key = NULL;
|
|
|
|
struct string_list *list = NULL;
|
|
|
|
const char *x = NULL;
|
|
|
|
const char *y = NULL;
|
|
|
|
const char *box = NULL;
|
2015-07-12 05:22:52 +00:00
|
|
|
input_overlay_t *ol = input_overlay_get_ptr();
|
|
|
|
config_file_t *conf = ol ? config_file_new(ol->overlay_path) : NULL;
|
2015-07-11 18:49:04 +00:00
|
|
|
|
2015-07-12 05:22:52 +00:00
|
|
|
if (!ol || !conf)
|
2015-07-11 18:49:04 +00:00
|
|
|
return false;
|
2015-03-19 22:13:25 +00:00
|
|
|
|
|
|
|
snprintf(overlay_desc_key, sizeof(overlay_desc_key),
|
|
|
|
"overlay%u_desc%u", ol_idx, desc_idx);
|
|
|
|
|
2013-10-16 14:59:24 +00:00
|
|
|
snprintf(overlay_desc_normalized_key, sizeof(overlay_desc_normalized_key),
|
2014-10-20 18:31:00 +00:00
|
|
|
"overlay%u_desc%u_normalized", ol_idx, desc_idx);
|
2015-07-11 18:49:04 +00:00
|
|
|
config_get_bool(conf, overlay_desc_normalized_key, &normalized);
|
2015-01-09 23:21:27 +00:00
|
|
|
|
|
|
|
by_pixel = !normalized;
|
2013-10-16 16:27:14 +00:00
|
|
|
|
2013-10-16 14:59:24 +00:00
|
|
|
if (by_pixel && (width == 0 || height == 0))
|
|
|
|
{
|
|
|
|
RARCH_ERR("[Overlay]: Base overlay is not set and not using normalized coordinates.\n");
|
2015-07-11 18:49:04 +00:00
|
|
|
goto error;
|
2013-10-16 14:59:24 +00:00
|
|
|
}
|
|
|
|
|
2015-07-11 18:49:04 +00:00
|
|
|
if (!config_get_array(conf, overlay_desc_key, overlay, sizeof(overlay)))
|
2013-02-17 00:04:04 +00:00
|
|
|
{
|
|
|
|
RARCH_ERR("[Overlay]: Didn't find key: %s.\n", overlay_desc_key);
|
2015-07-11 18:49:04 +00:00
|
|
|
goto error;
|
2013-02-17 00:04:04 +00:00
|
|
|
}
|
2012-12-22 12:27:00 +00:00
|
|
|
|
2015-01-09 23:21:27 +00:00
|
|
|
list = string_split(overlay, ", ");
|
2015-01-14 22:15:24 +00:00
|
|
|
|
2012-12-22 12:27:00 +00:00
|
|
|
if (!list)
|
2013-02-17 00:04:04 +00:00
|
|
|
{
|
|
|
|
RARCH_ERR("[Overlay]: Failed to split overlay desc.\n");
|
2015-07-11 18:49:04 +00:00
|
|
|
goto error;
|
2013-02-17 00:04:04 +00:00
|
|
|
}
|
2012-12-22 12:27:00 +00:00
|
|
|
|
|
|
|
if (list->size < 6)
|
|
|
|
{
|
2013-02-17 00:04:04 +00:00
|
|
|
RARCH_ERR("[Overlay]: Overlay desc is invalid. Requires at least 6 tokens.\n");
|
2015-07-11 18:49:04 +00:00
|
|
|
goto error;
|
2012-12-22 12:27:00 +00:00
|
|
|
}
|
|
|
|
|
2015-06-14 14:53:09 +00:00
|
|
|
key = list->elems[0].data;
|
2015-01-09 23:21:27 +00:00
|
|
|
x = list->elems[1].data;
|
|
|
|
y = list->elems[2].data;
|
|
|
|
box = list->elems[3].data;
|
2012-12-22 12:27:00 +00:00
|
|
|
|
2015-06-14 14:53:09 +00:00
|
|
|
box_hash = djb2_calculate(box);
|
|
|
|
key_hash = djb2_calculate(key);
|
|
|
|
|
2013-01-11 15:43:12 +00:00
|
|
|
desc->key_mask = 0;
|
|
|
|
|
2015-06-14 14:53:09 +00:00
|
|
|
switch (key_hash)
|
2013-02-23 21:57:39 +00:00
|
|
|
{
|
2015-06-14 14:53:09 +00:00
|
|
|
case KEY_ANALOG_LEFT:
|
|
|
|
desc->type = OVERLAY_TYPE_ANALOG_LEFT;
|
|
|
|
break;
|
|
|
|
case KEY_ANALOG_RIGHT:
|
|
|
|
desc->type = OVERLAY_TYPE_ANALOG_RIGHT;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (strstr(key, "retrok_") == key)
|
|
|
|
{
|
|
|
|
desc->type = OVERLAY_TYPE_KEYBOARD;
|
|
|
|
desc->key_mask = input_translate_str_to_rk(key + 7);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
const char *tmp = NULL;
|
|
|
|
|
|
|
|
desc->type = OVERLAY_TYPE_BUTTONS;
|
|
|
|
for (tmp = strtok_r(key, "|", &save); tmp; tmp = strtok_r(NULL, "|", &save))
|
|
|
|
{
|
|
|
|
if (strcmp(tmp, "nul") != 0)
|
|
|
|
desc->key_mask |= UINT64_C(1) << input_translate_str_to_bind_id(tmp);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (desc->key_mask & (UINT64_C(1) << RARCH_OVERLAY_NEXT))
|
|
|
|
{
|
|
|
|
char overlay_target_key[64] = {0};
|
|
|
|
|
|
|
|
snprintf(overlay_target_key, sizeof(overlay_target_key),
|
|
|
|
"overlay%u_desc%u_next_target", ol_idx, desc_idx);
|
2015-07-11 18:49:04 +00:00
|
|
|
config_get_array(conf, overlay_target_key,
|
2015-06-14 14:53:09 +00:00
|
|
|
desc->next_index_name, sizeof(desc->next_index_name));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2013-02-23 21:57:39 +00:00
|
|
|
}
|
|
|
|
|
2015-03-22 03:02:04 +00:00
|
|
|
width_mod = 1.0f;
|
|
|
|
height_mod = 1.0f;
|
|
|
|
|
|
|
|
if (by_pixel)
|
|
|
|
{
|
|
|
|
width_mod /= width;
|
|
|
|
height_mod /= height;
|
|
|
|
}
|
2013-10-16 14:59:24 +00:00
|
|
|
|
|
|
|
desc->x = (float)strtod(x, NULL) * width_mod;
|
|
|
|
desc->y = (float)strtod(y, NULL) * height_mod;
|
2012-12-22 12:27:00 +00:00
|
|
|
|
2015-06-14 14:53:09 +00:00
|
|
|
switch (box_hash)
|
2012-12-22 12:27:00 +00:00
|
|
|
{
|
2015-06-14 14:53:09 +00:00
|
|
|
case BOX_RADIAL:
|
|
|
|
desc->hitbox = OVERLAY_HITBOX_RADIAL;
|
|
|
|
break;
|
|
|
|
case BOX_RECT:
|
|
|
|
desc->hitbox = OVERLAY_HITBOX_RECT;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
RARCH_ERR("[Overlay]: Hitbox type (%s) is invalid. Use \"radial\" or \"rect\".\n", box);
|
2013-09-05 22:52:17 +00:00
|
|
|
ret = false;
|
|
|
|
goto end;
|
2015-06-14 14:53:09 +00:00
|
|
|
}
|
2013-09-05 22:52:17 +00:00
|
|
|
|
2015-06-14 14:53:09 +00:00
|
|
|
switch (desc->type)
|
|
|
|
{
|
|
|
|
case OVERLAY_TYPE_ANALOG_LEFT:
|
|
|
|
case OVERLAY_TYPE_ANALOG_RIGHT:
|
|
|
|
{
|
|
|
|
char overlay_analog_saturate_key[64] = {0};
|
|
|
|
|
|
|
|
if (desc->hitbox != OVERLAY_HITBOX_RADIAL)
|
|
|
|
{
|
|
|
|
RARCH_ERR("[Overlay]: Analog hitbox type must be \"radial\".\n");
|
|
|
|
ret = false;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
snprintf(overlay_analog_saturate_key, sizeof(overlay_analog_saturate_key),
|
|
|
|
"overlay%u_desc%u_saturate_pct", ol_idx, desc_idx);
|
2015-07-11 18:49:04 +00:00
|
|
|
if (!config_get_float(conf, overlay_analog_saturate_key,
|
2015-06-14 14:53:09 +00:00
|
|
|
&desc->analog_saturate_pct))
|
|
|
|
desc->analog_saturate_pct = 1.0f;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* OVERLAY_TYPE_BUTTONS - unhandled */
|
|
|
|
/* OVERLAY_TYPE_KEYBOARD - unhandled */
|
|
|
|
break;
|
2013-09-05 15:38:00 +00:00
|
|
|
}
|
|
|
|
|
2013-10-16 14:59:24 +00:00
|
|
|
desc->range_x = (float)strtod(list->elems[4].data, NULL) * width_mod;
|
|
|
|
desc->range_y = (float)strtod(list->elems[5].data, NULL) * height_mod;
|
|
|
|
|
2015-03-22 03:02:04 +00:00
|
|
|
desc->mod_x = desc->x - desc->range_x;
|
|
|
|
desc->mod_w = 2.0f * desc->range_x;
|
|
|
|
desc->mod_y = desc->y - desc->range_y;
|
|
|
|
desc->mod_h = 2.0f * desc->range_y;
|
2012-12-22 12:27:00 +00:00
|
|
|
|
2014-09-02 14:50:28 +00:00
|
|
|
snprintf(conf_key, sizeof(conf_key),
|
2014-10-20 18:31:00 +00:00
|
|
|
"overlay%u_desc%u_alpha_mod", ol_idx, desc_idx);
|
2013-10-21 10:42:47 +00:00
|
|
|
desc->alpha_mod = alpha_mod;
|
2015-07-11 18:49:04 +00:00
|
|
|
config_get_float(conf, conf_key, &desc->alpha_mod);
|
2013-10-21 10:42:47 +00:00
|
|
|
|
2014-09-02 14:50:28 +00:00
|
|
|
snprintf(conf_key, sizeof(conf_key),
|
2014-10-20 18:31:00 +00:00
|
|
|
"overlay%u_desc%u_range_mod", ol_idx, desc_idx);
|
2013-10-21 10:42:47 +00:00
|
|
|
desc->range_mod = range_mod;
|
2015-07-11 18:49:04 +00:00
|
|
|
config_get_float(conf, conf_key, &desc->range_mod);
|
2013-10-21 10:42:47 +00:00
|
|
|
|
2014-09-02 14:50:28 +00:00
|
|
|
snprintf(conf_key, sizeof(conf_key),
|
2014-10-20 18:31:00 +00:00
|
|
|
"overlay%u_desc%u_movable", ol_idx, desc_idx);
|
2015-07-11 23:33:14 +00:00
|
|
|
desc->movable = false;
|
|
|
|
desc->delta_x = 0.0f;
|
|
|
|
desc->delta_y = 0.0f;
|
2015-07-11 18:49:04 +00:00
|
|
|
config_get_bool(conf, conf_key, &desc->movable);
|
2013-12-31 16:15:28 +00:00
|
|
|
|
2013-10-21 10:42:47 +00:00
|
|
|
desc->range_x_mod = desc->range_x;
|
|
|
|
desc->range_y_mod = desc->range_y;
|
2013-10-16 16:27:14 +00:00
|
|
|
|
2015-03-19 22:02:50 +00:00
|
|
|
input_overlay->pos ++;
|
|
|
|
|
2012-12-22 12:27:00 +00:00
|
|
|
end:
|
|
|
|
if (list)
|
|
|
|
string_list_free(list);
|
2015-07-11 18:49:04 +00:00
|
|
|
if (conf)
|
|
|
|
config_file_free(conf);
|
2012-12-22 12:27:00 +00:00
|
|
|
return ret;
|
2015-07-11 18:49:04 +00:00
|
|
|
|
|
|
|
error:
|
|
|
|
if (list)
|
|
|
|
string_list_free(list);
|
|
|
|
if (conf)
|
|
|
|
config_file_free(conf);
|
|
|
|
return false;
|
2012-12-22 12:27:00 +00:00
|
|
|
}
|
|
|
|
|
2014-09-02 14:50:28 +00:00
|
|
|
static ssize_t input_overlay_find_index(const struct overlay *ol,
|
|
|
|
const char *name, size_t size)
|
2013-02-23 21:57:39 +00:00
|
|
|
{
|
2013-10-22 13:08:17 +00:00
|
|
|
size_t i;
|
2015-01-09 23:21:27 +00:00
|
|
|
|
2015-02-15 06:01:32 +00:00
|
|
|
if (!ol)
|
|
|
|
return -1;
|
|
|
|
|
2013-10-22 13:08:17 +00:00
|
|
|
for (i = 0; i < size; i++)
|
2013-02-23 21:57:39 +00:00
|
|
|
{
|
2015-01-14 22:15:24 +00:00
|
|
|
if (!strcmp(ol[i].name, name))
|
2013-02-23 21:57:39 +00:00
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2014-09-02 14:50:28 +00:00
|
|
|
static bool input_overlay_resolve_targets(struct overlay *ol,
|
2014-10-20 18:31:00 +00:00
|
|
|
size_t idx, size_t size)
|
2013-02-23 21:57:39 +00:00
|
|
|
{
|
2013-10-22 13:08:17 +00:00
|
|
|
size_t i;
|
2015-02-15 06:01:32 +00:00
|
|
|
struct overlay *current = NULL;
|
|
|
|
|
|
|
|
if (!ol)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
current = (struct overlay*)&ol[idx];
|
2013-02-23 21:57:39 +00:00
|
|
|
|
2013-10-22 13:08:17 +00:00
|
|
|
for (i = 0; i < current->size; i++)
|
2013-02-23 21:57:39 +00:00
|
|
|
{
|
|
|
|
const char *next = current->descs[i].next_index_name;
|
2015-01-09 23:21:27 +00:00
|
|
|
|
2013-02-23 21:57:39 +00:00
|
|
|
if (*next)
|
|
|
|
{
|
2014-10-20 21:11:28 +00:00
|
|
|
ssize_t next_idx = input_overlay_find_index(ol, next, size);
|
2015-01-09 23:21:27 +00:00
|
|
|
|
2014-10-20 21:11:28 +00:00
|
|
|
if (next_idx < 0)
|
2013-02-23 21:57:39 +00:00
|
|
|
{
|
2014-09-02 14:50:28 +00:00
|
|
|
RARCH_ERR("[Overlay]: Couldn't find overlay called: \"%s\".\n",
|
|
|
|
next);
|
2013-02-23 21:57:39 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-10-20 21:11:28 +00:00
|
|
|
current->descs[i].next_index = next_idx;
|
2013-02-23 21:57:39 +00:00
|
|
|
}
|
|
|
|
else
|
2014-10-20 18:31:00 +00:00
|
|
|
current->descs[i].next_index = (idx + 1) % size;
|
2013-02-23 21:57:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-07-12 05:22:52 +00:00
|
|
|
static void input_overlay_load_active(float opacity)
|
2015-02-27 01:26:15 +00:00
|
|
|
{
|
2015-07-12 05:22:52 +00:00
|
|
|
input_overlay_t *ol = input_overlay_get_ptr();
|
2015-02-27 01:26:15 +00:00
|
|
|
if (!ol)
|
|
|
|
return;
|
|
|
|
|
2015-07-11 23:33:14 +00:00
|
|
|
if (ol->iface && ol->iface->load)
|
|
|
|
ol->iface->load(ol->iface_data, ol->active->load_images,
|
|
|
|
ol->active->load_images_size);
|
2015-02-27 01:26:15 +00:00
|
|
|
|
2015-07-12 05:22:52 +00:00
|
|
|
input_overlay_set_alpha_mod(opacity);
|
|
|
|
input_overlay_set_vertex_geom();
|
2015-07-11 23:33:14 +00:00
|
|
|
|
|
|
|
if (ol->iface && ol->iface->full_screen)
|
|
|
|
ol->iface->full_screen(ol->iface_data, ol->active->full_screen);
|
2015-02-27 01:26:15 +00:00
|
|
|
}
|
|
|
|
|
2015-07-12 05:12:33 +00:00
|
|
|
bool input_overlay_load_overlays_resolve_iterate(void)
|
2015-02-21 08:26:52 +00:00
|
|
|
{
|
2015-07-12 05:12:33 +00:00
|
|
|
input_overlay_t *ol = input_overlay_get_ptr();
|
2015-02-27 00:25:08 +00:00
|
|
|
bool not_done = true;
|
|
|
|
|
2015-02-21 08:26:52 +00:00
|
|
|
if (!ol)
|
|
|
|
return false;
|
|
|
|
|
2015-02-27 01:21:17 +00:00
|
|
|
not_done = ol->resolve_pos < ol->size;
|
2015-02-27 00:25:08 +00:00
|
|
|
|
|
|
|
if (!not_done)
|
|
|
|
{
|
|
|
|
ol->state = OVERLAY_STATUS_DEFERRED_DONE;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-02-27 01:21:17 +00:00
|
|
|
if (!input_overlay_resolve_targets(ol->overlays, ol->resolve_pos, ol->size))
|
2015-02-27 00:25:08 +00:00
|
|
|
{
|
|
|
|
RARCH_ERR("[Overlay]: Failed to resolve next targets.\n");
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2015-02-27 01:26:15 +00:00
|
|
|
if (ol->resolve_pos == 0)
|
|
|
|
{
|
|
|
|
ol->active = &ol->overlays[0];
|
|
|
|
|
2015-07-12 05:22:52 +00:00
|
|
|
input_overlay_load_active(ol->deferred.opacity);
|
2015-02-27 01:26:15 +00:00
|
|
|
input_overlay_enable(ol, ol->deferred.enable);
|
|
|
|
}
|
|
|
|
|
2015-02-27 01:21:17 +00:00
|
|
|
ol->resolve_pos += 1;
|
2015-02-21 08:26:52 +00:00
|
|
|
|
|
|
|
return true;
|
2015-02-27 00:25:08 +00:00
|
|
|
error:
|
|
|
|
ol->state = OVERLAY_STATUS_DEFERRED_ERROR;
|
|
|
|
|
|
|
|
return false;
|
2015-02-21 08:26:52 +00:00
|
|
|
}
|
|
|
|
|
2015-02-23 19:57:49 +00:00
|
|
|
|
|
|
|
static bool input_overlay_load_overlay_image_done(struct overlay *overlay)
|
|
|
|
{
|
|
|
|
overlay->pos = 0;
|
2015-02-23 20:14:34 +00:00
|
|
|
/* Divide iteration steps by half of total descs if size is even,
|
2015-02-27 00:25:08 +00:00
|
|
|
* otherwise default to 8 (arbitrary value for now to speed things up). */
|
|
|
|
overlay->pos_increment = (overlay->size / 2) ? (overlay->size / 2) : 8;
|
2015-02-23 20:14:34 +00:00
|
|
|
|
|
|
|
#if 0
|
|
|
|
RARCH_LOG("pos increment: %u\n", overlay->pos_increment);
|
|
|
|
#endif
|
2015-02-23 19:57:49 +00:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-07-12 05:12:33 +00:00
|
|
|
bool input_overlay_load_overlays_iterate(void)
|
2015-02-21 08:26:52 +00:00
|
|
|
{
|
2015-03-22 07:14:36 +00:00
|
|
|
size_t i = 0;
|
|
|
|
bool not_done = true;
|
2015-03-20 02:30:17 +00:00
|
|
|
struct overlay *overlay = NULL;
|
2015-07-12 05:12:33 +00:00
|
|
|
input_overlay_t *ol = input_overlay_get_ptr();
|
2015-03-20 02:30:17 +00:00
|
|
|
|
2015-02-21 08:26:52 +00:00
|
|
|
if (!ol)
|
|
|
|
return false;
|
|
|
|
|
2015-03-20 02:30:17 +00:00
|
|
|
overlay = &ol->overlays[ol->pos];
|
|
|
|
|
2015-02-21 08:26:52 +00:00
|
|
|
not_done = ol->pos < ol->size;
|
|
|
|
|
|
|
|
if (!not_done)
|
|
|
|
{
|
2015-02-27 00:25:08 +00:00
|
|
|
ol->state = OVERLAY_STATUS_DEFERRED_LOADING_RESOLVE;
|
2015-02-21 08:26:52 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-02-23 05:52:20 +00:00
|
|
|
switch (ol->loading_status)
|
2015-02-21 20:20:21 +00:00
|
|
|
{
|
2015-02-23 05:52:20 +00:00
|
|
|
case OVERLAY_IMAGE_TRANSFER_NONE:
|
2015-02-23 06:34:14 +00:00
|
|
|
case OVERLAY_IMAGE_TRANSFER_BUSY:
|
2015-02-23 06:30:57 +00:00
|
|
|
ol->loading_status = OVERLAY_IMAGE_TRANSFER_DONE;
|
|
|
|
break;
|
|
|
|
case OVERLAY_IMAGE_TRANSFER_DONE:
|
2015-02-23 19:57:49 +00:00
|
|
|
input_overlay_load_overlay_image_done(&ol->overlays[ol->pos]);
|
2015-03-19 22:13:25 +00:00
|
|
|
ol->loading_status = OVERLAY_IMAGE_TRANSFER_DESC_IMAGE_ITERATE;
|
2015-03-14 05:19:16 +00:00
|
|
|
ol->overlays[ol->pos].pos = 0;
|
2015-02-23 19:57:49 +00:00
|
|
|
break;
|
2015-03-19 22:13:25 +00:00
|
|
|
case OVERLAY_IMAGE_TRANSFER_DESC_IMAGE_ITERATE:
|
2015-03-20 02:30:17 +00:00
|
|
|
for (i = 0; i < overlay->pos_increment; i++)
|
2015-03-19 22:13:25 +00:00
|
|
|
{
|
2015-03-20 02:30:17 +00:00
|
|
|
if (overlay->pos < overlay->size)
|
2015-03-19 22:13:25 +00:00
|
|
|
{
|
2015-07-12 05:22:52 +00:00
|
|
|
input_overlay_load_desc_image(
|
2015-04-13 18:02:06 +00:00
|
|
|
&overlay->descs[overlay->pos], overlay,
|
|
|
|
ol->pos, overlay->pos);
|
2015-03-19 22:13:25 +00:00
|
|
|
}
|
2015-03-20 02:30:17 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
overlay->pos = 0;
|
|
|
|
ol->loading_status = OVERLAY_IMAGE_TRANSFER_DESC_ITERATE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2015-03-19 22:13:25 +00:00
|
|
|
}
|
|
|
|
break;
|
2015-02-23 19:57:49 +00:00
|
|
|
case OVERLAY_IMAGE_TRANSFER_DESC_ITERATE:
|
2015-03-20 02:30:17 +00:00
|
|
|
for (i = 0; i < overlay->pos_increment; i++)
|
2015-02-23 05:52:20 +00:00
|
|
|
{
|
2015-03-20 02:30:17 +00:00
|
|
|
if (overlay->pos < overlay->size)
|
2015-03-14 05:29:45 +00:00
|
|
|
{
|
2015-07-12 05:22:52 +00:00
|
|
|
if (!input_overlay_load_desc(&overlay->descs[overlay->pos], overlay,
|
2015-03-20 02:30:17 +00:00
|
|
|
ol->pos, overlay->pos,
|
|
|
|
overlay->image.width, overlay->image.height,
|
|
|
|
overlay->config.normalized,
|
|
|
|
overlay->config.alpha_mod, overlay->config.range_mod))
|
2015-03-19 21:52:15 +00:00
|
|
|
{
|
2015-03-20 02:30:17 +00:00
|
|
|
RARCH_ERR("[Overlay]: Failed to load overlay descs for overlay #%u.\n",
|
|
|
|
(unsigned)overlay->pos);
|
|
|
|
goto error;
|
2015-03-19 21:52:15 +00:00
|
|
|
}
|
|
|
|
|
2015-03-14 05:29:45 +00:00
|
|
|
}
|
2015-03-20 02:30:17 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
overlay->pos = 0;
|
|
|
|
ol->loading_status = OVERLAY_IMAGE_TRANSFER_DESC_DONE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2015-02-23 05:52:20 +00:00
|
|
|
}
|
2015-02-23 19:57:49 +00:00
|
|
|
break;
|
|
|
|
case OVERLAY_IMAGE_TRANSFER_DESC_DONE:
|
2015-02-27 01:26:15 +00:00
|
|
|
if (ol->pos == 0)
|
2015-07-12 05:12:33 +00:00
|
|
|
input_overlay_load_overlays_resolve_iterate();
|
2015-02-23 06:26:34 +00:00
|
|
|
ol->pos += 1;
|
2015-02-27 00:25:08 +00:00
|
|
|
ol->loading_status = OVERLAY_IMAGE_TRANSFER_NONE;
|
2015-02-23 05:52:20 +00:00
|
|
|
break;
|
|
|
|
case OVERLAY_IMAGE_TRANSFER_ERROR:
|
2015-02-23 06:26:34 +00:00
|
|
|
goto error;
|
2015-02-23 05:52:20 +00:00
|
|
|
}
|
2015-02-21 08:26:52 +00:00
|
|
|
|
|
|
|
return true;
|
2015-03-20 02:30:17 +00:00
|
|
|
|
2015-02-21 08:26:52 +00:00
|
|
|
error:
|
|
|
|
ol->state = OVERLAY_STATUS_DEFERRED_ERROR;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-03-14 22:47:13 +00:00
|
|
|
|
2015-07-12 05:12:33 +00:00
|
|
|
bool input_overlay_load_overlays(void)
|
2012-12-22 12:27:00 +00:00
|
|
|
{
|
2015-02-23 17:53:13 +00:00
|
|
|
unsigned i;
|
2015-07-12 05:12:33 +00:00
|
|
|
input_overlay_t *ol = input_overlay_get_ptr();
|
2015-07-11 18:49:04 +00:00
|
|
|
config_file_t *conf = config_file_new(ol->overlay_path);
|
|
|
|
|
2015-07-12 05:12:33 +00:00
|
|
|
if (!ol || !conf)
|
2015-07-11 18:49:04 +00:00
|
|
|
return false;
|
2015-02-21 06:29:13 +00:00
|
|
|
|
2015-03-14 23:16:57 +00:00
|
|
|
for (i = 0; i < ol->pos_increment; i++, ol->pos++)
|
2015-02-23 17:53:13 +00:00
|
|
|
{
|
2015-06-12 21:52:52 +00:00
|
|
|
char conf_key[64] = {0};
|
|
|
|
char overlay_full_screen_key[64] = {0};
|
|
|
|
struct overlay *overlay = NULL;
|
|
|
|
bool to_cont = ol->pos < ol->size;
|
2015-03-14 23:16:57 +00:00
|
|
|
|
|
|
|
if (!to_cont)
|
|
|
|
{
|
|
|
|
ol->pos = 0;
|
|
|
|
ol->state = OVERLAY_STATUS_DEFERRED_LOADING;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
overlay = &ol->overlays[ol->pos];
|
2015-02-23 17:53:13 +00:00
|
|
|
|
|
|
|
if (!overlay)
|
|
|
|
continue;
|
|
|
|
|
2015-02-23 18:06:22 +00:00
|
|
|
snprintf(overlay->config.descs.key,
|
2015-03-14 23:16:57 +00:00
|
|
|
sizeof(overlay->config.descs.key), "overlay%u_descs", ol->pos);
|
2015-02-23 18:06:22 +00:00
|
|
|
|
2015-07-11 18:49:04 +00:00
|
|
|
if (!config_get_uint(conf, overlay->config.descs.key, &overlay->config.descs.size))
|
2015-02-23 18:06:22 +00:00
|
|
|
{
|
|
|
|
RARCH_ERR("[Overlay]: Failed to read number of descs from config key: %s.\n",
|
|
|
|
overlay->config.descs.key);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
overlay->descs = (struct overlay_desc*)
|
|
|
|
calloc(overlay->config.descs.size, sizeof(*overlay->descs));
|
|
|
|
|
|
|
|
if (!overlay->descs)
|
|
|
|
{
|
|
|
|
RARCH_ERR("[Overlay]: Failed to allocate descs.\n");
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
overlay->size = overlay->config.descs.size;
|
|
|
|
|
2015-02-23 18:18:51 +00:00
|
|
|
snprintf(overlay_full_screen_key, sizeof(overlay_full_screen_key),
|
2015-03-14 23:16:57 +00:00
|
|
|
"overlay%u_full_screen", ol->pos);
|
2015-02-23 18:18:51 +00:00
|
|
|
overlay->full_screen = false;
|
2015-07-11 18:49:04 +00:00
|
|
|
config_get_bool(conf, overlay_full_screen_key, &overlay->full_screen);
|
2015-02-23 18:18:51 +00:00
|
|
|
|
|
|
|
overlay->config.normalized = false;
|
|
|
|
overlay->config.alpha_mod = 1.0f;
|
|
|
|
overlay->config.range_mod = 1.0f;
|
|
|
|
|
|
|
|
snprintf(conf_key, sizeof(conf_key),
|
2015-03-14 23:16:57 +00:00
|
|
|
"overlay%u_normalized", ol->pos);
|
2015-07-11 18:49:04 +00:00
|
|
|
config_get_bool(conf, conf_key, &overlay->config.normalized);
|
2015-02-23 18:18:51 +00:00
|
|
|
|
2015-03-14 23:16:57 +00:00
|
|
|
snprintf(conf_key, sizeof(conf_key), "overlay%u_alpha_mod", ol->pos);
|
2015-07-11 18:49:04 +00:00
|
|
|
config_get_float(conf, conf_key, &overlay->config.alpha_mod);
|
2015-02-23 18:18:51 +00:00
|
|
|
|
2015-03-14 23:16:57 +00:00
|
|
|
snprintf(conf_key, sizeof(conf_key), "overlay%u_range_mod", ol->pos);
|
2015-07-11 18:49:04 +00:00
|
|
|
config_get_float(conf, conf_key, &overlay->config.range_mod);
|
2015-02-23 18:18:51 +00:00
|
|
|
|
2015-02-23 18:06:22 +00:00
|
|
|
/* Precache load image array for simplicity. */
|
|
|
|
overlay->load_images = (struct texture_image*)
|
|
|
|
calloc(1 + overlay->size, sizeof(struct texture_image));
|
|
|
|
|
|
|
|
if (!overlay->load_images)
|
|
|
|
{
|
|
|
|
RARCH_ERR("[Overlay]: Failed to allocate load_images.\n");
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2015-02-23 17:53:13 +00:00
|
|
|
snprintf(overlay->config.paths.key, sizeof(overlay->config.paths.key),
|
2015-03-14 23:16:57 +00:00
|
|
|
"overlay%u_overlay", ol->pos);
|
2015-02-23 17:53:13 +00:00
|
|
|
|
2015-07-11 18:49:04 +00:00
|
|
|
config_get_path(conf, overlay->config.paths.key,
|
2015-02-23 17:53:13 +00:00
|
|
|
overlay->config.paths.path, sizeof(overlay->config.paths.path));
|
|
|
|
|
2015-02-27 05:53:10 +00:00
|
|
|
if (overlay->config.paths.path[0] != '\0')
|
|
|
|
{
|
2015-06-12 21:52:52 +00:00
|
|
|
char overlay_resolved_path[PATH_MAX_LENGTH] = {0};
|
2015-02-27 05:53:10 +00:00
|
|
|
|
|
|
|
fill_pathname_resolve_relative(overlay_resolved_path, ol->overlay_path,
|
|
|
|
overlay->config.paths.path, sizeof(overlay_resolved_path));
|
|
|
|
|
2015-03-20 03:12:17 +00:00
|
|
|
if (!input_overlay_load_texture_image(overlay, &overlay->image, overlay_resolved_path))
|
2015-02-27 05:53:10 +00:00
|
|
|
{
|
|
|
|
RARCH_ERR("[Overlay]: Failed to load image: %s.\n",
|
|
|
|
overlay_resolved_path);
|
|
|
|
ol->loading_status = OVERLAY_IMAGE_TRANSFER_ERROR;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2015-02-23 17:53:13 +00:00
|
|
|
snprintf(overlay->config.names.key, sizeof(overlay->config.names.key),
|
2015-03-14 23:16:57 +00:00
|
|
|
"overlay%u_name", ol->pos);
|
2015-07-11 18:49:04 +00:00
|
|
|
config_get_array(conf, overlay->config.names.key,
|
2015-02-23 17:53:13 +00:00
|
|
|
overlay->name, sizeof(overlay->name));
|
|
|
|
|
|
|
|
/* By default, we stretch the overlay out in full. */
|
|
|
|
overlay->x = overlay->y = 0.0f;
|
|
|
|
overlay->w = overlay->h = 1.0f;
|
|
|
|
|
|
|
|
snprintf(overlay->config.rect.key, sizeof(overlay->config.rect.key),
|
2015-03-14 23:16:57 +00:00
|
|
|
"overlay%u_rect", ol->pos);
|
2015-02-23 17:53:13 +00:00
|
|
|
|
2015-07-11 18:49:04 +00:00
|
|
|
if (config_get_array(conf, overlay->config.rect.key,
|
2015-02-23 17:53:13 +00:00
|
|
|
overlay->config.rect.array, sizeof(overlay->config.rect.array)))
|
|
|
|
{
|
|
|
|
struct string_list *list = string_split(overlay->config.rect.array, ", ");
|
|
|
|
|
|
|
|
if (!list || list->size < 4)
|
|
|
|
{
|
|
|
|
RARCH_ERR("[Overlay]: Failed to split rect \"%s\" into at least four tokens.\n",
|
|
|
|
overlay->config.rect.array);
|
|
|
|
string_list_free(list);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
overlay->x = (float)strtod(list->elems[0].data, NULL);
|
|
|
|
overlay->y = (float)strtod(list->elems[1].data, NULL);
|
|
|
|
overlay->w = (float)strtod(list->elems[2].data, NULL);
|
|
|
|
overlay->h = (float)strtod(list->elems[3].data, NULL);
|
|
|
|
string_list_free(list);
|
|
|
|
}
|
2015-02-23 18:21:28 +00:00
|
|
|
|
|
|
|
/* Assume for now that scaling center is in the middle.
|
|
|
|
* TODO: Make this configurable. */
|
|
|
|
overlay->block_scale = false;
|
|
|
|
overlay->center_x = overlay->x + 0.5f * overlay->w;
|
|
|
|
overlay->center_y = overlay->y + 0.5f * overlay->h;
|
2015-02-23 17:53:13 +00:00
|
|
|
}
|
|
|
|
|
2015-07-11 18:49:04 +00:00
|
|
|
if (conf)
|
|
|
|
config_file_free(conf);
|
2013-02-23 21:57:39 +00:00
|
|
|
|
2015-02-21 08:26:52 +00:00
|
|
|
return true;
|
2015-02-21 06:29:13 +00:00
|
|
|
|
2015-02-21 08:26:52 +00:00
|
|
|
error:
|
2015-03-14 23:16:57 +00:00
|
|
|
ol->pos = 0;
|
2015-02-21 08:26:52 +00:00
|
|
|
ol->state = OVERLAY_STATUS_DEFERRED_ERROR;
|
2015-02-21 06:29:13 +00:00
|
|
|
|
2015-07-11 18:49:04 +00:00
|
|
|
if (conf)
|
|
|
|
config_file_free(conf);
|
|
|
|
|
2015-02-21 08:26:52 +00:00
|
|
|
return false;
|
2012-12-22 12:27:00 +00:00
|
|
|
}
|
|
|
|
|
2015-02-27 00:25:08 +00:00
|
|
|
|
2015-07-12 05:12:33 +00:00
|
|
|
bool input_overlay_new_done(void)
|
2015-02-27 00:25:08 +00:00
|
|
|
{
|
2015-07-12 05:12:33 +00:00
|
|
|
input_overlay_t *ol = input_overlay_get_ptr();
|
2015-02-27 00:25:08 +00:00
|
|
|
if (!ol)
|
|
|
|
return false;
|
|
|
|
|
2015-07-12 05:22:52 +00:00
|
|
|
input_overlay_set_alpha_mod(ol->deferred.opacity);
|
|
|
|
input_overlay_set_scale_factor(ol->deferred.scale_factor);
|
2015-02-27 00:25:08 +00:00
|
|
|
|
2015-07-12 05:22:52 +00:00
|
|
|
ol->next_index = (ol->index + 1) % ol->size;
|
|
|
|
ol->state = OVERLAY_STATUS_NONE;
|
|
|
|
ol->alive = true;
|
2015-02-27 00:25:08 +00:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2015-02-21 05:47:04 +00:00
|
|
|
|
2015-03-14 22:47:13 +00:00
|
|
|
static bool input_overlay_load_overlays_init(input_overlay_t *ol)
|
|
|
|
{
|
2015-07-11 18:49:04 +00:00
|
|
|
config_file_t *conf = config_file_new(ol->overlay_path);
|
|
|
|
|
|
|
|
if (!conf)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!config_get_uint(conf, "overlays", &ol->config.overlays.size))
|
2015-03-14 22:47:13 +00:00
|
|
|
{
|
|
|
|
RARCH_ERR("overlays variable not defined in config.\n");
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ol->config.overlays.size)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
ol->overlays = (struct overlay*)calloc(
|
|
|
|
ol->config.overlays.size, sizeof(*ol->overlays));
|
|
|
|
if (!ol->overlays)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
ol->size = ol->config.overlays.size;
|
|
|
|
ol->pos = 0;
|
|
|
|
ol->resolve_pos = 0;
|
2015-03-14 23:16:57 +00:00
|
|
|
ol->pos_increment = (ol->size / 4) ? (ol->size / 4) : 4;
|
2015-03-14 22:47:13 +00:00
|
|
|
|
2015-07-11 18:49:04 +00:00
|
|
|
config_file_free(conf);
|
|
|
|
|
2015-03-14 22:47:13 +00:00
|
|
|
return true;
|
|
|
|
|
|
|
|
error:
|
|
|
|
ol->state = OVERLAY_STATUS_DEFERRED_ERROR;
|
|
|
|
|
2015-07-11 18:49:04 +00:00
|
|
|
if (conf)
|
|
|
|
config_file_free(conf);
|
|
|
|
|
2015-03-14 22:47:13 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-01-09 23:59:05 +00:00
|
|
|
/**
|
|
|
|
* input_overlay_new:
|
2015-01-10 00:03:05 +00:00
|
|
|
* @path : Path to overlay file.
|
|
|
|
* @enable : Enable the overlay after initializing it?
|
2015-01-09 23:59:05 +00:00
|
|
|
*
|
|
|
|
* Creates and initializes an overlay handle.
|
|
|
|
*
|
|
|
|
* Returns: Overlay handle on success, otherwise NULL.
|
|
|
|
**/
|
2015-01-29 19:33:27 +00:00
|
|
|
input_overlay_t *input_overlay_new(const char *path, bool enable,
|
|
|
|
float opacity, float scale_factor)
|
2012-12-20 11:24:49 +00:00
|
|
|
{
|
|
|
|
input_overlay_t *ol = (input_overlay_t*)calloc(1, sizeof(*ol));
|
2015-03-18 18:40:00 +00:00
|
|
|
driver_t *driver = driver_get_ptr();
|
2012-12-20 19:23:53 +00:00
|
|
|
|
2012-12-20 11:24:49 +00:00
|
|
|
if (!ol)
|
|
|
|
goto error;
|
|
|
|
|
2015-03-22 07:14:36 +00:00
|
|
|
ol->overlay_path = strdup(path);
|
2013-10-16 14:59:24 +00:00
|
|
|
if (!ol->overlay_path)
|
|
|
|
{
|
|
|
|
free(ol);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-03-22 22:44:58 +00:00
|
|
|
if (!video_driver_overlay_interface(&ol->iface))
|
2012-12-20 11:24:49 +00:00
|
|
|
{
|
|
|
|
RARCH_ERR("Overlay interface is not present in video driver.\n");
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2015-03-18 18:40:00 +00:00
|
|
|
ol->iface_data = driver->video_data;
|
2012-12-20 11:24:49 +00:00
|
|
|
|
|
|
|
if (!ol->iface)
|
|
|
|
goto error;
|
|
|
|
|
2015-02-21 06:29:13 +00:00
|
|
|
ol->state = OVERLAY_STATUS_DEFERRED_LOAD;
|
|
|
|
ol->deferred.enable = enable;
|
|
|
|
ol->deferred.opacity = opacity;
|
|
|
|
ol->deferred.scale_factor = scale_factor;
|
2015-03-14 23:16:57 +00:00
|
|
|
ol->pos = 0;
|
2013-01-29 20:53:03 +00:00
|
|
|
|
2015-03-14 22:47:13 +00:00
|
|
|
input_overlay_load_overlays_init(ol);
|
|
|
|
|
2012-12-20 11:24:49 +00:00
|
|
|
return ol;
|
|
|
|
|
|
|
|
error:
|
2015-07-12 05:12:33 +00:00
|
|
|
input_overlay_free();
|
2012-12-20 11:24:49 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-01-09 23:59:05 +00:00
|
|
|
/**
|
|
|
|
* input_overlay_enable:
|
|
|
|
* @ol : Overlay handle.
|
|
|
|
* @enable : Enable or disable the overlay
|
|
|
|
*
|
|
|
|
* Enable or disable the overlay.
|
|
|
|
**/
|
2012-12-20 14:37:04 +00:00
|
|
|
void input_overlay_enable(input_overlay_t *ol, bool enable)
|
|
|
|
{
|
2015-01-09 23:21:27 +00:00
|
|
|
if (!ol)
|
|
|
|
return;
|
2012-12-20 14:37:04 +00:00
|
|
|
ol->enable = enable;
|
2015-07-11 23:33:14 +00:00
|
|
|
|
|
|
|
if (ol->iface && ol->iface->enable)
|
|
|
|
ol->iface->enable(ol->iface_data, enable);
|
2012-12-20 14:37:04 +00:00
|
|
|
}
|
|
|
|
|
2015-01-09 23:59:05 +00:00
|
|
|
/**
|
|
|
|
* inside_hitbox:
|
|
|
|
* @desc : Overlay descriptor handle.
|
|
|
|
* @x : X coordinate value.
|
|
|
|
* @y : Y coordinate value.
|
|
|
|
*
|
|
|
|
* Check whether the given @x and @y coordinates of the overlay
|
|
|
|
* descriptor @desc is inside the overlay descriptor's hitbox.
|
|
|
|
*
|
|
|
|
* Returns: true (1) if X, Y coordinates are inside a hitbox, otherwise false (0).
|
|
|
|
**/
|
2012-12-22 12:27:00 +00:00
|
|
|
static bool inside_hitbox(const struct overlay_desc *desc, float x, float y)
|
2012-12-20 11:24:49 +00:00
|
|
|
{
|
2015-02-15 06:01:32 +00:00
|
|
|
if (!desc)
|
|
|
|
return false;
|
|
|
|
|
2012-12-22 12:27:00 +00:00
|
|
|
switch (desc->hitbox)
|
|
|
|
{
|
|
|
|
case OVERLAY_HITBOX_RADIAL:
|
|
|
|
{
|
2014-09-02 14:50:28 +00:00
|
|
|
/* Ellipsis. */
|
2015-01-14 22:15:24 +00:00
|
|
|
float x_dist = (x - desc->x) / desc->range_x_mod;
|
|
|
|
float y_dist = (y - desc->y) / desc->range_y_mod;
|
2012-12-22 12:27:00 +00:00
|
|
|
float sq_dist = x_dist * x_dist + y_dist * y_dist;
|
2015-01-14 22:15:24 +00:00
|
|
|
return (sq_dist <= 1.0f);
|
2012-12-22 12:27:00 +00:00
|
|
|
}
|
2014-01-08 17:14:50 +00:00
|
|
|
|
2012-12-22 12:27:00 +00:00
|
|
|
case OVERLAY_HITBOX_RECT:
|
2013-10-21 10:42:47 +00:00
|
|
|
return (fabs(x - desc->x) <= desc->range_x_mod) &&
|
|
|
|
(fabs(y - desc->y) <= desc->range_y_mod);
|
2012-12-22 12:27:00 +00:00
|
|
|
}
|
2014-09-15 05:03:54 +00:00
|
|
|
|
|
|
|
return false;
|
2012-12-22 12:27:00 +00:00
|
|
|
}
|
2012-12-20 11:24:49 +00:00
|
|
|
|
2015-01-09 23:59:05 +00:00
|
|
|
/**
|
|
|
|
* input_overlay_poll:
|
|
|
|
* @out : Polled output data.
|
|
|
|
* @norm_x : Normalized X coordinate.
|
|
|
|
* @norm_y : Normalized Y coordinate.
|
|
|
|
*
|
|
|
|
* Polls input overlay.
|
|
|
|
*
|
|
|
|
* @norm_x and @norm_y are the result of
|
|
|
|
* input_translate_coord_viewport().
|
|
|
|
**/
|
2015-07-12 05:28:28 +00:00
|
|
|
static void input_overlay_poll(input_overlay_state_t *out,
|
2014-09-02 14:50:28 +00:00
|
|
|
int16_t norm_x, int16_t norm_y)
|
2012-12-20 11:24:49 +00:00
|
|
|
{
|
2013-10-22 13:08:17 +00:00
|
|
|
size_t i;
|
2015-01-09 23:21:27 +00:00
|
|
|
float x, y;
|
2015-07-12 05:28:28 +00:00
|
|
|
input_overlay_t *ol = input_overlay_get_ptr();
|
2015-01-09 23:21:27 +00:00
|
|
|
|
2013-09-05 22:19:07 +00:00
|
|
|
memset(out, 0, sizeof(*out));
|
|
|
|
|
2012-12-20 14:37:04 +00:00
|
|
|
if (!ol->enable)
|
2013-02-17 14:00:38 +00:00
|
|
|
{
|
|
|
|
ol->blocked = false;
|
2013-09-05 22:19:07 +00:00
|
|
|
return;
|
2013-02-17 14:00:38 +00:00
|
|
|
}
|
2012-12-20 14:37:04 +00:00
|
|
|
|
2014-09-02 14:50:28 +00:00
|
|
|
/* norm_x and norm_y is in [-0x7fff, 0x7fff] range,
|
|
|
|
* like RETRO_DEVICE_POINTER. */
|
2015-01-09 23:21:27 +00:00
|
|
|
x = (float)(norm_x + 0x7fff) / 0xffff;
|
|
|
|
y = (float)(norm_y + 0x7fff) / 0xffff;
|
2012-12-20 11:24:49 +00:00
|
|
|
|
2013-05-17 22:18:24 +00:00
|
|
|
x -= ol->active->mod_x;
|
|
|
|
y -= ol->active->mod_y;
|
|
|
|
x /= ol->active->mod_w;
|
|
|
|
y /= ol->active->mod_h;
|
2012-12-22 15:09:15 +00:00
|
|
|
|
2013-10-22 13:08:17 +00:00
|
|
|
for (i = 0; i < ol->active->size; i++)
|
2012-12-20 11:24:49 +00:00
|
|
|
{
|
2015-01-18 08:25:48 +00:00
|
|
|
float x_dist, y_dist;
|
2013-10-21 10:42:47 +00:00
|
|
|
struct overlay_desc *desc = &ol->active->descs[i];
|
2015-01-09 23:21:27 +00:00
|
|
|
|
2015-02-15 06:01:32 +00:00
|
|
|
if (!desc)
|
|
|
|
continue;
|
2013-10-21 10:42:47 +00:00
|
|
|
if (!inside_hitbox(desc, x, y))
|
2013-09-05 15:38:00 +00:00
|
|
|
continue;
|
|
|
|
|
2013-12-27 01:37:52 +00:00
|
|
|
desc->updated = true;
|
2015-03-22 07:14:36 +00:00
|
|
|
x_dist = x - desc->x;
|
|
|
|
y_dist = y - desc->y;
|
2015-01-18 08:25:48 +00:00
|
|
|
|
2015-07-11 23:33:14 +00:00
|
|
|
switch (desc->type)
|
2013-02-23 21:57:39 +00:00
|
|
|
{
|
2015-07-11 23:33:14 +00:00
|
|
|
case OVERLAY_TYPE_BUTTONS:
|
|
|
|
{
|
|
|
|
uint64_t mask = desc->key_mask;
|
2015-01-09 23:21:27 +00:00
|
|
|
|
2015-07-11 23:33:14 +00:00
|
|
|
out->buttons |= mask;
|
2013-02-23 21:57:39 +00:00
|
|
|
|
2015-07-11 23:33:14 +00:00
|
|
|
if (mask & (UINT64_C(1) << RARCH_OVERLAY_NEXT))
|
|
|
|
ol->next_index = desc->next_index;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case OVERLAY_TYPE_KEYBOARD:
|
|
|
|
if (desc->key_mask < RETROK_LAST)
|
|
|
|
OVERLAY_SET_KEY(out, desc->key_mask);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
float x_val = x_dist / desc->range_x;
|
|
|
|
float y_val = y_dist / desc->range_y;
|
|
|
|
float x_val_sat = x_val / desc->analog_saturate_pct;
|
|
|
|
float y_val_sat = y_val / desc->analog_saturate_pct;
|
2013-09-05 22:52:17 +00:00
|
|
|
|
2015-07-11 23:33:14 +00:00
|
|
|
unsigned int base = (desc->type == OVERLAY_TYPE_ANALOG_RIGHT) ? 2 : 0;
|
2015-01-14 22:15:24 +00:00
|
|
|
|
2015-07-11 23:33:14 +00:00
|
|
|
out->analog[base + 0] = clamp_float(x_val_sat, -1.0f, 1.0f) * 32767.0f;
|
|
|
|
out->analog[base + 1] = clamp_float(y_val_sat, -1.0f, 1.0f) * 32767.0f;
|
|
|
|
}
|
|
|
|
break;
|
2013-12-31 16:15:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (desc->movable)
|
|
|
|
{
|
2014-10-26 01:18:56 +00:00
|
|
|
desc->delta_x = clamp_float(x_dist, -desc->range_x, desc->range_x)
|
2014-09-02 14:50:28 +00:00
|
|
|
* ol->active->mod_w;
|
2014-10-26 01:18:56 +00:00
|
|
|
desc->delta_y = clamp_float(y_dist, -desc->range_y, desc->range_y)
|
2014-09-02 14:50:28 +00:00
|
|
|
* ol->active->mod_h;
|
2013-09-05 15:38:00 +00:00
|
|
|
}
|
2012-12-20 11:24:49 +00:00
|
|
|
}
|
|
|
|
|
2013-09-05 22:19:07 +00:00
|
|
|
if (!out->buttons)
|
2013-02-17 14:00:38 +00:00
|
|
|
ol->blocked = false;
|
|
|
|
else if (ol->blocked)
|
2013-09-05 22:19:07 +00:00
|
|
|
memset(out, 0, sizeof(*out));
|
2012-12-20 11:24:49 +00:00
|
|
|
}
|
|
|
|
|
2015-01-18 08:25:48 +00:00
|
|
|
/**
|
|
|
|
* input_overlay_update_desc_geom:
|
|
|
|
* @ol : overlay handle.
|
|
|
|
* @desc : overlay descriptors handle.
|
|
|
|
*
|
|
|
|
* Update input overlay descriptors' vertex geometry.
|
|
|
|
**/
|
2014-09-02 14:50:28 +00:00
|
|
|
static void input_overlay_update_desc_geom(input_overlay_t *ol,
|
|
|
|
struct overlay_desc *desc)
|
2013-12-31 16:15:28 +00:00
|
|
|
{
|
2015-02-15 06:01:32 +00:00
|
|
|
if (!desc || !desc->image.pixels)
|
2015-01-18 08:25:48 +00:00
|
|
|
return;
|
|
|
|
if (!desc->movable)
|
|
|
|
return;
|
2013-12-31 16:15:28 +00:00
|
|
|
|
2015-07-11 23:33:14 +00:00
|
|
|
if (ol->iface && ol->iface->vertex_geom)
|
|
|
|
ol->iface->vertex_geom(ol->iface_data, desc->image_index,
|
|
|
|
desc->mod_x + desc->delta_x, desc->mod_y + desc->delta_y,
|
|
|
|
desc->mod_w, desc->mod_h);
|
2015-01-18 08:25:48 +00:00
|
|
|
|
|
|
|
desc->delta_x = 0.0f;
|
|
|
|
desc->delta_y = 0.0f;
|
2013-12-31 16:15:28 +00:00
|
|
|
}
|
|
|
|
|
2015-01-09 23:59:05 +00:00
|
|
|
/**
|
|
|
|
* input_overlay_post_poll:
|
|
|
|
*
|
|
|
|
* Called after all the input_overlay_poll() calls to
|
|
|
|
* update the range modifiers for pressed/unpressed regions
|
|
|
|
* and alpha mods.
|
|
|
|
**/
|
2015-07-12 05:28:28 +00:00
|
|
|
void input_overlay_post_poll(float opacity)
|
2013-12-27 01:37:52 +00:00
|
|
|
{
|
|
|
|
size_t i;
|
2015-07-12 05:28:28 +00:00
|
|
|
input_overlay_t *ol = input_overlay_get_ptr();
|
2013-12-27 01:37:52 +00:00
|
|
|
|
2015-02-15 05:57:02 +00:00
|
|
|
if (!ol)
|
|
|
|
return;
|
|
|
|
|
2015-07-12 05:22:52 +00:00
|
|
|
input_overlay_set_alpha_mod(opacity);
|
2013-12-27 02:39:07 +00:00
|
|
|
|
2013-12-27 01:37:52 +00:00
|
|
|
for (i = 0; i < ol->active->size; i++)
|
|
|
|
{
|
|
|
|
struct overlay_desc *desc = &ol->active->descs[i];
|
|
|
|
|
2015-01-09 23:21:27 +00:00
|
|
|
if (!desc)
|
|
|
|
continue;
|
|
|
|
|
2015-01-14 22:15:24 +00:00
|
|
|
desc->range_x_mod = desc->range_x;
|
|
|
|
desc->range_y_mod = desc->range_y;
|
|
|
|
|
2013-12-27 01:37:52 +00:00
|
|
|
if (desc->updated)
|
|
|
|
{
|
2014-09-02 14:50:28 +00:00
|
|
|
/* If pressed this frame, change the hitbox. */
|
2015-01-14 22:15:24 +00:00
|
|
|
desc->range_x_mod *= desc->range_mod;
|
|
|
|
desc->range_y_mod *= desc->range_mod;
|
2013-12-27 02:39:07 +00:00
|
|
|
|
2013-12-31 18:03:58 +00:00
|
|
|
if (desc->image.pixels)
|
2015-07-11 23:33:14 +00:00
|
|
|
{
|
|
|
|
if (ol->iface && ol->iface->set_alpha)
|
|
|
|
ol->iface->set_alpha(ol->iface_data, desc->image_index,
|
|
|
|
desc->alpha_mod * opacity);
|
|
|
|
}
|
2013-12-27 01:37:52 +00:00
|
|
|
}
|
|
|
|
|
2013-12-31 16:15:28 +00:00
|
|
|
input_overlay_update_desc_geom(ol, desc);
|
2013-12-27 01:37:52 +00:00
|
|
|
desc->updated = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-01-09 23:59:05 +00:00
|
|
|
/**
|
|
|
|
* input_overlay_poll_clear:
|
|
|
|
* @ol : overlay handle
|
|
|
|
*
|
|
|
|
* Call when there is nothing to poll. Allows overlay to
|
|
|
|
* clear certain state.
|
|
|
|
**/
|
2015-07-12 05:28:28 +00:00
|
|
|
void input_overlay_poll_clear(float opacity)
|
2013-02-17 14:00:38 +00:00
|
|
|
{
|
2013-10-22 13:08:17 +00:00
|
|
|
size_t i;
|
2015-07-12 05:28:28 +00:00
|
|
|
input_overlay_t *ol = input_overlay_get_ptr();
|
2015-01-09 23:21:27 +00:00
|
|
|
|
2015-02-15 06:01:32 +00:00
|
|
|
if (!ol)
|
|
|
|
return;
|
|
|
|
|
2013-02-17 14:00:38 +00:00
|
|
|
ol->blocked = false;
|
2015-01-29 21:54:42 +00:00
|
|
|
|
2015-07-12 05:22:52 +00:00
|
|
|
input_overlay_set_alpha_mod(opacity);
|
2013-10-21 10:42:47 +00:00
|
|
|
|
2013-10-22 13:08:17 +00:00
|
|
|
for (i = 0; i < ol->active->size; i++)
|
2013-10-21 10:42:47 +00:00
|
|
|
{
|
|
|
|
struct overlay_desc *desc = &ol->active->descs[i];
|
2015-01-09 23:21:27 +00:00
|
|
|
|
|
|
|
if (!desc)
|
|
|
|
continue;
|
|
|
|
|
2013-10-21 10:42:47 +00:00
|
|
|
desc->range_x_mod = desc->range_x;
|
|
|
|
desc->range_y_mod = desc->range_y;
|
2013-12-27 01:37:52 +00:00
|
|
|
desc->updated = false;
|
2013-12-31 16:15:28 +00:00
|
|
|
|
|
|
|
desc->delta_x = 0.0f;
|
|
|
|
desc->delta_y = 0.0f;
|
|
|
|
input_overlay_update_desc_geom(ol, desc);
|
2013-10-21 10:42:47 +00:00
|
|
|
}
|
2013-02-17 14:00:38 +00:00
|
|
|
}
|
|
|
|
|
2015-01-09 23:59:05 +00:00
|
|
|
/**
|
|
|
|
* input_overlay_next:
|
|
|
|
* @ol : Overlay handle.
|
|
|
|
*
|
|
|
|
* Switch to the next available overlay
|
|
|
|
* screen.
|
|
|
|
**/
|
2015-07-12 05:22:52 +00:00
|
|
|
void input_overlay_next(float opacity)
|
2012-12-20 11:24:49 +00:00
|
|
|
{
|
2015-07-12 05:22:52 +00:00
|
|
|
input_overlay_t *ol = input_overlay_get_ptr();
|
2014-10-03 12:53:04 +00:00
|
|
|
if (!ol)
|
|
|
|
return;
|
|
|
|
|
2015-07-12 05:22:52 +00:00
|
|
|
ol->index = ol->next_index;
|
|
|
|
ol->active = &ol->overlays[ol->index];
|
2012-12-22 12:27:00 +00:00
|
|
|
|
2015-07-12 05:22:52 +00:00
|
|
|
input_overlay_load_active(opacity);
|
2013-10-16 14:59:24 +00:00
|
|
|
|
2015-07-12 05:22:52 +00:00
|
|
|
ol->blocked = true;
|
2013-02-24 11:52:48 +00:00
|
|
|
ol->next_index = (ol->index + 1) % ol->size;
|
2013-01-11 15:23:04 +00:00
|
|
|
}
|
|
|
|
|
2015-01-09 23:59:05 +00:00
|
|
|
/**
|
|
|
|
* input_overlay_full_screen:
|
|
|
|
*
|
|
|
|
* Checks if the overlay is fullscreen.
|
|
|
|
*
|
|
|
|
* Returns: true (1) if overlay is fullscreen, otherwise false (0).
|
|
|
|
**/
|
2015-07-12 05:28:28 +00:00
|
|
|
bool input_overlay_full_screen(void)
|
2013-01-11 15:23:04 +00:00
|
|
|
{
|
2015-07-12 05:28:28 +00:00
|
|
|
input_overlay_t *ol = input_overlay_get_ptr();
|
2014-07-25 17:52:44 +00:00
|
|
|
if (!ol)
|
|
|
|
return false;
|
2013-01-11 15:23:04 +00:00
|
|
|
return ol->active->full_screen;
|
2012-12-20 11:24:49 +00:00
|
|
|
}
|
|
|
|
|
2015-01-09 23:59:05 +00:00
|
|
|
/**
|
|
|
|
* input_overlay_free:
|
|
|
|
* @ol : Overlay handle.
|
|
|
|
*
|
|
|
|
* Frees overlay handle.
|
|
|
|
**/
|
2015-07-12 05:12:33 +00:00
|
|
|
void input_overlay_free(void)
|
2012-12-20 11:24:49 +00:00
|
|
|
{
|
2015-07-12 05:12:33 +00:00
|
|
|
input_overlay_t *ol = input_overlay_get_ptr();
|
2012-12-20 11:24:49 +00:00
|
|
|
if (!ol)
|
|
|
|
return;
|
|
|
|
|
2012-12-22 12:27:00 +00:00
|
|
|
input_overlay_free_overlays(ol);
|
|
|
|
|
2015-07-11 23:33:14 +00:00
|
|
|
if (ol->iface && ol->iface->enable)
|
2012-12-20 11:24:49 +00:00
|
|
|
ol->iface->enable(ol->iface_data, false);
|
|
|
|
|
2015-07-11 23:33:14 +00:00
|
|
|
if (ol->overlay_path)
|
|
|
|
free(ol->overlay_path);
|
|
|
|
ol->overlay_path = NULL;
|
2012-12-20 11:24:49 +00:00
|
|
|
free(ol);
|
|
|
|
}
|
|
|
|
|
2015-07-08 23:10:30 +00:00
|
|
|
void input_overlay_free_ptr(void)
|
|
|
|
{
|
2015-07-12 05:12:33 +00:00
|
|
|
input_overlay_free();
|
2015-07-08 23:10:30 +00:00
|
|
|
overlay_ptr = NULL;
|
|
|
|
|
2015-07-11 20:45:02 +00:00
|
|
|
memset(&overlay_st_ptr, 0, sizeof(overlay_st_ptr));
|
2015-07-08 23:10:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int input_overlay_new_ptr(void)
|
|
|
|
{
|
|
|
|
driver_t *driver = driver_get_ptr();
|
|
|
|
settings_t *settings = config_get_ptr();
|
|
|
|
|
|
|
|
if (driver->osk_enable)
|
|
|
|
{
|
|
|
|
if (!*settings->osk.overlay)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (!*settings->input.overlay)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
overlay_ptr = input_overlay_new(
|
|
|
|
driver->osk_enable ?
|
|
|
|
settings->osk.overlay : settings->input.overlay,
|
|
|
|
driver->osk_enable ?
|
|
|
|
settings->osk.enable : settings->input.overlay_enable,
|
|
|
|
settings->input.overlay_opacity,
|
|
|
|
settings->input.overlay_scale);
|
|
|
|
|
|
|
|
if (!overlay_ptr)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-01-09 23:59:05 +00:00
|
|
|
/**
|
|
|
|
* input_overlay_set_alpha_mod:
|
|
|
|
* @ol : Overlay handle.
|
|
|
|
* @mod : New modulating factor to apply.
|
|
|
|
*
|
|
|
|
* Sets a modulating factor for alpha channel. Default is 1.0.
|
|
|
|
* The alpha factor is applied for all overlays.
|
|
|
|
**/
|
2015-07-12 05:22:52 +00:00
|
|
|
void input_overlay_set_alpha_mod(float mod)
|
2013-01-29 20:51:15 +00:00
|
|
|
{
|
2013-10-22 13:08:17 +00:00
|
|
|
unsigned i;
|
2015-07-12 05:22:52 +00:00
|
|
|
input_overlay_t *ol = input_overlay_get_ptr();
|
2014-09-28 15:52:15 +00:00
|
|
|
|
|
|
|
if (!ol)
|
|
|
|
return;
|
|
|
|
|
2013-10-22 13:08:17 +00:00
|
|
|
for (i = 0; i < ol->active->load_images_size; i++)
|
2015-01-29 19:33:27 +00:00
|
|
|
ol->iface->set_alpha(ol->iface_data, i, mod);
|
2013-01-29 20:51:15 +00:00
|
|
|
}
|
2015-07-11 06:07:14 +00:00
|
|
|
|
2015-07-12 05:03:39 +00:00
|
|
|
bool input_overlay_is_alive(void)
|
2015-07-11 06:07:14 +00:00
|
|
|
{
|
2015-07-12 05:03:39 +00:00
|
|
|
input_overlay_t *ol = input_overlay_get_ptr();
|
2015-07-11 06:07:14 +00:00
|
|
|
if (!ol)
|
|
|
|
return false;
|
2015-07-11 21:45:23 +00:00
|
|
|
return ol->alive;
|
2015-07-11 06:07:14 +00:00
|
|
|
}
|
|
|
|
|
2015-07-12 05:12:33 +00:00
|
|
|
enum overlay_status input_overlay_status(void)
|
2015-07-11 06:07:14 +00:00
|
|
|
{
|
2015-07-12 05:12:33 +00:00
|
|
|
input_overlay_t *ol = input_overlay_get_ptr();
|
2015-07-11 06:07:14 +00:00
|
|
|
if (!ol)
|
|
|
|
return OVERLAY_STATUS_NONE;
|
|
|
|
return ol->state;
|
|
|
|
}
|
2015-07-12 04:47:39 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* input_poll_overlay:
|
|
|
|
*
|
|
|
|
* Poll pressed buttons/keys on currently active overlay.
|
|
|
|
**/
|
|
|
|
void input_poll_overlay(float opacity)
|
|
|
|
{
|
|
|
|
input_overlay_state_t old_key_state;
|
|
|
|
unsigned i, j, device;
|
|
|
|
uint16_t key_mod = 0;
|
|
|
|
bool polled = false;
|
|
|
|
settings_t *settings = config_get_ptr();
|
|
|
|
input_overlay_state_t *ol_state = input_overlay_get_state_ptr();
|
|
|
|
|
2015-07-12 05:03:39 +00:00
|
|
|
if (!input_overlay_is_alive() || !ol_state)
|
2015-07-12 04:47:39 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
memcpy(old_key_state.keys, ol_state->keys,
|
|
|
|
sizeof(ol_state->keys));
|
|
|
|
memset(ol_state, 0, sizeof(*ol_state));
|
|
|
|
|
2015-07-12 05:28:28 +00:00
|
|
|
device = input_overlay_full_screen() ?
|
2015-07-12 04:47:39 +00:00
|
|
|
RARCH_DEVICE_POINTER_SCREEN : RETRO_DEVICE_POINTER;
|
|
|
|
|
|
|
|
for (i = 0;
|
|
|
|
input_driver_state(NULL, 0, device, i,
|
|
|
|
RETRO_DEVICE_ID_POINTER_PRESSED);
|
|
|
|
i++)
|
|
|
|
{
|
|
|
|
input_overlay_state_t polled_data;
|
|
|
|
int16_t x = input_driver_state(NULL, 0,
|
|
|
|
device, i, RETRO_DEVICE_ID_POINTER_X);
|
|
|
|
int16_t y = input_driver_state(NULL, 0,
|
|
|
|
device, i, RETRO_DEVICE_ID_POINTER_Y);
|
|
|
|
|
2015-07-12 05:28:28 +00:00
|
|
|
input_overlay_poll(&polled_data, x, y);
|
2015-07-12 04:47:39 +00:00
|
|
|
|
|
|
|
ol_state->buttons |= polled_data.buttons;
|
|
|
|
|
|
|
|
for (j = 0; j < ARRAY_SIZE(ol_state->keys); j++)
|
|
|
|
ol_state->keys[j] |= polled_data.keys[j];
|
|
|
|
|
|
|
|
/* Fingers pressed later take prio and matched up
|
|
|
|
* with overlay poll priorities. */
|
|
|
|
for (j = 0; j < 4; j++)
|
|
|
|
if (polled_data.analog[j])
|
|
|
|
ol_state->analog[j] = polled_data.analog[j];
|
|
|
|
|
|
|
|
polled = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (OVERLAY_GET_KEY(ol_state, RETROK_LSHIFT) ||
|
|
|
|
OVERLAY_GET_KEY(ol_state, RETROK_RSHIFT))
|
|
|
|
key_mod |= RETROKMOD_SHIFT;
|
|
|
|
|
|
|
|
if (OVERLAY_GET_KEY(ol_state, RETROK_LCTRL) ||
|
|
|
|
OVERLAY_GET_KEY(ol_state, RETROK_RCTRL))
|
|
|
|
key_mod |= RETROKMOD_CTRL;
|
|
|
|
|
|
|
|
if (OVERLAY_GET_KEY(ol_state, RETROK_LALT) ||
|
|
|
|
OVERLAY_GET_KEY(ol_state, RETROK_RALT))
|
|
|
|
key_mod |= RETROKMOD_ALT;
|
|
|
|
|
|
|
|
if (OVERLAY_GET_KEY(ol_state, RETROK_LMETA) ||
|
|
|
|
OVERLAY_GET_KEY(ol_state, RETROK_RMETA))
|
|
|
|
key_mod |= RETROKMOD_META;
|
|
|
|
|
|
|
|
/* CAPSLOCK SCROLLOCK NUMLOCK */
|
|
|
|
for (i = 0; i < ARRAY_SIZE(ol_state->keys); i++)
|
|
|
|
{
|
|
|
|
if (ol_state->keys[i] != old_key_state.keys[i])
|
|
|
|
{
|
|
|
|
uint32_t orig_bits = old_key_state.keys[i];
|
|
|
|
uint32_t new_bits = ol_state->keys[i];
|
|
|
|
|
|
|
|
for (j = 0; j < 32; j++)
|
|
|
|
if ((orig_bits & (1 << j)) != (new_bits & (1 << j)))
|
|
|
|
input_keyboard_event(new_bits & (1 << j),
|
|
|
|
i * 32 + j, 0, key_mod, RETRO_DEVICE_POINTER);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Map "analog" buttons to analog axes like regular input drivers do. */
|
|
|
|
for (j = 0; j < 4; j++)
|
|
|
|
{
|
|
|
|
unsigned bind_plus = RARCH_ANALOG_LEFT_X_PLUS + 2 * j;
|
|
|
|
unsigned bind_minus = bind_plus + 1;
|
|
|
|
|
|
|
|
if (ol_state->analog[j])
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (ol_state->buttons & (1UL << bind_plus))
|
|
|
|
ol_state->analog[j] += 0x7fff;
|
|
|
|
if (ol_state->buttons & (1UL << bind_minus))
|
|
|
|
ol_state->analog[j] -= 0x7fff;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check for analog_dpad_mode.
|
|
|
|
* Map analogs to d-pad buttons when configured. */
|
|
|
|
switch (settings->input.analog_dpad_mode[0])
|
|
|
|
{
|
|
|
|
case ANALOG_DPAD_LSTICK:
|
|
|
|
case ANALOG_DPAD_RSTICK:
|
|
|
|
{
|
|
|
|
float analog_x, analog_y;
|
|
|
|
unsigned analog_base = 2;
|
|
|
|
|
|
|
|
if (settings->input.analog_dpad_mode[0] == ANALOG_DPAD_LSTICK)
|
|
|
|
analog_base = 0;
|
|
|
|
|
|
|
|
analog_x = (float)ol_state->analog[analog_base + 0] / 0x7fff;
|
|
|
|
analog_y = (float)ol_state->analog[analog_base + 1] / 0x7fff;
|
|
|
|
|
|
|
|
if (analog_x <= -settings->input.axis_threshold)
|
|
|
|
ol_state->buttons |= (1UL << RETRO_DEVICE_ID_JOYPAD_LEFT);
|
|
|
|
if (analog_x >= settings->input.axis_threshold)
|
|
|
|
ol_state->buttons |= (1UL << RETRO_DEVICE_ID_JOYPAD_RIGHT);
|
|
|
|
if (analog_y <= -settings->input.axis_threshold)
|
|
|
|
ol_state->buttons |= (1UL << RETRO_DEVICE_ID_JOYPAD_UP);
|
|
|
|
if (analog_y >= settings->input.axis_threshold)
|
|
|
|
ol_state->buttons |= (1UL << RETRO_DEVICE_ID_JOYPAD_DOWN);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (polled)
|
2015-07-12 05:28:28 +00:00
|
|
|
input_overlay_post_poll(opacity);
|
2015-07-12 04:47:39 +00:00
|
|
|
else
|
2015-07-12 05:28:28 +00:00
|
|
|
input_overlay_poll_clear(opacity);
|
2015-07-12 04:47:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void input_state_overlay(int16_t *ret, unsigned port, unsigned device, unsigned idx,
|
|
|
|
unsigned id)
|
|
|
|
{
|
|
|
|
input_overlay_state_t *ol_state = input_overlay_get_state_ptr();
|
|
|
|
|
|
|
|
if (!ol_state)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (port != 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
switch (device)
|
|
|
|
{
|
|
|
|
case RETRO_DEVICE_JOYPAD:
|
|
|
|
if (ol_state && ol_state->buttons & (UINT64_C(1) << id))
|
|
|
|
*ret |= 1;
|
|
|
|
break;
|
|
|
|
case RETRO_DEVICE_KEYBOARD:
|
|
|
|
if (id < RETROK_LAST)
|
|
|
|
{
|
|
|
|
if (OVERLAY_GET_KEY(ol_state, id))
|
|
|
|
*ret |= 1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case RETRO_DEVICE_ANALOG:
|
|
|
|
{
|
|
|
|
unsigned base = 0;
|
|
|
|
|
|
|
|
if (idx == RETRO_DEVICE_INDEX_ANALOG_RIGHT)
|
|
|
|
base = 2;
|
|
|
|
if (id == RETRO_DEVICE_ID_ANALOG_Y)
|
|
|
|
base += 1;
|
|
|
|
if (ol_state && ol_state->analog[base])
|
|
|
|
*ret = ol_state->analog[base];
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2015-07-12 04:54:35 +00:00
|
|
|
|
|
|
|
bool input_overlay_key_pressed(int key)
|
|
|
|
{
|
|
|
|
input_overlay_state_t *ol_state = input_overlay_get_state_ptr();
|
|
|
|
|
|
|
|
if (!ol_state)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return (ol_state->buttons & (1ULL << key));
|
|
|
|
}
|