void display(float interval) { VGfloat cc[] = {0,0,0,1}; vgSetfv(VG_CLEAR_COLOR, 4, cc); vgClear(0,0,testWidth(),testHeight()); vgSeti(VG_MATRIX_MODE, VG_MATRIX_FILL_PAINT_TO_USER); vgLoadIdentity(); vgTranslate(tx, ty); vgRotate(ang); vgScale(sx, sy); vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE); vgLoadIdentity(); vgSetPaint(radialFill, VG_FILL_PATH); vgDrawPath(p, VG_FILL_PATH); vgTranslate(tx, ty); vgRotate(ang); vgScale(sx, sy); vgSetPaint(blackFill, VG_FILL_PATH | VG_STROKE_PATH); vgDrawPath(radius, VG_STROKE_PATH); vgDrawPath(center, VG_STROKE_PATH); vgDrawPath(focus, VG_FILL_PATH); }
void display(float interval) { VGfloat cc[] = {0,0,0,1}; vgSetfv(VG_CLEAR_COLOR, 4, cc); vgClear(0,0,testWidth(),testHeight()); vgSeti(VG_MATRIX_MODE, VG_MATRIX_FILL_PAINT_TO_USER); vgLoadIdentity(); vgTranslate(tx, ty); vgScale(sx, sy); vgRotate(a); vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE); vgLoadIdentity(); vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE); vgSeti(VG_IMAGE_MODE, VG_DRAW_IMAGE_MULTIPLY); vgLoadIdentity(); vgSetPaint(patternFill, VG_FILL_PATH); /*vgDrawPath(p, VG_FILL_PATH);*/ vgDrawImage(backImage); vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE); vgLoadIdentity(); vgTranslate(tx, ty); vgScale(sx, sy); vgRotate(a); vgSetPaint(blackFill, VG_FILL_PATH | VG_STROKE_PATH); vgDrawPath(org, VG_FILL_PATH); }
static void vg_draw_message(vg_t *vg, const char *msg) { settings_t *settings = config_get_ptr(); if (!vg->mLastMsg || strcmp(vg->mLastMsg, msg)) vg_render_message(vg, msg); vgSeti(VG_SCISSORING, VG_FALSE); vgSeti(VG_IMAGE_MODE, VG_DRAW_IMAGE_STENCIL); VGfloat origins[] = { vg->mScreenWidth * settings->video.msg_pos_x - 2.0f, vg->mScreenHeight * settings->video.msg_pos_y - 2.0f, }; vgSetfv(VG_GLYPH_ORIGIN, 2, origins); vgSetPaint(vg->mPaintBg, VG_FILL_PATH); vgDrawGlyphs(vg->mFont, vg->mMsgLength, vg->mGlyphIndices, NULL, NULL, VG_FILL_PATH, VG_TRUE); origins[0] += 2.0f; origins[1] += 2.0f; vgSetfv(VG_GLYPH_ORIGIN, 2, origins); vgSetPaint(vg->mPaintFg, VG_FILL_PATH); vgDrawGlyphs(vg->mFont, vg->mMsgLength, vg->mGlyphIndices, NULL, NULL, VG_FILL_PATH, VG_TRUE); vgSeti(VG_SCISSORING, VG_TRUE); vgSeti(VG_IMAGE_MODE, VG_DRAW_IMAGE_NORMAL); }
void CNVGCSIcon::ConstructL(const TDesC8& aBuf) { iNVGIconData = CNVGIconData::NewL(aBuf.Length()); iOpenVGHandles = COpenVGHandleStore::NewL(); if (iPath == VG_INVALID_HANDLE) { iPath = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_S_32, 1.0f/65536.0f, 0.0f, 0, 0, VG_PATH_CAPABILITY_APPEND_TO); iOpenVGHandles->AddPathDHL(iPath); } if (iFillPaint == VG_INVALID_HANDLE) { iFillPaint = vgCreatePaint(); iOpenVGHandles->AddPaintDHL(iFillPaint); } vgSetPaint(iFillPaint, VG_FILL_PATH); if (iStrokePaint == VG_INVALID_HANDLE) { iStrokePaint = vgCreatePaint(); iOpenVGHandles->AddPaintDHL(iStrokePaint); } vgSetPaint(iStrokePaint, VG_STROKE_PATH); }
void loadTiger() { int i; VGPath temp; temp = testCreatePath(); tigerPaths = (VGPath*)malloc(pathCount * sizeof(VGPath)); vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE); vgTranslate(-100,100); vgScale(1,-1); for (i=0; i<pathCount; ++i) { vgClearPath(temp, VG_PATH_CAPABILITY_ALL); vgAppendPathData(temp, commandCounts[i], commandArrays[i], dataArrays[i]); tigerPaths[i] = testCreatePath(); vgTransformPath(tigerPaths[i], temp); } tigerStroke = vgCreatePaint(); tigerFill = vgCreatePaint(); vgSetPaint(tigerStroke, VG_STROKE_PATH); vgSetPaint(tigerFill, VG_FILL_PATH); vgLoadIdentity(); vgDestroyPath(temp); }
static void rpi_draw_message(rpi_t *rpi, const char *msg) { if (!rpi->mLastMsg || strcmp(rpi->mLastMsg, msg)) rpi_render_message(rpi, msg); vgSeti(VG_SCISSORING, VG_FALSE); vgSeti(VG_IMAGE_MODE, VG_DRAW_IMAGE_STENCIL); VGfloat origins[] = { rpi->mScreenWidth * g_settings.video.msg_pos_x - 2.0f, rpi->mScreenHeight * g_settings.video.msg_pos_y - 2.0f, }; vgSetfv(VG_GLYPH_ORIGIN, 2, origins); vgSetPaint(rpi->mPaintBg, VG_FILL_PATH); vgDrawGlyphs(rpi->mFont, rpi->mMsgLength, rpi->mGlyphIndices, NULL, NULL, VG_FILL_PATH, VG_TRUE); origins[0] += 2.0f; origins[1] += 2.0f; vgSetfv(VG_GLYPH_ORIGIN, 2, origins); vgSetPaint(rpi->mPaintFg, VG_FILL_PATH); vgDrawGlyphs(rpi->mFont, rpi->mMsgLength, rpi->mGlyphIndices, NULL, NULL, VG_FILL_PATH, VG_TRUE); vgSeti(VG_SCISSORING, VG_TRUE); vgSeti(VG_IMAGE_MODE, VG_DRAW_IMAGE_NORMAL); }
CNVGCSIcon::~CNVGCSIcon() { vgSetPaint(VG_INVALID_HANDLE, VG_FILL_PATH); vgSetPaint(VG_INVALID_HANDLE, VG_STROKE_PATH); delete iNVGIconData; delete iOpenVGHandles; }
/******************************************************************************* * Function Name : RenderScene * Returns : true if no error occured * Description : Main rendering loop function of the program. The shell will * call this function every frame. *******************************************************************************/ bool OVGMaskLayer::RenderScene() { //Clear the screen with the current clear colour vgClear(0, 0, m_ui32ScreenWidth, m_ui32ScreenHeight); // Set the paint and draw the path vgSetPaint(m_avgColourPaint[1], VG_FILL_PATH); vgDrawPath(m_avgPath[0], VG_STROKE_PATH | VG_FILL_PATH); //Enable masking vgSeti(VG_MASKING, VG_TRUE); // Set paint vgSetPaint(m_avgColourPaint[2], VG_FILL_PATH); /* Modify the drawing surface's mask layer by loading it with the values from our first mask layer. See OVGMasking for more details on vgMask. */ vgMask(m_vgMaskLayer[0], VG_SET_MASK, 0, 0, m_ui32ScreenWidth, m_ui32ScreenHeight); // Draw our path vgDrawPath(m_avgPath[1], VG_STROKE_PATH | VG_FILL_PATH); // Load the second mask layer into the mask vgMask(m_vgMaskLayer[1], VG_SET_MASK, 0, 0, m_ui32ScreenWidth, m_ui32ScreenHeight); // Draw our path vgDrawPath(m_avgPath[2], VG_STROKE_PATH | VG_FILL_PATH); // Change paint for the triangle vgSetPaint(m_avgColourPaint[0], VG_FILL_PATH); // Merge our first mask layer into the mask (that currently contains the data from our second layer) vgMask(m_vgMaskLayer[0], VG_INTERSECT_MASK, 0, 0, m_ui32ScreenWidth, m_ui32ScreenHeight); // Draw our path vgDrawPath(m_avgPath[3], VG_STROKE_PATH | VG_FILL_PATH); // Disable masking vgSeti(VG_MASKING, VG_FALSE); // Draw title and logo m_PrintVG.DisplayDefaultTitle("MaskLayer", "", ePVRTPrint3DSDKLogo); return true; }
// 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); }
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()); } }
void render() { vgSetPaint(paint_, VG_FILL_PATH); assert(!vgGetError()); vgDrawPath(path_, VG_FILL_PATH); 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); }
// 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); }
// setstops sets color stops for gradients void setstop(VGPaint paint, VGfloat * stops, int n) { VGboolean multmode = VG_FALSE; VGColorRampSpreadMode spreadmode = VG_COLOR_RAMP_SPREAD_REPEAT; vgSetParameteri(paint, VG_PAINT_COLOR_RAMP_SPREAD_MODE, spreadmode); vgSetParameteri(paint, VG_PAINT_COLOR_RAMP_PREMULTIPLIED, multmode); vgSetParameterfv(paint, VG_PAINT_COLOR_RAMP_STOPS, 5 * n, stops); vgSetPaint(paint, VG_FILL_PATH); }
void CTSmallWindowOpenVG::RenderL() { CTWindow::RenderL(); // Make sure that this egl status is active eglMakeCurrent(iDisplay, iSurface, iSurface, iContextVG); VGfloat clearColor[4] = {0.1f, 0.2f, 0.4f, 1.f}; VGfloat scaleFactor = Size().iWidth/200.f; if (Size().iHeight/200.f < scaleFactor) { scaleFactor = Size().iHeight/200.f; } iCurrentRotation = iTime; if (iCurrentRotation >= 360.f) { iCurrentRotation -= 360.f; } vgSetfv(VG_CLEAR_COLOR, 4, clearColor); vgClear(0, 0, Size().iWidth, Size().iHeight); vgLoadIdentity(); vgTranslate((float)Size().iHeight / 2, (float)Size().iHeight / 2); vgScale(scaleFactor, scaleFactor); vgRotate(iCurrentRotation); vgTranslate(-50.f, -50.f); vgSeti(VG_BLEND_MODE, VG_BLEND_SRC_OVER); vgSeti(VG_FILL_RULE, VG_EVEN_ODD); vgSetPaint(iFillPaint, VG_FILL_PATH); vgSetf(VG_STROKE_LINE_WIDTH, 10.f); vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_ROUND); vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND); vgSetf(VG_STROKE_MITER_LIMIT, 0.f); vgSetPaint(iStrokePaint, VG_STROKE_PATH); vgDrawPath(iPath, VG_FILL_PATH | VG_STROKE_PATH); iTime++; eglSwapBuffers(iDisplay, iSurface); }
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(); }
// C function:: void vgSetPaint(VGPaint paint, VGbitfield paintModes); JNIEXPORT jint JNICALL Java_com_example_startvg_VG11_vgSetPaint( JNIEnv * env, jobject obj, long paint, int paintModes){ vgSetPaint( (VGPaint) paint, (VGbitfield) paintModes ); }
void OpenVG_SVGHandler::draw_recursive( group_t& group ) { // push the group matrix onto the stack pushTransform( group.transform ); vgLoadMatrix( topTransform().m ); for ( list<path_object_t>::iterator it = group.path_objects.begin(); it != group.path_objects.end(); it++ ) { path_object_t& po = *it; uint32_t draw_params = 0; if ( po.fill ) { vgSetPaint( po.fill, VG_FILL_PATH ); draw_params |= VG_FILL_PATH; } if ( po.stroke ) { vgSetPaint( po.stroke, VG_STROKE_PATH ); vgSetf( VG_STROKE_LINE_WIDTH, po.stroke_width ); draw_params |= VG_STROKE_PATH; } if( draw_params == 0 ) { // if no stroke or fill use the default black fill vgSetPaint( _blackBackFill, VG_FILL_PATH ); draw_params |= VG_FILL_PATH; } // set the fill rule vgSeti( VG_FILL_RULE, po.fill_rule ); // trasnform pushTransform( po.transform ); vgLoadMatrix( topTransform().m ); vgDrawPath( po.path, draw_params ); popTransform(); vgLoadMatrix( topTransform().m ); } for ( list<group_t>::iterator it = group.children.begin(); it != group.children.end(); it++ ) { draw_recursive( *it ); } popTransform(); vgLoadMatrix( topTransform().m ); }
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 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); }
void PS_render(PS* ps) { int i; assert(ps); vgSeti(VG_BLEND_MODE, VG_BLEND_SRC_OVER); for(i=0;i<ps->m_numPaths;i++) { vgSeti(VG_FILL_RULE, ps->m_paths[i].m_fillRule); vgSetPaint(ps->m_paths[i].m_fillPaint, VG_FILL_PATH); if(ps->m_paths[i].m_paintMode & VG_STROKE_PATH) { vgSetf(VG_STROKE_LINE_WIDTH, ps->m_paths[i].m_strokeWidth); vgSeti(VG_STROKE_CAP_STYLE, ps->m_paths[i].m_capStyle); vgSeti(VG_STROKE_JOIN_STYLE, ps->m_paths[i].m_joinStyle); vgSetf(VG_STROKE_MITER_LIMIT, ps->m_paths[i].m_miterLimit); vgSetPaint(ps->m_paths[i].m_strokePaint, VG_STROKE_PATH); } vgDrawPath(ps->m_paths[i].m_path, ps->m_paths[i].m_paintMode); } assert(vgGetError() == VG_NO_ERROR); }
static void draw(void) { VGfloat point[2], tangent[2]; int i = 0; vgClear(0, 0, window_width(), window_height()); vgSetPaint(fill, VG_FILL_PATH); vgDrawPath(path, VG_FILL_PATH); draw_marks(path); vgFlush(); }
/******************************************************************************* * Function Name : RenderScene * Returns : true if no error occured * Description : Main rendering loop function of the program. The shell will * call this function every frame. *******************************************************************************/ bool CIntroducingPVRShell::RenderScene() { /* Clear the screen with clear colour. Clear is pixel based, so we need the dimensions of the screen. */ vgClear(0, 0, PVRShellGet(prefWidth), PVRShellGet(prefHeight)); // Set the current fill paint... vgSetPaint(m_vgFillPaint, VG_FILL_PATH); // ... and draw a filled triangle vgDrawPath(m_vgPath, VG_FILL_PATH); return true; }
static void init(void) { VGfloat clearColor[] = {1.0f, 1.0f, 1.0f, 1.0f};/* white color */ VGfloat fillColor[] = {1.0f, 0.0f, 0.0f, 1.0f};/* red color */ static const VGubyte segments[4] = {VG_MOVE_TO_ABS, VG_SCCWARC_TO_ABS, VG_SCCWARC_TO_ABS, VG_CLOSE_PATH}; VGfloat data[12]; const VGfloat cx = 0, cy=29, width=80, height=40; const VGfloat hw = width * 0.5f; const VGfloat hh = height * 0.5f; data[0] = cx + hw; data[1] = cy; data[2] = hw; data[3] = hh; data[4] = 0; data[5] = cx - hw; data[6] = cy; data[7] = hw; data[8] = hh; data[9] = 0; data[10] = data[0]; data[11] = cy; vgSetfv(VG_CLEAR_COLOR, 4, clearColor); vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_NONANTIALIASED); path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 0, 0, VG_PATH_CAPABILITY_ALL); if (path == VG_INVALID_HANDLE) { return; } paint = vgCreatePaint(); if (paint == VG_INVALID_HANDLE) { vgDestroyPath(path); return; } vgAppendPathData(path, 4, segments, data); vgSetParameterfv(paint, VG_PAINT_COLOR, 4, fillColor); vgSetParameteri( paint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR); vgSetPaint(paint, VG_FILL_PATH); }
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); }
static void init(void) { static const VGubyte cmds[6] = {VG_MOVE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS, VG_CLOSE_PATH}; static const VGfloat coords[] = { 0, 200, 300, 200, 50, 0, 150, 300, 250, 0}; path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1, 0, 0, 0, VG_PATH_CAPABILITY_ALL); vgAppendPathData(path, 6, cmds, coords); fill = vgCreatePaint(); vgSetParameterfv(fill, VG_PAINT_COLOR, 4, green_color); vgSetPaint(fill, VG_FILL_PATH); vgSetfv(VG_CLEAR_COLOR, 4, white_color); }
/******************************************************************************* * Function Name : RenderScene * Returns : true if no error occured * Description : Main rendering loop function of the program. The shell will * call this function every frame. *******************************************************************************/ bool CTransforms::RenderScene() { m_ui32AbsTime = PVRShellGetTime(); // Clear the screen with clear color. vgClear(0, 0, PVRShellGet(prefWidth), PVRShellGet(prefHeight)); // Set fill paint vgSetPaint(m_vgPaint, VG_FILL_PATH); unsigned int ui32TimeSinceStart = PVRShellGetTime() - m_ui32StartTime; // toggle segment type every 3 seconds int ui32ActiveTransform = (ui32TimeSinceStart % (3000 * 7)) / 3000; switch(ui32ActiveTransform) { case 0: DoTranslate(); break; case 1: DoScaleCentered(); break; case 2: DoScaleOrigin(); break; case 3: DoRotateCentered(); break; case 4: DoRotateOrigin(); break; case 5: DoShearCentered(); break; case 6: DoShearOrigin(); break; } // Draw user interface static char* apszTransforms[] = { "Translation", "Scaling (centered on object)", "Scaling (from origin)", "Rotate (centered on object)", "Rotate (around origin)", "Shear (centered on object)", "Shear (from origin)", }; m_PrintVG.DisplayDefaultTitle("Transforms", apszTransforms[ui32ActiveTransform], ePVRTPrint3DLogoIMG); return true; }
int main(int argc, char **argv) { float rotate, color[4] = {0.0, 0.33, 0.33, 1.0}; VGPath path; VGPaint paintStroke; VGubyte pathSegments[] = {VG_MOVE_TO_ABS, VG_LINE_TO_ABS, VG_CLOSE_PATH}; float pathData[] = {200.0, 300.0, 100.0, 100.0}; float incData[] = { 1.0, 2.0, -2.5, -0.5}; EGLDisplayState *eglState = eglOpenDisplay(0 /* min win dimension */, 8 /* min color component size */, 8 /* min alpha size */, 0 /* min Z depth */, EGL_OPENVG_BIT /* render type */); path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0, 0.0, 0, 0, VG_PATH_CAPABILITY_APPEND_TO | VG_PATH_CAPABILITY_MODIFY); vgAppendPathData(path, 3, pathSegments, pathData); paintStroke = vgCreatePaint(); vgSetColor(paintStroke, 0x00FF00FF); vgSetParameteri(paintStroke, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR); vgSetPaint(paintStroke, VG_STROKE_PATH | VG_FILL_PATH); vgSetf(VG_STROKE_LINE_WIDTH, 5.0); vgLoadIdentity(); for (rotate = 0.0; rotate < 1000.0; rotate++) { color[0] = rotate / 1000.0; vgSetfv(VG_CLEAR_COLOR, 4, color); vgClear(0, 0, eglState->win.width, eglState->win.height); bounce(2, pathData, incData, eglState->win.width, eglState->win.height); vgModifyPathCoords(path, 0, 3, pathData); vgDrawPath(path, VG_STROKE_PATH); eglUpdateDisplay(eglState); } eglCloseDisplay(eglState); }
static void init(void) { static const VGubyte sqrCmds[5] = {VG_MOVE_TO_ABS, VG_HLINE_TO_ABS, VG_VLINE_TO_ABS, VG_HLINE_TO_ABS, VG_CLOSE_PATH}; static const VGfloat sqrCoords[5] = {50.0f, 50.0f, 250.0f, 250.0f, 50.0f}; path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1, 0, 0, 0, VG_PATH_CAPABILITY_APPEND_TO); vgAppendPathData(path, 5, sqrCmds, sqrCoords); fill = vgCreatePaint(); vgSetParameterfv(fill, VG_PAINT_COLOR, 4, color); vgSetPaint(fill, VG_FILL_PATH); vgSetfv(VG_CLEAR_COLOR, 4, white_color); vgSetf(VG_STROKE_LINE_WIDTH, 10); vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_BUTT); vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND); vgSetf(VG_STROKE_MITER_LIMIT, 4.0f); vgSeti(VG_MASKING, VG_TRUE); vgMask(VG_INVALID_HANDLE, VG_CLEAR_MASK, 25, 25, 100, 100); }
LRESULT OnPaint(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { VGPaint strokePaint = vgCreatePaint(); vgSetPaint(strokePaint, VG_STROKE_PATH); VGfloat color[4] = { 1.0f, 0.0f, 0.0f, 1.0f }; vgSetParameterfv(strokePaint, VG_PAINT_COLOR, 4, &color[0]); VGPath line = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1, 0, 0, 0, VG_PATH_CAPABILITY_ALL); vguLine(line, 20, 20, 130, 130); VGPath square = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1, 0, 0, 0, VG_PATH_CAPABILITY_ALL); vguRect(square, 10.0f, 10.0f, 130.0f, 50.0f); vgSetf(VG_STROKE_LINE_WIDTH, 7.0f); vgDrawPath(line, VG_STROKE_PATH); vgDrawPath(square, VG_STROKE_PATH); ::ValidateRect(hWnd, NULL); return 0; }