static void *vg_init(const video_info_t *video, const input_driver_t **input, void **input_data)
{
unsigned temp_width = 0, temp_height = 0;
VGfloat clearColor[4] = {0, 0, 0, 1};
settings_t *settings = config_get_ptr();
driver_t *driver = driver_get_ptr();
const gfx_ctx_driver_t *ctx = NULL;
vg_t *vg = (vg_t*)calloc(1, sizeof(vg_t));
if (!vg)
goto error;
ctx = gfx_ctx_init_first(vg, settings->video.context_driver,
GFX_CTX_OPENVG_API, 0, 0, false);
if (!ctx)
goto error;
driver->video_context = ctx;
gfx_ctx_get_video_size(vg, &temp_width, &temp_height);
RARCH_LOG("Detecting screen resolution %ux%u.\n", temp_width, temp_height);
if (temp_width != 0 && temp_height != 0)
{
video_driver_set_size_width(temp_width);
video_driver_set_size_width(temp_height);
}
gfx_ctx_swap_interval(vg, video->vsync ? 1 : 0);
gfx_ctx_update_window_title(vg);
vg->mTexType = video->rgb32 ? VG_sXRGB_8888 : VG_sRGB_565;
vg->keep_aspect = video->force_aspect;
unsigned win_width = video->width;
unsigned win_height = video->height;
if (video->fullscreen && (win_width == 0) && (win_height == 0))
{
video_driver_get_size(&temp_width, &temp_height);
win_width = temp_width;
win_height = temp_height;
}
if (!gfx_ctx_set_video_mode(vg, win_width, win_height, video->fullscreen))
goto error;
video_driver_get_size(&temp_width, &temp_height);
temp_width = 0;
temp_height = 0;
gfx_ctx_get_video_size(vg, &temp_width, &temp_height);
vg->should_resize = true;
if (temp_width != 0 && temp_height != 0)
{
RARCH_LOG("Verified window resolution %ux%u.\n", temp_width, temp_height);
video_driver_set_size_width(temp_width);
video_driver_set_size_height(temp_height);
}
video_driver_get_size(&temp_width, &temp_height);
vg->mScreenAspect = (float)temp_width / temp_height;
gfx_ctx_translate_aspect(vg, &vg->mScreenAspect, temp_width, temp_height);
vgSetfv(VG_CLEAR_COLOR, 4, clearColor);
vg->mTextureWidth = vg->mTextureHeight = video->input_scale * RARCH_SCALE_BASE;
vg->mImage = vgCreateImage(vg->mTexType, vg->mTextureWidth, vg->mTextureHeight,
video->smooth ? VG_IMAGE_QUALITY_BETTER : VG_IMAGE_QUALITY_NONANTIALIASED);
vg_set_nonblock_state(vg, !video->vsync);
gfx_ctx_input_driver(vg, input, input_data);
if (settings->video.font_enable && font_renderer_create_default(&vg->font_driver, &vg->mFontRenderer,
*settings->video.font_path ? settings->video.font_path : NULL, settings->video.font_size))
{
vg->mFont = vgCreateFont(0);
if (vg->mFont != VG_INVALID_HANDLE)
{
vg->mFontsOn = true;
vg->mFontHeight = settings->video.font_size;
vg->mPaintFg = vgCreatePaint();
vg->mPaintBg = vgCreatePaint();
VGfloat paintFg[] = { settings->video.msg_color_r, settings->video.msg_color_g, settings->video.msg_color_b, 1.0f };
VGfloat paintBg[] = { settings->video.msg_color_r / 2.0f, settings->video.msg_color_g / 2.0f, settings->video.msg_color_b / 2.0f, 0.5f };
vgSetParameteri(vg->mPaintFg, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
vgSetParameterfv(vg->mPaintFg, VG_PAINT_COLOR, 4, paintFg);
vgSetParameteri(vg->mPaintBg, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
vgSetParameterfv(vg->mPaintBg, VG_PAINT_COLOR, 4, paintBg);
}
}
if (vg_query_extension("KHR_EGL_image") && gfx_ctx_image_buffer_init(vg, video))
{
pvgCreateEGLImageTargetKHR = (PFNVGCREATEEGLIMAGETARGETKHRPROC)gfx_ctx_get_proc_address("vgCreateEGLImageTargetKHR");
if (pvgCreateEGLImageTargetKHR)
{
RARCH_LOG("[VG] Using EGLImage buffer\n");
vg->mEglImageBuf = true;
}
}
#if 0
const char *ext = (const char*)vgGetString(VG_EXTENSIONS);
if (ext)
RARCH_LOG("[VG] Supported extensions: %s\n", ext);
#endif
return vg;
error:
if (vg)
free(vg);
if (driver)
driver->video_context = NULL;
return NULL;
}
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;
}
