RetroArch/menu/menu_shader.c

362 lines
10 KiB
C
Raw Normal View History

/* RetroArch - A frontend for libretro.
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
2015-01-07 16:46:50 +00:00
* Copyright (C) 2011-2015 - Daniel De Matteis
*
* 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-05-12 11:14:04 +00:00
#include <string.h>
#include <compat/strl.h>
#include <retro_assert.h>
2014-10-21 22:23:06 +00:00
#include <file/file_path.h>
2015-05-15 20:08:37 +00:00
#include "menu.h"
#include "menu_hash.h"
2015-05-12 11:14:04 +00:00
#include "menu_shader.h"
#include "../configuration.h"
#include "../runloop.h"
2015-09-04 19:43:08 +00:00
2015-01-10 04:53:41 +00:00
/**
* menu_shader_manager_init:
*
* Initializes shader manager.
**/
2015-02-11 20:27:01 +00:00
void menu_shader_manager_init(menu_handle_t *menu)
{
2015-01-10 04:53:41 +00:00
#ifdef HAVE_SHADER_MANAGER
uint32_t ext_hash;
2015-01-10 04:53:41 +00:00
char preset_path[PATH_MAX_LENGTH];
2015-03-20 19:43:22 +00:00
const char *ext = NULL;
2015-01-19 20:24:08 +00:00
struct video_shader *shader = NULL;
2015-03-20 19:43:22 +00:00
config_file_t *conf = NULL;
const char *config_path = NULL;
settings_t *settings = config_get_ptr();
2015-03-21 03:43:18 +00:00
global_t *global = global_get_ptr();
if (!menu)
return;
2015-01-19 20:24:08 +00:00
shader = (struct video_shader*)menu->shader;
2015-07-27 15:18:10 +00:00
if (*global->path.core_specific_config
2015-03-20 19:43:22 +00:00
&& settings->core_specific_config)
2015-07-27 15:18:10 +00:00
config_path = global->path.core_specific_config;
else if (*global->path.config)
config_path = global->path.config;
/* In a multi-config setting, we can't have
* conflicts on menu.cgp/menu.glslp. */
if (config_path)
{
fill_pathname_base(menu->default_glslp, config_path,
sizeof(menu->default_glslp));
path_remove_extension(menu->default_glslp);
strlcat(menu->default_glslp, ".glslp", sizeof(menu->default_glslp));
fill_pathname_base(menu->default_cgp, config_path,
sizeof(menu->default_cgp));
path_remove_extension(menu->default_cgp);
strlcat(menu->default_cgp, ".cgp", sizeof(menu->default_cgp));
}
else
{
strlcpy(menu->default_glslp, "menu.glslp", sizeof(menu->default_glslp));
strlcpy(menu->default_cgp, "menu.cgp", sizeof(menu->default_cgp));
}
2015-03-20 19:43:22 +00:00
ext = path_get_extension(settings->video.shader_path);
2015-06-17 17:55:24 +00:00
ext_hash = menu_hash_calculate(ext);
switch (ext_hash)
{
case MENU_VALUE_GLSLP:
case MENU_VALUE_CGP:
conf = config_file_new(settings->video.shader_path);
if (conf)
{
if (video_shader_read_conf_cgp(conf, shader))
{
video_shader_resolve_relative(shader, settings->video.shader_path);
video_shader_resolve_parameters(conf, shader);
}
config_file_free(conf);
}
break;
case MENU_VALUE_GLSL:
case MENU_VALUE_CG:
strlcpy(shader->pass[0].source.path, settings->video.shader_path,
sizeof(shader->pass[0].source.path));
shader->passes = 1;
break;
default:
{
const char *shader_dir = *settings->video.shader_dir ?
settings->video.shader_dir : settings->system_directory;
fill_pathname_join(preset_path, shader_dir, "menu.glslp", sizeof(preset_path));
conf = config_file_new(preset_path);
if (!conf)
{
fill_pathname_join(preset_path, shader_dir, "menu.cgp", sizeof(preset_path));
conf = config_file_new(preset_path);
}
if (conf)
{
if (video_shader_read_conf_cgp(conf, shader))
{
video_shader_resolve_relative(shader, preset_path);
video_shader_resolve_parameters(conf, shader);
}
config_file_free(conf);
}
}
break;
}
2015-01-10 04:53:41 +00:00
#endif
}
2015-01-10 04:53:41 +00:00
/**
* menu_shader_manager_set_preset:
* @shader : Shader handle.
* @type : Type of shader.
* @preset_path : Preset path to load from.
*
* Sets shader preset.
**/
2015-01-19 20:24:08 +00:00
void menu_shader_manager_set_preset(struct video_shader *shader,
2015-01-10 04:53:41 +00:00
unsigned type, const char *preset_path)
{
2015-01-10 04:53:41 +00:00
#ifdef HAVE_SHADER_MANAGER
2015-03-20 19:43:22 +00:00
config_file_t *conf = NULL;
settings_t *settings = config_get_ptr();
2015-01-11 17:30:56 +00:00
2015-03-20 19:43:22 +00:00
settings->video.shader_enable = false;
2015-03-22 21:17:52 +00:00
if (!video_driver_set_shader((enum rarch_shader_type)type, preset_path))
2015-01-11 17:30:56 +00:00
return;
/* Makes sure that we use Menu Preset shader on driver reinit.
* Only do this when the cgp actually works to avoid potential errors. */
2015-03-20 19:43:22 +00:00
strlcpy(settings->video.shader_path, preset_path ? preset_path : "",
sizeof(settings->video.shader_path));
settings->video.shader_enable = true;
2015-01-11 17:30:56 +00:00
if (!preset_path)
return;
if (!shader)
return;
/* Load stored Preset into menu on success.
* Used when a preset is directly loaded.
* No point in updating when the Preset was
* created from the menu itself. */
conf = config_file_new(preset_path);
2015-01-11 17:32:16 +00:00
if (!conf)
return;
2015-01-11 17:32:16 +00:00
RARCH_LOG("Setting Menu shader: %s.\n", preset_path ? preset_path : "N/A (stock)");
if (video_shader_read_conf_cgp(conf, shader))
2015-01-11 17:32:16 +00:00
{
video_shader_resolve_relative(shader, preset_path);
video_shader_resolve_parameters(conf, shader);
}
2015-01-11 17:32:16 +00:00
config_file_free(conf);
2015-01-11 17:30:56 +00:00
menu_entries_set_refresh(false);
2015-01-10 04:53:41 +00:00
#endif
}
2015-01-10 04:53:41 +00:00
/**
* menu_shader_manager_save_preset:
* @basename : basename of preset
* @apply : immediately set preset after saving
*
* Save a shader preset to disk.
**/
void menu_shader_manager_save_preset(
const char *basename, bool apply)
{
2015-01-10 04:53:41 +00:00
#ifdef HAVE_SHADER_MANAGER
char buffer[PATH_MAX_LENGTH], config_directory[PATH_MAX_LENGTH], preset_path[PATH_MAX_LENGTH];
2015-03-20 19:43:22 +00:00
unsigned d, type = RARCH_SHADER_NONE;
2015-06-26 17:37:03 +00:00
const char *dirs[3] = {0};
2015-03-20 19:43:22 +00:00
config_file_t *conf = NULL;
bool ret = false;
2015-03-21 03:43:18 +00:00
global_t *global = global_get_ptr();
2015-03-20 19:43:22 +00:00
settings_t *settings = config_get_ptr();
2015-04-14 11:01:33 +00:00
menu_handle_t *menu = menu_driver_get_ptr();
2015-04-14 11:01:33 +00:00
if (!menu)
{
RARCH_ERR("Cannot save shader preset, menu handle is not initialized.\n");
return;
}
2015-04-14 11:01:33 +00:00
type = menu_shader_manager_get_type(menu->shader);
if (type == RARCH_SHADER_NONE)
return;
*config_directory = '\0';
if (basename)
{
strlcpy(buffer, basename, sizeof(buffer));
/* Append extension automatically as appropriate. */
if (!strstr(basename, ".cgp") && !strstr(basename, ".glslp"))
{
2015-06-15 04:08:49 +00:00
switch (type)
{
case RARCH_SHADER_GLSL:
strlcat(buffer, ".glslp", sizeof(buffer));
break;
case RARCH_SHADER_CG:
strlcat(buffer, ".cgp", sizeof(buffer));
break;
}
}
}
else
{
const char *conf_path = (type == RARCH_SHADER_GLSL) ?
2015-04-14 11:01:33 +00:00
menu->default_glslp : menu->default_cgp;
strlcpy(buffer, conf_path, sizeof(buffer));
}
2015-07-27 15:18:10 +00:00
if (*global->path.config)
fill_pathname_basedir(config_directory,
2015-07-27 15:18:10 +00:00
global->path.config, sizeof(config_directory));
2015-06-26 17:37:03 +00:00
dirs[0] = settings->video.shader_dir;
dirs[1] = settings->menu_config_directory;
dirs[2] = config_directory;
if (!(conf = (config_file_t*)config_file_new(NULL)))
return;
2015-04-14 11:01:33 +00:00
video_shader_write_conf_cgp(conf, menu->shader);
for (d = 0; d < ARRAY_SIZE(dirs); d++)
{
if (!*dirs[d])
continue;
2015-01-10 04:53:41 +00:00
fill_pathname_join(preset_path, dirs[d], buffer, sizeof(preset_path));
if (config_file_write(conf, preset_path))
{
2015-01-10 04:53:41 +00:00
RARCH_LOG("Saved shader preset to %s.\n", preset_path);
if (apply)
2015-01-10 04:53:41 +00:00
menu_shader_manager_set_preset(NULL, type, preset_path);
ret = true;
break;
}
else
2015-01-10 04:53:41 +00:00
RARCH_LOG("Failed writing shader preset to %s.\n", preset_path);
}
config_file_free(conf);
if (!ret)
RARCH_ERR("Failed to save shader preset. Make sure config directory and/or shader dir are writable.\n");
2015-01-10 04:53:41 +00:00
#endif
}
2015-01-10 04:53:41 +00:00
/**
* menu_shader_manager_get_type:
* @shader : shader handle
*
* Gets type of shader.
*
* Returns: type of shader.
**/
2015-01-19 20:24:08 +00:00
unsigned menu_shader_manager_get_type(const struct video_shader *shader)
{
2015-01-10 04:53:41 +00:00
#ifndef HAVE_SHADER_MANAGER
return RARCH_SHADER_NONE;
#else
/* All shader types must be the same, or we cannot use it. */
unsigned i = 0, type = 0;
if (!shader)
return RARCH_SHADER_NONE;
for (i = 0; i < shader->passes; i++)
{
enum rarch_shader_type pass_type =
video_shader_parse_type(shader->pass[i].source.path,
RARCH_SHADER_NONE);
switch (pass_type)
{
case RARCH_SHADER_CG:
case RARCH_SHADER_GLSL:
if (type == RARCH_SHADER_NONE)
type = pass_type;
else if (type != pass_type)
return RARCH_SHADER_NONE;
break;
default:
return RARCH_SHADER_NONE;
}
}
return type;
2015-01-10 04:53:41 +00:00
#endif
}
2015-01-10 04:53:41 +00:00
/**
* menu_shader_manager_apply_changes:
*
* Apply shader state changes.
**/
void menu_shader_manager_apply_changes(void)
{
2015-01-10 04:53:41 +00:00
#ifdef HAVE_SHADER_MANAGER
2015-04-14 11:01:33 +00:00
menu_handle_t *menu = menu_driver_get_ptr();
unsigned shader_type = menu_shader_manager_get_type(menu->shader);
2015-04-14 11:01:33 +00:00
if (menu->shader->passes
&& shader_type != RARCH_SHADER_NONE)
{
menu_shader_manager_save_preset(NULL, true);
return;
}
/* Fall-back */
#if defined(HAVE_CG) || defined(HAVE_HLSL) || defined(HAVE_GLSL)
shader_type = video_shader_parse_type("", DEFAULT_SHADER_TYPE);
#endif
if (shader_type == RARCH_SHADER_NONE)
{
#if defined(HAVE_GLSL)
shader_type = RARCH_SHADER_GLSL;
#elif defined(HAVE_CG) || defined(HAVE_HLSL)
shader_type = RARCH_SHADER_CG;
#endif
}
menu_shader_manager_set_preset(NULL, shader_type, NULL);
#endif
2015-01-10 04:53:41 +00:00
}
2015-06-15 00:15:46 +00:00
void menu_shader_free(menu_handle_t *menu)
{
#ifdef HAVE_SHADER_MANAGER
if (menu->shader)
free(menu->shader);
menu->shader = NULL;
#endif
}