static int action_ok_shader_preset_load(const char *path, const char *label, unsigned type, size_t idx) { const char *menu_path = NULL; char shader_path[PATH_MAX_LENGTH]; menu_handle_t *menu = menu_driver_get_ptr(); if (!menu) return -1; (void)shader_path; (void)menu_path; #ifdef HAVE_SHADER_MANAGER menu_list_get_last_stack(menu->menu_list, &menu_path, NULL, NULL); fill_pathname_join(shader_path, menu_path, path, sizeof(shader_path)); menu_shader_manager_set_preset(menu->shader, video_shader_parse_type(shader_path, RARCH_SHADER_NONE), shader_path); menu_list_flush_stack_by_needle(menu->menu_list, "shader_options"); return 0; #else return -1; #endif }
/** * menu_shader_manager_get_type: * @shader : shader handle * * Gets type of shader. * * Returns: type of shader. **/ unsigned menu_shader_manager_get_type(const void *data) { unsigned type = RARCH_SHADER_NONE; #ifdef HAVE_SHADER_MANAGER const struct video_shader *shader = (const struct video_shader*)data; /* All shader types must be the same, or we cannot use it. */ unsigned i = 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: case RARCH_SHADER_SLANG: if (type == RARCH_SHADER_NONE) type = pass_type; else if (type != pass_type) return RARCH_SHADER_NONE; break; default: break; } } #endif return type; }
/** * 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 }
/** * menu_shader_manager_apply_changes: * * Apply shader state changes. **/ void menu_shader_manager_apply_changes(void) { #ifdef HAVE_SHADER_MANAGER menu_handle_t *menu = menu_driver_get_ptr(); unsigned shader_type = menu_shader_manager_get_type(menu->shader); 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 }
void ShaderParamsDialog::onShaderLoadPresetClicked() { QString path; QString filter; QByteArray pathArray; struct video_shader *menu_shader = NULL; struct video_shader *video_shader = NULL; const char *pathData = NULL; settings_t *settings = config_get_ptr(); enum rarch_shader_type type = RARCH_SHADER_NONE; bool is_preset = false; if (!settings) return; getShaders(&menu_shader, &video_shader); if (!menu_shader) return; filter = "Shader Preset ("; /* NOTE: Maybe we should have a way to get a list of all shader types instead of hard-coding this? */ if (video_shader_is_supported(RARCH_SHADER_CG) && video_shader_get_type_from_ext(file_path_str(FILE_PATH_CGP_EXTENSION), &is_preset) != RARCH_SHADER_NONE) filter += QLatin1Literal("*") + file_path_str(FILE_PATH_CGP_EXTENSION); if (video_shader_is_supported(RARCH_SHADER_GLSL) && video_shader_get_type_from_ext(file_path_str(FILE_PATH_GLSLP_EXTENSION), &is_preset) != RARCH_SHADER_NONE) filter += QLatin1Literal(" *") + file_path_str(FILE_PATH_GLSLP_EXTENSION); if (video_shader_is_supported(RARCH_SHADER_SLANG) && video_shader_get_type_from_ext(file_path_str(FILE_PATH_SLANGP_EXTENSION), &is_preset) != RARCH_SHADER_NONE) filter += QLatin1Literal(" *") + file_path_str(FILE_PATH_SLANGP_EXTENSION); filter += ")"; path = QFileDialog::getOpenFileName(this, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET), settings->paths.directory_video_shader, filter); if (path.isEmpty()) return; pathArray = path.toUtf8(); pathData = pathArray.constData(); type = video_shader_parse_type(pathData, RARCH_SHADER_NONE); menu_shader_manager_set_preset(menu_shader, type, pathData); }
static bool d3d_construct(d3d_video_t *d3d, const video_info_t *info, const input_driver_t **input, void **input_data) { unsigned full_x, full_y; settings_t *settings = config_get_ptr(); d3d->should_resize = false; #if defined(HAVE_MENU) d3d->menu = new overlay_t(); if (!d3d->menu) return false; d3d->menu->tex_coords[0] = 0; d3d->menu->tex_coords[1] = 0; d3d->menu->tex_coords[2] = 1; d3d->menu->tex_coords[3] = 1; d3d->menu->vert_coords[0] = 0; d3d->menu->vert_coords[1] = 1; d3d->menu->vert_coords[2] = 1; d3d->menu->vert_coords[3] = -1; #endif memset(&d3d->windowClass, 0, sizeof(d3d->windowClass)); #ifdef HAVE_WINDOW d3d->windowClass.lpfnWndProc = WndProcD3D; win32_window_init(&d3d->windowClass, true, NULL); #endif #ifdef HAVE_MONITOR bool windowed_full; RECT mon_rect; MONITORINFOEX current_mon; HMONITOR hm_to_use; win32_monitor_info(¤t_mon, &hm_to_use, &d3d->cur_mon_id); mon_rect = current_mon.rcMonitor; g_resize_width = info->width; g_resize_height = info->height; windowed_full = settings->video.windowed_fullscreen; full_x = (windowed_full || info->width == 0) ? (mon_rect.right - mon_rect.left) : info->width; full_y = (windowed_full || info->height == 0) ? (mon_rect.bottom - mon_rect.top) : info->height; RARCH_LOG("[D3D]: Monitor size: %dx%d.\n", (int)(mon_rect.right - mon_rect.left), (int)(mon_rect.bottom - mon_rect.top)); #else gfx_ctx_get_video_size(&full_x, &full_y); #endif { unsigned new_width = info->fullscreen ? full_x : info->width; unsigned new_height = info->fullscreen ? full_y : info->height; video_driver_set_size(&new_width, &new_height); } #ifdef HAVE_WINDOW DWORD style; unsigned win_width, win_height; RECT rect = {0}; video_driver_get_size(&win_width, &win_height); win32_set_style(¤t_mon, &hm_to_use, &win_width, &win_height, info->fullscreen, windowed_full, &rect, &mon_rect, &style); win32_window_create(d3d, style, &mon_rect, win_width, win_height, info->fullscreen); win32_set_window(&win_width, &win_height, info->fullscreen, windowed_full, &rect); #endif #ifdef HAVE_SHADERS /* This should only be done once here * to avoid set_shader() to be overridden * later. */ enum rarch_shader_type type = video_shader_parse_type(settings->video.shader_path, RARCH_SHADER_NONE); if (settings->video.shader_enable && type == RARCH_SHADER_CG) d3d->shader_path = settings->video.shader_path; if (!d3d_process_shader(d3d)) return false; #endif d3d->video_info = *info; if (!d3d_initialize(d3d, &d3d->video_info)) return false; gfx_ctx_input_driver(input, input_data); RARCH_LOG("[D3D]: Init complete.\n"); return true; }
static bool d3d_construct(d3d_video_t *d3d, const video_info_t *info, const input_driver_t **input, void **input_data) { unsigned full_x, full_y; driver_t *driver = driver_get_ptr(); settings_t *settings = config_get_ptr(); d3d->should_resize = false; #ifndef _XBOX gfx_set_dwm(); #endif #if defined(HAVE_MENU) if (d3d->menu) free(d3d->menu); d3d->menu = (overlay_t*)calloc(1, sizeof(overlay_t)); if (!d3d->menu) return false; d3d->menu->tex_coords.x = 0; d3d->menu->tex_coords.y = 0; d3d->menu->tex_coords.w = 1; d3d->menu->tex_coords.h = 1; d3d->menu->vert_coords.x = 0; d3d->menu->vert_coords.y = 1; d3d->menu->vert_coords.w = 1; d3d->menu->vert_coords.h = -1; #endif #if defined(HAVE_WINDOW) && !defined(_XBOX) memset(&d3d->windowClass, 0, sizeof(d3d->windowClass)); d3d->windowClass.cbSize = sizeof(d3d->windowClass); d3d->windowClass.style = CS_HREDRAW | CS_VREDRAW; d3d->windowClass.lpfnWndProc = WindowProc; d3d->windowClass.hInstance = NULL; d3d->windowClass.hCursor = LoadCursor(NULL, IDC_ARROW); d3d->windowClass.lpszClassName = "RetroArch"; d3d->windowClass.hIcon = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON)); d3d->windowClass.hIconSm = (HICON)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON), IMAGE_ICON, 16, 16, 0); if (!info->fullscreen) d3d->windowClass.hbrBackground = (HBRUSH)COLOR_WINDOW; RegisterClassEx(&d3d->windowClass); #endif #ifdef HAVE_MONITOR RECT mon_rect = d3d_monitor_rect(d3d); bool windowed_full = settings->video.windowed_fullscreen; full_x = (windowed_full || info->width == 0) ? (mon_rect.right - mon_rect.left) : info->width; full_y = (windowed_full || info->height == 0) ? (mon_rect.bottom - mon_rect.top) : info->height; RARCH_LOG("[D3D]: Monitor size: %dx%d.\n", (int)(mon_rect.right - mon_rect.left), (int)(mon_rect.bottom - mon_rect.top)); #else if (d3d->ctx_driver && d3d->ctx_driver->get_video_size) d3d->ctx_driver->get_video_size(d3d, &full_x, &full_y); #endif d3d->screen_width = info->fullscreen ? full_x : info->width; d3d->screen_height = info->fullscreen ? full_y : info->height; #ifndef _XBOX #ifdef HAVE_WINDOW char buffer[128]; unsigned win_width = d3d->screen_width; unsigned win_height = d3d->screen_height; RECT rect = {0}; if (!info->fullscreen) { rect.right = d3d->screen_width; rect.bottom = d3d->screen_height; AdjustWindowRect(&rect, WS_OVERLAPPEDWINDOW, FALSE); win_width = rect.right - rect.left; win_height = rect.bottom - rect.top; } video_monitor_get_fps(buffer, sizeof(buffer), NULL, 0); std::string title = buffer; title += " || Direct3D"; d3d->hWnd = CreateWindowEx(0, "RetroArch", title.c_str(), info->fullscreen ? (WS_EX_TOPMOST | WS_POPUP) : WS_OVERLAPPEDWINDOW, info->fullscreen ? mon_rect.left : CW_USEDEFAULT, info->fullscreen ? mon_rect.top : CW_USEDEFAULT, win_width, win_height, NULL, NULL, NULL, d3d); driver->display_type = RARCH_DISPLAY_WIN32; driver->video_display = 0; driver->video_window = (uintptr_t)d3d->hWnd; #endif #endif if (d3d && d3d->ctx_driver && d3d->ctx_driver->show_mouse) d3d->ctx_driver->show_mouse(d3d, !info->fullscreen #ifdef HAVE_OVERLAY || d3d->overlays_enabled #endif ); #ifndef _XBOX #ifdef HAVE_WINDOW if (!info->fullscreen && settings->ui.menubar_enable) { RECT rc_temp = {0, 0, win_height, 0x7FFF}; SetMenu(d3d->hWnd, LoadMenu(GetModuleHandle(NULL),MAKEINTRESOURCE(IDR_MENU))); SendMessage(d3d->hWnd, WM_NCCALCSIZE, FALSE, (LPARAM)&rc_temp); win_height += rc_temp.top + rect.top; SetWindowPos(d3d->hWnd, NULL, 0, 0, win_width, win_height, SWP_NOMOVE); } ShowWindow(d3d->hWnd, SW_RESTORE); UpdateWindow(d3d->hWnd); SetForegroundWindow(d3d->hWnd); SetFocus(d3d->hWnd); #endif #ifdef HAVE_SHADERS /* This should only be done once here * to avoid set_shader() to be overridden * later. */ enum rarch_shader_type type = video_shader_parse_type(settings->video.shader_path, RARCH_SHADER_NONE); if (settings->video.shader_enable && type == RARCH_SHADER_CG) d3d->shader_path = settings->video.shader_path; if (!d3d_process_shader(d3d)) return false; #endif #endif d3d->video_info = *info; if (!d3d_initialize(d3d, &d3d->video_info)) return false; if (input && input_data && d3d->ctx_driver && d3d->ctx_driver->input_driver) d3d->ctx_driver->input_driver(d3d, input, input_data); RARCH_LOG("[D3D]: Init complete.\n"); return true; }