bool gfx_ctx_menu_init(void)
{
gl_t *gl = driver.video_data;
if (!gl)
return false;
#ifdef HAVE_CG_MENU
glGenTextures(1, &gl->menu_texture_id);
RARCH_LOG("Loading texture image for menu...\n");
if (!texture_image_load(default_paths.menu_border_file, &menu_texture))
{
RARCH_ERR("Failed to load texture image for menu.\n");
return false;
}
glBindTexture(GL_TEXTURE_2D, gl->menu_texture_id);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_ARGB_SCE, menu_texture.width, menu_texture.height, 0,
GL_ARGB_SCE, GL_UNSIGNED_INT_8_8_8_8, menu_texture.pixels);
glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
free(menu_texture.pixels);
#endif
return true;
}
void texture_image_border_load(const char *path)
{
gl_t *gl = driver.video_data;
if (!gl)
return;
#ifdef HAVE_RMENU
glGenTextures(1, &menu_texture_id);
RARCH_LOG("Loading texture image for menu...\n");
if (!texture_image_load(path, &g_extern.console.menu_texture))
{
RARCH_ERR("Failed to load texture image for menu.\n");
return;
}
glBindTexture(GL_TEXTURE_2D, menu_texture_id);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, gl->border_type);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, gl->border_type);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, RARCH_GL_INTERNAL_FORMAT32,
g_extern.console.menu_texture.width, g_extern.console.menu_texture.height, 0,
RARCH_GL_TEXTURE_TYPE32, RARCH_GL_FORMAT32, g_extern.console.menu_texture.pixels);
glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
free(g_extern.console.menu_texture.pixels);
#endif
}
static bool load_textures(void)
{
unsigned i;
if (!cg_shader->luts)
return true;
glGenTextures(cg_shader->luts, lut_textures);
for (i = 0; i < cg_shader->luts; i++)
{
RARCH_LOG("Loading image from: \"%s\".\n",
cg_shader->lut[i].path);
struct texture_image img = {0};
if (!texture_image_load(cg_shader->lut[i].path, &img))
{
RARCH_ERR("Failed to load picture ...\n");
return false;
}
load_texture_data(lut_textures[i], &img,
cg_shader->lut[i].filter != RARCH_FILTER_NEAREST,
gl_wrap_type_to_enum(cg_shader->lut[i].wrap));
texture_image_free(&img);
}
glBindTexture(GL_TEXTURE_2D, 0);
return true;
}
bool gl_load_luts(const struct gfx_shader *generic_shader, GLuint *lut_textures)
{
unsigned i, num_luts;
num_luts = min(generic_shader->luts, GFX_MAX_TEXTURES);
if (!generic_shader->luts)
return true;
// Original shader_glsl.c code only generated one texture handle. I assume
// it was a bug, but if not, replace num_luts with 1 when GLSL is used.
glGenTextures(num_luts, lut_textures);
for (i = 0; i < num_luts; i++)
{
struct texture_image img = {0};
RARCH_LOG("Loading texture image from: \"%s\" ...\n",
generic_shader->lut[i].path);
if (!texture_image_load(&img, generic_shader->lut[i].path))
{
RARCH_ERR("Failed to load texture image from: \"%s\"\n", generic_shader->lut[i].path);
return false;
}
gl_load_texture_data(lut_textures[i], &img,
gl_wrap_type_to_enum(generic_shader->lut[i].wrap),
generic_shader->lut[i].filter != RARCH_FILTER_NEAREST,
generic_shader->lut[i].mipmap);
texture_image_free(&img);
}
glBindTexture(GL_TEXTURE_2D, 0);
return true;
}
static void mui_context_reset_textures(mui_handle_t *mui, const char *iconpath)
{
unsigned i;
for (i = 0; i < MUI_TEXTURE_LAST; i++)
{
struct texture_image ti = {0};
char path[PATH_MAX_LENGTH] = {0};
switch(i)
{
case MUI_TEXTURE_POINTER:
fill_pathname_join(path, iconpath, "pointer.png", sizeof(path));
break;
case MUI_TEXTURE_BACK:
fill_pathname_join(path, iconpath, "back.png", sizeof(path));
break;
case MUI_TEXTURE_SWITCH_ON:
fill_pathname_join(path, iconpath, "on.png", sizeof(path));
break;
case MUI_TEXTURE_SWITCH_OFF:
fill_pathname_join(path, iconpath, "off.png", sizeof(path));
break;
case MUI_TEXTURE_TAB_MAIN_ACTIVE:
fill_pathname_join(path, iconpath, "main_tab_active.png", sizeof(path));
break;
case MUI_TEXTURE_TAB_PLAYLISTS_ACTIVE:
fill_pathname_join(path, iconpath, "playlists_tab_active.png", sizeof(path));
break;
case MUI_TEXTURE_TAB_SETTINGS_ACTIVE:
fill_pathname_join(path, iconpath, "settings_tab_active.png", sizeof(path));
break;
case MUI_TEXTURE_TAB_MAIN_PASSIVE:
fill_pathname_join(path, iconpath, "main_tab_passive.png", sizeof(path));
break;
case MUI_TEXTURE_TAB_PLAYLISTS_PASSIVE:
fill_pathname_join(path, iconpath, "playlists_tab_passive.png", sizeof(path));
break;
case MUI_TEXTURE_TAB_SETTINGS_PASSIVE:
fill_pathname_join(path, iconpath, "settings_tab_passive.png", sizeof(path));
break;
}
if (string_is_empty(path) || !path_file_exists(path))
continue;
texture_image_load(&ti, path);
mui->textures.list[i].id = menu_display_texture_load(&ti,
TEXTURE_FILTER_MIPMAP_LINEAR);
texture_image_free(&ti);
}
}
static void rmenu_context_reset(void *data)
{
menu_handle_t *menu = (menu_handle_t*)data;
if (!menu)
return;
texture_image_load(driver.video_data, g_extern.menu_texture_path, menu_texture);
menu->width = menu_texture->width;
menu->height = menu_texture->height;
menu_texture_inited = false;
}
static void rmenu_init_assets(void *data, void *video_data)
{
rgui_handle_t *rgui = (rgui_handle_t*)data;
if (!rgui)
return;
menu_texture = (struct texture_image*)calloc(1, sizeof(*menu_texture));
texture_image_load(g_extern.menu_texture_path, menu_texture);
rgui->width = menu_texture->width;
rgui->height = menu_texture->height;
rmenu_set_texture(rgui, video_data, true);
}
static GLuint png_texture_load(const char * file_name)
{
struct texture_image ti;
texture_image_load(&ti, file_name);
// Generate the OpenGL texture object
GLuint texture;
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ti.width, ti.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, ti.pixels);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
return texture;
}
bool gl_load_luts(const struct video_shader *shader,
GLuint *textures_lut)
{
unsigned i;
unsigned num_luts = min(shader->luts, GFX_MAX_TEXTURES);
if (!shader->luts)
return true;
glGenTextures(num_luts, textures_lut);
for (i = 0; i < num_luts; i++)
{
struct texture_image img = {0};
enum texture_filter_type filter_type = TEXTURE_FILTER_LINEAR;
RARCH_LOG("Loading texture image from: \"%s\" ...\n",
shader->lut[i].path);
if (!texture_image_load(&img, shader->lut[i].path))
{
RARCH_ERR("Failed to load texture image from: \"%s\"\n",
shader->lut[i].path);
return false;
}
if (shader->lut[i].filter == RARCH_FILTER_NEAREST)
filter_type = TEXTURE_FILTER_NEAREST;
if (shader->lut[i].mipmap)
{
if (filter_type == TEXTURE_FILTER_NEAREST)
filter_type = TEXTURE_FILTER_MIPMAP_NEAREST;
else
filter_type = TEXTURE_FILTER_MIPMAP_LINEAR;
}
gl_load_texture_data(textures_lut[i],
shader->lut[i].wrap,
filter_type, 4,
img.width, img.height,
img.pixels, sizeof(uint32_t));
texture_image_free(&img);
}
glBindTexture(GL_TEXTURE_2D, 0);
return true;
}
int c_tex::BindTexture(char* pszPath)
{
bTextureOK = false;
glGenTextures(1, &nTexId[0]);
if(fbaRL->FileExist(pszPath))
{
if(!texture_image_load(pszPath, &_texture))
{
glDeleteTextures(1, &nTexId[0]);
return 0;
} else {
bTextureOK = true;
glEnable(GL_VSYNC_SCE);
glEnable(GL_TEXTURE_2D);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
glBindTexture(GL_TEXTURE_2D, nTexId[0]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(
GL_TEXTURE_2D,
0,
GL_ARGB_SCE,
_texture.width,
_texture.height,
0,
GL_BGRA,
GL_UNSIGNED_INT_8_8_8_8_REV,
_texture.pixels
);
glBindTexture(GL_TEXTURE_2D, nTexId[0]);
SAFE_FREE(_texture.pixels)
return 1;
}
}
return 0;
}
static bool load_luts(void)
{
if (!glsl_shader->luts)
return true;
glGenTextures(1, gl_teximage);
for (unsigned i = 0; i < glsl_shader->luts; i++)
{
RARCH_LOG("Loading texture image from: \"%s\" ...\n",
glsl_shader->lut[i].path);
struct texture_image img = {0};
if (!texture_image_load(glsl_shader->lut[i].path, &img))
{
RARCH_ERR("Failed to load texture image from: \"%s\"\n", glsl_shader->lut[i].path);
return false;
}
glBindTexture(GL_TEXTURE_2D, gl_teximage[i]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, BORDER_FUNC);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, BORDER_FUNC);
GLenum filter = glsl_shader->lut[i].filter == RARCH_FILTER_NEAREST ?
GL_NEAREST : GL_LINEAR;
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
glTexImage2D(GL_TEXTURE_2D,
0, driver.gfx_use_rgba ? GL_RGBA : RARCH_GL_INTERNAL_FORMAT32,
img.width, img.height, 0,
driver.gfx_use_rgba ? GL_RGBA : RARCH_GL_TEXTURE_TYPE32,
RARCH_GL_FORMAT32, img.pixels);
glBindTexture(GL_TEXTURE_2D, 0);
free(img.pixels);
}
return true;
}
static GLuint lakka_png_texture_load_(const char * file_name)
{
if (! path_file_exists(file_name))
return 0;
struct texture_image ti = {0};
texture_image_load(&ti, file_name);
/* Generate the OpenGL texture object */
GLuint texture = 0;
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ti.width, ti.height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, ti.pixels);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
free(ti.pixels);
return texture;
}
static void rmenu_context_reset(void)
{
char menu_bg[PATH_MAX_LENGTH];
menu_handle_t *menu = menu_driver_get_ptr();
settings_t *settings = config_get_ptr();
if (!menu)
return;
if (*settings->menu.wallpaper)
strlcpy(menu_bg, settings->menu.wallpaper, sizeof(menu_bg));
else
rmenu_wallpaper_set_defaults(menu_bg, sizeof(menu_bg));
if (path_file_exists(menu_bg))
texture_image_load(menu_texture, menu_bg);
menu->frame_buf.width = menu_texture->width;
menu->frame_buf.height = menu_texture->height;
menu_texture_inited = false;
}
static void rmenu_context_reset(void)
{
char menu_bg[PATH_MAX_LENGTH] = {0};
menu_handle_t *menu = menu_driver_get_ptr();
settings_t *settings = config_get_ptr();
if (!menu)
return;
if (*settings->menu.wallpaper)
strlcpy(menu_bg, settings->menu.wallpaper, sizeof(menu_bg));
else
rmenu_wallpaper_set_defaults(menu_bg, sizeof(menu_bg));
if (path_file_exists(menu_bg))
texture_image_load(menu_texture, menu_bg);
menu_display_ctl(MENU_DISPLAY_CTL_SET_WIDTH, &menu_texture->width);
menu_display_ctl(MENU_DISPLAY_CTL_SET_HEIGHT, &menu_texture->height);
menu_texture_inited = false;
}
static bool gfx_ctx_rmenu_init(void)
{
gl_t *gl = driver.video_data;
if (!gl)
return false;
if (rmenu_inited)
return true;
#ifdef HAVE_RMENU
glGenTextures(1, &menu_texture_id);
RARCH_LOG("Loading texture image for menu...\n");
if (!texture_image_load(default_paths.menu_border_file, &menu_texture))
{
RARCH_ERR("Failed to load texture image for menu.\n");
return false;
}
glBindTexture(GL_TEXTURE_2D, menu_texture_id);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, gl->border_type);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, gl->border_type);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, RARCH_GL_INTERNAL_FORMAT32,
menu_texture.width, menu_texture.height, 0,
RARCH_GL_TEXTURE_TYPE32, RARCH_GL_FORMAT32, menu_texture.pixels);
glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
free(menu_texture.pixels);
#endif
rmenu_inited = true;
return true;
}
static void rmenu_context_reset(void *data)
{
char menu_bg[PATH_MAX];
menu_handle_t *menu = (menu_handle_t*)data;
if (!menu)
return;
fill_pathname_join(menu_bg, g_settings.assets_directory,
"rmenu", sizeof(menu_bg));
#ifdef _XBOX1
fill_pathname_join(menu_bg, menu_bg, "sd", sizeof(menu_bg));
#else
fill_pathname_join(menu_bg, menu_bg, "hd", sizeof(menu_bg));
#endif
fill_pathname_join(menu_bg, menu_bg, "main_menu.png", sizeof(menu_bg));
if (path_file_exists(menu_bg))
texture_image_load(menu_texture, menu_bg);
menu->width = menu_texture->width;
menu->height = menu_texture->height;
menu_texture_inited = false;
}
static bool input_overlay_load_desc(input_overlay_t *ol, config_file_t *conf, struct overlay_desc *desc,
unsigned ol_index, unsigned desc_index,
unsigned width, unsigned height,
bool normalized, float alpha_mod, float range_mod)
{
bool ret = true;
char overlay_desc_key[64];
snprintf(overlay_desc_key, sizeof(overlay_desc_key), "overlay%u_desc%u", ol_index, desc_index);
char overlay_desc_image_key[64];
snprintf(overlay_desc_image_key, sizeof(overlay_desc_image_key),
"overlay%u_desc%u_overlay", ol_index, desc_index);
char image_path[PATH_MAX];
if (config_get_path(conf, overlay_desc_image_key, image_path, sizeof(image_path)))
{
char path[PATH_MAX];
fill_pathname_resolve_relative(path, ol->overlay_path, image_path, sizeof(path));
struct texture_image img = {0};
if (texture_image_load(&img, path))
desc->image = img;
}
char overlay_desc_normalized_key[64];
snprintf(overlay_desc_normalized_key, sizeof(overlay_desc_normalized_key),
"overlay%u_desc%u_normalized", ol_index, desc_index);
config_get_bool(conf, overlay_desc_normalized_key, &normalized);
bool by_pixel = !normalized;
if (by_pixel && (width == 0 || height == 0))
{
RARCH_ERR("[Overlay]: Base overlay is not set and not using normalized coordinates.\n");
return false;
}
char overlay[256];
if (!config_get_array(conf, overlay_desc_key, overlay, sizeof(overlay)))
{
RARCH_ERR("[Overlay]: Didn't find key: %s.\n", overlay_desc_key);
return false;
}
struct string_list *list = string_split(overlay, ", ");
if (!list)
{
RARCH_ERR("[Overlay]: Failed to split overlay desc.\n");
return false;
}
if (list->size < 6)
{
string_list_free(list);
RARCH_ERR("[Overlay]: Overlay desc is invalid. Requires at least 6 tokens.\n");
return false;
}
const char *x = list->elems[1].data;
const char *y = list->elems[2].data;
const char *box = list->elems[3].data;
char *key = list->elems[0].data;
char *save;
desc->key_mask = 0;
if (strcmp(key, "analog_left") == 0)
desc->type = OVERLAY_TYPE_ANALOG_LEFT;
else if (strcmp(key, "analog_right") == 0)
desc->type = OVERLAY_TYPE_ANALOG_RIGHT;
else if (strstr(key, "retrok_") == key)
{
desc->type = OVERLAY_TYPE_KEYBOARD;
desc->key_mask = input_translate_str_to_rk(key + 7);
}
else
{
const char *tmp;
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];
snprintf(overlay_target_key, sizeof(overlay_target_key), "overlay%u_desc%u_next_target", ol_index, desc_index);
config_get_array(conf, overlay_target_key, desc->next_index_name, sizeof(desc->next_index_name));
}
}
float width_mod = by_pixel ? (1.0f / width) : 1.0f;
float height_mod = by_pixel ? (1.0f / height) : 1.0f;
desc->x = (float)strtod(x, NULL) * width_mod;
desc->y = (float)strtod(y, NULL) * height_mod;
if (!strcmp(box, "radial"))
desc->hitbox = OVERLAY_HITBOX_RADIAL;
else if (!strcmp(box, "rect"))
desc->hitbox = OVERLAY_HITBOX_RECT;
else
{
RARCH_ERR("[Overlay]: Hitbox type (%s) is invalid. Use \"radial\" or \"rect\".\n", box);
ret = false;
goto end;
}
if (desc->type == OVERLAY_TYPE_ANALOG_LEFT || desc->type == OVERLAY_TYPE_ANALOG_RIGHT)
{
if (desc->hitbox != OVERLAY_HITBOX_RADIAL)
{
RARCH_ERR("[Overlay]: Analog hitbox type must be \"radial\".\n");
ret = false;
goto end;
}
char overlay_analog_saturate_key[64];
snprintf(overlay_analog_saturate_key, sizeof(overlay_analog_saturate_key), "overlay%u_desc%u_saturate_pct", ol_index, desc_index);
if (!config_get_float(conf, overlay_analog_saturate_key, &desc->analog_saturate_pct))
desc->analog_saturate_pct = 1.0f;
}
desc->range_x = (float)strtod(list->elems[4].data, NULL) * width_mod;
desc->range_y = (float)strtod(list->elems[5].data, NULL) * height_mod;
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;
char conf_key[64];
snprintf(conf_key, sizeof(conf_key), "overlay%u_desc%u_alpha_mod", ol_index, desc_index);
desc->alpha_mod = alpha_mod;
config_get_float(conf, conf_key, &desc->alpha_mod);
snprintf(conf_key, sizeof(conf_key), "overlay%u_desc%u_range_mod", ol_index, desc_index);
desc->range_mod = range_mod;
config_get_float(conf, conf_key, &desc->range_mod);
snprintf(conf_key, sizeof(conf_key), "overlay%u_desc%u_movable", ol_index, desc_index);
desc->movable = false;
desc->delta_x = 0.0f;
desc->delta_y = 0.0f;
config_get_bool(conf, conf_key, &desc->movable);
desc->range_x_mod = desc->range_x;
desc->range_y_mod = desc->range_y;
end:
if (list)
string_list_free(list);
return ret;
}
static bool get_texture_image(const char *shader_path, xmlNodePtr ptr)
{
if (gl_teximage_cnt >= MAX_TEXTURES)
{
RARCH_WARN("Too many texture images. Ignoring ...\n");
return true;
}
bool linear = true;
xmlChar *filename = xmlGetProp(ptr, (const xmlChar*)"file");
xmlChar *filter = xmlGetProp(ptr, (const xmlChar*)"filter");
xmlChar *id = xmlGetProp(ptr, (const xmlChar*)"id");
char *last = NULL;
struct texture_image img;
if (!id)
{
RARCH_ERR("Could not find ID in texture.\n");
goto error;
}
if (!filename)
{
RARCH_ERR("Could not find filename in texture.\n");
goto error;
}
if (filter && strcmp((const char*)filter, "nearest") == 0)
linear = false;
char tex_path[PATH_MAX];
strlcpy(tex_path, shader_path, sizeof(tex_path));
last = strrchr(tex_path, '/');
if (!last) last = strrchr(tex_path, '\\');
if (last) last[1] = '\0';
strlcat(tex_path, (const char*)filename, sizeof(tex_path));
RARCH_LOG("Loading texture image from: \"%s\" ...\n", tex_path);
if (!texture_image_load(tex_path, &img))
{
RARCH_ERR("Failed to load texture image from: \"%s\"\n", tex_path);
goto error;
}
strlcpy(gl_teximage_uniforms[gl_teximage_cnt], (const char*)id, sizeof(gl_teximage_uniforms[0]));
glGenTextures(1, &gl_teximage[gl_teximage_cnt]);
pglActiveTexture(GL_TEXTURE0 + gl_teximage_cnt + 1);
glBindTexture(GL_TEXTURE_2D, gl_teximage[gl_teximage_cnt]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, BORDER_FUNC);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, BORDER_FUNC);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, linear ? GL_LINEAR : GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, linear ? GL_LINEAR : GL_NEAREST);
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
glTexImage2D(GL_TEXTURE_2D,
0, RARCH_GL_INTERNAL_FORMAT32,
img.width, img.height, 0, RARCH_GL_TEXTURE_TYPE32, RARCH_GL_FORMAT32, img.pixels);
pglActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, 0);
free(img.pixels);
xmlFree(filename);
xmlFree(id);
if (filter)
xmlFree(filter);
gl_teximage_cnt++;
return true;
error:
if (filename)
xmlFree(filename);
if (filter)
xmlFree(filter);
if (filter)
xmlFree(id);
return false;
}
static bool input_overlay_load_overlay(config_file_t *conf, const char *config_path,
struct overlay *overlay, unsigned index)
{
char overlay_path_key[64];
char overlay_name_key[64];
char overlay_path[PATH_MAX];
char overlay_resolved_path[PATH_MAX];
snprintf(overlay_path_key, sizeof(overlay_path_key), "overlay%u_overlay", index);
if (!config_get_path(conf, overlay_path_key, overlay_path, sizeof(overlay_path)))
{
RARCH_ERR("[Overlay]: Config key: %s is not set.\n", overlay_path_key);
return false;
}
snprintf(overlay_name_key, sizeof(overlay_name_key), "overlay%u_name", index);
config_get_array(conf, overlay_name_key, overlay->name, sizeof(overlay->name));
fill_pathname_resolve_relative(overlay_resolved_path, config_path,
overlay_path, sizeof(overlay_resolved_path));
struct texture_image img = {0};
if (!texture_image_load(overlay_resolved_path, &img))
{
RARCH_ERR("Failed to load image: %s.\n", overlay_path);
return false;
}
overlay->image = img.pixels;
overlay->width = img.width;
overlay->height = img.height;
// By default, we stretch the overlay out in full.
overlay->x = overlay->y = 0.0f;
overlay->w = overlay->h = 1.0f;
char overlay_rect_key[64];
snprintf(overlay_rect_key, sizeof(overlay_rect_key), "overlay%u_rect", index);
char overlay_rect[256];
if (config_get_array(conf, overlay_rect_key, overlay_rect, sizeof(overlay_rect)))
{
struct string_list *list = string_split(overlay_rect, ", ");
if (list->size < 4)
{
RARCH_ERR("[Overlay]: Failed to split rect \"%s\" into at least four tokens.\n", overlay_rect);
return false;
}
overlay->x = strtod(list->elems[0].data, NULL);
overlay->y = strtod(list->elems[1].data, NULL);
overlay->w = strtod(list->elems[2].data, NULL);
overlay->h = strtod(list->elems[3].data, NULL);
string_list_free(list);
}
char overlay_full_screen_key[64];
snprintf(overlay_full_screen_key, sizeof(overlay_full_screen_key),
"overlay%u_full_screen", index);
overlay->full_screen = false;
config_get_bool(conf, overlay_full_screen_key, &overlay->full_screen);
char overlay_descs_key[64];
snprintf(overlay_descs_key, sizeof(overlay_descs_key), "overlay%u_descs", index);
unsigned descs = 0;
if (!config_get_uint(conf, overlay_descs_key, &descs))
{
RARCH_ERR("[Overlay]: Failed to read number of descs from config key: %s.\n", overlay_descs_key);
return false;
}
overlay->descs = (struct overlay_desc*)calloc(descs, sizeof(*overlay->descs));
if (!overlay->descs)
{
RARCH_ERR("[Overlay]: Failed to allocate descs.\n");
return false;
}
overlay->size = descs;
for (size_t i = 0; i < overlay->size; i++)
{
if (!input_overlay_load_desc(conf, &overlay->descs[i], index, i, img.width, img.height))
{
RARCH_ERR("[Overlay]: Failed to load overlay descs for overlay #%u.\n", (unsigned)i);
return false;
}
}
// 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;
return true;
}
static bool get_texture_image(const char *shader_path, xmlNodePtr ptr)
{
if (gl_teximage_cnt >= MAX_TEXTURES)
{
RARCH_WARN("Too many texture images. Ignoring ...\n");
return true;
}
bool linear = true;
char filename[PATH_MAX];
char filter[64];
char id[64];
xml_get_prop(filename, sizeof(filename), ptr, "file");
xml_get_prop(filter, sizeof(filter), ptr, "filter");
xml_get_prop(id, sizeof(id), ptr, "id");
struct texture_image img;
if (!*id)
{
RARCH_ERR("Could not find ID in texture.\n");
return false;
}
if (!*filename)
{
RARCH_ERR("Could not find filename in texture.\n");
return false;
}
if (strcmp(filter, "nearest") == 0)
linear = false;
char tex_path[PATH_MAX];
fill_pathname_resolve_relative(tex_path, shader_path, (const char*)filename, sizeof(tex_path));
RARCH_LOG("Loading texture image from: \"%s\" ...\n", tex_path);
if (!texture_image_load(tex_path, &img))
{
RARCH_ERR("Failed to load texture image from: \"%s\"\n", tex_path);
return false;
}
strlcpy(gl_teximage_uniforms[gl_teximage_cnt], (const char*)id, sizeof(gl_teximage_uniforms[0]));
glGenTextures(1, &gl_teximage[gl_teximage_cnt]);
pglActiveTexture(GL_TEXTURE0 + gl_teximage_cnt + 1);
glBindTexture(GL_TEXTURE_2D, gl_teximage[gl_teximage_cnt]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, BORDER_FUNC);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, BORDER_FUNC);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, linear ? GL_LINEAR : GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, linear ? GL_LINEAR : GL_NEAREST);
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
glTexImage2D(GL_TEXTURE_2D,
0, driver.gfx_use_rgba ? GL_RGBA : RARCH_GL_INTERNAL_FORMAT32,
img.width, img.height, 0, driver.gfx_use_rgba ? GL_RGBA : RARCH_GL_TEXTURE_TYPE32,
RARCH_GL_FORMAT32, img.pixels);
pglActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, 0);
free(img.pixels);
gl_teximage_cnt++;
return true;
}
static bool input_overlay_load_overlay(input_overlay_t *ol, config_file_t *conf, const char *config_path,
struct overlay *overlay, unsigned index)
{
size_t i;
char overlay_path_key[64];
char overlay_name_key[64];
char overlay_path[PATH_MAX];
char overlay_resolved_path[PATH_MAX];
snprintf(overlay_path_key, sizeof(overlay_path_key), "overlay%u_overlay", index);
if (config_get_path(conf, overlay_path_key, overlay_path, sizeof(overlay_path)))
{
struct texture_image img = {0};
fill_pathname_resolve_relative(overlay_resolved_path, config_path,
overlay_path, sizeof(overlay_resolved_path));
if (texture_image_load(&img, overlay_resolved_path))
overlay->image = img;
else
{
RARCH_ERR("[Overlay]: Failed to load image: %s.\n", overlay_resolved_path);
return false;
}
}
snprintf(overlay_name_key, sizeof(overlay_name_key), "overlay%u_name", index);
config_get_array(conf, overlay_name_key, 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;
char overlay_rect_key[64];
snprintf(overlay_rect_key, sizeof(overlay_rect_key), "overlay%u_rect", index);
char overlay_rect[256];
if (config_get_array(conf, overlay_rect_key, overlay_rect, sizeof(overlay_rect)))
{
struct string_list *list = string_split(overlay_rect, ", ");
if (list->size < 4)
{
RARCH_ERR("[Overlay]: Failed to split rect \"%s\" into at least four tokens.\n", overlay_rect);
return false;
}
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);
}
char overlay_full_screen_key[64];
snprintf(overlay_full_screen_key, sizeof(overlay_full_screen_key),
"overlay%u_full_screen", index);
overlay->full_screen = false;
config_get_bool(conf, overlay_full_screen_key, &overlay->full_screen);
char overlay_descs_key[64];
snprintf(overlay_descs_key, sizeof(overlay_descs_key), "overlay%u_descs", index);
unsigned descs = 0;
if (!config_get_uint(conf, overlay_descs_key, &descs))
{
RARCH_ERR("[Overlay]: Failed to read number of descs from config key: %s.\n", overlay_descs_key);
return false;
}
overlay->descs = (struct overlay_desc*)calloc(descs, sizeof(*overlay->descs));
if (!overlay->descs)
{
RARCH_ERR("[Overlay]: Failed to allocate descs.\n");
return false;
}
overlay->size = descs;
char conf_key[64];
bool normalized = false;
snprintf(conf_key, sizeof(conf_key),
"overlay%u_normalized", index);
config_get_bool(conf, conf_key, &normalized);
float alpha_mod = 1.0f;
snprintf(conf_key, sizeof(conf_key), "overlay%u_alpha_mod", index);
config_get_float(conf, conf_key, &alpha_mod);
float range_mod = 1.0f;
snprintf(conf_key, sizeof(conf_key), "overlay%u_range_mod", index);
config_get_float(conf, conf_key, &range_mod);
for (i = 0; i < overlay->size; i++)
{
if (!input_overlay_load_desc(ol, conf, &overlay->descs[i], index, i,
overlay->image.width, overlay->image.height,
normalized, alpha_mod, range_mod))
{
RARCH_ERR("[Overlay]: Failed to load overlay descs for overlay #%u.\n", (unsigned)i);
return false;
}
}
// 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");
return false;
}
if (overlay->image.pixels)
overlay->load_images[overlay->load_images_size++] = overlay->image;
for (i = 0; i < overlay->size; i++)
{
if (overlay->descs[i].image.pixels)
{
overlay->descs[i].image_index = overlay->load_images_size;
overlay->load_images[overlay->load_images_size++] = overlay->descs[i].image;
}
}
// 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;
return true;
}
bool input_overlay_load_overlays(input_overlay_t *ol)
{
unsigned i;
config_file_t *conf = NULL;
if (!ol)
return false;
conf = config_file_new(ol->overlay_path);
if (!conf)
{
RARCH_ERR("Failed to load config file: %s.\n", ol->overlay_path);
return false;
}
if (!config_get_uint(conf, "overlays", &ol->config.overlays.size))
{
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;
for (i = 0; i < ol->size; i++)
{
char conf_key[64];
char overlay_full_screen_key[64];
struct overlay *overlay = &ol->overlays[i];
if (!overlay)
continue;
snprintf(overlay->config.descs.key,
sizeof(overlay->config.descs.key), "overlay%u_descs", i);
if (!config_get_uint(conf, overlay->config.descs.key, &overlay->config.descs.size))
{
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;
snprintf(overlay_full_screen_key, sizeof(overlay_full_screen_key),
"overlay%u_full_screen", i);
overlay->full_screen = false;
config_get_bool(conf, overlay_full_screen_key, &overlay->full_screen);
overlay->config.normalized = false;
overlay->config.alpha_mod = 1.0f;
overlay->config.range_mod = 1.0f;
snprintf(conf_key, sizeof(conf_key),
"overlay%u_normalized", i);
config_get_bool(conf, conf_key, &overlay->config.normalized);
snprintf(conf_key, sizeof(conf_key), "overlay%u_alpha_mod", i);
config_get_float(conf, conf_key, &overlay->config.alpha_mod);
snprintf(conf_key, sizeof(conf_key), "overlay%u_range_mod", i);
config_get_float(conf, conf_key, &overlay->config.range_mod);
/* 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;
}
snprintf(overlay->config.paths.key, sizeof(overlay->config.paths.key),
"overlay%u_overlay", i);
config_get_path(conf, overlay->config.paths.key,
overlay->config.paths.path, sizeof(overlay->config.paths.path));
if (overlay->config.paths.path[0] != '\0')
{
char overlay_resolved_path[PATH_MAX_LENGTH];
struct texture_image img = {0};
fill_pathname_resolve_relative(overlay_resolved_path, ol->overlay_path,
overlay->config.paths.path, sizeof(overlay_resolved_path));
if (!texture_image_load(&img, overlay_resolved_path))
{
RARCH_ERR("[Overlay]: Failed to load image: %s.\n",
overlay_resolved_path);
ol->loading_status = OVERLAY_IMAGE_TRANSFER_ERROR;
goto error;
}
overlay->image = img;
}
snprintf(overlay->config.names.key, sizeof(overlay->config.names.key),
"overlay%u_name", i);
config_get_array(conf, overlay->config.names.key,
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),
"overlay%u_rect", i);
if (config_get_array(conf, overlay->config.rect.key,
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);
}
/* 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;
}
ol->state = OVERLAY_STATUS_DEFERRED_LOADING;
config_file_free(conf);
return true;
error:
config_file_free(conf);
ol->state = OVERLAY_STATUS_DEFERRED_ERROR;
return false;
}
