/*******************************************************************************
* Function Name : DoScaleOrigin
* Description : Demonstrate the effect of scaling from the origin.
*******************************************************************************/
void CTransforms::DoScaleOrigin()
{
// Make sure we're operating on the path user-to-surface matrix
vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
// Load Identity matrix. This clears all previous transformations
vgLoadIdentity();
// To be independent of screen resolution, we need to scale the
// coordinates so everything in the range [0, 1] will be visible
vgScale((float) PVRShellGet(prefWidth), (float) PVRShellGet(prefHeight));
// turn time(ms) into a periodic triangle function
int i32Zigzag = m_ui32AbsTime % 2000;
if(i32Zigzag > 1000)
i32Zigzag = 2000 - i32Zigzag;
i32Zigzag = PVRT_MAX(100, PVRT_MIN(900, i32Zigzag));
float fScaleFactor = 0.3f + (i32Zigzag * 0.0009f);
// Scaling a scene from the origin means that objects will
// either get pulled towards the origin or move away from it
// along with being resized.
vgScale(fScaleFactor, fScaleFactor);
// draw first path
vgDrawPath(m_avgPaths[0], VG_STROKE_PATH | VG_FILL_PATH);
// draw second path
vgDrawPath(m_avgPaths[1], VG_STROKE_PATH | 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);
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);
}
/*******************************************************************************
* Function Name : DoShearOrigin
* Description : Demonstrate the effect of shearing from the origin.
*******************************************************************************/
void CTransforms::DoShearOrigin()
{
// Make sure we're operating on the path user-to-surface matrix
vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
// Load Identity matrix. This clears all previous transformations
vgLoadIdentity();
// To be independent of screen resolution, we need to scale the
// coordinates so everything in the range [0, 1] will be visible
vgScale((float)PVRShellGet(prefWidth), (float)PVRShellGet(prefHeight));
// turn time(ms) into a periodic triangle function
int i32Zigzag = m_ui32AbsTime % 2000;
if(i32Zigzag > 1000)
i32Zigzag = 2000 - i32Zigzag;
i32Zigzag = PVRT_MAX(100, PVRT_MIN(900, i32Zigzag)) - 500;
vgShear(i32Zigzag * 0.001f, 0);
// draw first path
vgDrawPath(m_avgPaths[0], VG_STROKE_PATH | VG_FILL_PATH);
// draw second path
vgDrawPath(m_avgPaths[1], VG_STROKE_PATH | VG_FILL_PATH);
}
/*******************************************************************************
* Function Name : DoShearCentered
* Description : Demonstrate the effect of shearing centred on a
* shape. Each path is transformed separately.
*******************************************************************************/
void CTransforms::DoShearCentered()
{
// Make sure we're operating on the path user-to-surface matrix
vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
// Load Identity matrix. This clears all previous transformations
vgLoadIdentity();
// To be independent of screen resolution, we need to scale the
// coordinates so everything in the range [0, 1] will be visible
vgScale((float)PVRShellGet(prefWidth), (float)PVRShellGet(prefHeight));
// Unlike OpenGL, OpenVG does not maintain a matrix stack. So instead of
// pushing the current matrix to the stack, we have to store it ourselves
float afUnitMatrix[3 * 3];
vgGetMatrix(afUnitMatrix);
// turn time(ms) into a clipped periodic triangle function
int i32Zigzag1 = m_ui32AbsTime % 2000;
if(i32Zigzag1 > 1000)
i32Zigzag1 = 2000 - i32Zigzag1;
i32Zigzag1 = PVRT_MAX(250, PVRT_MIN(750, i32Zigzag1)) - 500;
// and again, now with shifted phase
int i32Zigzag2 = (m_ui32AbsTime + 500) % 2000;
if(i32Zigzag2 > 1000)
i32Zigzag2 = 2000 - i32Zigzag2;
i32Zigzag2 = PVRT_MAX(250, PVRT_MIN(750, i32Zigzag2)) - 500;
// Scaling a shape from its center is identical to moving it to the
// origin, scaling it there, and moving it back where it was.
//
// IMPORTANT:
// Since OpenVG right-multiplies matrices, you conceptually need to
// call the transformation functions in backwards order.
vgTranslate(0.5f, 0.75f);
vgShear(0.001f * i32Zigzag1, 0);
vgTranslate(-0.5f, -0.75f);
// draw first path
vgDrawPath(m_avgPaths[0], VG_STROKE_PATH | VG_FILL_PATH);
// restore the unit matrix ([0, 1] visible)
vgLoadMatrix(afUnitMatrix);
// transformation for second path
vgTranslate(0.5f, 0.25f);
vgShear(0.001f * i32Zigzag2, 0);
vgTranslate(-0.5f, -0.25f);
// draw second path
vgDrawPath(m_avgPaths[1], VG_STROKE_PATH | VG_FILL_PATH);
}
/*******************************************************************************
* Function Name : DoTranslate
* Description : Demonstrate the effect of translations. Each path is
* translated separately
*******************************************************************************/
void CTransforms::DoTranslate()
{
// Make sure we're operating on the path user-to-surface matrix
vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
// Load Identity matrix. This clears all previous transformations
vgLoadIdentity();
// To be independent of screen resolution, we need to scale the
// coordinates so everything in the range [0, 1] will be visible
vgScale((float) PVRShellGet(prefWidth), (float) PVRShellGet(prefHeight));
// Unlike OpenGL, OpenVG does not maintain a matrix stack. So instead of
// pushing the current matrix to the stack, we have to store it ourselves
float afUnitMatrix[3 * 3];
vgGetMatrix(afUnitMatrix);
// turn time(ms) into a clipped periodic triangle function
int i32Zigzag1 = m_ui32AbsTime % 2000;
if(i32Zigzag1 > 1000)
i32Zigzag1 = 2000 - i32Zigzag1;
i32Zigzag1 = PVRT_MAX(250, PVRT_MIN(750, i32Zigzag1)) - 500;
// and again, now with shifted phase
int i32Zigzag2 = (m_ui32AbsTime + 500) % 2000;
if(i32Zigzag2 > 1000)
i32Zigzag2 = 2000 - i32Zigzag2;
i32Zigzag2 = PVRT_MAX(250, PVRT_MIN(750, i32Zigzag2)) - 250;
// translation for first path
vgTranslate(-0.001f * i32Zigzag1, -0.001f * i32Zigzag2);
// draw first path
vgDrawPath(m_avgPaths[0], VG_STROKE_PATH | VG_FILL_PATH);
// restore the unit matrix ([0, 1] visible)
vgLoadMatrix(afUnitMatrix);
// translation for second path
vgTranslate(0.001f * i32Zigzag1, 0.001f * i32Zigzag2);
// draw second path
vgDrawPath(m_avgPaths[1], VG_STROKE_PATH | VG_FILL_PATH);
}
/*******************************************************************************
* 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;
}
void PainterOpenVG::drawLine(const IntPoint& from, const IntPoint& to)
{
ASSERT(m_state);
if (m_state->strokeDisabled())
return;
m_surface->makeCurrent();
VGPath path = vgCreatePath(
VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F,
1.0 /* scale */, 0.0 /* bias */,
2 /* expected number of segments */,
4 /* expected number of total coordinates */,
VG_PATH_CAPABILITY_APPEND_TO);
ASSERT_VG_NO_ERROR();
VGUErrorCode errorCode;
// Try to align lines to pixels, centering them between pixels for odd thickness values.
if (fmod(m_state->strokeThickness + 0.5, 2.0) < 1.0)
errorCode = vguLine(path, from.x(), from.y(), to.x(), to.y());
else if ((to.y() - from.y()) > (to.x() - from.x())) // more vertical than horizontal
errorCode = vguLine(path, from.x() + 0.5, from.y(), to.x() + 0.5, to.y());
else
errorCode = vguLine(path, from.x(), from.y() + 0.5, to.x(), to.y() + 0.5);
if (errorCode == VGU_NO_ERROR) {
vgDrawPath(path, VG_STROKE_PATH);
ASSERT_VG_NO_ERROR();
}
vgDestroyPath(path);
ASSERT_VG_NO_ERROR();
}
void render() {
vgSetPaint(paint_, VG_FILL_PATH);
assert(!vgGetError());
vgDrawPath(path_, VG_FILL_PATH);
assert(!vgGetError());
}
int FreeFormDrawing::draw ( )
{
Control::draw();
list<vector<VGuint>>::iterator SCiter = m_stroke_color.begin();
list<vector<VGufloat>>::iterator SWiter = m_stroke_widths.begin();
list<vector<VGubyte>>::iterator Cmditer = m_commands.begin();
list<vector<VGufloat>>::iterator Coorditer = m_coords.begin();
for ( ; Coorditer!=m_coords.end(); )
{
int numCmds = Cmditer.size();
int numCoords = Coorditer.size();
VGPath path = vgCreatePath(VG_PATH_FORMAT_STANDARD,
VG_PATH_DATATYPE_F,
1.0f, 0.0f, // scale,bias
numCmds, numCoords,
VG_PATH_CAPABILITY_ALL);
StrokeWidth ( *SWiter );
Stroke_l ( 0xFFFF00FF );
vgAppendPathData(path, numCmds, commands, Coorditer->data() );
vgDrawPath (path, VG_STROKE_PATH );
SCiter++; SWiter++;
Cmditer++; Coorditer++;
}
}
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 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);
}
void PainterOpenVG::drawEllipse(const IntRect& rect, VGbitfield specifiedPaintModes)
{
ASSERT(m_state);
VGbitfield paintModes = 0;
if (!m_state->strokeDisabled())
paintModes |= VG_STROKE_PATH;
if (!m_state->fillDisabled())
paintModes |= VG_FILL_PATH;
paintModes &= specifiedPaintModes;
if (!paintModes)
return;
m_surface->makeCurrent();
VGPath path = vgCreatePath(
VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F,
1.0 /* scale */, 0.0 /* bias */,
4 /* expected number of segments */,
12 /* expected number of total coordinates */,
VG_PATH_CAPABILITY_APPEND_TO);
ASSERT_VG_NO_ERROR();
if (vguEllipse(path, rect.x() + rect.width() / 2.0, rect.y() + rect.height() / 2.0, rect.width(), rect.height()) == VGU_NO_ERROR) {
vgDrawPath(path, paintModes);
ASSERT_VG_NO_ERROR();
}
vgDestroyPath(path);
ASSERT_VG_NO_ERROR();
}
// Text renders a string of text at a specified location, size, using the specified font glyphs
// derived from http://web.archive.org/web/20070808195131/http://developer.hybrid.fi/font2openvg/renderFont.cpp.txt
void Text(VGfloat x, VGfloat y, const char *s, Fontinfo f, int pointsize) {
VGfloat size = (VGfloat) pointsize, xx = x, mm[9];
vgGetMatrix(mm);
int character;
unsigned char *ss = (unsigned char *)s;
while ((ss = next_utf8_char(ss, &character)) != NULL) {
int glyph = f.CharacterMap[character];
if (character >= MAXFONTPATH-1) {
continue;
}
if (glyph == -1) {
continue; //glyph is undefined
}
VGfloat mat[9] = {
size, 0.0f, 0.0f,
0.0f, size, 0.0f,
xx, y, 1.0f
};
vgLoadMatrix(mm);
vgMultMatrix(mat);
vgDrawPath(f.Glyphs[glyph], VG_FILL_PATH);
xx += size * f.GlyphAdvances[glyph] / 65536.0f;
}
vgLoadMatrix(mm);
}
//Display functions
void display(float interval)
{
int i;
const VGfloat *style;
VGfloat clearColor[] = {1,1,1,1};
if (animate) {
ang += interval * 360 * 0.1f;
if (ang > 360) ang -= 360;
}
vgSetfv(VG_CLEAR_COLOR, 4, clearColor);
vgClear(0,0,testWidth(),testHeight());
vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
vgLoadIdentity();
vgTranslate(testWidth()/2 + tx,testHeight()/2 + ty);
vgScale(sx, sy);
vgRotate(ang);
for (i=0; i<pathCount; ++i) {
style = styleArrays[i];
vgSetParameterfv(tigerStroke, VG_PAINT_COLOR, 4, &style[0]);
vgSetParameterfv(tigerFill, VG_PAINT_COLOR, 4, &style[4]);
vgSetf(VG_STROKE_LINE_WIDTH, style[8]);
vgDrawPath(tigerPaths[i], (VGint)style[9]); // Bingo!!, Draw it!!
}
vgFlush();
}
static void
draw(void)
{
vgClear(0, 0, window_width(), window_height());
vgDrawPath(path, VG_FILL_PATH);
vgFlush();
}
// poly makes either a polygon or polyline
void poly(VGfloat * x, VGfloat * y, VGint n, VGbitfield flag) {
VGfloat points[n * 2];
VGPath path = newpath();
interleave(x, y, n, points);
vguPolygon(path, points, n, VG_FALSE);
vgDrawPath(path, flag);
vgDestroyPath(path);
}
static void
draw(void)
{
vgClear(0, 0, window_width(), window_height());
vgLoadIdentity();
vgTranslate(50, 21);
vgDrawPath(path, VG_FILL_PATH);
vgFlush();
}
/*******************************************************************************
* Function Name : DoRotateCentered
* Description : Demonstrate the effect of rotating around the centre of a
* shape. Each path is transformed separately.
*******************************************************************************/
void CTransforms::DoRotateCentered()
{
// Make sure we're operating on the path user-to-surface matrix
vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
// Load Identity matrix. This clears all previous transformations
vgLoadIdentity();
// To be independent of screen resolution, we need to scale the
// coordinates so everything in the range [0, 1] will be visible
vgScale((float)PVRShellGet(prefWidth), (float)PVRShellGet(prefHeight));
// Unlike OpenGL, OpenVG does not maintain a matrix stack. So instead of
// pushing the current matrix to the stack, we have to store it ourselves
float afUnitMatrix[3*3];
vgGetMatrix(afUnitMatrix);
float fRotationAngle = m_ui32AbsTime * 0.03f;
// Scaling a shape from its center is identical to moving it to the
// origin, scaling it there, and moving it back where it was.
//
// IMPORTANT:
// Since OpenVG right-multiplies matrices, you conceptually need to
// call the transformation functions in backwards order.
vgTranslate(0.5f, 0.75f);
vgRotate(fRotationAngle);
vgTranslate(-0.5f, -0.75f);
// draw first path
vgDrawPath(m_avgPaths[0], VG_STROKE_PATH | VG_FILL_PATH);
// restore the unit matrix ([0, 1] visible)
vgLoadMatrix(afUnitMatrix);
// transformation for second path
vgTranslate(0.5f, 0.25f);
vgRotate(-fRotationAngle);
vgTranslate(-0.5f, -0.25f);
// draw second path
vgDrawPath(m_avgPaths[1], VG_STROKE_PATH | VG_FILL_PATH);
}
// C function:: void vgDrawPath(VGPath path, VGbitfield paintModes);
JNIEXPORT jint JNICALL
Java_com_example_startvg_VG11_vgDrawPath(
JNIEnv * env, jobject obj,
jlong path, jint paintModes ){
vgDrawPath(
(VGPath) path,
(VGbitfield) paintModes
);
}
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);
}
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;
}
void NwSvgFigure::draw()
{
setAttribute();
VGbitfield paintModes = 0;
if( STROKE_NONE != m_svgAttribute.nStrokeType )
{
paintModes |= VG_STROKE_PATH;
}
if( FILL_NONE != m_svgAttribute.nFillType )
{
paintModes |= VG_FILL_PATH;
}
vgDrawPath(m_path, paintModes);
//vgFinish();
vgClearPath(m_path, VG_PATH_CAPABILITY_ALL);
}
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;
}
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
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);
}
void display(float interval)
{
VGfloat cc[] = {0,0,0,1};
angle += interval * 0.4 * PI;
if (angle > 2*PI) angle -= 2*PI;
amount = (sin(angle) + 1) * 0.5f;
createMorph();
vgSetfv(VG_CLEAR_COLOR, 4, cc);
vgClear(0,0,testWidth(),testHeight());
vgLoadIdentity();
vgTranslate(testWidth()/2, testHeight()/2);
vgScale(1.5, 1.5);
vgDrawPath(iMorph, VG_FILL_PATH);
}
void PainterOpenVG::drawPolygon(size_t numPoints, const FloatPoint* points, VGbitfield specifiedPaintModes)
{
ASSERT(m_state);
VGbitfield paintModes = 0;
if (!m_state->strokeDisabled())
paintModes |= VG_STROKE_PATH;
if (!m_state->fillDisabled())
paintModes |= VG_FILL_PATH;
paintModes &= specifiedPaintModes;
if (!paintModes)
return;
m_surface->makeCurrent();
// Path segments: all points + "close path".
const VGint numSegments = numPoints + 1;
const VGint numCoordinates = numPoints * 2;
VGPath path = vgCreatePath(
VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F,
1.0 /* scale */, 0.0 /* bias */,
numSegments /* expected number of segments */,
numCoordinates /* expected number of total coordinates */,
VG_PATH_CAPABILITY_APPEND_TO);
ASSERT_VG_NO_ERROR();
Vector<VGfloat> vgPoints(numCoordinates);
for (int i = 0; i < numPoints; ++i) {
vgPoints[i*2] = points[i].x();
vgPoints[i*2 + 1] = points[i].y();
}
if (vguPolygon(path, vgPoints.data(), numPoints, VG_TRUE /* closed */) == VGU_NO_ERROR) {
vgDrawPath(path, paintModes);
ASSERT_VG_NO_ERROR();
}
vgDestroyPath(path);
ASSERT_VG_NO_ERROR();
}
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 );
}
void display(float interval)
{
int x,y,p;
VGfloat white[] = {1,1,1,1};
vgSetfv(VG_CLEAR_COLOR, 4, white);
vgClear(0, 0, testWidth(), testHeight());
vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
for (y=0, p=0; y<3; ++y) {
for (x=0; x<3; ++x, ++p) {
if (p > NUM_PRIMITIVES) break;
vgLoadIdentity();
vgTranslate(100 + x*150, 100 + y*150);
vgDrawPath(primitives[p], VG_STROKE_PATH);
}
}
}