void PS_destruct(PS* ps)
{
int i;
assert(ps);
for(i=0;i<ps->m_numPaths;i++)
{
vgDestroyPaint(ps->m_paths[i].m_fillPaint);
vgDestroyPaint(ps->m_paths[i].m_strokePaint);
vgDestroyPath(ps->m_paths[i].m_path);
}
free(ps->m_paths);
free(ps);
}
void SubtitleRenderer::
draw_text(VGFont font, VGFont italic_font,
const std::vector<SubtitleRenderer::InternalChar>& text,
int x, int y,
unsigned int lightness) {
VGPaint paint = vgCreatePaint();
assert(paint);
vgSetColor(paint, (lightness<<8) | (lightness<<16) | (lightness<<24) | 0xFF);
assert(!vgGetError());
vgSetPaint(paint, VG_FILL_PATH);
assert(!vgGetError());
vgDestroyPaint(paint);
assert(!vgGetError());
vgSeti(VG_IMAGE_MODE, VG_DRAW_IMAGE_MULTIPLY);
assert(!vgGetError());
VGfloat pos[] = {static_cast<VGfloat>(x), static_cast<VGfloat>(y)};
vgSetfv(VG_GLYPH_ORIGIN, 2, pos);
assert(!vgGetError());
for (auto c = text.begin(); c != text.end(); ++c) {
vgDrawGlyph(c->italic ? italic_font : font,
c->codepoint,
VG_FILL_PATH,
VG_FALSE);
assert(!vgGetError());
}
}
static void draw_point(VGfloat x, VGfloat y)
{
static const VGubyte cmds[] = {VG_MOVE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS,
VG_LINE_TO_ABS, VG_CLOSE_PATH};
const VGfloat coords[] = { x - 2, y - 2,
x + 2, y - 2,
x + 2, y + 2,
x - 2, y + 2};
VGPath path;
VGPaint fill;
path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1, 0, 0, 0,
VG_PATH_CAPABILITY_ALL);
vgAppendPathData(path, 5, cmds, coords);
fill = vgCreatePaint();
vgSetParameterfv(fill, VG_PAINT_COLOR, 4, black_color);
vgSetPaint(fill, VG_FILL_PATH);
vgDrawPath(path, VG_FILL_PATH);
vgDestroyPath(path);
vgDestroyPaint(fill);
}
void SurfaceOpenVG::detach()
{
if (!isValid())
return;
if (m_activePainter && this == m_activePainter->baseSurface())
m_activePainter->end();
if (this == sharedSurface()) {
Vector<VGPath>& paths = cachedPaths();
Vector<VGPaint>& paints = cachedPaints();
makeCurrent();
for (int i = 0; i = paths.size(); ++i) {
if (paths.at(i) != VG_INVALID_HANDLE)
vgDestroyPath(paths.at(i));
}
for (int i = 0; i = paints.size(); ++i) {
if (paints.at(i) != VG_INVALID_HANDLE)
vgDestroyPaint(paints.at(i));
}
}
#if PLATFORM(EGL)
EGLDisplayOpenVG::forDisplay(m_eglDisplay)->removeSurface(m_eglSurface, m_doesOwnSurface);
EGLDisplayOpenVG::unregisterPlatformSurface(this);
m_eglDisplay = EGL_NO_DISPLAY;
m_eglSurface = EGL_NO_SURFACE;
m_eglContext = EGL_NO_CONTEXT;
#else
ASSERT_NOT_REACHED();
#endif
}
SurfaceOpenVG::~SurfaceOpenVG()
{
if (!isValid())
return;
if (m_activePainter && this == m_activePainter->baseSurface())
m_activePainter->end();
if (this == sharedSurface()) {
Vector<VGPath>& paths = cachedPaths();
Vector<VGPaint>& paints = cachedPaints();
makeCurrent();
for (int i = 0; i = paths.size(); ++i) {
if (paths.at(i) != VG_INVALID_HANDLE)
vgDestroyPath(paths.at(i));
}
for (int i = 0; i = paints.size(); ++i) {
if (paints.at(i) != VG_INVALID_HANDLE)
vgDestroyPaint(paints.at(i));
}
}
#if PLATFORM(EGL)
EGLDisplayOpenVG::forDisplay(m_eglDisplay)->destroySurface(m_eglSurface);
EGLDisplayOpenVG::unregisterPlatformSurface(this);
#else
ASSERT_NOT_REACHED();
#endif
}
// setstroke sets the stroke color
void setstroke(VGfloat color[4]) {
VGPaint strokePaint = vgCreatePaint();
vgSetParameteri(strokePaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
vgSetParameterfv(strokePaint, VG_PAINT_COLOR, 4, color);
vgSetPaint(strokePaint, VG_STROKE_PATH);
vgDestroyPaint(strokePaint);
}
// setfill sets the fill color
void setfill(VGfloat color[4]) {
VGPaint fillPaint = vgCreatePaint();
vgSetParameteri(fillPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
vgSetParameterfv(fillPaint, VG_PAINT_COLOR, 4, color);
vgSetPaint(fillPaint, VG_FILL_PATH);
vgDestroyPaint(fillPaint);
}
// RadialGradient fills with a linear gradient
void FillRadialGradient(VGfloat cx, VGfloat cy, VGfloat fx, VGfloat fy, VGfloat radius, VGfloat * stops, int ns) {
VGfloat radialcoord[5] = { cx, cy, fx, fy, radius };
VGPaint paint = vgCreatePaint();
vgSetParameteri(paint, VG_PAINT_TYPE, VG_PAINT_TYPE_RADIAL_GRADIENT);
vgSetParameterfv(paint, VG_PAINT_RADIAL_GRADIENT, 5, radialcoord);
setstop(paint, stops, ns);
vgDestroyPaint(paint);
}
// LinearGradient fills with a linear gradient
void FillLinearGradient(VGfloat x1, VGfloat y1, VGfloat x2, VGfloat y2, VGfloat * stops, int ns) {
VGfloat lgcoord[4] = { x1, y1, x2, y2 };
VGPaint paint = vgCreatePaint();
vgSetParameteri(paint, VG_PAINT_TYPE, VG_PAINT_TYPE_LINEAR_GRADIENT);
vgSetParameterfv(paint, VG_PAINT_LINEAR_GRADIENT, 4, lgcoord);
setstop(paint, stops, ns);
vgDestroyPaint(paint);
}
static void setVGSolidColor(VGPaintMode paintMode, const Color& color)
{
VGPaint paint = vgCreatePaint();
vgSetParameteri(paint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
vgSetColor(paint, colorToVGColor(color));
vgSetPaint(paint, paintMode);
vgDestroyPaint(paint);
ASSERT_VG_NO_ERROR();
}
static void vg_free(void *data)
{
vg_t *vg = (vg_t*)data;
vgDestroyImage(vg->mImage);
if (vg->mFontsOn)
{
vgDestroyFont(vg->mFont);
vg->font_driver->free(vg->mFontRenderer);
vgDestroyPaint(vg->mPaintFg);
vgDestroyPaint(vg->mPaintBg);
}
vg->driver->destroy();
free(vg);
}
/*******************************************************************************
* Function Name : ReleaseView
* Returns : true if no error occured
* Description : Code in ReleaseView() will be called by the Shell before
* changing to a new rendering context.
*******************************************************************************/
bool CIntroducingPVRShell::ReleaseView()
{
// Cleanup: destroy OpenVG path and paint
vgDestroyPath(m_vgPath);
m_vgPath = 0;
vgDestroyPaint(m_vgFillPaint);
m_vgFillPaint = 0;
return true;
}
OpenVG_SVGHandler::~OpenVG_SVGHandler() {
vgDestroyPaint( _blackBackFill );
_blackBackFill = 0;
if( _batch ) {
vgDestroyBatchMNK( _batch );
_batch = 0;
}
}
void text_widget_free_handle ( struct TEXT_WIDGET_HANDLE handle )
{
if ( handle.d != NULL ) {
g_object_unref( handle.d->layout );
g_object_unref( handle.d->context );
g_object_unref( handle.d->font_map );
vgDestroyPaint( handle.d->foreground );
free( handle.d );
handle.d = NULL;
}
}
CTSmallWindowOpenVG::~CTSmallWindowOpenVG()
{
// Make sure that this egl status is active
eglMakeCurrent(iDisplay, iSurface, iSurface, iContextVG);
vgDestroyPaint(iFillPaint);
vgDestroyPaint(iStrokePaint);
vgDestroyPath(iPath);
if (iContextVG != EGL_NO_CONTEXT)
{
eglDestroyContext(iDisplay,iContextVG);
}
if (iSurface != EGL_NO_SURFACE)
{
eglDestroySurface(iDisplay,iSurface);
}
// Call eglMakeCurrent() to ensure the surfaces and contexts are truly destroyed.
eglMakeCurrent(iDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
//eglTerminate(iDisplay);
eglReleaseThread();
}
/*******************************************************************************
* Function Name : ReleaseView
* Returns : Nothing
* Description : Code in ReleaseView() will be called by the Shell before
* changing to a new rendering context.
*******************************************************************************/
bool CTransforms::ReleaseView()
{
// Cleanup: destroy paths and paint
vgDestroyPath(m_avgPaths[0]);
vgDestroyPath(m_avgPaths[1]);
vgDestroyPaint(m_vgPaint);
// Cleanup for custom text drawing
m_PrintVG.Terminate();
return true;
}
static void vg_free(void *data)
{
vg_t *vg = (vg_t*)data;
if (!vg)
return;
vgDestroyImage(vg->mImage);
if (vg->mFontsOn)
{
vgDestroyFont(vg->mFont);
vg->font_driver->free(vg->mFontRenderer);
vgDestroyPaint(vg->mPaintFg);
vgDestroyPaint(vg->mPaintBg);
}
gfx_ctx_free(vg);
free(vg);
}
/*******************************************************************************
* Function Name : ReleaseView
* Returns : true if no error occured
* Description : Code in ReleaseView() will be called by the Shell before
* changing to a new rendering context.
*******************************************************************************/
bool OVGFont::ReleaseView()
{
// Cleanup: destroy OpenVG path and paint
vgDestroyFont(m_vgPathFont);
m_vgPathFont = 0;
vgDestroyFont(m_vgImageFont);
m_vgPathFont = 0;
vgDestroyPaint(m_vgFontPaint);
m_vgFontPaint = 0;
return true;
}
static void
draw(void)
{
VGint WINDSIZEX = window_width();
VGint WINDSIZEY = window_height();
VGPaint fill;
VGPath box;
VGfloat color[4] = {1.f, 0.f, 0.f, 1.f};
VGfloat bgCol[4] = {0.7f, 0.7f, 0.7f, 1.0f};
VGfloat transCol[4] = {0.f, 0.f, 0.f, 0.f};
VGImage image = vgCreateImage(VG_sRGBA_8888, img_width, img_height,
VG_IMAGE_QUALITY_NONANTIALIASED);
/* Background clear */
fill = vgCreatePaint();
vgSetParameterfv(fill, VG_PAINT_COLOR, 4, color);
vgSetPaint(fill, VG_FILL_PATH);
box = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F,
1, 0, 0, 0, VG_PATH_CAPABILITY_ALL);
/* Rectangle to cover completely 16x16 pixel area. */
RectToPath(box, 0, 0, 64, 64);
vgSetfv(VG_CLEAR_COLOR, 4, transCol);
vgClearImage(image, 0, 0, img_width, img_height);
vgSetfv(VG_CLEAR_COLOR, 4, color);
vgClearImage(image, 10, 10, 12, 12);
//vgImageSubData(image, pukki_64x64_data, pukki_64x64_stride,
// VG_sRGBA_8888, 0, 0, 32, 32);
vgSeti(VG_MASKING, VG_TRUE);
vgLoadIdentity();
vgSetfv(VG_CLEAR_COLOR, 4, bgCol);
vgClear(0, 0, WINDSIZEX, WINDSIZEY);
vgMask(image, VG_FILL_MASK, 0, 0, window_width(), window_height());
vgMask(image, VG_SET_MASK, x_pos, y_pos, 100, 100);
vgDrawPath(box, VG_FILL_PATH);
//vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);
//vgTranslate(-10, -10);
//vgDrawImage(image);
vgDestroyPaint(fill);
vgDestroyPath(box);
}
static void rpi_free(void *data)
{
rpi_t *rpi = (rpi_t*)data;
vgDestroyImage(rpi->mImage);
#ifdef HAVE_FREETYPE
if (rpi->mFontsOn)
{
vgDestroyFont(rpi->mFont);
font_renderer_free(rpi->mFontRenderer);
vgDestroyPaint(rpi->mPaintFg);
vgDestroyPaint(rpi->mPaintBg);
}
#endif
// Release EGL resources
eglMakeCurrent(rpi->mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
eglDestroySurface(rpi->mDisplay, rpi->mSurface);
eglDestroyContext(rpi->mDisplay, rpi->mContext);
eglTerminate(rpi->mDisplay);
free(rpi);
}
static void
draw(void)
{
VGPath line;
VGPaint fillPaint;
VGubyte lineCommands[3] = {VG_MOVE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS};
VGfloat lineCoords[] = {-2.0f,-1.0f, 0.0f,0.0f, -1.0f, -2.0f};
VGfloat clearColor[] = {0.0f, 0.0f, 0.0f, 1.0f};/* black color */
VGfloat fillColor[] = {1.0f, 1.0f, 1.0f, 1.0f};/* white color */
//VGfloat testRadius = 60.0f;
VGfloat testRadius = 10.0f;
int WINDSIZEX = window_width();
int WINDSIZEY = window_height();
line = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F,
1.0f, 0.0f, 0, 0, VG_PATH_CAPABILITY_ALL);
fillPaint = vgCreatePaint();
vgSetf(VG_STROKE_LINE_WIDTH, 1.0f);
//vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_ROUND);
vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND);
//vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_BEVEL);
vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_BETTER);
vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
vgLoadIdentity();
vgTranslate(60, 60);
vgScale(testRadius * 2, testRadius * 2);
vgAppendPathData(line, 3, lineCommands, lineCoords);
vgSetfv(VG_CLEAR_COLOR, 4, clearColor);
vgSetPaint(fillPaint, VG_STROKE_PATH);
vgSetParameterfv(fillPaint, VG_PAINT_COLOR, 4, fillColor);
vgSetParameteri( fillPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
vgClear(0, 0, WINDSIZEX, WINDSIZEY);
vgDrawPath(line, VG_STROKE_PATH);
vgDestroyPath(line);
vgDestroyPaint(fillPaint);
}
/*!***************************************************************************
@Function ~CPVRTPVGObject
@Description CPVRTPVGObject class destructor where Paths and Paints are deallocated
*****************************************************************************/
CPVRTPVGObject::~CPVRTPVGObject()
{
if(m_bInitialized)
{
m_bInitialized = false;
for(int i = 0; i < m_i32NumPaints; ++i)
{
vgDestroyPaint(m_pPaints[i]);
}
for(int j = 0; j < m_i32NumPaths; ++j)
{
vgDestroyPath(m_pPaths[j].m_path);
}
free(m_pPaths);
free(m_pPaints);
}
}
COpenVGHandleStore::~COpenVGHandleStore()
{
TInt handleListCount = iHandles.Count();
for (TInt i = 0; i < handleListCount; i++)
{
if (iHandles[i].iVGHandle)
{
switch (iHandles[i].iHandleType)
{
case TLVVGHandlePair::EVGPath:
vgDestroyPath(iHandles[i].iVGHandle);
break;
case TLVVGHandlePair::EVGPaint:
vgDestroyPaint(iHandles[i].iVGHandle);
break;
case TLVVGHandlePair::EVGImage:
vgDestroyImage(iHandles[i].iVGHandle);
break;
}
}
}
iHandles.Close();
}
/** 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;
}
static void deinitialise_renderer(envelope_render_internal_t *renderer)
{
vgDestroyPath(renderer->state.path);
vgDestroyPaint(renderer->state.line_paint);
vgDestroyPaint(renderer->state.text_paint);
}
void text_widget_draw_text ( struct TEXT_WIDGET_HANDLE handle )
{
if ( handle.d == NULL || handle.d->layout == NULL )
return;
vgSetPaint( handle.d->foreground, VG_FILL_PATH );
vgSeti( VG_MATRIX_MODE, VG_MATRIX_GLYPH_USER_TO_SURFACE );
vgLoadIdentity();
#if 0
// Overscan (in dots, evidently).
vgTranslate( 14.f, 8.f );
#endif
// Offset in mm.
vgScale( handle.d->dpmm_x, handle.d->dpmm_y );
// Move to the corner.
vgTranslate( handle.d->x_mm, handle.d->y_mm );
// Back to dots.
vgScale( 1.f/handle.d->dpmm_x, 1.f/handle.d->dpmm_y );
int height = PANGO_PIXELS( pango_layout_get_height( handle.d->layout ) );
PangoLayoutIter* li = pango_layout_get_iter( handle.d->layout );
do {
PangoLayoutRun* run = pango_layout_iter_get_run( li );
if ( run == NULL )
continue;
PangoRectangle logical_rect;
int baseline_pango = pango_layout_iter_get_baseline( li );
int baseline_pixel = PANGO_PIXELS( baseline_pango );
pango_layout_iter_get_run_extents( li, NULL, &logical_rect );
int x_pixel = PANGO_PIXELS( logical_rect.x );
PangoFont* pg_font = run->item->analysis.font;
FT_Face face = pango_fc_font_lock_face( (PangoFcFont*)pg_font );
if ( face != NULL ) {
struct VG_DATA* vg_data = face->size->generic.data;
if ( vg_data != NULL ) {
// About the only extra attribute we can manage is the foreground
// color. But, it might be nice to render a background color
// to see just how badly the text is fitted into the widget
// box.
GSList* attr_item = run->item->analysis.extra_attrs;
while ( attr_item ) {
PangoAttribute* attr = attr_item->data;
switch ( attr->klass->type ) {
case PANGO_ATTR_FOREGROUND:
{
PangoColor color = ((PangoAttrColor*)attr)->color;
VGfloat new_color[] = { (float)color.red / 65535.f,
(float)color.green / 65535.f,
(float)color.blue / 65535.f, 1.f };
VGPaint new_paint = vgCreatePaint();
vgSetParameterfv( new_paint, VG_PAINT_COLOR, 4, new_color );
vgSetPaint( new_paint, VG_FILL_PATH );
vgDestroyPaint( new_paint );
}
break;
default:
printf( "\tHmm. Unknown attribute: %d\n", attr->klass->type );
}
attr_item = attr_item->next;
}
// Note: inverted Y coordinate
VGfloat point[2] = { x_pixel, height - baseline_pixel };
vgSetfv( VG_GLYPH_ORIGIN, 2, point );
VGFont vg_font = vg_data->font;
int g;
for ( g = 0; g < run->glyphs->num_glyphs; g++ ) {
vgDrawGlyph( vg_font, run->glyphs->glyphs[g].glyph, VG_FILL_PATH,
VG_TRUE );
}
if ( vgGetPaint( VG_FILL_PATH ) != handle.d->foreground ) {
vgSetPaint( handle.d->foreground, VG_FILL_PATH );
}
}
pango_fc_font_unlock_face( (PangoFcFont*)pg_font );
}
} while ( pango_layout_iter_next_run( li ) );
// Iterators are not free.
pango_layout_iter_free( li);
}
/****************************************************************************
** Application entry point
****************************************************************************/
int main()
{
// Variable set in the message handler to finish the demo
bool bDemoDone = false;
// X11 variables
Display* x11Display = 0;
Window x11Window = 0;
Colormap x11Colormap = 0;
EGLDisplay eglDisplay = 0;
EGLConfig eglConfig = 0;
EGLSurface eglSurface = 0;
EGLContext eglContext = 0;
int i32NumConfigs, i32MajorVersion, i32MinorVersion;
/*
Step 0 - Initialize OpenVG
--------------------------
The following code up to the next comment block consists of the
steps 0 to 8 taken straight from the Initialization tutorial.
*/
Window sRootWindow;
XSetWindowAttributes sWA;
unsigned int ui32Mask;
int i32Depth;
// Initializes the display and screen
x11Display = XOpenDisplay( 0 );
if (!x11Display)
{
printf("Error: Unable to open X display\n");
goto cleanup;
}
long x11Screen;
x11Screen = XDefaultScreen( x11Display );
// Gets the window parameters
sRootWindow = RootWindow(x11Display, x11Screen);
i32Depth = DefaultDepth(x11Display, x11Screen);
XVisualInfo* x11Visual;
x11Visual = new XVisualInfo;
XMatchVisualInfo( x11Display, x11Screen, i32Depth, TrueColor, x11Visual);
if (!x11Visual)
{
printf("Error: Unable to acquire visual\n");
goto cleanup;
}
x11Colormap = XCreateColormap( x11Display, sRootWindow, x11Visual->visual, AllocNone );
sWA.colormap = x11Colormap;
// Add to these for handling other events
sWA.event_mask = StructureNotifyMask | ExposureMask | ButtonPressMask | ButtonReleaseMask | KeyPressMask | KeyReleaseMask;
ui32Mask = CWBackPixel | CWBorderPixel | CWEventMask | CWColormap;
// Creates the X11 window
x11Window = XCreateWindow( x11Display, RootWindow(x11Display, x11Screen), 0, 0, WINDOW_WIDTH, WINDOW_HEIGHT,
0, CopyFromParent, InputOutput, CopyFromParent, ui32Mask, &sWA);
XMapWindow(x11Display, x11Window);
XFlush(x11Display);
eglDisplay = (EGLDisplay)eglGetDisplay((NativeDisplayType)x11Display);
if(!eglInitialize(eglDisplay, &i32MajorVersion, &i32MinorVersion))
{
printf("Error: eglInitialize() failed.\n");
goto cleanup;
}
eglBindAPI(EGL_OPENVG_API);
static const int ai32ConfigAttribs[] =
{
EGL_RED_SIZE, 5,
EGL_GREEN_SIZE, 6,
EGL_BLUE_SIZE, 5,
EGL_ALPHA_SIZE, 0,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENVG_BIT,
EGL_NONE
};
if(!eglChooseConfig(eglDisplay, ai32ConfigAttribs, &eglConfig, 1, &i32NumConfigs) || (i32NumConfigs != 1))
{
printf("Error: eglChooseConfig() failed.\n");
goto cleanup;
}
eglSurface = eglCreateWindowSurface(eglDisplay, eglConfig, (NativeWindowType)x11Window, NULL);
if((eglGetError() != EGL_SUCCESS) || (eglSurface == EGL_NO_SURFACE))
{
printf("Error: eglCreateWindowSurface() failed.\n");
goto cleanup;
}
eglContext = eglCreateContext(eglDisplay, eglConfig, NULL, NULL);
if((eglGetError() != EGL_SUCCESS) || (eglContext == EGL_NO_CONTEXT))
{
printf("Error: eglCreateContext() failed.\n");
goto cleanup;
}
eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext);
if(eglGetError() != EGL_SUCCESS)
{
printf("Error: eglMakeCurrent() failed.\n");
goto cleanup;
}
/*
Steps 1 to 4 - Prepare OpenVG to draw a triangle
------------------------------------------------
At this point we could theoretically start drawing with OpenVG. But
we have to specify what to draw and how to draw it first.
*/
/*
Step 1 - Set up a device independent coordinate system
------------------------------------------------------
Initially, the OpenVG coordinate system is based on the output resolution.
To get a device independent coordinate system, we need to apply a
transformation: Scaling by the output resolution means that coordinates
between (0, 0) and (1, 1) will be visible on screen, with the origin
in the lower left corner.
Transformations are described more in-depth in the Transforms tutorial.
It should be noted that different aspect ratios often require
special attention regarding the layout of elements on screen.
*/
int i32WindowWidth, i32WindowHeight;
eglQuerySurface(eglDisplay, eglSurface, EGL_WIDTH, &i32WindowWidth);
eglQuerySurface(eglDisplay, eglSurface, EGL_HEIGHT, &i32WindowHeight);
vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
vgLoadIdentity();
vgScale((float)i32WindowWidth, (float)i32WindowHeight);
/*
Step 2 - Create a path
----------------------
Drawing shapes with OpenVG requires a path which represents a series of
line and curve segments describing the outline of the shape. The shape
does not need to be closed, but for now we will start with a simple
triangle.
First we create a path handle, then we append segment and point data.
Creating a path involves choosing a datatype used for point data (we use
float here, indicated by VG_PATH_DATATYPE_F) and capabilities that we want
to use. Picking the right capabilities is important as the OpenVG driver
can use a more efficient and compact internal representation for paths
with limited capabilities. We only need two capabilities for this tutorial:
adding data to the path and drawing it, with the latter being implicitly
enabled for all paths.
*/
VGPath vgTriangle;
vgTriangle = vgCreatePath(
VG_PATH_FORMAT_STANDARD,
VG_PATH_DATATYPE_F,
1.0f, 0.0f, 4, 3,
(unsigned int)VG_PATH_CAPABILITY_APPEND_TO);
/*
The segments of a path are described as a series of commands, represented as
an array of bytes. You can imagine the commands being performed by a pen:
First the pen moves to a starting location without drawing, from there it
draws a line to a second point. Then another line to a third point. After
that, it closes the shape by drawing a line from the last point to the
starting location: triangle finished!
The suffixes _ABS and _REL attached to the commands indicate whether the
coordinates are to be interpreted as absolute locations (seen from the
origin)or as being relative to the location of the current point.
*/
VGubyte aui8PathSegments[4];
aui8PathSegments[0] = VG_MOVE_TO_ABS;
aui8PathSegments[1] = VG_LINE_TO_ABS;
aui8PathSegments[2] = VG_LINE_TO_ABS;
aui8PathSegments[3] = VG_CLOSE_PATH;
/*
In addition to the array of commands, the path needs a list of points. A
command can "consume" from 0 to 6 values, depending on its type. MOVE_TO
and LINE_TO each take two values, CLOSE_PATH takes none.
A triangle requires 3 2D vertices.
*/
VGfloat afPoints[6];
afPoints[0] = 0.3f;
afPoints[1] = 0.3f;
afPoints[2] = 0.7f;
afPoints[3] = 0.3f;
afPoints[4] = 0.5f;
afPoints[5] = 0.7f;
/*
When appending data to the path, only the number of segments needs to be
specified since the number of points used depends on the actual commands.
*/
vgAppendPathData(vgTriangle, 4, aui8PathSegments, afPoints);
/*
Path capabilities should be removed as soon as they are no longer needed.
The OpenVG implementation might work more efficiently if it knows that
path data will not change since it can use an optimized internal
representation.
*/
vgRemovePathCapabilities(vgTriangle, VG_PATH_CAPABILITY_APPEND_TO);
/*
Step 3 - Create a paint
-----------------------
To fill a shape, we need a paint that describes how to fill it: a gradient,
pattern, or single color. Here we choose a paint with type COLOR that
is a simple opaque red. vgSetColor is a shortcut function that takes a
non-premultiplied sRGBA color encoded as a 32bit integer in RGBA_8888 form.
*/
VGPaint vgFillPaint;
vgFillPaint = vgCreatePaint();
vgSetParameteri(vgFillPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
vgSetColor(vgFillPaint, 0xFFFFAAFF);
/*
Step 4 - Prepare the render loop
--------------------------------
The clear color will be used whenever calling vgClear(). The color is given
as non-premultiplied sRGBA, represented by four float values.
*/
VGfloat afClearColor[4];
afClearColor[0] = 0.6f;
afClearColor[1] = 0.8f;
afClearColor[2] = 1.0f;
afClearColor[3] = 1.0f;
// Set the clear color
vgSetfv(VG_CLEAR_COLOR, 4, afClearColor);
/*
Step 5 - Render loop
--------------------
Start the render loop for 1000 frames!
*/
for(int i = 0; i < 1000; ++i)
{
// Check if the message handler finished the demo
if (bDemoDone) break;
// Clear the whole surface with the clear color
vgClear(0, 0, i32WindowWidth, i32WindowHeight);
// Set the current fill paint...
vgSetPaint(vgFillPaint, VG_FILL_PATH);
// Draw the triangle!
vgDrawPath(vgTriangle, VG_FILL_PATH);
/*
Drawing is double buffered, so you never see any intermediate
results of the drawing. When you have finished drawing
you have to call eglSwapBuffers to make the results appear on
screen.
*/
eglSwapBuffers(eglDisplay, eglSurface);
// Managing the X11 messages
int i32NumMessages = XPending( x11Display );
for( int i = 0; i < i32NumMessages; i++ )
{
XEvent event;
XNextEvent( x11Display, &event );
switch( event.type )
{
// Exit on mouse click
case ButtonPress:
bDemoDone = true;
break;
default:
break;
}
}
}
/*
Step 6 - Destroy resources
--------------------------
OpenVG resources like paths and paints need to be destroyed
when they are no longer needed.
*/
vgDestroyPath(vgTriangle);
vgDestroyPaint(vgFillPaint);
cleanup:
/*
Step 7 - Terminate OpenVG
-------------------------
Again, the following code is taken from the Initialization tutorial,
steps 10 and 11.
*/
eglMakeCurrent(eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
eglTerminate(eglDisplay);
if (x11Window) XDestroyWindow(x11Display, x11Window);
if (x11Colormap) XFreeColormap( x11Display, x11Colormap );
if (x11Display) XCloseDisplay(x11Display);
// Say goodbye
printf("%s finished.", pszAppName);
return 0;
}
~BoxRenderer() {
vgDestroyPath(path_);
assert(!vgGetError());
vgDestroyPaint(paint_);
assert(!vgGetError());
}
static void deinitialise_renderer(setting_render_internal_t* renderer)
{
vgDestroyPaint(renderer->state.text_paint);
}
