/****************************************************************************
** InitView() is called by PVRShell each time a rendering variable is changed
** in the Shell menu (Z-Buffer On/Off, resolution change, buffering mode...)
** In this function one should initialise all variables that are dependant on
** general rendering variables (screen mode, 3D device, etc...)
****************************************************************************/
bool OVGFont::InitView()
{
CPVRTPVGObject* pPVGObj;
VGImage vgImage;
VGImage vgChild;
float fW,fH;
PVRTVECTOR2 fGlyphOrigin, fEscapement;
// Store the screen width and height
m_ui32ScreenWidth = PVRShellGet(prefWidth);
m_ui32ScreenHeight = PVRShellGet(prefHeight);
// Set the clear colour
VGfloat afClearColour[] = { 0.6f, 0.8f, 1.0f, 1.0f };
vgSetfv(VG_CLEAR_COLOR, 4, afClearColour);
// Initialise PrintVG for the logo and the title
m_PrintVG.Initialize(m_ui32ScreenWidth, m_ui32ScreenHeight);
// Load the font path data from the pvg file
pPVGObj = CPVRTPVGObject::FromFile(c_szPVGFile);
if(pPVGObj == NULL)
{
PVRShellSet(prefExitMessage, "Error: Failed to load Font.pvg.");
return false;
}
if(pPVGObj->m_i32NumPaths != g_i32ImageCharNo)
{
PVRShellSet(prefExitMessage, "Error: Font.pvg doesn't contain the expected amount of characters.");
delete pPVGObj;
return false;
}
// Load the image based font data
if(PVRTImageLoadFromPVR(c_szPVRFile, &vgImage) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "Error: Failed to open mask.pvr.");
return false;
}
/*
Create two fonts. m_vgPathFont will purely contain glyphs represented by paths
and m_vgImageFont by images. It is also reasonable to have a font that contains
a mixture but we are keeping them seperate so they can be compared.
*/
m_vgImageFont = vgCreateFont(g_i32ImageCharNo);
m_vgPathFont = vgCreateFont(pPVGObj->m_i32NumPaths);
// Add the glyphs to the fonts.
for(int i = 0; i < g_i32ImageCharNo; ++i)
{
// Load glyph from path data
/*
Each path in the PVG file represents a glyph. First we need to acquire the origin
of the glyph so we use vgPathBounds to achieve this as the origin described in
g_CharDesc is for the image.
*/
vgPathBounds(pPVGObj->m_pPaths[i].m_path, &fGlyphOrigin.x, &fGlyphOrigin.y, &fW, &fH);
// We offset the origin so glyphs like a 'y' are lower
fGlyphOrigin.x += g_CharDesc[i].fOriginOffset.x;
fGlyphOrigin.y += g_CharDesc[i].fOriginOffset.y;
/*
Add the glyph and assign it a unique ID. The characters we're loading have ASCII codes ranging from
33 to 128 hence we're giving the glyphs IDs starting at 33. The glyph origin defines the coordinates
in path space at which to start drawing the glyph and the escapement character is the offset to start
drawing the next following character.
*/
vgSetGlyphToPath(m_vgPathFont, 33 + i, pPVGObj->m_pPaths[i].m_path, VG_TRUE, (VGfloat*) &fGlyphOrigin.x, (VGfloat*) &g_CharDesc[i].fEscapement.x);
// Load glyph from image data
/*
Using a child image we 'cut' the glyph out of the main image (see the child image training course for
an explanation).
*/
vgChild = vgChildImage(vgImage, g_CharDesc[i].i32Origin[0], g_CharDesc[i].i32Origin[1], g_CharDesc[i].i32Width, g_CharDesc[i].i32Height);
/*
We then add the child image to the font. We use the origin offset value directly for the value as the glyph's
origin is 0,0 within the child image.
*/
vgSetGlyphToImage(m_vgImageFont, 33 + i, vgChild, (VGfloat*) &g_CharDesc[i].fOriginOffset.x, (VGfloat*) &g_CharDesc[i].fEscapement.x);
// Destroy the child image as we no longer need it.
vgDestroyImage(vgChild);
}
// Destroy the image as it is no longer required
vgDestroyImage(vgImage);
// Destroy the PVG data as it too is no longer required
delete pPVGObj;
pPVGObj = 0;
// Space
/*
Glyphs such as spaces that do not have a visual representation can be added to
the fonts by passing VG_INVALID_HANDLE instead of a path or image handle.
*/
// Set the glyph origin and escapement for the space...
fGlyphOrigin.x = 0.0f;
fGlyphOrigin.y = 0.0f;
// ... We're giving the space a width of 10.0f
fEscapement.x = 10.0f;
fEscapement.y = 0.0f;
vgSetGlyphToImage(m_vgImageFont, 32, VG_INVALID_HANDLE, (VGfloat*) &fGlyphOrigin.x, (VGfloat*) &fEscapement.x);
vgSetGlyphToPath(m_vgPathFont, 32, VG_INVALID_HANDLE, VG_TRUE, (VGfloat*) &fGlyphOrigin.x, (VGfloat*) &fEscapement.x);
// Create font paint
m_vgFontPaint = vgCreatePaint();
vgSetParameteri(m_vgFontPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
vgSetColor(m_vgFontPaint, PVRTRGBA(255,0,0,255));
return true;
}
struct VG_DATA* vg_data_new ( void )
{
struct VG_DATA* vg_data = malloc( sizeof( struct VG_DATA ) );
vg_data->font = vgCreateFont( 256 );
memset( vg_data->cmap, 0, sizeof vg_data->cmap );
return vg_data;
}
void SubtitleRenderer::initialize_vg() {
// get an EGL display connection
display_ = eglGetDisplay(EGL_DEFAULT_DISPLAY);
ENFORCE(display_);
// initialize the EGL display connection
ENFORCE(eglInitialize(display_, NULL, NULL));
// get an appropriate EGL frame buffer configuration
static const EGLint attribute_list[] = {
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_NONE
};
EGLConfig config{};
EGLint num_config{};
ENFORCE(eglChooseConfig(display_, attribute_list, &config, 1, &num_config));
ENFORCE(num_config);
ENFORCE(eglBindAPI(EGL_OPENVG_API));
static EGL_DISPMANX_WINDOW_T nativewindow;
nativewindow.element = dispman_element_;
nativewindow.width = buffer_width_;
nativewindow.height = buffer_height_;
surface_ = eglCreateWindowSurface(display_, config, &nativewindow, NULL);
ENFORCE(surface_);
// create an EGL rendering context
context_ = eglCreateContext(display_, config, EGL_NO_CONTEXT, NULL);
ENFORCE(context_);
auto result = eglMakeCurrent(display_, surface_, surface_, context_);
assert(result);
vgSeti(VG_FILTER_FORMAT_LINEAR, VG_TRUE);
assert(!vgGetError());
vgSeti(VG_IMAGE_QUALITY, VG_IMAGE_QUALITY_NONANTIALIASED);
assert(!vgGetError());
auto create_vg_font = [](VGFont& font) {
font = vgCreateFont(64);
ENFORCE(font);
};
create_vg_font(vg_font_);
create_vg_font(vg_font_border_);
// VGfloat color[4] = { 1.0f, 0.0f, 0.0f, 1.0f };
// vgSetfv(VG_CLEAR_COLOR, 4, color);
}
VCOS_STATUS_T vgft_font_init(VGFT_FONT_T *font)
{
font->ft_face = NULL;
font->vg_font = vgCreateFont(0);
if (font->vg_font == VG_INVALID_HANDLE)
{
return VCOS_ENOMEM;
}
return VCOS_SUCCESS;
}
void SubtitleRenderer::
initialize_fonts(const std::string& font_path, float font_size) {
ENFORCE(!FT_Init_FreeType(&ft_library_));
ENFORCE2(!FT_New_Face(ft_library_, font_path.c_str(), 0, &ft_face_),
"Unable to open font");
ENFORCE(!FT_Set_Pixel_Sizes(ft_face_, 0, font_size*screen_height_));
auto get_bbox = [this](char32_t cp) {
auto glyph_index = FT_Get_Char_Index(ft_face_, cp);
ENFORCE(!FT_Load_Glyph(ft_face_, glyph_index, FT_LOAD_NO_HINTING));
FT_Glyph glyph;
ENFORCE(!FT_Get_Glyph(ft_face_->glyph, &glyph));
SCOPE_EXIT {FT_Done_Glyph(glyph);};
FT_BBox bbox;
FT_Glyph_Get_CBox(glyph, FT_GLYPH_BBOX_PIXELS, &bbox);
return bbox;
};
constexpr float padding_factor = 0.05f;
int y_min = get_bbox('g').yMin;
int y_max = get_bbox('M').yMax;
y_max += -y_min*0.7f;
line_height_ = y_max - y_min;
const int v_padding = line_height_*padding_factor + 0.5f;
line_height_ += v_padding*2;
box_offset_ = y_min-v_padding;
box_h_padding_ = line_height_/5.0f + 0.5f;
constexpr float border_thickness = 0.045f;
ENFORCE(!FT_Stroker_New(ft_library_, &ft_stroker_));
FT_Stroker_Set(ft_stroker_,
line_height_*border_thickness*64.0f,
FT_STROKER_LINECAP_ROUND,
FT_STROKER_LINEJOIN_ROUND,
0);
vgSeti(VG_FILTER_FORMAT_LINEAR, VG_TRUE);
assert(!vgGetError());
vgSeti(VG_IMAGE_QUALITY, VG_IMAGE_QUALITY_NONANTIALIASED);
assert(!vgGetError());
auto create_vg_font = [](VGFont& font) {
font = vgCreateFont(128);
ENFORCE(font);
};
create_vg_font(vg_font_);
create_vg_font(vg_font_border_);
}
GLDEF_C TInt E32Main()
{
RDebug::Printf("testing VG 1.0 function");
VGPath path0 = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 0, 0, VG_PATH_CAPABILITY_ALL);
RDebug::Printf("finished testing VG 1.0 function");
#ifdef OPENVG_VERSION_1_1
if(strcmp((const char*)vgGetString(VG_VERSION), "1.1")==0)
{
RDebug::Printf("testing function introduced in 1.1");
VGFont font = vgCreateFont(245);
vgDrawGlyph(font, 2, 256, VG_FALSE);
RDebug::Printf("finished testing function introduced in 1.1");
}
#endif
return 0;
}
static void *rpi_init(const video_info_t *video, const input_driver_t **input, void **input_data)
{
int32_t success;
EGLBoolean result;
EGLint num_config;
rpi_t *rpi = (rpi_t*)calloc(1, sizeof(rpi_t));
*input = NULL;
static EGL_DISPMANX_WINDOW_T nativewindow;
DISPMANX_ELEMENT_HANDLE_T dispman_element;
DISPMANX_DISPLAY_HANDLE_T dispman_display;
DISPMANX_UPDATE_HANDLE_T dispman_update;
DISPMANX_MODEINFO_T dispman_modeinfo;
VC_RECT_T dst_rect;
VC_RECT_T src_rect;
static const EGLint attribute_list[] =
{
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_NONE
};
EGLConfig config;
bcm_host_init();
// get an EGL display connection
rpi->mDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
rarch_assert(rpi->mDisplay != EGL_NO_DISPLAY);
// initialize the EGL display connection
result = eglInitialize(rpi->mDisplay, NULL, NULL);
rarch_assert(result != EGL_FALSE);
eglBindAPI(EGL_OPENVG_API);
// get an appropriate EGL frame buffer configuration
result = eglChooseConfig(rpi->mDisplay, attribute_list, &config, 1, &num_config);
rarch_assert(result != EGL_FALSE);
// create an EGL rendering context
rpi->mContext = eglCreateContext(rpi->mDisplay, config, EGL_NO_CONTEXT, NULL);
rarch_assert(rpi->mContext != EGL_NO_CONTEXT);
// create an EGL window surface
success = graphics_get_display_size(0 /* LCD */, &rpi->mScreenWidth, &rpi->mScreenHeight);
rarch_assert(success >= 0);
dst_rect.x = 0;
dst_rect.y = 0;
dst_rect.width = rpi->mScreenWidth;
dst_rect.height = rpi->mScreenHeight;
src_rect.x = 0;
src_rect.y = 0;
src_rect.width = rpi->mScreenWidth << 16;
src_rect.height = rpi->mScreenHeight << 16;
dispman_display = vc_dispmanx_display_open(0 /* LCD */);
vc_dispmanx_display_get_info(dispman_display, &dispman_modeinfo);
dispman_update = vc_dispmanx_update_start(0);
dispman_element = vc_dispmanx_element_add(dispman_update, dispman_display,
0 /*layer*/, &dst_rect, 0 /*src*/,
&src_rect, DISPMANX_PROTECTION_NONE, 0 /*alpha*/, 0 /*clamp*/, DISPMANX_NO_ROTATE);
nativewindow.element = dispman_element;
nativewindow.width = rpi->mScreenWidth;
nativewindow.height = rpi->mScreenHeight;
vc_dispmanx_update_submit_sync(dispman_update);
rpi->mSurface = eglCreateWindowSurface(rpi->mDisplay, config, &nativewindow, NULL);
rarch_assert(rpi->mSurface != EGL_NO_SURFACE);
// connect the context to the surface
result = eglMakeCurrent(rpi->mDisplay, rpi->mSurface, rpi->mSurface, rpi->mContext);
rarch_assert(result != EGL_FALSE);
rpi->mTexType = video->rgb32 ? VG_sABGR_8888 : VG_sARGB_1555;
rpi->mKeepAspect = video->force_aspect;
// check for SD televisions: they should always be 4:3
if (dispman_modeinfo.width == 720 && (dispman_modeinfo.height == 480 || dispman_modeinfo.height == 576))
rpi->mScreenAspect = 4.0f / 3.0f;
else
rpi->mScreenAspect = (float)dispman_modeinfo.width / dispman_modeinfo.height;
VGfloat clearColor[4] = {0, 0, 0, 1};
vgSetfv(VG_CLEAR_COLOR, 4, clearColor);
rpi->mTextureWidth = rpi->mTextureHeight = video->input_scale * RARCH_SCALE_BASE;
// We can't use the native format because there's no sXRGB_1555 type and
// emulation cores can send 0 in the top bit. We lose some speed on
// conversion but I doubt it has any real affect, since we are only drawing
// one image at the end of the day. Still keep the alpha channel for ABGR.
rpi->mImage = vgCreateImage(video->rgb32 ? VG_sABGR_8888 : VG_sXBGR_8888,
rpi->mTextureWidth, rpi->mTextureHeight,
video->smooth ? VG_IMAGE_QUALITY_BETTER : VG_IMAGE_QUALITY_NONANTIALIASED);
rpi_set_nonblock_state(rpi, !video->vsync);
linuxraw_input_t *linuxraw_input = (linuxraw_input_t*)input_linuxraw.init();
if (linuxraw_input)
{
*input = (const input_driver_t *)&input_linuxraw;
*input_data = linuxraw_input;
}
#ifdef HAVE_FREETYPE
if (g_settings.video.font_enable)
{
rpi->mFont = vgCreateFont(0);
rpi->mFontHeight = g_settings.video.font_size * (g_settings.video.font_scale ? (float) rpi->mScreenWidth / 1280.0f : 1.0f);
const char *path = g_settings.video.font_path;
if (!*path || !path_file_exists(path))
path = font_renderer_get_default_font();
rpi->mFontRenderer = font_renderer_new(path, rpi->mFontHeight);
if (rpi->mFont != VG_INVALID_HANDLE && rpi->mFontRenderer)
{
rpi->mFontsOn = true;
rpi->mPaintFg = vgCreatePaint();
rpi->mPaintBg = vgCreatePaint();
VGfloat paintFg[] = { g_settings.video.msg_color_r, g_settings.video.msg_color_g, g_settings.video.msg_color_b, 1.0f };
VGfloat paintBg[] = { g_settings.video.msg_color_r / 2.0f, g_settings.video.msg_color_g / 2.0f, g_settings.video.msg_color_b / 2.0f, 0.5f };
vgSetParameteri(rpi->mPaintFg, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
vgSetParameterfv(rpi->mPaintFg, VG_PAINT_COLOR, 4, paintFg);
vgSetParameteri(rpi->mPaintBg, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
vgSetParameterfv(rpi->mPaintBg, VG_PAINT_COLOR, 4, paintBg);
}
}
#endif
struct sigaction sa;
sa.sa_handler = rpi_kill;
sa.sa_flags = SA_RESTART;
sigemptyset(&sa.sa_mask);
sigaction(SIGINT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
return rpi;
}
static void *vg_init(const video_info_t *video, const input_driver_t **input, void **input_data)
{
vg_t *vg = (vg_t*)calloc(1, sizeof(vg_t));
if (!vg)
return NULL;
vg->driver = gfx_ctx_init_first(GFX_CTX_OPENVG_API, 0, 0);
if (!vg->driver)
{
free(vg);
return NULL;
}
vg->driver->get_video_size(&vg->mScreenWidth, &vg->mScreenHeight);
RARCH_LOG("Detecting screen resolution %ux%u.\n", vg->mScreenWidth, vg->mScreenHeight);
vg->driver->swap_interval(video->vsync ? 1 : 0);
vg->driver->update_window_title();
vg->mTexType = video->rgb32 ? VG_sXRGB_8888 : VG_sRGB_565;
vg->mKeepAspect = video->force_aspect;
unsigned win_width = video->width;
unsigned win_height = video->height;
if (video->fullscreen && (win_width == 0) && (win_height == 0))
{
win_width = vg->mScreenWidth;
win_height = vg->mScreenHeight;
}
if (!vg->driver->set_video_mode(win_width, win_height, video->fullscreen))
{
free(vg);
return NULL;
}
vg->driver->get_video_size(&vg->mScreenWidth, &vg->mScreenHeight);
RARCH_LOG("Verified window resolution %ux%u.\n", vg->mScreenWidth, vg->mScreenHeight);
vg->should_resize = true;
if (vg->driver->translate_aspect)
vg->mScreenAspect = vg->driver->translate_aspect(vg->mScreenWidth, vg->mScreenHeight);
else
vg->mScreenAspect = (float)vg->mScreenWidth / vg->mScreenHeight;
VGfloat clearColor[4] = {0, 0, 0, 1};
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);
vg->driver->input_driver(input, input_data);
if (g_settings.video.font_enable && font_renderer_create_default(&vg->font_driver, &vg->mFontRenderer))
{
vg->mFont = vgCreateFont(0);
if (vg->mFont != VG_INVALID_HANDLE)
{
vg->mFontsOn = true;
vg->mFontHeight = g_settings.video.font_size * (g_settings.video.font_scale ? (float) vg->mScreenWidth / 1280.0f : 1.0f);
vg->mPaintFg = vgCreatePaint();
vg->mPaintBg = vgCreatePaint();
VGfloat paintFg[] = { g_settings.video.msg_color_r, g_settings.video.msg_color_g, g_settings.video.msg_color_b, 1.0f };
VGfloat paintBg[] = { g_settings.video.msg_color_r / 2.0f, g_settings.video.msg_color_g / 2.0f, g_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") && vg->driver->init_egl_image_buffer(video))
{
pvgCreateEGLImageTargetKHR = (PFNVGCREATEEGLIMAGETARGETKHRPROC)vg->driver->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;
}
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;
}
int createFont(FT_Face fontFace, FT_UInt size)
{
initFreeTypeLibrary();
VGfloat glyphOrigin[2];
VGfloat escapement[2];
FT_Stroker fontStroker;
int error = FT_Stroker_New(freeTypeLibrary, &fontStroker);
if (error) {
logInfo(LOG_FREETYPE, "Error FT_Stroker_New.(error=%d)\n", error);
return -1;
}
FT_Stroker_Set(fontStroker,
2*64.0f, // Need to get the right value based on size.
FT_STROKER_LINECAP_ROUND,
FT_STROKER_LINEJOIN_ROUND,
0);
VGFont tmpFont;
struct fontListItem *tmpFontListItem = fontExists(fontFace, size);
if (tmpFontListItem == NULL) {
tmpFont = vgCreateFont(fontFace->num_glyphs);
if (tmpFont == VG_INVALID_HANDLE) {
logInfo(LOG_FREETYPE, "Error could not create vgCreateFont.\n");
return -1;
}
tmpFontListItem = malloc(sizeof(struct fontListItem));
tmpFontListItem->fontFace = fontFace;
tmpFontListItem->size = size;
tmpFontListItem->font = tmpFont;
addToFontList(tmpFontListItem);
}
else {
return 0;
}
error = FT_Set_Char_Size( fontFace, /* handle to face object */
0, /* char_width in 1/64th of points */
size*64, /* char_height in 1/64th of points */
72, /* horizontal device resolution */
72 ); /* vertical device resolution */
if (error) {
logInfo(LOG_FREETYPE, "Error FT_Set_Char_Size.(error=%d)\n", error);
return -1;
}
int index;
int counter = 0;
FT_UInt charIndex;
VGImage image = VG_INVALID_HANDLE;
VGImage softenedImage;
VGfloat blustStdDev;
int padding;
int image_width;
int image_height;
VGErrorCode vg_error;
FT_Glyph glyph;
logInfo(LOG_FREETYPE, "This font contains %ld glyphs.\n", fontFace->num_glyphs);
for (index = 32; (index < 256) && (counter < fontFace->num_glyphs); index++) {
counter++;
charIndex = FT_Get_Char_Index(fontFace, index);
logInfo(LOG_FREETYPE, "index=0x%x, charIndex=0x%x\n", index, charIndex);
escapement[0] = 0;
escapement[1] = 0;
if (charIndex == 0) {
vgSetGlyphToImage(tmpFont, index, VG_INVALID_HANDLE, escapement, escapement);
logInfo(LOG_FREETYPE, "charindex== 0\n");
continue;
}
error = FT_Load_Glyph(fontFace, charIndex, FT_LOAD_NO_HINTING);
if (error) {
vgSetGlyphToImage(tmpFont, index, VG_INVALID_HANDLE, escapement, escapement);
logInfo(LOG_FREETYPE, "Error FT_Load_Glyph (error:%d)\n", error);
continue;
}
error = FT_Get_Glyph(fontFace->glyph, &glyph);
if (error) {
vgSetGlyphToImage(tmpFont, index, VG_INVALID_HANDLE, escapement, escapement);
logInfo(LOG_FREETYPE, "Error FT_Get_Glyph (error:%d)\n", error);
continue;
}
/*
error = FT_Glyph_StrokeBorder(&glyph, fontStroker, 0, 1);
if (error) {
FT_Done_Glyph(glyph);
vgSetGlyphToImage(tmpFont, index, VG_INVALID_HANDLE, escapement, escapement);
logInfo(LOG_FREETYPE, "Error FT_Glyph_StrokeBorder (error:%d)\n", error);
continue;
}
*/
error = FT_Glyph_To_Bitmap(&glyph, FT_RENDER_MODE_NORMAL, NULL, 1);
if (error) {
FT_Done_Glyph(glyph);
vgSetGlyphToImage(tmpFont, index, VG_INVALID_HANDLE, escapement, escapement);
logInfo(LOG_FREETYPE, "Error FT_Glyph_To_Bitmap (error:%d)\n", error);
continue;
}
FT_BitmapGlyph bitGlyph = (FT_BitmapGlyph)glyph;
FT_Bitmap bitmap = bitGlyph->bitmap;
if (bitmap.width > 0 && bitmap.rows > 0) {
blustStdDev = 0.6;
padding = (3*blustStdDev + 0.5);
image_width = bitmap.width + padding*2;
image_height = bitmap.rows + padding*2;
image = vgCreateImage(VG_A_8, image_width, image_height, VG_IMAGE_QUALITY_NONANTIALIASED);
if (image == VG_INVALID_HANDLE) {
FT_Done_Glyph(glyph);
vgSetGlyphToImage(tmpFont, index, VG_INVALID_HANDLE, escapement, escapement);
logInfo(LOG_FREETYPE, "vgCreateImage (error:%d)\n", vgGetError());
continue;
}
if (bitmap.pitch > 0) {
vgImageSubData(image,
bitmap.buffer + bitmap.pitch*(bitmap.rows-1),
-bitmap.pitch,
VG_A_8,
padding,
padding,
bitmap.width,
bitmap.rows);
} else {
vgImageSubData(image,
bitmap.buffer,
bitmap.pitch,
VG_A_8,
padding,
padding,
bitmap.width,
bitmap.rows);
}
vg_error = vgGetError();
if (vg_error) {
vgDestroyImage(image);
FT_Done_Glyph(glyph);
vgSetGlyphToImage(tmpFont, index, VG_INVALID_HANDLE, escapement, escapement);
showVGErrorStr(vg_error, "vgImageSubData");
continue;
}
softenedImage = vgCreateImage(VG_A_8,
image_width,
image_height,
VG_IMAGE_QUALITY_NONANTIALIASED);
if (softenedImage == VG_INVALID_HANDLE) {
vgDestroyImage(image);
FT_Done_Glyph(glyph);
vgSetGlyphToImage(tmpFont, index, VG_INVALID_HANDLE, escapement, escapement);
logInfo(LOG_FREETYPE, "vgCreateImage (error:%d)\n", vgGetError());
continue;
}
// Even out hard and soft edges
vgGaussianBlur(softenedImage, image, blustStdDev, blustStdDev, VG_TILE_FILL);
vg_error = vgGetError();
if (vg_error) {
vgDestroyImage(softenedImage);
vgDestroyImage(image);
FT_Done_Glyph(glyph);
vgSetGlyphToImage(tmpFont, index, VG_INVALID_HANDLE, escapement, escapement);
showVGErrorStr(vg_error, "vgGaussianBlur");
continue;
}
vgDestroyImage(image);
image = softenedImage;
glyphOrigin[0] = (VGfloat)(padding - bitGlyph->left);
glyphOrigin[1] = (VGfloat)(padding + bitmap.rows - bitGlyph->top - 1);
}
else {
logInfo(LOG_FREETYPE, "Error bitmap.width = %d, bitmap.rows = %d\n", bitmap.width, bitmap.rows);
}
escapement[0] = (VGfloat)((fontFace->glyph->advance.x + 32) / 64);
escapement[1] = 0;
vgSetGlyphToImage(tmpFont, index, image, glyphOrigin, escapement);
vg_error = vgGetError();
if (vg_error) {
vgDestroyImage(softenedImage);
vgDestroyImage(image);
FT_Done_Glyph(glyph);
vgSetGlyphToImage(tmpFont, index, VG_INVALID_HANDLE, escapement, escapement);
showVGErrorStr(vg_error, "vgSetGlyphToImage");
continue;
}
logInfo(LOG_FREETYPE, "Create glyph %d.\n", index);
FT_Done_Glyph(glyph);
if (image != VG_INVALID_HANDLE) {
vgDestroyImage(image);
}
}
return 0;
}