static void *gl1_gfx_init(const video_info_t *video,
const input_driver_t **input, void **input_data)
{
unsigned full_x, full_y;
gfx_ctx_input_t inp;
gfx_ctx_mode_t mode;
void *ctx_data = NULL;
const gfx_ctx_driver_t *ctx_driver = NULL;
unsigned win_width = 0, win_height = 0;
unsigned temp_width = 0, temp_height = 0;
settings_t *settings = config_get_ptr();
gl1_t *gl1 = (gl1_t*)calloc(1, sizeof(*gl1));
const char *vendor = NULL;
const char *renderer = NULL;
const char *version = NULL;
const char *extensions = NULL;
int interval = 0;
struct retro_hw_render_callback *hwr = NULL;
if (!gl1)
return NULL;
*input = NULL;
*input_data = NULL;
gl1_video_width = video->width;
gl1_video_height = video->height;
gl1_rgb32 = video->rgb32;
gl1_video_bits = video->rgb32 ? 32 : 16;
if (video->rgb32)
gl1_video_pitch = video->width * 4;
else
gl1_video_pitch = video->width * 2;
ctx_driver = video_context_driver_init_first(gl1,
settings->arrays.video_context_driver,
GFX_CTX_OPENGL_API, 1, 1, false, &ctx_data);
if (!ctx_driver)
goto error;
if (ctx_data)
gl1->ctx_data = ctx_data;
gl1->ctx_driver = ctx_driver;
video_context_driver_set((const gfx_ctx_driver_t*)ctx_driver);
RARCH_LOG("[GL1]: Found GL1 context: %s\n", ctx_driver->ident);
video_context_driver_get_video_size(&mode);
full_x = mode.width;
full_y = mode.height;
mode.width = 0;
mode.height = 0;
/* Clear out potential error flags in case we use cached context. */
glGetError();
if (string_is_equal(ctx_driver->ident, "null"))
goto error;
RARCH_LOG("[GL1]: Detecting screen resolution %ux%u.\n", full_x, full_y);
win_width = video->width;
win_height = video->height;
if (video->fullscreen && (win_width == 0) && (win_height == 0))
{
win_width = full_x;
win_height = full_y;
}
mode.width = win_width;
mode.height = win_height;
mode.fullscreen = video->fullscreen;
interval = video->swap_interval;
video_context_driver_swap_interval(&interval);
if (!video_context_driver_set_video_mode(&mode))
goto error;
gl1->fullscreen = video->fullscreen;
mode.width = 0;
mode.height = 0;
video_context_driver_get_video_size(&mode);
temp_width = mode.width;
temp_height = mode.height;
mode.width = 0;
mode.height = 0;
/* Get real known video size, which might have been altered by context. */
if (temp_width != 0 && temp_height != 0)
video_driver_set_size(&temp_width, &temp_height);
video_driver_get_size(&temp_width, &temp_height);
RARCH_LOG("[GL1]: Using resolution %ux%u\n", temp_width, temp_height);
vendor = (const char*)glGetString(GL_VENDOR);
renderer = (const char*)glGetString(GL_RENDERER);
version = (const char*)glGetString(GL_VERSION);
extensions = (const char*)glGetString(GL_EXTENSIONS);
if (!string_is_empty(version))
sscanf(version, "%d.%d", &gl1->version_major, &gl1->version_minor);
if (!string_is_empty(extensions))
gl1->extensions = string_split(extensions, " ");
RARCH_LOG("[GL1]: Vendor: %s, Renderer: %s.\n", vendor, renderer);
RARCH_LOG("[GL1]: Version: %s.\n", version);
RARCH_LOG("[GL1]: Extensions: %s\n", extensions);
{
char device_str[128];
device_str[0] = '\0';
if (!string_is_empty(vendor))
{
strlcpy(device_str, vendor, sizeof(device_str));
strlcat(device_str, " ", sizeof(device_str));
}
if (!string_is_empty(renderer))
strlcat(device_str, renderer, sizeof(device_str));
video_driver_set_gpu_device_string(device_str);
if (!string_is_empty(version))
video_driver_set_gpu_api_version_string(version);
}
inp.input = input;
inp.input_data = input_data;
video_context_driver_input_driver(&inp);
if (settings->bools.video_font_enable)
font_driver_init_osd(gl1, false,
video->is_threaded,
FONT_DRIVER_RENDER_OPENGL1_API);
gl1->smooth = settings->bools.video_smooth;
gl1->supports_bgra = string_list_find_elem(gl1->extensions, "GL_EXT_bgra");
glDisable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glDisable(GL_STENCIL_TEST);
glDisable(GL_SCISSOR_TEST);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glGenTextures(1, &gl1->tex);
glGenTextures(1, &gl1->menu_tex);
hwr = video_driver_get_hw_context();
memcpy(gl1->tex_info.coord, gl1_tex_coords, sizeof(gl1->tex_info.coord));
gl1->vertex_ptr = hwr->bottom_left_origin
? gl1_vertexes : gl1_vertexes_flipped;
gl1->textures = 4;
gl1->white_color_ptr = gl1_white_color;
gl1->coords.vertex = gl1->vertex_ptr;
gl1->coords.tex_coord = gl1->tex_info.coord;
gl1->coords.color = gl1->white_color_ptr;
gl1->coords.lut_tex_coord = gl1_tex_coords;
gl1->coords.vertices = 4;
RARCH_LOG("[GL1]: Init complete.\n");
return gl1;
error:
video_context_driver_destroy();
if (gl1)
{
if (gl1->extensions)
string_list_free(gl1->extensions);
free(gl1);
}
return NULL;
}
static bool d3d_construct(d3d_video_t *d3d,
const video_info_t *info, const input_driver_t **input,
void **input_data)
{
gfx_ctx_input_t inp;
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_mode_t mode;
video_context_driver_get_video_size(&mode);
full_x = mode.width;
full_y = mode.height;
}
#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->path.shader, RARCH_SHADER_NONE);
if (settings->video.shader_enable && type == RARCH_SHADER_CG)
d3d->shader_path = settings->path.shader;
if (!d3d_process_shader(d3d))
return false;
#endif
d3d->video_info = *info;
if (!d3d_initialize(d3d, &d3d->video_info))
return false;
inp.input = input;
inp.input_data = input_data;
video_context_driver_input_driver(&inp);
RARCH_LOG("[D3D]: Init complete.\n");
return true;
}
static void *gdi_gfx_init(const video_info_t *video,
const input_driver_t **input, void **input_data)
{
unsigned full_x, full_y;
gfx_ctx_input_t inp;
gfx_ctx_mode_t mode;
const gfx_ctx_driver_t *ctx_driver = NULL;
unsigned win_width = 0, win_height = 0;
unsigned temp_width = 0, temp_height = 0;
settings_t *settings = config_get_ptr();
gdi_t *gdi = (gdi_t*)calloc(1, sizeof(*gdi));
*input = NULL;
*input_data = NULL;
gdi_video_width = video->width;
gdi_video_height = video->height;
gdi_rgb32 = video->rgb32;
gdi_video_bits = video->rgb32 ? 32 : 16;
if (video->rgb32)
gdi_video_pitch = video->width * 4;
else
gdi_video_pitch = video->width * 2;
gdi_gfx_create();
ctx_driver = video_context_driver_init_first(gdi,
settings->arrays.video_context_driver,
GFX_CTX_GDI_API, 1, 0, false);
if (!ctx_driver)
goto error;
video_context_driver_set((const gfx_ctx_driver_t*)ctx_driver);
RARCH_LOG("[GDI]: Found GDI context: %s\n", ctx_driver->ident);
video_context_driver_get_video_size(&mode);
full_x = mode.width;
full_y = mode.height;
mode.width = 0;
mode.height = 0;
RARCH_LOG("[GDI]: Detecting screen resolution %ux%u.\n", full_x, full_y);
win_width = video->width;
win_height = video->height;
if (video->fullscreen && (win_width == 0) && (win_height == 0))
{
win_width = full_x;
win_height = full_y;
}
mode.width = win_width;
mode.height = win_height;
mode.fullscreen = video->fullscreen;
if (!video_context_driver_set_video_mode(&mode))
goto error;
mode.width = 0;
mode.height = 0;
video_context_driver_get_video_size(&mode);
temp_width = mode.width;
temp_height = mode.height;
mode.width = 0;
mode.height = 0;
/* Get real known video size, which might have been altered by context. */
if (temp_width != 0 && temp_height != 0)
video_driver_set_size(&temp_width, &temp_height);
video_driver_get_size(&temp_width, &temp_height);
RARCH_LOG("[GDI]: Using resolution %ux%u\n", temp_width, temp_height);
inp.input = input;
inp.input_data = input_data;
video_context_driver_input_driver(&inp);
if (settings->bools.video_font_enable)
font_driver_init_osd(gdi, false,
video->is_threaded,
FONT_DRIVER_RENDER_GDI);
RARCH_LOG("[GDI]: Init complete.\n");
return gdi;
error:
video_context_driver_destroy();
if (gdi)
free(gdi);
return NULL;
}