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); }