static void frontend_win32_environment_get(int *argc, char *argv[],
void *args, void *params_data)
{
gfx_set_dwm();
fill_pathname_expand_special(g_defaults.dirs[DEFAULT_DIR_ASSETS],
":\\assets", sizeof(g_defaults.dirs[DEFAULT_DIR_ASSETS]));
fill_pathname_expand_special(g_defaults.dirs[DEFAULT_DIR_AUDIO_FILTER],
":\\filters\\audio", sizeof(g_defaults.dirs[DEFAULT_DIR_AUDIO_FILTER]));
fill_pathname_expand_special(g_defaults.dirs[DEFAULT_DIR_VIDEO_FILTER],
":\\filters\\video", sizeof(g_defaults.dirs[DEFAULT_DIR_VIDEO_FILTER]));
fill_pathname_expand_special(g_defaults.dirs[DEFAULT_DIR_CHEATS],
":\\cheats", sizeof(g_defaults.dirs[DEFAULT_DIR_CHEATS]));
fill_pathname_expand_special(g_defaults.dirs[DEFAULT_DIR_DATABASE],
":\\database\\rdb", sizeof(g_defaults.dirs[DEFAULT_DIR_DATABASE]));
fill_pathname_expand_special(g_defaults.dirs[DEFAULT_DIR_CURSOR],
":\\database\\cursors", sizeof(g_defaults.dirs[DEFAULT_DIR_CURSOR]));
fill_pathname_expand_special(g_defaults.dirs[DEFAULT_DIR_PLAYLIST],
":\\playlists", sizeof(g_defaults.dirs[DEFAULT_DIR_ASSETS]));
fill_pathname_expand_special(g_defaults.dirs[DEFAULT_DIR_RECORD_CONFIG],
":\\config\\record", sizeof(g_defaults.dirs[DEFAULT_DIR_RECORD_CONFIG]));
fill_pathname_expand_special(g_defaults.dirs[DEFAULT_DIR_RECORD_OUTPUT],
":\\recordings", sizeof(g_defaults.dirs[DEFAULT_DIR_RECORD_OUTPUT]));
fill_pathname_expand_special(g_defaults.dirs[DEFAULT_DIR_MENU_CONFIG],
":\\config", sizeof(g_defaults.dirs[DEFAULT_DIR_MENU_CONFIG]));
fill_pathname_expand_special(g_defaults.dirs[DEFAULT_DIR_REMAP],
":\\config\\remaps", sizeof(g_defaults.dirs[DEFAULT_DIR_REMAP]));
fill_pathname_expand_special(g_defaults.dirs[DEFAULT_DIR_WALLPAPERS],
":\\assets\\wallpapers", sizeof(g_defaults.dirs[DEFAULT_DIR_WALLPAPERS]));
fill_pathname_expand_special(g_defaults.dirs[DEFAULT_DIR_THUMBNAILS],
":\\thumbnails", sizeof(g_defaults.dirs[DEFAULT_DIR_THUMBNAILS]));
fill_pathname_expand_special(g_defaults.dirs[DEFAULT_DIR_OVERLAY],
":\\overlays", sizeof(g_defaults.dirs[DEFAULT_DIR_OVERLAY]));
fill_pathname_expand_special(g_defaults.dirs[DEFAULT_DIR_CORE],
":\\cores", sizeof(g_defaults.dirs[DEFAULT_DIR_CORE]));
fill_pathname_expand_special(g_defaults.dirs[DEFAULT_DIR_CORE_INFO],
":\\info", sizeof(g_defaults.dirs[DEFAULT_DIR_CORE_INFO]));
fill_pathname_expand_special(g_defaults.dirs[DEFAULT_DIR_AUTOCONFIG],
":\\autoconfig", sizeof(g_defaults.dirs[DEFAULT_DIR_AUTOCONFIG]));
fill_pathname_expand_special(g_defaults.dirs[DEFAULT_DIR_SHADER],
":\\shaders", sizeof(g_defaults.dirs[DEFAULT_DIR_SHADER]));
fill_pathname_expand_special(g_defaults.dirs[DEFAULT_DIR_CORE_ASSETS],
":\\downloads", sizeof(g_defaults.dirs[DEFAULT_DIR_CORE_ASSETS]));
fill_pathname_expand_special(g_defaults.dirs[DEFAULT_DIR_SCREENSHOT],
":\\screenshots", sizeof(g_defaults.dirs[DEFAULT_DIR_SCREENSHOT]));
fill_pathname_expand_special(g_defaults.dirs[DEFAULT_DIR_SRAM],
":\\saves", sizeof(g_defaults.dirs[DEFAULT_DIR_SRAM]));
fill_pathname_expand_special(g_defaults.dirs[DEFAULT_DIR_SAVESTATE],
":\\states", sizeof(g_defaults.dirs[DEFAULT_DIR_SAVESTATE]));
fill_pathname_expand_special(g_defaults.dirs[DEFAULT_DIR_SYSTEM],
":\\system", sizeof(g_defaults.dirs[DEFAULT_DIR_SYSTEM]));
fill_pathname_expand_special(g_defaults.dirs[DEFAULT_DIR_LOGS],
":\\logs", sizeof(g_defaults.dirs[DEFAULT_DIR_LOGS]));
#ifdef HAVE_MENU
#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES)
snprintf(g_defaults.settings.menu,
sizeof(g_defaults.settings.menu), "xmb");
#endif
#endif
}
static void frontend_win32_environment_get(int *argc, char *argv[],
void *args, void *params_data)
{
gfx_set_dwm();
fill_pathname_expand_special(g_defaults.dir.assets,
":\\assets", sizeof(g_defaults.dir.assets));
fill_pathname_expand_special(g_defaults.dir.audio_filter,
":\\filters\\audio", sizeof(g_defaults.dir.audio_filter));
fill_pathname_expand_special(g_defaults.dir.video_filter,
":\\filters\\video", sizeof(g_defaults.dir.video_filter));
fill_pathname_expand_special(g_defaults.dir.cheats,
":\\cheats", sizeof(g_defaults.dir.cheats));
fill_pathname_expand_special(g_defaults.dir.database,
":\\database\\rdb", sizeof(g_defaults.dir.database));
fill_pathname_expand_special(g_defaults.dir.cursor,
":\\database\\cursors", sizeof(g_defaults.dir.cursor));
fill_pathname_expand_special(g_defaults.dir.playlist,
":\\playlists", sizeof(g_defaults.dir.assets));
fill_pathname_expand_special(g_defaults.dir.menu_config,
":\\config", sizeof(g_defaults.dir.menu_config));
fill_pathname_expand_special(g_defaults.dir.remap,
":\\config\\remaps", sizeof(g_defaults.dir.remap));
fill_pathname_expand_special(g_defaults.dir.wallpapers,
":\\assets\\wallpapers", sizeof(g_defaults.dir.wallpapers));
fill_pathname_expand_special(g_defaults.dir.thumbnails,
":\\thumbnails", sizeof(g_defaults.dir.thumbnails));
fill_pathname_expand_special(g_defaults.dir.overlay,
":\\overlays", sizeof(g_defaults.dir.overlay));
fill_pathname_expand_special(g_defaults.dir.core,
":\\cores", sizeof(g_defaults.dir.core));
fill_pathname_expand_special(g_defaults.dir.core_info,
":\\info", sizeof(g_defaults.dir.core_info));
fill_pathname_expand_special(g_defaults.dir.autoconfig,
":\\autoconfig", sizeof(g_defaults.dir.autoconfig));
fill_pathname_expand_special(g_defaults.dir.shader,
":\\shaders", sizeof(g_defaults.dir.shader));
fill_pathname_expand_special(g_defaults.dir.core_assets,
":\\downloads", sizeof(g_defaults.dir.core_assets));
fill_pathname_expand_special(g_defaults.dir.screenshot,
":\\screenshots", sizeof(g_defaults.dir.screenshot));
/* don't force this in the driver anymore, these will be handled by
a dummy config file so they can be reset to content dir
fill_pathname_expand_special(g_defaults.dir.sram,
":\\saves", sizeof(g_defaults.dir.sram));
fill_pathname_expand_special(g_defaults.dir.savestate,
":\\states", sizeof(g_defaults.dir.savestate));
fill_pathname_expand_special(g_defaults.dir.system,
":\\system", sizeof(g_defaults.dir.system));
*/
#ifdef HAVE_MENU
#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES)
snprintf(g_defaults.settings.menu, sizeof(g_defaults.settings.menu), "xmb");
#endif
#endif
}
static void frontend_win32_environment_get(int *argc, char *argv[],
void *args, void *params_data)
{
gfx_set_dwm();
}
static void *sdl2_gfx_init(const video_info_t *video, const input_driver_t **input, void **input_data)
{
#ifdef _WIN32
gfx_set_dwm();
#endif
#ifdef HAVE_X11
XInitThreads();
#endif
int i;
if (SDL_WasInit(0) == 0)
{
if (SDL_Init(SDL_INIT_VIDEO) < 0)
return NULL;
}
else if (SDL_InitSubSystem(SDL_INIT_VIDEO) < 0)
return NULL;
sdl2_video_t *vid = (sdl2_video_t*)calloc(1, sizeof(*vid));
if (!vid)
return NULL;
RARCH_LOG("[SDL]: Available renderers (change with $SDL_RENDER_DRIVER):\n");
for (i = 0; i < SDL_GetNumRenderDrivers(); ++i)
{
SDL_RendererInfo renderer;
if (SDL_GetRenderDriverInfo(i, &renderer) == 0)
RARCH_LOG("\t%s\n", renderer.name);
}
RARCH_LOG("[SDL]: Available displays:\n");
for(i = 0; i < SDL_GetNumVideoDisplays(); ++i)
{
SDL_DisplayMode mode;
if (SDL_GetCurrentDisplayMode(i, &mode) < 0)
RARCH_LOG("\tDisplay #%i mode: unknown.\n", i);
else
RARCH_LOG("\tDisplay #%i mode: %ix%i@%ihz.\n", i, mode.w, mode.h,
mode.refresh_rate);
}
// void *sdl_input = NULL;
if (!video->fullscreen)
RARCH_LOG("[SDL]: Creating window @ %ux%u\n", video->width, video->height);
unsigned flags;
if (video->fullscreen)
{
flags = g_settings.video.windowed_fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : SDL_WINDOW_FULLSCREEN;
}
else
flags = SDL_WINDOW_RESIZABLE;
vid->window = SDL_CreateWindow("", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
video->width, video->height, flags);
if (!vid->window)
{
RARCH_ERR("[SDL]: Failed to init SDL window: %s\n", SDL_GetError());
goto error;
}
vid->video = *video;
vid->video.smooth = g_settings.video.smooth;
vid->should_resize = true;
sdl_tex_zero(&vid->frame);
sdl_tex_zero(&vid->menu);
if (video->fullscreen)
SDL_ShowCursor(SDL_DISABLE);
sdl2_init_renderer(vid);
sdl2_init_font(vid, g_settings.video.font_path, g_settings.video.font_size);
sdl2_gfx_set_handles(vid);
*input = NULL;
*input_data = NULL;
return vid;
error:
sdl2_gfx_free(vid);
return NULL;
}
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;
}
static void *gl_init(const video_info_t *video, const input_driver_t **input, void **input_data)
{
#ifdef _WIN32
gfx_set_dwm();
#endif
#ifdef RARCH_CONSOLE
if (driver.video_data)
return driver.video_data;
#endif
gl_t *gl = (gl_t*)calloc(1, sizeof(gl_t));
if (!gl)
return NULL;
if (!gfx_ctx_init())
{
free(gl);
return NULL;
}
unsigned full_x = 0, full_y = 0;
gfx_ctx_get_video_size(&full_x, &full_y);
RARCH_LOG("Detecting resolution %ux%u.\n", full_x, full_y);
gfx_ctx_set_swap_interval(video->vsync ? 1 : 0, false);
unsigned win_width = video->width;
unsigned win_height = video->height;
if (video->fullscreen && (win_width == 0) && (win_height == 0))
{
win_width = full_x;
win_height = full_y;
}
if (!gfx_ctx_set_video_mode(win_width, win_height,
g_settings.video.force_16bit ? 15 : 0, video->fullscreen))
{
free(gl);
return NULL;
}
#ifndef RARCH_CONSOLE
gfx_ctx_update_window_title(true);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
#endif
#if (defined(HAVE_XML) || defined(HAVE_CG)) && defined(_WIN32)
// Win32 GL lib doesn't have some functions needed for XML shaders.
// Need to load dynamically :(
if (!load_gl_proc())
{
gfx_ctx_destroy();
free(gl);
return NULL;
}
#endif
gl->vsync = video->vsync;
gl->fullscreen = video->fullscreen;
gl->full_x = full_x;
gl->full_y = full_y;
gl->win_width = win_width;
gl->win_height = win_height;
RARCH_LOG("GL: Using resolution %ux%u\n", gl->win_width, gl->win_height);
#if defined(HAVE_CG_MENU) && defined(RARCH_CONSOLE)
RARCH_LOG("Initializing menu shader ...\n");
gl_cg_set_menu_shader(default_paths.menu_shader_file);
#endif
if (!gl_shader_init())
{
RARCH_ERR("Shader init failed.\n");
gfx_ctx_destroy();
free(gl);
return NULL;
}
RARCH_LOG("GL: Loaded %u program(s).\n", gl_shader_num());
#ifdef HAVE_FBO
// Set up render to texture.
gl_init_fbo(gl, RARCH_SCALE_BASE * video->input_scale,
RARCH_SCALE_BASE * video->input_scale);
#endif
gl->keep_aspect = video->force_aspect;
// Apparently need to set viewport for passes when we aren't using FBOs.
gl_shader_use(0);
gl_set_viewport(gl, gl->win_width, gl->win_height, false, true);
gl_shader_use(1);
gl_set_viewport(gl, gl->win_width, gl->win_height, false, true);
bool force_smooth = false;
if (gl_shader_filter_type(1, &force_smooth))
gl->tex_filter = force_smooth ? GL_LINEAR : GL_NEAREST;
else
gl->tex_filter = video->smooth ? GL_LINEAR : GL_NEAREST;
gl->texture_type = RARCH_GL_TEXTURE_TYPE;
gl->texture_fmt = video->rgb32 ? RARCH_GL_FORMAT32 : RARCH_GL_FORMAT16;
gl->base_size = video->rgb32 ? sizeof(uint32_t) : sizeof(uint16_t);
glEnable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glDisable(GL_DITHER);
glClearColor(0, 0, 0, 1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(2, GL_FLOAT, 0, vertex_ptr);
memcpy(gl->tex_coords, tex_coords, sizeof(tex_coords));
glTexCoordPointer(2, GL_FLOAT, 0, gl->tex_coords);
glColorPointer(4, GL_FLOAT, 0, white_color);
set_lut_texture_coords(tex_coords);
gl->tex_w = RARCH_SCALE_BASE * video->input_scale;
gl->tex_h = RARCH_SCALE_BASE * video->input_scale;
#ifdef HAVE_OPENGL_TEXREF
glGenBuffers(1, &gl->pbo);
glBindBuffer(GL_TEXTURE_REFERENCE_BUFFER_SCE, gl->pbo);
glBufferData(GL_TEXTURE_REFERENCE_BUFFER_SCE,
gl->tex_w * gl->tex_h * gl->base_size * TEXTURES, NULL, GL_STREAM_DRAW);
#endif
// Empty buffer that we use to clear out the texture with on res change.
gl->empty_buf = calloc(gl->tex_w * gl->tex_h, gl->base_size);
gl_init_textures(gl);
for (unsigned i = 0; i < TEXTURES; i++)
{
gl->last_width[i] = gl->tex_w;
gl->last_height[i] = gl->tex_h;
}
for (unsigned i = 0; i < TEXTURES; i++)
{
gl->prev_info[i].tex = gl->texture[(gl->tex_index - (i + 1)) & TEXTURES_MASK];
gl->prev_info[i].input_size[0] = gl->tex_w;
gl->prev_info[i].tex_size[0] = gl->tex_w;
gl->prev_info[i].input_size[1] = gl->tex_h;
gl->prev_info[i].tex_size[1] = gl->tex_h;
memcpy(gl->prev_info[i].coord, tex_coords, sizeof(tex_coords));
}
gfx_ctx_input_driver(input, input_data);
gl_init_font(gl, g_settings.video.font_path, g_settings.video.font_size);
if (!gl_check_error())
{
gfx_ctx_destroy();
free(gl);
return NULL;
}
return gl;
}
static void *gl_init(const video_info_t *video, const input_driver_t **input, void **input_data)
{
#ifdef _WIN32
gfx_set_dwm();
#endif
if (!sdlwrap_init())
return NULL;
const SDL_VideoInfo *video_info = SDL_GetVideoInfo();
rarch_assert(video_info);
unsigned full_x = video_info->current_w;
unsigned full_y = video_info->current_h;
RARCH_LOG("Detecting desktop resolution %ux%u.\n", full_x, full_y);
sdlwrap_set_swap_interval(video->vsync ? 1 : 0, false);
unsigned win_width = video->width;
unsigned win_height = video->height;
if (video->fullscreen && (win_width == 0) && (win_height == 0))
{
win_width = full_x;
win_height = full_y;
}
if (!sdlwrap_set_video_mode(win_width, win_height,
g_settings.video.force_16bit ? 15 : 0, video->fullscreen))
return NULL;
gfx_window_title_reset();
char buf[128];
if (gfx_window_title(buf, sizeof(buf)))
sdlwrap_wm_set_caption(buf);
// Remove that ugly mouse :D
SDL_ShowCursor(SDL_DISABLE);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
#if (defined(HAVE_XML) || defined(HAVE_CG)) && defined(_WIN32)
// Win32 GL lib doesn't have some functions needed for XML shaders.
// Need to load dynamically :(
if (!load_gl_proc())
{
sdlwrap_destroy();
return NULL;
}
#endif
gl_t *gl = (gl_t*)calloc(1, sizeof(gl_t));
if (!gl)
{
sdlwrap_destroy();
return NULL;
}
gl->vsync = video->vsync;
gl->fullscreen = video->fullscreen;
gl->full_x = full_x;
gl->full_y = full_y;
gl->win_width = win_width;
gl->win_height = win_height;
RARCH_LOG("GL: Using resolution %ux%u\n", gl->win_width, gl->win_height);
if (!gl_shader_init())
{
RARCH_ERR("Shader init failed.\n");
sdlwrap_destroy();
free(gl);
return NULL;
}
RARCH_LOG("GL: Loaded %u program(s).\n", gl_shader_num());
#ifdef HAVE_FBO
// Set up render to texture.
gl_init_fbo(gl, RARCH_SCALE_BASE * video->input_scale,
RARCH_SCALE_BASE * video->input_scale);
#endif
gl->keep_aspect = video->force_aspect;
// Apparently need to set viewport for passes when we aren't using FBOs.
gl_shader_use(0);
set_viewport(gl, gl->win_width, gl->win_height, false, true);
gl_shader_use(1);
set_viewport(gl, gl->win_width, gl->win_height, false, true);
bool force_smooth;
if (gl_shader_filter_type(1, &force_smooth))
gl->tex_filter = force_smooth ? GL_LINEAR : GL_NEAREST;
else
gl->tex_filter = video->smooth ? GL_LINEAR : GL_NEAREST;
gl->texture_type = GL_BGRA;
gl->texture_fmt = video->rgb32 ? GL_UNSIGNED_INT_8_8_8_8_REV : GL_UNSIGNED_SHORT_1_5_5_5_REV;
gl->base_size = video->rgb32 ? sizeof(uint32_t) : sizeof(uint16_t);
glEnable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glDisable(GL_DITHER);
glClearColor(0, 0, 0, 1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glGenTextures(TEXTURES, gl->texture);
for (unsigned i = 0; i < TEXTURES; i++)
{
glBindTexture(GL_TEXTURE_2D, gl->texture[i]);
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->tex_filter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl->tex_filter);
}
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(2, GL_FLOAT, 0, vertexes_flipped);
memcpy(gl->tex_coords, tex_coords, sizeof(tex_coords));
glTexCoordPointer(2, GL_FLOAT, 0, gl->tex_coords);
glColorPointer(4, GL_FLOAT, 0, white_color);
set_lut_texture_coords(tex_coords);
gl->tex_w = RARCH_SCALE_BASE * video->input_scale;
gl->tex_h = RARCH_SCALE_BASE * video->input_scale;
// Empty buffer that we use to clear out the texture with on res change.
gl->empty_buf = calloc(gl->tex_w * gl->tex_h, gl->base_size);
for (unsigned i = 0; i < TEXTURES; i++)
{
glBindTexture(GL_TEXTURE_2D, gl->texture[i]);
glPixelStorei(GL_UNPACK_ROW_LENGTH, gl->tex_w);
glTexImage2D(GL_TEXTURE_2D,
0, GL_RGBA, gl->tex_w, gl->tex_h, 0, gl->texture_type,
gl->texture_fmt, gl->empty_buf ? gl->empty_buf : NULL);
}
glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
for (unsigned i = 0; i < TEXTURES; i++)
{
gl->last_width[i] = gl->tex_w;
gl->last_height[i] = gl->tex_h;
}
for (unsigned i = 0; i < TEXTURES; i++)
{
gl->prev_info[i].tex = gl->texture[(gl->tex_index - (i + 1)) & TEXTURES_MASK];
gl->prev_info[i].input_size[0] = gl->tex_w;
gl->prev_info[i].tex_size[0] = gl->tex_w;
gl->prev_info[i].input_size[1] = gl->tex_h;
gl->prev_info[i].tex_size[1] = gl->tex_h;
memcpy(gl->prev_info[i].coord, tex_coords, sizeof(tex_coords));
}
// Hook up SDL input driver to get SDL_QUIT events and RESIZE.
sdl_input_t *sdl_input = (sdl_input_t*)input_sdl.init();
if (sdl_input)
{
*input = &input_sdl;
*input_data = sdl_input;
}
else
*input = NULL;
gl_init_font(gl, g_settings.video.font_path, g_settings.video.font_size);
if (!gl_check_error())
{
sdlwrap_destroy();
free(gl);
return NULL;
}
return gl;
}
