/** * menu_shader_manager_apply_changes: * * Apply shader state changes. **/ void menu_shader_manager_apply_changes(void) { #ifdef HAVE_SHADER_MANAGER unsigned shader_type; struct video_shader *shader = menu_shader_get(); if (!shader) return; shader_type = menu_shader_manager_get_type(shader); if (shader->passes && shader_type != RARCH_SHADER_NONE) { menu_shader_manager_save_preset(NULL, true, false); 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; #elif defined(HAVE_VULKAN) shader_type = RARCH_SHADER_SLANG; #endif } menu_shader_manager_set_preset(NULL, shader_type, NULL); #endif }
static void menu_action_setting_disp_set_label_shader_filter_pass( file_list_t* list, unsigned *w, unsigned type, unsigned i, const char *label, char *s, size_t len, const char *entry_label, const char *path, char *s2, size_t len2) { struct video_shader *shader = menu_shader_get(); struct video_shader_pass *shader_pass = shader ? &shader->pass[type - MENU_SETTINGS_SHADER_PASS_FILTER_0] : NULL; *s = '\0'; *w = 19; strlcpy(s2, path, len2); if (!shader_pass) return; switch (shader_pass->filter) { case 0: strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DONT_CARE), len); break; case 1: strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LINEAR), len); break; case 2: strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NEAREST), len); break; } }
static void menu_action_setting_disp_set_label_shader_scale_pass( file_list_t* list, unsigned *w, unsigned type, unsigned i, const char *label, char *s, size_t len, const char *entry_label, const char *path, char *s2, size_t len2) { unsigned pass = 0; unsigned scale_value = 0; struct video_shader *shader = menu_shader_get(); struct video_shader_pass *shader_pass = shader ? &shader->pass[type - MENU_SETTINGS_SHADER_PASS_SCALE_0] : NULL; *s = '\0'; *w = 19; strlcpy(s2, path, len2); (void)pass; (void)scale_value; if (!shader_pass) return; scale_value = shader_pass->fbo.scale_x; if (!scale_value) strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DONT_CARE), len); else snprintf(s, len, "%ux", scale_value); }
void menu_shader_manager_increment_amount_passes(void) { struct video_shader *shader = menu_shader_get(); if (!shader) return; shader->passes++; }
unsigned menu_shader_manager_get_amount_passes(void) { struct video_shader *shader = menu_shader_get(); if (!shader) return 0; return shader->passes; }
struct video_shader_pass *menu_shader_manager_get_pass(unsigned i) { struct video_shader *shader = menu_shader_get(); if (!shader) return NULL; return &shader->pass[i]; }
void ShaderParamsDialog::getShaders(struct video_shader **menu_shader, struct video_shader **video_shader) { video_shader_ctx_t shader_info = {0}; struct video_shader *shader = menu_shader_get(); if (menu_shader) { if (shader) { *menu_shader = shader; } else { *menu_shader = NULL; } } if (video_shader) { if (shader) { *video_shader = shader_info.data; } else { *video_shader = NULL; } } if (video_shader) { if (!video_shader_driver_get_current_shader(&shader_info)) { *video_shader = NULL; return; } if (!shader_info.data || shader_info.data->num_parameters > GFX_MAX_PARAMETERS) { *video_shader = NULL; return; } if (shader_info.data) { *video_shader = shader_info.data; } else { *video_shader = NULL; } } }
static int action_right_shader_filter_pass(unsigned type, const char *label, bool wraparound) { unsigned pass = type - MENU_SETTINGS_SHADER_PASS_FILTER_0; unsigned delta = 1; struct video_shader *shader = menu_shader_get(); struct video_shader_pass *shader_pass = shader ? &shader->pass[pass] : NULL; if (!shader_pass) return menu_cbs_exit(); shader_pass->filter = ((shader_pass->filter + delta) % 3); return 0; }
int menu_shader_manager_clear_num_passes(void) { #ifdef HAVE_SHADER_MANAGER bool refresh = false; struct video_shader *shader = menu_shader_get(); if (shader->passes) shader->passes = 0; menu_entries_ctl(MENU_ENTRIES_CTL_SET_REFRESH, &refresh); video_shader_resolve_parameters(NULL, shader); #endif return 0; }
static void menu_action_setting_disp_set_label_shader_num_passes( file_list_t* list, unsigned *w, unsigned type, unsigned i, const char *label, char *s, size_t len, const char *entry_label, const char *path, char *s2, size_t len2) { struct video_shader *shader = menu_shader_get(); unsigned pass_count = shader ? shader->passes : 0; *s = '\0'; *w = 19; strlcpy(s2, path, len2); snprintf(s, len, "%u", pass_count); }
static int action_right_shader_num_passes(unsigned type, const char *label, bool wraparound) { bool refresh = false; struct video_shader *shader = menu_shader_get(); unsigned pass_count = shader ? shader->passes : 0; if (!shader) return menu_cbs_exit(); if (pass_count < GFX_MAX_SHADERS) menu_shader_manager_increment_amount_passes(); menu_entries_ctl(MENU_ENTRIES_CTL_SET_REFRESH, &refresh); menu_driver_ctl(RARCH_MENU_CTL_SET_PREVENT_POPULATE, NULL); video_shader_resolve_parameters(NULL, shader); return 0; }
static int action_right_shader_scale_pass(unsigned type, const char *label, bool wraparound) { unsigned current_scale, delta; unsigned pass = type - MENU_SETTINGS_SHADER_PASS_SCALE_0; struct video_shader *shader = menu_shader_get(); struct video_shader_pass *shader_pass = shader ? &shader->pass[pass] : NULL; if (!shader_pass) return menu_cbs_exit(); current_scale = shader_pass->fbo.scale_x; delta = 1; current_scale = (current_scale + delta) % 6; shader_pass->fbo.valid = current_scale; shader_pass->fbo.scale_x = shader_pass->fbo.scale_y = current_scale; return 0; }
static int action_left_shader_num_passes(unsigned type, const char *label, bool wraparound) { #ifdef HAVE_SHADER_MANAGER bool refresh = false; struct video_shader *shader = menu_shader_get(); if (!shader) return menu_cbs_exit(); if (menu_shader_manager_get_amount_passes()) menu_shader_manager_decrement_amount_passes(); menu_entries_ctl(MENU_ENTRIES_CTL_SET_REFRESH, &refresh); menu_driver_ctl(RARCH_MENU_CTL_SET_PREVENT_POPULATE, NULL); video_shader_resolve_parameters(NULL, shader); #endif return 0; }
static void menu_action_setting_disp_set_label_shader_preset_parameter( file_list_t* list, unsigned *w, unsigned type, unsigned i, const char *label, char *s, size_t len, const char *entry_label, const char *path, char *s2, size_t len2) { struct video_shader *shader = menu_shader_get(); struct video_shader_parameter *param = shader ? &shader->parameters[type - MENU_SETTINGS_SHADER_PRESET_PARAMETER_0] : NULL; *s = '\0'; *w = 19; strlcpy(s2, path, len2); if (param) snprintf(s, len, "%.2f [%.2f %.2f]", param->current, param->minimum, param->maximum); }
static void menu_action_setting_disp_set_label_shader_pass( file_list_t* list, unsigned *w, unsigned type, unsigned i, const char *label, char *s, size_t len, const char *entry_label, const char *path, char *s2, size_t len2) { struct video_shader *shader = menu_shader_get(); struct video_shader_pass *shader_pass = shader ? &shader->pass[type - MENU_SETTINGS_SHADER_PASS_0] : NULL; *s = '\0'; *w = 19; strlcpy(s2, path, len2); strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NOT_AVAILABLE), len); if (!shader_pass) return; if (!string_is_empty(shader_pass->source.path)) fill_pathname_base(s, shader_pass->source.path, len); }
int shader_action_parameter_right(unsigned type, const char *label, bool wraparound) { video_shader_ctx_t shader_info; struct video_shader *shader = menu_shader_get(); struct video_shader_parameter *param_menu = NULL; struct video_shader_parameter *param_prev = NULL; int ret = 0; video_shader_driver_get_current_shader(&shader_info); param_prev = &shader_info.data->parameters[type - MENU_SETTINGS_SHADER_PARAMETER_0]; param_menu = shader ? &shader->parameters[type - MENU_SETTINGS_SHADER_PARAMETER_0] : NULL; if (!param_prev || !param_menu) return menu_cbs_exit(); ret = generic_shader_action_parameter_right(param_prev, type, label, wraparound); param_menu->current = param_prev->current; return ret; }
/** * menu_shader_manager_save_preset: * @basename : basename of preset * @apply : immediately set preset after saving * * Save a shader preset to disk. **/ bool menu_shader_manager_save_preset( const char *basename, bool apply, bool fullpath) { #ifdef HAVE_SHADER_MANAGER bool ret = false; char buffer[PATH_MAX_LENGTH]; char config_directory[PATH_MAX_LENGTH]; char preset_path[PATH_MAX_LENGTH]; unsigned d, type = RARCH_SHADER_NONE; const char *dirs[3] = {0}; config_file_t *conf = NULL; struct video_shader *shader = menu_shader_get(); buffer[0] = config_directory[0] = '\0'; preset_path[0] = '\0'; if (!shader) return false; type = menu_shader_manager_get_type(shader); if (type == RARCH_SHADER_NONE) return false; *config_directory = '\0'; if (basename) { strlcpy(buffer, basename, sizeof(buffer)); /* Append extension automatically as appropriate. */ if ( !strstr(basename, file_path_str(FILE_PATH_CGP_EXTENSION)) && !strstr(basename, file_path_str(FILE_PATH_GLSLP_EXTENSION)) && !strstr(basename, file_path_str(FILE_PATH_SLANGP_EXTENSION))) { switch (type) { case RARCH_SHADER_GLSL: strlcat(buffer, file_path_str(FILE_PATH_GLSLP_EXTENSION), sizeof(buffer)); break; case RARCH_SHADER_SLANG: strlcat(buffer, file_path_str(FILE_PATH_SLANGP_EXTENSION), sizeof(buffer)); break; case RARCH_SHADER_CG: strlcat(buffer, file_path_str(FILE_PATH_CGP_EXTENSION), sizeof(buffer)); break; } } } else { const char *conf_path = NULL; switch (type) { case RARCH_SHADER_GLSL: conf_path = default_glslp; break; case RARCH_SHADER_SLANG: conf_path = default_slangp; break; default: case RARCH_SHADER_CG: conf_path = default_cgp; break; } if (!string_is_empty(conf_path)) strlcpy(buffer, conf_path, sizeof(buffer)); } if (!path_is_empty(RARCH_PATH_CONFIG)) fill_pathname_basedir( config_directory, path_get(RARCH_PATH_CONFIG), sizeof(config_directory)); if (!fullpath) { settings_t *settings = config_get_ptr(); dirs[0] = settings->paths.directory_video_shader; dirs[1] = settings->paths.directory_menu_config; dirs[2] = config_directory; } conf = (config_file_t*)config_file_new(NULL); if (!conf) return false; video_shader_write_conf_cgp(conf, shader); if (fullpath) { if (!string_is_empty(basename)) strlcpy(preset_path, buffer, sizeof(preset_path)); if (config_file_write(conf, preset_path)) { RARCH_LOG("Saved shader preset to %s.\n", preset_path); if (apply) menu_shader_manager_set_preset(NULL, type, preset_path); ret = true; } else RARCH_LOG("Failed writing shader preset to %s.\n", preset_path); } else { for (d = 0; d < ARRAY_SIZE(dirs); d++) { if (!*dirs[d]) continue; fill_pathname_join(preset_path, dirs[d], buffer, sizeof(preset_path)); if (config_file_write(conf, preset_path)) { RARCH_LOG("Saved shader preset to %s.\n", preset_path); if (apply) menu_shader_manager_set_preset(NULL, type, preset_path); ret = true; break; } else RARCH_LOG("Failed writing shader preset to %s.\n", preset_path); } } config_file_free(conf); if (ret) return true; RARCH_ERR("Failed to save shader preset. Make sure config directory" " and/or shader dir are writable.\n"); #endif return false; }