static void gfx_ctx_rmenu_frame(void *data)
{
gl_t *gl = (gl_t*)data;
gl_shader_use(gl, RARCH_CG_MENU_SHADER_INDEX);
gl_set_viewport(gl, gl->win_width, gl->win_height, true, false);
if (gl->shader)
{
gl->shader->set_params(gl->win_width, gl->win_height,
gl->win_width, gl->win_height,
gl->win_width, gl->win_height,
g_extern.frame_count, NULL, NULL, NULL, 0);
}
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, menu_texture_id);
gl->coords.vertex = vertexes_flipped;
gl_shader_set_coords(gl, &gl->coords, &gl->mvp);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
gl_set_viewport(gl, gl->win_width, gl->win_height, false, true);
}
static bool gl_xml_shader(void *data, const char *path)
{
gl_t *gl = (gl_t*)data;
#ifdef HAVE_FBO
gl_deinit_fbo(gl);
glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
#endif
gl_shader_deinit();
if (!gl_glsl_init(path))
return false;
#ifdef HAVE_FBO
// Set up render to texture again.
gl_init_fbo(gl, gl->tex_w, gl->tex_h);
#endif
// 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);
return true;
}
static void lakka_frame(void)
{
struct font_output_list *msg;
gl_t *gl = (gl_t*)driver.video_data;
menu_category_t *active_category = (menu_category_t*)&categories[menu_active_category];
menu_item_t *active_item;
if (!driver.menu || !gl || !active_category)
return;
active_item = (menu_item_t*)&active_category->items[active_category->active_item];
update_tweens(0.002);
glViewport(0, 0, gl->win_width, gl->win_height);
lakka_draw_background();
lakka_draw_categories();
if (depth == 0 && active_category)
lakka_draw_text(active_category->name, title_margin_left, title_margin_top, 1, 1.0);
else if (active_item)
lakka_draw_text(active_item->name, title_margin_left, title_margin_top, 1, 1.0);
lakka_draw_icon(textures[TEXTURE_ARROW].id,
margin_left + hspacing*(menu_active_category+1) + all_categories_x + icon_size/2.0,
margin_top + vspacing*active_item_factor + icon_size/2.0, arrow_alpha, 0, i_active_zoom);
gl_set_viewport(gl, gl->win_width, gl->win_height, false, false);
}
static void gl_raster_font_restore_viewport(gl_t *gl)
{
glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
glDisable(GL_BLEND);
gl_set_viewport(gl, gl->win_width, gl->win_height, false, true);
}
static void lakka_draw_text(const char *str, float x, float y, float scale, float alpha)
{
if (alpha > global_alpha)
alpha = global_alpha;
if (alpha == 0)
return;
gl_t *gl = (gl_t*)driver.video_data;
if (!gl)
return;
if (x < -icon_size || x > gl->win_width + icon_size || y < -icon_size || y > gl->win_height + icon_size)
return;
gl_set_viewport(gl, gl->win_width, gl->win_height, false, false);
struct font_params params = {0};
params.x = x / gl->win_width;
params.y = 1.0f - y / gl->win_height;
params.scale = scale;
params.color = FONT_COLOR_RGBA(255, 255, 255, (uint8_t)(255 * alpha));
params.full_screen = true;
if (font_driver)
font_driver->render_msg(font, str, ¶ms);
}
static void gl2_renderchain_start_render(void *data,
void *chain_data,
video_frame_info_t *video_info)
{
/* Used when rendering to an FBO.
* Texture coords have to be aligned
* with vertex coordinates. */
static const GLfloat fbo_vertexes[] = {
0, 0,
1, 0,
0, 1,
1, 1
};
gl_t *gl = (gl_t*)data;
gl2_renderchain_t *chain = (gl2_renderchain_t*)chain_data;
glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
gl2_bind_fb(chain->fbo[0]);
gl_set_viewport(gl,
video_info, gl->fbo_rect[0].img_width,
gl->fbo_rect[0].img_height, true, false);
/* Need to preserve the "flipped" state when in FBO
* as well to have consistent texture coordinates.
*
* We will "flip" it in place on last pass. */
gl->coords.vertex = fbo_vertexes;
#if defined(GL_FRAMEBUFFER_SRGB) && !defined(HAVE_OPENGLES)
if (chain->has_srgb_fbo)
glEnable(GL_FRAMEBUFFER_SRGB);
#endif
}
static void gl_update_resize(gl_t *gl)
{
#ifdef HAVE_FBO
if (!gl->render_to_tex)
gl_set_viewport(gl, gl->win_width, gl->win_height, false, true);
else
{
gl_check_fbo_dimensions(gl);
// Go back to what we're supposed to do, render to FBO #0 :D
gl_start_frame_fbo(gl);
}
#else
gl_set_viewport(gl, gl->win_width, gl->win_height, false, true);
#endif
}
static void lakka_frame(void)
{
menu_item_t *active_item = NULL;
menu_category_t *active_category = NULL;
lakka_handle_t *lakka = NULL;
gl_t *gl = (gl_t*)driver_video_resolve(NULL);
if (!gl)
return;
if (!driver.menu)
return;
lakka = (lakka_handle_t*)driver.menu->userdata;
if (!lakka)
return;
active_category = (menu_category_t*)
&lakka->categories[lakka->menu_active_category];
if (!active_category)
return;
active_item = (menu_item_t*)
&active_category->items[active_category->active_item];
update_tweens(0.002);
#if defined(HAVE_FBO) && defined(LAKKA_EFFECTS)
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
lakka_draw_categories(lakka);
lakka_draw_arrow(lakka);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glViewport(0, 0, gl->win_width, gl->win_height);
lakka_draw_background();
lakka_draw_fbo();
#else
glViewport(0, 0, gl->win_width, gl->win_height);
lakka_draw_background();
lakka_draw_categories(lakka);
lakka_draw_arrow(lakka);
#endif
if (lakka->depth == 0)
lakka_draw_text(lakka, active_category->name,
lakka->title_margin_left, lakka->title_margin_top, 1, 1.0);
else if (active_item)
lakka_draw_text(lakka, active_item->name,
lakka->title_margin_left, lakka->title_margin_top, 1, 1.0);
gl_set_viewport(gl, gl->win_width, gl->win_height, false, false);
glDisable(GL_BLEND);
}
static void gl_event (const r_event_t *event) {
switch (event->type) {
case R_EVENT_RESIZE:
gl_set_viewport(0, 0, event->data.resize.width, event->data.resize.height);
break;
default:
break;
}
}
static bool gl_init (GNUC_UNUSED engine_module_t *self) {
gl_clear = con_var_get("gl_clear", "1", "clear screen on every frame", CON_OBJ_FL_SAVE);
int w, h, orientation;
cl_video_get_mode_current(&w, &h, &orientation);
gl_set_viewport(0, 0, w, h);
glClearColor(CLEAR_COLOR, 0.0f);
glClearDepth(1.0f);
return true;
}
static inline void gl_start_frame_fbo(gl_t *gl)
{
glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
pglBindFramebuffer(GL_FRAMEBUFFER, gl->fbo[0]);
gl->render_to_tex = true;
gl_set_viewport(gl, gl->fbo_rect[0].img_width, gl->fbo_rect[0].img_height, true, false);
// Need to preserve the "flipped" state when in FBO as well to have
// consistent texture coordinates.
// We will "flip" it in place on last pass.
if (gl->render_to_tex)
glVertexPointer(2, GL_FLOAT, 0, vertexes);
}
static bool gfx_ctx_orientation_update(void)
{
gl_t *gl = (gl_t*)driver.video_data;
// Get real known video size, which might have been altered by context.
gfx_ctx_get_video_size(&gl->win_width, &gl->win_height);
RARCH_LOG("GL: Using resolution %ux%u\n", gl->win_width, gl->win_height);
if (gl->full_x || gl->full_y) // We got bogus from gfx_ctx_get_video_size. Replace.
{
gl->full_x = gl->win_width;
gl->full_y = gl->win_height;
}
#ifdef HAVE_GLSL
gl_glsl_use(0);
#endif
gl_set_viewport(gl, gl->win_width, gl->win_height, false, true);
#ifdef HAVE_GLSL
gl_glsl_use(1);
#endif
gl_set_viewport(gl, gl->win_width, gl->win_height, false, true);
}
static void gl_render_menu(gl_t *gl)
{
gl_shader_use(RARCH_CG_MENU_SHADER_INDEX);
gl_shader_set_params(gl->win_width, gl->win_height, gl->win_width,
gl->win_height, gl->win_width, gl->win_height, gl->frame_count,
NULL, NULL, NULL, 0);
gl_set_viewport(gl, gl->win_width, gl->win_height, true, false);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, gl->menu_texture_id);
glVertexPointer(2, GL_FLOAT, 0, default_vertex_ptr);
glDrawArrays(GL_QUADS, 0, 4);
glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
}
static void gl_raster_font_setup_viewport(gl_raster_t *font, bool full_screen)
{
gl_t *gl = font->gl;
if (!gl)
return;
gl_set_viewport(gl, gl->win_width, gl->win_height, full_screen, false);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBlendEquation(GL_FUNC_ADD);
glBindTexture(GL_TEXTURE_2D, font->tex);
if (gl->shader && gl->shader->use)
gl->shader->use(gl, GL_SHADER_STOCK_BLEND);
}
void gl_renderchain_start_render(gl_t *gl)
{
glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
glBindFramebuffer(RARCH_GL_FRAMEBUFFER, gl->fbo[0]);
gl_set_viewport(gl, gl->fbo_rect[0].img_width,
gl->fbo_rect[0].img_height, true, false);
/* Need to preserve the "flipped" state when in FBO
* as well to have consistent texture coordinates.
*
* We will "flip" it in place on last pass. */
gl->coords.vertex = fbo_vertexes;
#if defined(GL_FRAMEBUFFER_SRGB) && !defined(HAVE_OPENGLES)
if (gl->has_srgb_fbo)
glEnable(GL_FRAMEBUFFER_SRGB);
#endif
}
static inline void gl_copy_frame(gl_t *gl, const void *frame, unsigned width, unsigned height, unsigned pitch)
{
if (!gl->fbo_inited)
gl_set_viewport(gl, gl->win_width, gl->win_height, false, true);
size_t buffer_addr = gl->tex_w * gl->tex_h * gl->tex_index * gl->base_size;
size_t buffer_stride = gl->tex_w * gl->base_size;
const uint8_t *frame_copy = frame;
size_t frame_copy_size = width * gl->base_size;
for (unsigned h = 0; h < height; h++)
{
glBufferSubData(GL_TEXTURE_REFERENCE_BUFFER_SCE,
buffer_addr,
frame_copy_size,
frame_copy);
frame_copy += pitch;
buffer_addr += buffer_stride;
}
}
static void xmb_draw_text(const char *str, float x,
float y, float scale, float alpha)
{
uint8_t a8 = 0;
struct font_params params = {0};
xmb_handle_t *xmb = (xmb_handle_t*)driver.menu->userdata;
if (!xmb)
return;
if (alpha > xmb->alpha)
alpha = xmb->alpha;
a8 = 255 * alpha;
if (a8 == 0)
return;
gl_t *gl = (gl_t*)driver_video_resolve(NULL);
if (!gl)
return;
if (x < -xmb->icon_size || x > gl->win_width + xmb->icon_size
|| y < -xmb->icon_size || y > gl->win_height + xmb->icon_size)
return;
gl_set_viewport(gl, gl->win_width, gl->win_height, false, false);
params.x = x / gl->win_width;
params.y = 1.0f - y / gl->win_height;
params.scale = scale;
params.color = FONT_COLOR_RGBA(255, 255, 255, a8);
params.full_screen = true;
if (driver.video_data && driver.video_poke
&& driver.video_poke->set_osd_msg)
driver.video_poke->set_osd_msg(driver.video_data,
str, ¶ms);
}
static void lakka_draw_text(lakka_handle_t *lakka,
const char *str, float x,
float y, float scale, float alpha)
{
if (alpha > lakka->global_alpha)
alpha = lakka->global_alpha;
uint8_t a8 = 255 * alpha;
if (!lakka)
return;
if (a8 == 0)
return;
gl_t *gl = (gl_t*)driver_video_resolve(NULL);
if (!gl)
return;
if (x < -lakka->icon_size || x > gl->win_width + lakka->icon_size
|| y < -lakka->icon_size || y > gl->win_height + lakka->icon_size)
return;
gl_set_viewport(gl, gl->win_width, gl->win_height, false, false);
struct font_params params = {0};
params.x = x / gl->win_width;
params.y = 1.0f - y / gl->win_height;
params.scale = scale;
params.color = FONT_COLOR_RGBA(255, 255, 255, a8);
params.full_screen = true;
if (driver.video_data && driver.video_poke
&& driver.video_poke->set_osd_msg)
driver.video_poke->set_osd_msg(driver.video_data,
str, ¶ms);
}
static void glui_blit_line(float x, float y, const char *message, bool green)
{
gl_t *gl = (gl_t*)driver_video_resolve(NULL);
if (!driver.menu || !gl)
return;
gl_set_viewport(gl, gl->win_width, gl->win_height, false, false);
struct font_params params = {0};
params.x = x / gl->win_width;
params.y = 1.0f - y / gl->win_height;
params.scale = 1.0;
params.color = green ? FONT_COLOR_RGBA(100, 255, 100, 255)
: FONT_COLOR_RGBA(255, 255, 255, 255);
params.full_screen = true;
if (driver.video_data && driver.video_poke
&& driver.video_poke->set_osd_msg)
driver.video_poke->set_osd_msg(driver.video_data,
message, ¶ms, NULL);
}
static void lakka_frame(void)
{
struct font_output_list *msg;
gl_t *gl = (gl_t*)driver.video_data;
menu_category_t *active_category = (menu_category_t*)&categories[menu_active_category];
menu_item_t *active_item;
if (!driver.menu || !gl || !active_category)
return;
active_item = (menu_item_t*)&active_category->items[active_category->active_item];
update_tweens(0.002);
glViewport(0, 0, gl->win_width, gl->win_height);
lakka_draw_background();
lakka_draw_categories();
if (depth == 0)
{
if (active_category)
lakka_draw_text(&active_category->out, 15.0, 40.0, 1, 1.0);
}
else
{
if (active_item)
lakka_draw_text(&active_item->out, 15.0, 40.0, 1, 1.0);
lakka_draw_icon(textures[TEXTURE_ARROW].id,
156 + HSPACING*(menu_active_category+1) + all_categories_x + 150 +-dim/2.0,
300 + VSPACING*2.4 + (dim/2.0), 1, 0, I_ACTIVE_ZOOM);
}
gl_set_viewport(gl, gl->win_width, gl->win_height, false, false);
}
static void lakka_draw_text(struct font_output_list *out, float x, float y, float scale, float alpha)
{
int i;
struct font_output *head;
struct font_rect geom;
struct gl_ortho ortho = {0, 1, 0, 1, -1, 1};
gl_t *gl = (gl_t*)driver.video_data;
if (alpha > global_alpha)
alpha = global_alpha;
if (!font || !gl || !out)
return;
for (i = 0; i < 4; i++)
{
font_color[4 * i + 0] = 1.0;
font_color[4 * i + 1] = 1.0;
font_color[4 * i + 2] = 1.0;
font_color[4 * i + 3] = alpha;
}
if (gl->shader && gl->shader->use)
gl->shader->use(gl, GL_SHADER_STOCK_BLEND);
gl_set_viewport(gl, gl->win_width, gl->win_height, true, false);
glEnable(GL_BLEND);
GLfloat font_vertex[8];
GLfloat font_vertex_dark[8];
GLfloat font_tex_coords[8];
glBindTexture(GL_TEXTURE_2D, font_tex);
gl->coords.tex_coord = font_tex_coords;
head = (struct font_output*)out->head;
calculate_msg_geometry(head, &geom);
adjust_power_of_two(gl, &geom);
blit_fonts(gl, head, &geom);
font_last_width = geom.width;
font_last_height = geom.height;
calculate_font_coords(gl, font_vertex, font_vertex_dark, font_tex_coords,
scale, x / gl->win_width, (gl->win_height - y) / gl->win_height);
gl->coords.vertex = font_vertex;
gl->coords.color = font_color;
gl_shader_set_coords(gl, &gl->coords, &gl->mvp);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
// Post - Go back to old rendering path.
gl->coords.vertex = gl->vertex_ptr;
gl->coords.tex_coord = gl->tex_coords;
gl->coords.color = gl->white_color_ptr;
glBindTexture(GL_TEXTURE_2D, textures[TEXTURE_MAIN].id);
glDisable(GL_BLEND);
gl_set_projection(gl, &ortho, true);
}
void gl_renderchain_render(gl_t *gl,
uint64_t frame_count,
const struct video_tex_info *tex_info,
const struct video_tex_info *feedback_info)
{
unsigned mip_level;
video_shader_ctx_mvp_t mvp;
video_shader_ctx_coords_t coords;
video_shader_ctx_params_t params;
video_shader_ctx_info_t shader_info;
unsigned width, height;
const struct video_fbo_rect *prev_rect;
struct video_tex_info *fbo_info;
struct video_tex_info fbo_tex_info[GFX_MAX_SHADERS];
int i;
GLfloat xamt, yamt;
unsigned fbo_tex_info_cnt = 0;
GLfloat fbo_tex_coords[8] = {0.0f};
video_driver_get_size(&width, &height);
/* Render the rest of our passes. */
gl->coords.tex_coord = fbo_tex_coords;
/* Calculate viewports, texture coordinates etc,
* and render all passes from FBOs, to another FBO. */
for (i = 1; i < gl->fbo_pass; i++)
{
video_shader_ctx_mvp_t mvp;
video_shader_ctx_coords_t coords;
video_shader_ctx_params_t params;
const struct video_fbo_rect *rect = &gl->fbo_rect[i];
prev_rect = &gl->fbo_rect[i - 1];
fbo_info = &fbo_tex_info[i - 1];
xamt = (GLfloat)prev_rect->img_width / prev_rect->width;
yamt = (GLfloat)prev_rect->img_height / prev_rect->height;
set_texture_coords(fbo_tex_coords, xamt, yamt);
fbo_info->tex = gl->fbo_texture[i - 1];
fbo_info->input_size[0] = prev_rect->img_width;
fbo_info->input_size[1] = prev_rect->img_height;
fbo_info->tex_size[0] = prev_rect->width;
fbo_info->tex_size[1] = prev_rect->height;
memcpy(fbo_info->coord, fbo_tex_coords, sizeof(fbo_tex_coords));
fbo_tex_info_cnt++;
glBindFramebuffer(RARCH_GL_FRAMEBUFFER, gl->fbo[i]);
shader_info.data = gl;
shader_info.idx = i + 1;
shader_info.set_active = true;
video_shader_driver_use(&shader_info);
glBindTexture(GL_TEXTURE_2D, gl->fbo_texture[i - 1]);
mip_level = i + 1;
if (video_shader_driver_mipmap_input(&mip_level)
&& gl_check_capability(GL_CAPS_MIPMAP))
glGenerateMipmap(GL_TEXTURE_2D);
glClear(GL_COLOR_BUFFER_BIT);
/* Render to FBO with certain size. */
gl_set_viewport(gl, rect->img_width, rect->img_height, true, false);
params.data = gl;
params.width = prev_rect->img_width;
params.height = prev_rect->img_height;
params.tex_width = prev_rect->width;
params.tex_height = prev_rect->height;
params.out_width = gl->vp.width;
params.out_height = gl->vp.height;
params.frame_counter = (unsigned int)frame_count;
params.info = tex_info;
params.prev_info = gl->prev_info;
params.feedback_info = feedback_info;
params.fbo_info = fbo_tex_info;
params.fbo_info_cnt = fbo_tex_info_cnt;
video_shader_driver_set_parameters(¶ms);
gl->coords.vertices = 4;
coords.handle_data = NULL;
coords.data = &gl->coords;
video_shader_driver_set_coords(&coords);
mvp.data = gl;
mvp.matrix = &gl->mvp;
video_shader_driver_set_mvp(&mvp);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
#if defined(GL_FRAMEBUFFER_SRGB) && !defined(HAVE_OPENGLES)
if (gl->has_srgb_fbo)
glDisable(GL_FRAMEBUFFER_SRGB);
#endif
/* Render our last FBO texture directly to screen. */
prev_rect = &gl->fbo_rect[gl->fbo_pass - 1];
xamt = (GLfloat)prev_rect->img_width / prev_rect->width;
yamt = (GLfloat)prev_rect->img_height / prev_rect->height;
set_texture_coords(fbo_tex_coords, xamt, yamt);
/* Push final FBO to list. */
fbo_info = &fbo_tex_info[gl->fbo_pass - 1];
fbo_info->tex = gl->fbo_texture[gl->fbo_pass - 1];
fbo_info->input_size[0] = prev_rect->img_width;
fbo_info->input_size[1] = prev_rect->img_height;
fbo_info->tex_size[0] = prev_rect->width;
fbo_info->tex_size[1] = prev_rect->height;
memcpy(fbo_info->coord, fbo_tex_coords, sizeof(fbo_tex_coords));
fbo_tex_info_cnt++;
/* Render our FBO texture to back buffer. */
gl_bind_backbuffer();
shader_info.data = gl;
shader_info.idx = gl->fbo_pass + 1;
shader_info.set_active = true;
video_shader_driver_use(&shader_info);
glBindTexture(GL_TEXTURE_2D, gl->fbo_texture[gl->fbo_pass - 1]);
mip_level = gl->fbo_pass + 1;
if (video_shader_driver_mipmap_input(&mip_level)
&& gl_check_capability(GL_CAPS_MIPMAP))
glGenerateMipmap(GL_TEXTURE_2D);
glClear(GL_COLOR_BUFFER_BIT);
gl_set_viewport(gl, width, height, false, true);
params.data = gl;
params.width = prev_rect->img_width;
params.height = prev_rect->img_height;
params.tex_width = prev_rect->width;
params.tex_height = prev_rect->height;
params.out_width = gl->vp.width;
params.out_height = gl->vp.height;
params.frame_counter = (unsigned int)frame_count;
params.info = tex_info;
params.prev_info = gl->prev_info;
params.feedback_info = feedback_info;
params.fbo_info = fbo_tex_info;
params.fbo_info_cnt = fbo_tex_info_cnt;
video_shader_driver_set_parameters(¶ms);
gl->coords.vertex = gl->vertex_ptr;
gl->coords.vertices = 4;
coords.handle_data = NULL;
coords.data = &gl->coords;
video_shader_driver_set_coords(&coords);
mvp.data = gl;
mvp.matrix = &gl->mvp;
video_shader_driver_set_mvp(&mvp);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
gl->coords.tex_coord = gl->tex_info.coord;
}
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 glui_frame(void)
{
unsigned x, y;
size_t i;
char title[PATH_MAX], title_buf[PATH_MAX],
title_msg[PATH_MAX];
const char *dir = NULL;
const char *label = NULL;
unsigned menu_type = 0;
size_t end;
gl_t *gl = (gl_t*)driver_video_resolve(NULL);
glui_handle_t *glui = NULL;
if (!driver.menu || !gl)
return;
glui = (glui_handle_t*)driver.menu->userdata;
if (!glui)
return;
if (driver.menu->need_refresh
&& g_extern.is_menu
&& !driver.menu->msg_force)
return;
glui->line_height = g_settings.video.font_size * 4 / 3;
glui->glyph_width = glui->line_height / 2;
glui->margin = gl->win_width / 20 ;
glui->term_width = (gl->win_width - glui->margin * 2) / glui->glyph_width;
glui->term_height = (gl->win_height - glui->margin * 2) / glui->line_height - 2;
driver.menu->mouse.ptr = (driver.menu->mouse.y - glui->margin) /
glui->line_height - 2 + driver.menu->begin;
glViewport(0, 0, gl->win_width, gl->win_height);
if (driver.menu->mouse.wheeldown && driver.menu->begin
< menu_list_get_size(driver.menu->menu_list) - glui->term_height)
driver.menu->begin++;
if (driver.menu->mouse.wheelup && driver.menu->begin > 0)
driver.menu->begin--;
/* Do not scroll if all items are visible. */
if (menu_list_get_size(driver.menu->menu_list) <= glui->term_height)
driver.menu->begin = 0;
end = (driver.menu->begin + glui->term_height <=
menu_list_get_size(driver.menu->menu_list)) ?
driver.menu->begin + glui->term_height :
menu_list_get_size(driver.menu->menu_list);
glui_render_background(false);
menu_list_get_last_stack(driver.menu->menu_list, &dir, &label, &menu_type);
get_title(label, dir, menu_type, title, sizeof(title));
menu_ticker_line(title_buf, glui->term_width - 3,
g_extern.frame_count / glui->margin, title, true);
glui_blit_line(glui->margin * 2, glui->margin + glui->line_height,
title_buf, true);
const char *core_name = g_extern.menu.info.library_name;
if (!core_name)
core_name = g_extern.system.info.library_name;
if (!core_name)
core_name = "No Core";
const char *core_version = g_extern.menu.info.library_version;
if (!core_version)
core_version = g_extern.system.info.library_version;
if (!core_version)
core_version = "";
snprintf(title_msg, sizeof(title_msg), "%s - %s %s", PACKAGE_VERSION,
core_name, core_version);
glui_blit_line(
glui->margin * 2,
glui->margin + glui->term_height * glui->line_height
+ glui->line_height * 2, title_msg, true);
x = glui->margin;
y = glui->margin + glui->line_height * 2;
for (i = driver.menu->begin; i < end; i++, y += glui->line_height)
{
char message[PATH_MAX], type_str[PATH_MAX],
entry_title_buf[PATH_MAX], type_str_buf[PATH_MAX],
path_buf[PATH_MAX];
const char *path = NULL, *entry_label = NULL;
unsigned type = 0, w = 0;
bool selected = false;
menu_list_get_at_offset(driver.menu->menu_list->selection_buf, i, &path,
&entry_label, &type);
rarch_setting_t *setting = (rarch_setting_t*)setting_data_find_setting(
driver.menu->list_settings,
driver.menu->menu_list->selection_buf->list[i].label);
(void)setting;
disp_set_label(driver.menu->menu_list->selection_buf, &w, type, i, label,
type_str, sizeof(type_str),
entry_label, path,
path_buf, sizeof(path_buf));
selected = (i == driver.menu->selection_ptr);
menu_ticker_line(entry_title_buf, glui->term_width - (w + 1 + 2),
g_extern.frame_count / glui->margin, path_buf, selected);
menu_ticker_line(type_str_buf, w,
g_extern.frame_count / glui->margin, type_str, selected);
strlcpy(message, entry_title_buf, sizeof(message));
glui_blit_line(x, y, message, selected);
glui_blit_line(gl->win_width - glui->glyph_width * w - glui->margin ,
y, type_str_buf, selected);
}
#ifdef GEKKO
const char *message_queue;
if (driver.menu->msg_force)
{
message_queue = msg_queue_pull(g_extern.msg_queue);
driver.menu->msg_force = false;
}
else
message_queue = driver.current_msg;
glui_render_messagebox(message_queue);
#endif
if (driver.menu->keyboard.display)
{
char msg[PATH_MAX];
const char *str = *driver.menu->keyboard.buffer;
if (!str)
str = "";
glui_render_background(true);
snprintf(msg, sizeof(msg), "%s\n%s", driver.menu->keyboard.label, str);
glui_render_messagebox(msg);
}
if (glui->box_message[0] != '\0')
{
glui_render_background(true);
glui_render_messagebox(glui->box_message);
glui->box_message[0] = '\0';
}
if (driver.menu->mouse.enable)
glui_draw_cursor(driver.menu->mouse.x, driver.menu->mouse.y);
gl_set_viewport(gl, gl->win_width, gl->win_height, false, false);
}
bool gl_initialize(int screen_wid,int screen_high,int fsaa_mode,char *err_str)
{
int sdl_flags;
GLint ntxtsize;
#if defined(D3_OS_LINUX) || defined(D3_OS_WINDOWS)
GLenum glew_error;
#endif
#ifdef D3_OS_IPHONE
const GLenum discards[]={GL_DEPTH_ATTACHMENT,GL_STENCIL_ATTACHMENT};
#endif
// reset sizes to the desktop
// if they are at default
if ((screen_wid==-1) || (screen_high==-1)) {
screen_wid=render_info.desktop.wid;
screen_high=render_info.desktop.high;
}
// setup rendering sizes
#ifndef D3_ROTATE_VIEW
view.screen.x_sz=screen_wid;
view.screen.y_sz=screen_high;
#else
view.screen.x_sz=screen_high;
view.screen.y_sz=screen_wid;
#endif
view.screen.wide=gl_is_size_widescreen(view.screen.x_sz,view.screen.y_sz);
// normal attributes
SDL_GL_SetAttribute(SDL_GL_RED_SIZE,8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE,8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE,8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE,8);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE,24);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE,8);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER,1);
#ifdef D3_OPENGL_ES
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION,2);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION,0);
#endif
#ifdef D3_OS_IPHONE
SDL_GL_SetAttribute(SDL_GL_RETAINED_BACKING,1);
#endif
// full screen anti-aliasing attributes
switch (fsaa_mode) {
case fsaa_mode_2x:
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS,1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES,2);
break;
case fsaa_mode_4x:
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS,1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES,4);
break;
case fsaa_mode_8x:
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS,1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES,8);
break;
}
// start window or full screen
sdl_flags=SDL_WINDOW_OPENGL|SDL_WINDOW_SHOWN;
if (!gl_in_window_mode()) sdl_flags|=(SDL_WINDOW_FULLSCREEN|SDL_WINDOW_BORDERLESS);
sdl_wind=SDL_CreateWindow("dim3",SDL_WINDOWPOS_CENTERED,SDL_WINDOWPOS_CENTERED,screen_wid,screen_high,sdl_flags);
if (sdl_wind==NULL) {
sprintf(err_str,"SDL: Could not create window (Error: %s)",SDL_GetError());
return(FALSE);
}
sdl_gl_ctx=SDL_GL_CreateContext(sdl_wind);
// use glew on linux and windows
#if defined(D3_OS_LINUX) || defined(D3_OS_WINDOWS)
glew_error=glewInit();
if (glew_error!=GL_NO_ERROR) {
strcpy(err_str,glewGetErrorString(glew_error));
return(FALSE);
}
#endif
// grab openGL attributes
strncpy(render_info.name,(char*)glGetString(GL_RENDERER),64);
render_info.name[63]=0x0;
strncpy(render_info.ext_string,(char*)glGetString(GL_EXTENSIONS),8192);
render_info.ext_string[8191]=0x0;
glGetIntegerv(GL_MAX_TEXTURE_SIZE,&ntxtsize);
render_info.texture_max_size=(int)ntxtsize;
if (!gl_check_initialize(err_str)) return(FALSE);
// stick refresh rate to 60
render_info.monitor_refresh_rate=60;
#ifndef D3_ROTATE_VIEW
gl_set_viewport(0,0,view.screen.x_sz,view.screen.y_sz);
#else
gl_set_viewport(0,0,view.screen.y_sz,view.screen.x_sz);
#endif
gl_setup_context();
#ifndef D3_OPENGL_ES
if (fsaa_mode!=fsaa_mode_none) glEnable(GL_MULTISAMPLE);
#endif
// clear the entire window so it doesn't flash
glClearColor(0.0f,0.0f,0.0f,0.0f);
glClear(GL_COLOR_BUFFER_BIT);
#ifdef D3_OS_IPHONE
glDiscardFramebufferEXT(GL_FRAMEBUFFER,2,discards);
#endif
SDL_GL_SwapWindow(sdl_wind);
// texture utility initialize
gl_texture_initialize();
return(TRUE);
}
static void setup_font(void *data, const char *msg, GLfloat scale, GLfloat pos_x, GLfloat pos_y)
{
gl_t *gl = (gl_t*)data;
if (!gl->font)
return;
gl_shader_use(gl, 0);
gl_set_viewport(gl, gl->win_width, gl->win_height, false, false);
glEnable(GL_BLEND);
GLfloat font_vertex[8];
GLfloat font_vertex_dark[8];
GLfloat font_tex_coords[8];
glBindTexture(GL_TEXTURE_2D, gl->font_tex);
gl->coords.tex_coord = font_tex_coords;
struct font_output_list out;
// If we get the same message, there's obviously no need to render fonts again ...
if (strcmp(gl->font_last_msg, msg) != 0)
{
gl->font_driver->render_msg(gl->font, msg, &out);
struct font_output *head = out.head;
struct font_rect geom;
calculate_msg_geometry(head, &geom);
adjust_power_of_two(gl, &geom);
blit_fonts(gl, head, &geom);
gl->font_driver->free_output(gl->font, &out);
strlcpy(gl->font_last_msg, msg, sizeof(gl->font_last_msg));
gl->font_last_width = geom.width;
gl->font_last_height = geom.height;
}
calculate_font_coords(gl, font_vertex, font_vertex_dark, font_tex_coords,
scale, pos_x, pos_y);
gl->coords.vertex = font_vertex_dark;
gl->coords.color = gl->font_color_dark;
gl_shader_set_coords(gl, &gl->coords, &gl->mvp);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
gl->coords.vertex = font_vertex;
gl->coords.color = gl->font_color;
gl_shader_set_coords(gl, &gl->coords, &gl->mvp);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
// Post - Go back to old rendering path.
gl->coords.vertex = vertexes_flipped;
gl->coords.tex_coord = gl->tex_coords;
gl->coords.color = white_color;
glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
glDisable(GL_BLEND);
struct gl_ortho ortho = {0, 1, 0, 1, -1, 1};
gl_set_projection(gl, &ortho, true);
}
static void gl_frame_fbo(gl_t *gl, const struct gl_tex_info *tex_info)
{
GLfloat fbo_tex_coords[8] = {0.0f};
// Render the rest of our passes.
glTexCoordPointer(2, GL_FLOAT, 0, fbo_tex_coords);
// It's kinda handy ... :)
const struct gl_fbo_rect *prev_rect;
const struct gl_fbo_rect *rect;
struct gl_tex_info *fbo_info;
struct gl_tex_info fbo_tex_info[MAX_SHADERS];
unsigned fbo_tex_info_cnt = 0;
// Calculate viewports, texture coordinates etc, and render all passes from FBOs, to another FBO.
for (int i = 1; i < gl->fbo_pass; i++)
{
prev_rect = &gl->fbo_rect[i - 1];
rect = &gl->fbo_rect[i];
fbo_info = &fbo_tex_info[i - 1];
GLfloat xamt = (GLfloat)prev_rect->img_width / prev_rect->width;
GLfloat yamt = (GLfloat)prev_rect->img_height / prev_rect->height;
set_texture_coords(fbo_tex_coords, xamt, yamt);
fbo_info->tex = gl->fbo_texture[i - 1];
fbo_info->input_size[0] = prev_rect->img_width;
fbo_info->input_size[1] = prev_rect->img_height;
fbo_info->tex_size[0] = prev_rect->width;
fbo_info->tex_size[1] = prev_rect->height;
memcpy(fbo_info->coord, fbo_tex_coords, sizeof(fbo_tex_coords));
pglBindFramebuffer(GL_FRAMEBUFFER, gl->fbo[i]);
gl_shader_use(i + 1);
glBindTexture(GL_TEXTURE_2D, gl->fbo_texture[i - 1]);
glClear(GL_COLOR_BUFFER_BIT);
// Render to FBO with certain size.
gl_set_viewport(gl, rect->img_width, rect->img_height, true, false);
gl_shader_set_params(prev_rect->img_width, prev_rect->img_height,
prev_rect->width, prev_rect->height,
gl->vp_width, gl->vp_height, gl->frame_count,
tex_info, gl->prev_info, fbo_tex_info, fbo_tex_info_cnt);
glDrawArrays(GL_QUADS, 0, 4);
fbo_tex_info_cnt++;
}
// Render our last FBO texture directly to screen.
prev_rect = &gl->fbo_rect[gl->fbo_pass - 1];
GLfloat xamt = (GLfloat)prev_rect->img_width / prev_rect->width;
GLfloat yamt = (GLfloat)prev_rect->img_height / prev_rect->height;
set_texture_coords(fbo_tex_coords, xamt, yamt);
// Render our FBO texture to back buffer.
pglBindFramebuffer(GL_FRAMEBUFFER, 0);
gl_shader_use(gl->fbo_pass + 1);
glBindTexture(GL_TEXTURE_2D, gl->fbo_texture[gl->fbo_pass - 1]);
glClear(GL_COLOR_BUFFER_BIT);
gl->render_to_tex = false;
gl_set_viewport(gl, gl->win_width, gl->win_height, false, true);
gl_shader_set_params(prev_rect->img_width, prev_rect->img_height,
prev_rect->width, prev_rect->height,
gl->vp_width, gl->vp_height, gl->frame_count,
tex_info, gl->prev_info, fbo_tex_info, fbo_tex_info_cnt);
glVertexPointer(2, GL_FLOAT, 0, vertex_ptr);
glDrawArrays(GL_QUADS, 0, 4);
glTexCoordPointer(2, GL_FLOAT, 0, gl->tex_coords);
}
static void xmb_frame(void)
{
int i;
char title_msg[64];
size_t end;
const char *dir = NULL;
const char *label = NULL;
unsigned menu_type = 0;
xmb_handle_t *xmb = (xmb_handle_t*)driver.menu->userdata;
gl_t *gl = (gl_t*)driver_video_resolve(NULL);
if (!xmb || !gl)
return;
if (driver.menu->need_refresh
&& g_extern.is_menu
&& !driver.menu->msg_force)
return;
update_tweens(0.002);
glViewport(0, 0, gl->win_width, gl->win_height);
xmb_render_background();
file_list_get_last(driver.menu->menu_stack, &dir, &label, &menu_type);
get_title(label, dir, menu_type, xmb->title, sizeof(xmb->title));
xmb_draw_text(xmb->title, 30, 40, 1, 1);
const char *core_name = g_extern.menu.info.library_name;
if (!core_name)
core_name = g_extern.system.info.library_name;
if (!core_name)
core_name = "No Core";
const char *core_version = g_extern.menu.info.library_version;
if (!core_version)
core_version = g_extern.system.info.library_version;
if (!core_version)
core_version = "";
snprintf(title_msg, sizeof(title_msg), "%s - %s %s", PACKAGE_VERSION,
core_name, core_version);
xmb_draw_text(title_msg, 30, gl->win_height - 30, 1, 1);
end = file_list_get_size(driver.menu->selection_buf);
for (i = 0; i < end; i++)
{
char value[PATH_MAX], path_buf[PATH_MAX];
const char *path = NULL, *entry_label = NULL;
unsigned type = 0, w = 0;
xmb_node_t *node = NULL;
file_list_get_at_offset(driver.menu->selection_buf, i, &path,
&entry_label, &type);
node = (xmb_node_t*)file_list_get_userdata_at_offset(
driver.menu->selection_buf, i);
disp_set_label(&w, type, i, label,
value, sizeof(value),
entry_label, path,
path_buf, sizeof(path_buf));
xmb_draw_icon(xmb->textures[XMB_TEXTURE_SETTING].id,
xmb->margin_left + xmb->hspacing - xmb->icon_size/2.0,
xmb->margin_top + node->y + xmb->icon_size/2.0,
node->alpha,
0,
node->zoom);
xmb_draw_text(path_buf,
xmb->margin_left + xmb->hspacing + xmb->label_margin_left,
xmb->margin_top + node->y + xmb->label_margin_top,
1,
node->alpha);
xmb_draw_text(value,
xmb->margin_left + xmb->hspacing +
xmb->label_margin_left + xmb->setting_margin_left,
xmb->margin_top + node->y + xmb->label_margin_top,
1,
node->alpha);
}
xmb_draw_icon(xmb->textures[XMB_TEXTURE_SETTINGS].id,
xmb->margin_left + xmb->hspacing - xmb->icon_size / 2.0,
xmb->margin_top + xmb->icon_size / 2.0,
1.0,
0,
1.0);
#ifdef GEKKO
const char *message_queue;
if (driver.menu->msg_force)
{
message_queue = msg_queue_pull(g_extern.msg_queue);
driver.menu->msg_force = false;
}
else
message_queue = driver.current_msg;
xmb_render_messagebox(message_queue);
#endif
if (driver.menu->keyboard.display)
{
char msg[PATH_MAX];
const char *str = *driver.menu->keyboard.buffer;
if (!str)
str = "";
snprintf(msg, sizeof(msg), "%s\n%s",
driver.menu->keyboard.label, str);
xmb_render_messagebox(msg);
}
if (xmb->box_message[0] != '\0')
{
xmb_render_background();
xmb_render_messagebox(xmb->box_message);
xmb->box_message[0] = '\0';
}
gl_set_viewport(gl, gl->win_width, gl->win_height, false, false);
}
static void gl_render_msg(void *data, const char *msg, const struct font_params *params)
{
GLfloat x, y, scale, drop_mod;
GLfloat color[4], color_dark[4];
int drop_x, drop_y;
bool full_screen;
gl_raster_t *font = (gl_raster_t*)data;
if (!font)
return;
gl_t *gl = font->gl;
if (params)
{
x = params->x;
y = params->y;
scale = params->scale;
full_screen = params->full_screen;
drop_x = params->drop_x;
drop_y = params->drop_y;
drop_mod = params->drop_mod;
color[0] = FONT_COLOR_GET_RED(params->color) / 255.0f;
color[1] = FONT_COLOR_GET_GREEN(params->color) / 255.0f;
color[2] = FONT_COLOR_GET_BLUE(params->color) / 255.0f;
color[3] = FONT_COLOR_GET_ALPHA(params->color) / 255.0f;
// If alpha is 0.0f, turn it into default 1.0f
if (color[3] <= 0.0f)
color[3] = 1.0f;
}
else
{
x = g_settings.video.msg_pos_x;
y = g_settings.video.msg_pos_y;
scale = 1.0f;
full_screen = false;
color[0] = g_settings.video.msg_color_r;
color[1] = g_settings.video.msg_color_g;
color[2] = g_settings.video.msg_color_b;
color[3] = 1.0f;
drop_x = -2;
drop_y = -2;
drop_mod = 0.3f;
}
gl_set_viewport(gl, gl->win_width, gl->win_height, full_screen, false);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBlendEquation(GL_FUNC_ADD);
if (drop_x || drop_y)
{
color_dark[0] = color[0] * drop_mod;
color_dark[1] = color[1] * drop_mod;
color_dark[2] = color[2] * drop_mod;
color_dark[3] = color[3];
render_message(font, msg, scale, color_dark,
x + scale * drop_x / gl->vp.width, y + scale * drop_y / gl->vp.height);
}
render_message(font, msg, scale, color, x, y);
glDisable(GL_BLEND);
gl_set_viewport(gl, gl->win_width, gl->win_height, false, true);
}
