static void vg_calculate_quad(vg_t *vg)
{
unsigned width, height;
video_driver_get_size(&width, &height);
/* set viewport for aspect ratio, taken from the OpenGL driver. */
if (vg->keep_aspect)
{
float desired_aspect = video_driver_get_aspect_ratio();
/* If the aspect ratios of screen and desired aspect ratio
* are sufficiently equal (floating point stuff),
* assume they are actually equal. */
if (fabs(vg->mScreenAspect - desired_aspect) < 0.0001)
{
vg->x1 = 0;
vg->y1 = 0;
vg->x2 = width;
vg->y2 = height;
}
else if (vg->mScreenAspect > desired_aspect)
{
float delta = (desired_aspect / vg->mScreenAspect - 1.0) / 2.0 + 0.5;
vg->x1 = width * (0.5 - delta);
vg->y1 = 0;
vg->x2 = 2.0 * width * delta + vg->x1;
vg->y2 = height + vg->y1;
}
else
{
float delta = (vg->mScreenAspect / desired_aspect - 1.0) / 2.0 + 0.5;
vg->x1 = 0;
vg->y1 = height * (0.5 - delta);
vg->x2 = width + vg->x1;
vg->y2 = 2.0 * height * delta + vg->y1;
}
}
else
{
vg->x1 = 0;
vg->y1 = 0;
vg->x2 = width;
vg->y2 = height;
}
vg->scissor[0] = vg->x1;
vg->scissor[1] = vg->y1;
vg->scissor[2] = vg->x2 - vg->x1;
vg->scissor[3] = vg->y2 - vg->y1;
vgSetiv(VG_SCISSOR_RECTS, 4, vg->scissor);
}
static void vg_calculate_quad(vg_t *vg)
{
// set viewport for aspect ratio, taken from the OpenGL driver
if (vg->mKeepAspect)
{
global_t *global = global_get_ptr();
float desired_aspect = global->system.aspect_ratio;
// If the aspect ratios of screen and desired aspect ratio are sufficiently equal (floating point stuff),
// assume they are actually equal.
if (fabs(vg->mScreenAspect - desired_aspect) < 0.0001)
{
vg->x1 = 0;
vg->y1 = 0;
vg->x2 = vg->mScreenWidth;
vg->y2 = vg->mScreenHeight;
}
else if (vg->mScreenAspect > desired_aspect)
{
float delta = (desired_aspect / vg->mScreenAspect - 1.0) / 2.0 + 0.5;
vg->x1 = vg->mScreenWidth * (0.5 - delta);
vg->y1 = 0;
vg->x2 = 2.0 * vg->mScreenWidth * delta + vg->x1;
vg->y2 = vg->mScreenHeight + vg->y1;
}
else
{
float delta = (vg->mScreenAspect / desired_aspect - 1.0) / 2.0 + 0.5;
vg->x1 = 0;
vg->y1 = vg->mScreenHeight * (0.5 - delta);
vg->x2 = vg->mScreenWidth + vg->x1;
vg->y2 = 2.0 * vg->mScreenHeight * delta + vg->y1;
}
}
else
{
vg->x1 = 0;
vg->y1 = 0;
vg->x2 = vg->mScreenWidth;
vg->y2 = vg->mScreenHeight;
}
vg->scissor[0] = vg->x1;
vg->scissor[1] = vg->y1;
vg->scissor[2] = vg->x2 - vg->x1;
vg->scissor[3] = vg->y2 - vg->y1;
vgSetiv(VG_SCISSOR_RECTS, 4, vg->scissor);
}
static void update_display(setting_render_internal_t* renderer)
{
// Render it out
vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
vgLoadIdentity();
vgSetfv(VG_CLEAR_COLOR, 4, renderer->definition.background_colour);
vgClear(renderer->definition.x, renderer->definition.y,
renderer->definition.width, renderer->definition.height);
vgSetiv(VG_SCISSOR_RECTS, 4, &renderer->definition.x);
vgSeti(VG_SCISSORING, VG_TRUE);
vgTranslate(renderer->definition.x, renderer->definition.y);
vgSeti(VG_RENDERING_QUALITY, renderer->definition.text_quality);
vgSetPaint(renderer->state.text_paint, VG_FILL_PATH);
gfx_render_text(renderer->definition.text_x_offset, renderer->definition.text_y_offset, renderer->definition.text, &gfx_font_sans, renderer->definition.text_size);
VGfloat text_width = gfx_text_width(renderer->definition.text, &gfx_font_sans, renderer->definition.text_size);
const size_t buffer_size = 512;
char setting_text_buffer[buffer_size];
setting_t* setting = renderer->definition.setting;
switch(setting->type)
{
case SETTING_TYPE_INT:
{
snprintf(setting_text_buffer, buffer_size - 1, renderer->definition.format, setting_get_value_int(setting));
break;
}
case SETTING_TYPE_FLOAT:
{
snprintf(setting_text_buffer, buffer_size - 1, renderer->definition.format, setting_get_value_float(setting));
break;
}
case SETTING_TYPE_ENUM:
{
snprintf(setting_text_buffer, buffer_size - 1, renderer->definition.format, setting_get_value_enum(setting));
break;
}
default:
snprintf(setting_text_buffer, buffer_size - 1, "ILLEGAL SETTING TYPE: %d", (int)setting->type);
break;
}
setting_text_buffer[buffer_size - 1] = 0;
gfx_render_text(text_width + 2 + renderer->definition.text_x_offset, renderer->definition.text_y_offset,
setting_text_buffer, &gfx_font_sans, renderer->definition.text_size);
vgSeti(VG_SCISSORING, VG_FALSE);
}
static void rpi_calculate_quad(rpi_t *rpi)
{
// set viewport for aspect ratio, taken from the OpenGL driver
if (rpi->mKeepAspect)
{
float desired_aspect = g_settings.video.aspect_ratio;
// If the aspect ratios of screen and desired aspect ratio are sufficiently equal (floating point stuff),
// assume they are actually equal.
if (fabs(rpi->mScreenAspect - desired_aspect) < 0.0001)
{
rpi->x1 = 0;
rpi->y1 = 0;
rpi->x2 = rpi->mScreenWidth;
rpi->y2 = rpi->mScreenHeight;
}
else if (rpi->mScreenAspect > desired_aspect)
{
float delta = (desired_aspect / rpi->mScreenAspect - 1.0) / 2.0 + 0.5;
rpi->x1 = rpi->mScreenWidth * (0.5 - delta);
rpi->y1 = 0;
rpi->x2 = 2.0 * rpi->mScreenWidth * delta + rpi->x1;
rpi->y2 = rpi->mScreenHeight + rpi->y1;
}
else
{
float delta = (rpi->mScreenAspect / desired_aspect - 1.0) / 2.0 + 0.5;
rpi->x1 = 0;
rpi->y1 = rpi->mScreenHeight * (0.5 - delta);
rpi->x2 = rpi->mScreenWidth + rpi->x1;
rpi->y2 = 2.0 * rpi->mScreenHeight * delta + rpi->y1;
}
}
else
{
rpi->x1 = 0;
rpi->y1 = 0;
rpi->x2 = rpi->mScreenWidth;
rpi->y2 = rpi->mScreenHeight;
}
rpi->scissor[0] = rpi->x1;
rpi->scissor[1] = rpi->y1;
rpi->scissor[2] = rpi->x2 - rpi->x1;
rpi->scissor[3] = rpi->y2 - rpi->y1;
vgSetiv(VG_SCISSOR_RECTS, 4, rpi->scissor);
}
/** Render text.
*
* FIXME: Not at all optimal - re-renders each time.
* FIXME: Not UTF-8 aware
* FIXME: better caching
*/
VCOS_STATUS_T gx_priv_render_text( GX_DISPLAY_T *disp,
GRAPHICS_RESOURCE_HANDLE res,
uint32_t x,
uint32_t y,
uint32_t width,
uint32_t height,
uint32_t fg_colour,
uint32_t bg_colour,
const char *text,
uint32_t text_length,
uint32_t text_size )
{
VGfloat vg_colour[4];
VGFT_FONT_T *font;
VGPaint fg;
GX_CLIENT_STATE_T save;
VCOS_STATUS_T status = VCOS_SUCCESS;
int clip = 1;
vcos_demand(inited); // has gx_font_init() been called?
gx_priv_save(&save, res);
if (width == GRAPHICS_RESOURCE_WIDTH &&
height == GRAPHICS_RESOURCE_HEIGHT)
{
clip = 0;
}
width = (width == GRAPHICS_RESOURCE_WIDTH) ? res->width : width;
height = (height == GRAPHICS_RESOURCE_HEIGHT) ? res->height : height;
font = find_font(text, text_size);
if (!font)
{
status = VCOS_ENOMEM;
goto finish;
}
// setup the clipping rectangle
if (clip)
{
VGint coords[] = {x,y,width,height};
vgSeti(VG_SCISSORING, VG_TRUE);
vgSetiv(VG_SCISSOR_RECTS, 4, coords);
}
// setup the background colour if needed
if (bg_colour != GRAPHICS_TRANSPARENT_COLOUR)
{
int err;
VGfloat rendered_w, rendered_h;
VGfloat vg_bg_colour[4];
// setup the background colour...
gx_priv_colour_to_paint(bg_colour, vg_bg_colour);
vgSetfv(VG_CLEAR_COLOR, 4, vg_bg_colour);
// fill in a rectangle...
vgft_get_text_extents(font, text, text_length, (VGfloat)x, (VGfloat)y, &rendered_w, &rendered_h);
if ( ( 0 < (VGint)rendered_w ) && ( 0 < (VGint)rendered_h ) )
{
vgClear(x, y, (VGint)rendered_w, (VGint)rendered_h);
err = vgGetError();
if (err)
{
GX_LOG("Error %d clearing bg text %d %d %g %g",
err, x, y, rendered_w, rendered_h);
vcos_assert(0);
} // if
} // if
} // if
// setup the foreground colour
fg = vgCreatePaint();
if (!fg)
{
status = VCOS_ENOMEM;
goto finish;
}
// draw the foreground text
vgSetParameteri(fg, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
gx_priv_colour_to_paint(fg_colour, vg_colour);
vgSetParameterfv(fg, VG_PAINT_COLOR, 4, vg_colour);
vgSetPaint(fg, VG_FILL_PATH);
vgft_font_draw(font, (VGfloat)x, (VGfloat)y, text, text_length, VG_FILL_PATH);
vgDestroyPaint(fg);
vcos_assert(vgGetError() == 0);
vgSeti(VG_SCISSORING, VG_FALSE);
finish:
gx_priv_restore(&save);
return status;
}
// ClipRect limits the drawing area to specified rectangle
void ClipRect(VGint x, VGint y, VGint w, VGint h) {
vgSeti(VG_SCISSORING, VG_TRUE);
VGint coords[4] = { x, y, w, h };
vgSetiv(VG_SCISSOR_RECTS, 4, coords);
}
