vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_BETTER);
vgSeti(VG_IMAGE_QUALITY, VG_IMAGE_QUALITY_BETTER);
vgSeti(VG_SCISSORING, VG_FALSE);
col[0] = 0.0f; col[1] = 0.0f; col[2] = 0.0f; col[3] = 0.0f;
vgSetfv(VG_CLEAR_COLOR, 4, col);
vgClear(0, 0, 256, 256);

// create some paths
path0 = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 0, 0, VG_PATH_CAPABILITY_ALL);
pathSegs[0] = VG_MOVE_TO_ABS;
pathData[0] = -20.0f; pathData[1] = 20.0f;
pathSegs[1] = VG_CUBIC_TO_ABS;
pathData[2] = -200.0f; pathData[3] = 170.0f; pathData[4] = -200.0f; pathData[5] = -170.0f; pathData[6] = -20.0f; pathData[7] = -20.0f;
pathSegs[2] = VG_CUBIC_TO_ABS;
pathData[8] = -170.0f; pathData[9] = -200.0f; pathData[10] = 170.0f; pathData[11] = -200.0f; pathData[12] = 20.0f; pathData[13] = -20.0f;
pathSegs[3] = VG_CUBIC_TO_ABS;
pathData[14] = 200.0f; pathData[15] = -170.0f; pathData[16] = 200.0f; pathData[17] = 170.0f; pathData[18] = 20.0f; pathData[19] = 20.0f;
pathSegs[4] = VG_CUBIC_TO_ABS;
pathData[20] = 170.0f; pathData[21] = 200.0f; pathData[22] = -170.0f; pathData[23] = 200.0f; pathData[24] = -20.0f; pathData[25] = 20.0f;
pathSegs[5] = VG_CLOSE_PATH;
vgAppendPathData(path0, 6, pathSegs, pathData);

path1 = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 0, 0, VG_PATH_CAPABILITY_ALL);
pathSegs[0] = VG_MOVE_TO_ABS;
pathData[0] = -100.0f; pathData[1] = -100.0f;
pathSegs[1] = VG_LINE_TO_ABS;
pathData[2] = -100.0f; pathData[3] = 100.0f;
pathSegs[2] = VG_LINE_TO_ABS;
pathData[4] = 100.0f; pathData[5] = 100.0f;
pathSegs[3] = VG_MOVE_TO_ABS;
pathData[6] = -80.0f; pathData[7] = -100.0f;
pathSegs[4] = VG_LINE_TO_ABS;
pathData[8] = 100.0f; pathData[9] = -100.0f;
pathSegs[5] = VG_LINE_TO_ABS;
pathData[10] = 100.0f; pathData[11] = 80.0f;
vgAppendPathData(path1, 6, pathSegs, pathData);

path2 = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 0, 0, VG_PATH_CAPABILITY_ALL);
pathSegs[0] = VG_MOVE_TO_ABS;
pathData[0] = -100.0f; pathData[1] = -100.0f;
pathSegs[1] = VG_LINE_TO_ABS;
pathData[2] = -100.0f; pathData[3] = 100.0f;
pathSegs[2] = VG_LINE_TO_ABS;
pathData[4] = 100.0f; pathData[5] = 100.0f;
pathSegs[3] = VG_LINE_TO_ABS;
pathData[6] = -100.0f; pathData[7] = -100.0f;
pathSegs[4] = VG_CLOSE_PATH;
pathSegs[5] = VG_MOVE_TO_ABS;
pathData[8] = -60.0f; pathData[9] = -100.0f;
pathSegs[6] = VG_LINE_TO_ABS;
pathData[10] = 100.0f; pathData[11] = -100.0f;
pathSegs[7] = VG_LINE_TO_ABS;
pathData[12] = 100.0f; pathData[13] = 60.0f;
pathSegs[8] = VG_CLOSE_PATH;
pathSegs[9] = VG_MOVE_TO_ABS;
pathData[14] = -140.0f; pathData[15] = -140.0f;
pathSegs[10] = VG_LINE_TO_ABS;
pathData[16] = -140.0f; pathData[17] = 140.0f;
pathSegs[11] = VG_LINE_TO_ABS;
pathData[18] = 140.0f; pathData[19] = 140.0f;
pathSegs[12] = VG_LINE_TO_ABS;
pathData[20] = 140.0f; pathData[21] = -140.0f;
vgAppendPathData(path2, 13, pathSegs, pathData);

path3 = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 0, 0, VG_PATH_CAPABILITY_ALL);
pathSegs[0] = VG_MOVE_TO_ABS;
pathData[0] = -120.0f; pathData[1] = -120.0f;
pathSegs[1] = VG_LINE_TO_ABS;
pathData[2] = -120.0f; pathData[3] = 120.0f;
pathSegs[2] = VG_LINE_TO_ABS;
pathData[4] = 120.0f; pathData[5] = 120.0f;
pathSegs[3] = VG_LINE_TO_ABS;
pathData[6] = 120.0f; pathData[7] = -120.0f;
pathSegs[4] = VG_CLOSE_PATH;
pathSegs[5] = VG_MOVE_TO_ABS;
pathData[8] = -80.0f; pathData[9] = 0.0f;
pathSegs[6] = VG_LINE_TO_ABS;
pathData[10] = 80.0f; pathData[11] = 0.0f;
pathSegs[7] = VG_LINE_TO_ABS;
pathData[12] = 50.0f; pathData[13] = -30.0f;
vgAppendPathData(path3, 8, pathSegs, pathData);

path4 = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 0, 0, VG_PATH_CAPABILITY_ALL);
pathSegs[0] = VG_MOVE_TO_ABS;
pathData[0] = -0.00005f;
pathData[1] = -0.00005f;
pathSegs[1] = VG_CUBIC_TO_ABS;
pathData[2] = +0.0001f;
pathData[3] = +0.0001f;
pathData[4] = -0.0001f;
pathData[5] = +0.0001f;
pathData[6] = +0.00005f;
pathData[7] = -0.00005f;
vgAppendPathData(path4, 2, pathSegs, pathData);

// NB: path5 should be the result from a path4 flattening. Code has been taken from Reference Implementation
path5 = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 0, 0, VG_PATH_CAPABILITY_ALL);
j = 0;
for (i = 0; i < 256; ++i) {
	float p0x = -0.00005f;
	float p0y = -0.00005f;
	float p1x = +0.0001f;
	float p1y = +0.0001f;
	float p2x = -0.0001f;
	float p2y = +0.0001f;
	float p3x = +0.00005f;
	float p3y = -0.00005f;
	float t = (float)i / 255.0f;
	float u = 1.0f - t;
	pathData[j++] = u * u * u * p0x + 3.0f * t * u * u * p1x + 3.0f * t * t * u * p2x + t * t * t * p3x;
	pathData[j++] = u * u * u * p0y + 3.0f * t * u * u * p1y + 3.0f * t * t * u * p2y + t * t * t * p3y;
}
vguPolygon(path5, pathData, j / 2, VG_FALSE);

// create and set a paint for fill
strokePaint = vgCreatePaint();
vgSetParameteri(strokePaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
col[0] = 0.0f; col[1] = 0.0f; col[2] = 0.0f; col[3] = 0.75f;
vgSetParameterfv(strokePaint, VG_PAINT_COLOR, 4, col);	
vgSetPaint(strokePaint, VG_STROKE_PATH);
vgSeti(VG_SCISSORING, VG_FALSE);
// set clear color and blend mode
col[0] = 1.0f; col[1] = 1.0f; col[2] = 1.0f; col[3] = 1.0f;
vgSetfv(VG_CLEAR_COLOR, 4, col);
vgSeti(VG_BLEND_MODE, VG_BLEND_SRC_OVER);
vgSeti(VG_MASKING, VG_FALSE);

// set model view matrix
vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
vgLoadIdentity();
vgTranslate(128.0f, 128.0f);
vgScale(0.73f, 0.73f);


// set a dash pattern and a phase
dashPattern[0] = 43.0f; dashPattern[1] = 10.0f; dashPattern[2] = 20.0f; dashPattern[3] = 15.0f;
vgSetfv(VG_STROKE_DASH_PATTERN, 4, dashPattern);
vgSetf(VG_STROKE_DASH_PHASE, 0.0f);
vgSetf(VG_STROKE_LINE_WIDTH, 20.0f);
vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_BEVEL);
vgClear(0, 0, 256, 256);
vgDrawPath(path2, VG_STROKE_PATH);
saveDrawingSurface(f, "draw_stroke_00.png", "Test dashed stroke with butt caps and bevel joins.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);

dashPattern[0] = 11.0f; dashPattern[1] = 40.0f; dashPattern[2] = 20.0f; dashPattern[3] = 40.0f;
vgSetfv(VG_STROKE_DASH_PATTERN, 4, dashPattern);
vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_SQUARE);
vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_MITER);
vgSetf(VG_STROKE_MITER_LIMIT, 4.0f);
vgClear(0, 0, 256, 256);
vgDrawPath(path2, VG_STROKE_PATH);
saveDrawingSurface(f, "draw_stroke_01.png", "Test dashed stroke with square caps and miter joins.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);

vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_ROUND);
vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND);
vgClear(0, 0, 256, 256);
vgDrawPath(path2, VG_STROKE_PATH);
saveDrawingSurface(f, "draw_stroke_02.png", "Test dashed stroke with round caps and round joins.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);

vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_MITER);
vgSetf(VG_STROKE_MITER_LIMIT, 16.0f);

dashPattern[0] = 63.0f; dashPattern[1] = 10.0f; dashPattern[2] = 20.0f; dashPattern[3] = 15.0f;
vgSetfv(VG_STROKE_DASH_PATTERN, 4, dashPattern);
vgSetf(VG_STROKE_DASH_PHASE, -1263.0f);
vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
vgClear(0, 0, 256, 256);
vgDrawPath(path3, VG_STROKE_PATH);
saveDrawingSurface(f, "draw_stroke_03.png", "Test dashed stroke changing dash phase.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);

dashPattern[0] = 0.0f; dashPattern[1] = 30.0f; dashPattern[2] = 60.0f; dashPattern[3] = 35.0f;
dashPattern[4] = -30.0f; dashPattern[5] = 40.0f;
vgSetfv(VG_STROKE_DASH_PATTERN, 6, dashPattern);
vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_ROUND);
vgClear(0, 0, 256, 256);
vgDrawPath(path3, VG_STROKE_PATH);
saveDrawingSurface(f, "draw_stroke_04.png", "Test negative dashing.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);

dashPattern[0] = 70.0f; dashPattern[1] = 35.0f; dashPattern[2] = 0.0f; dashPattern[3] = 30.0f;
dashPattern[4] = 0.0f; dashPattern[5] = 40.0f;
vgSetfv(VG_STROKE_DASH_PATTERN, 6, dashPattern);
vgClear(0, 0, 256, 256);
vgDrawPath(path0, VG_STROKE_PATH);
saveDrawingSurface(f, "draw_stroke_05.png", "Test dashing on a smooth shape.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);

dashPattern[0] = 70.0f; dashPattern[1] = 50.0f; dashPattern[2] = 860.0f; dashPattern[3] = 30.0f;
vgSetfv(VG_STROKE_DASH_PATTERN, 4, dashPattern);
vgSetf(VG_STROKE_DASH_PHASE, 0.0f);
vgClear(0, 0, 256, 256);
vgDrawPath(path3, VG_STROKE_PATH);
saveDrawingSurface(f, "draw_stroke_06.png", "Test dashing overflow.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);

dashPattern[0] = 50.0f; dashPattern[1] = 50.0f; dashPattern[2] = 90.0f; dashPattern[3] = 50.0f;
vgSetfv(VG_STROKE_DASH_PATTERN, 4, dashPattern);
vgSetf(VG_STROKE_DASH_PHASE, -25.0f);
vgClear(0, 0, 256, 256);
vgDrawPath(path3, VG_STROKE_PATH);
saveDrawingSurface(f, "draw_stroke_07.png", "Test dashing join ends, first case.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);

dashPattern[0] = 50.0f; dashPattern[1] = 50.0f; dashPattern[2] = 110.0f; dashPattern[3] = 50.0f;
vgSetfv(VG_STROKE_DASH_PATTERN, 4, dashPattern);
vgSetf(VG_STROKE_DASH_PHASE, -25.0f);
vgClear(0, 0, 256, 256);
vgDrawPath(path3, VG_STROKE_PATH);
saveDrawingSurface(f, "draw_stroke_08.png", "Test dashing join ends, second case.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);

dashPattern[0] = 50.0f; dashPattern[1] = 50.0f; dashPattern[2] = 90.0f; dashPattern[3] = 50.0f;
vgSetfv(VG_STROKE_DASH_PATTERN, 4, dashPattern);
vgSetf(VG_STROKE_DASH_PHASE, 0.0f);
vgClear(0, 0, 256, 256);
vgDrawPath(path3, VG_STROKE_PATH);
saveDrawingSurface(f, "draw_stroke_09.png", "Test dashing join ends, third case.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);

dashPattern[0] = 50.0f; dashPattern[1] = 50.0f; dashPattern[2] = 110.0f; dashPattern[3] = 50.0f;
vgSetfv(VG_STROKE_DASH_PATTERN, 4, dashPattern);
vgSetf(VG_STROKE_DASH_PHASE, 0.0f);
vgClear(0, 0, 256, 256);
vgDrawPath(path3, VG_STROKE_PATH);
saveDrawingSurface(f, "draw_stroke_10.png", "Test dashing join ends, fourth case.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);

vgSetfv(VG_STROKE_DASH_PATTERN, 0, NULL);
vgClear(0, 0, 256, 256);
vgDrawPath(path0, VG_STROKE_PATH);
saveDrawingSurface(f, "draw_stroke_11.png", "Test solid stroke on a smooth shape.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);

vgClear(0, 0, 256, 256);
vgSetf(VG_STROKE_LINE_WIDTH, 0.5f);
vgDrawPath(path0, VG_STROKE_PATH);
saveDrawingSurface(f, "draw_stroke_12.png", "Test solid thin stroke on a smooth shape.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);

vgClear(0, 0, 256, 256);
vgSetf(VG_STROKE_LINE_WIDTH, 20.0f);
vgDrawPath(path2, VG_STROKE_PATH);
saveDrawingSurface(f, "draw_stroke_13.png", "Test solid stroke on a sharp shape.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);

vgSetfv(VG_STROKE_DASH_PATTERN, 0, NULL);
vgSetf(VG_STROKE_LINE_WIDTH, 126.0f);
vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND);
vgClear(0, 0, 256, 256);
vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);		
vgLoadIdentity();
vgTranslate(64.0f, 128.0f);
vgDrawPath(path4, VG_STROKE_PATH);
vgLoadIdentity();
vgTranslate(192.0f, 128.0f);
vgDrawPath(path5, VG_STROKE_PATH);
saveDrawingSurface(f, "draw_stroke_14.png", "Test solid stroke on a degenerative shape.\nNB: both shapes should look really close.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);


vgClear(0, 0, 256, 256);
vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
vgSetf(VG_STROKE_LINE_WIDTH, 56.0f);
vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_BEVEL);
pathSegs[0] = VG_MOVE_TO_ABS;
pathSegs[1] = VG_LINE_TO_ABS;
pathSegs[2] = VG_LINE_TO_ABS;
pathData[0] = -4.0f;
pathData[1] = 0.0f;
pathData[2] = 0.0f;
pathData[3] = 0.0f;
for (i = 0; i < 4; i++) {
	for (j = 0; j < 4; j++) {
		vgClearPath(path0, VG_PATH_CAPABILITY_ALL);
		pathData[4] = 4.0f * (VGfloat)cos((i * 4 + j) / 16.0f * 6.2831f);
		pathData[5] = 4.0f * (VGfloat)sin((i * 4 + j) / 16.0f * 6.2831f);
		vgAppendPathData(path0, 3, pathSegs, pathData);
		vgLoadIdentity();
		vgTranslate(j * 64.0f + 32.0f, i * 64.0f + 32.0f);
		vgDrawPath(path0, VG_STROKE_PATH);
	}
}
saveDrawingSurface(f, "draw_stroke_15.png", "Test 'real' joins between two curve segments, different dirctions (large stroke width).", 0, 0, 256, 256);
eglSwapBuffers(display, surface);


vgClear(0, 0, 256, 256);
vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
vgSetf(VG_STROKE_LINE_WIDTH, 4.0f);
vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_BEVEL);
pathSegs[0] = VG_MOVE_TO_ABS;
pathSegs[1] = VG_LINE_TO_ABS;
pathSegs[2] = VG_LINE_TO_ABS;
pathData[0] = -28.0f;
pathData[1] = 0.0f;
pathData[2] = 0.0f;
pathData[3] = 0.0f;
for (i = 0; i < 4; i++) {
	for (j = 0; j < 4; j++) {
		vgClearPath(path0, VG_PATH_CAPABILITY_ALL);
		pathData[4] = 28.0f * (VGfloat)cos((i * 4 + j) / 16.0f * 6.2831f);
		pathData[5] = 28.0f * (VGfloat)sin((i * 4 + j) / 16.0f * 6.2831f);
		vgAppendPathData(path0, 3, pathSegs, pathData);
		vgLoadIdentity();
		vgTranslate(j * 64.0f + 32.0f, i * 64.0f + 32.0f);
		vgDrawPath(path0, VG_STROKE_PATH);
	}
}
saveDrawingSurface(f, "draw_stroke_16.png", "Test 'real' joins between two curve segments, different dirctions (small stroke width).", 0, 0, 256, 256);
eglSwapBuffers(display, surface);


vgClear(0, 0, 256, 256);
vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
vgSetf(VG_STROKE_LINE_WIDTH, 40.0f);
vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_BEVEL);
pathSegs[0] = VG_MOVE_TO_ABS;
pathSegs[1] = VG_LINE_TO_ABS;
pathSegs[2] = VG_LINE_TO_ABS;
pathData[0] = -20.0f;
pathData[1] = 0.0f;
pathData[2] = 0.0f;
pathData[3] = 0.0f;
for (i = 0; i < 4; i++) {
	for (j = 0; j < 4; j++) {
		vgClearPath(path0, VG_PATH_CAPABILITY_ALL);
		pathData[4] = 20.0f * (VGfloat)cos((i * 4 + j) / 16.0f * 6.2831f);
		pathData[5] = 20.0f * (VGfloat)sin((i * 4 + j) / 16.0f * 6.2831f);
		vgAppendPathData(path0, 3, pathSegs, pathData);
		vgLoadIdentity();
		vgTranslate(j * 64.0f + 32.0f, i * 64.0f + 32.0f);
		vgDrawPath(path0, VG_STROKE_PATH);
	}
}
saveDrawingSurface(f, "draw_stroke_17.png", "Test 'real' joins between two curve segments, different dirctions (medium stroke width).", 0, 0, 256, 256);
eglSwapBuffers(display, surface);


vgClear(0, 0, 256, 256);
vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
vgSetf(VG_STROKE_LINE_WIDTH, 56.0f);
vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_BEVEL);
for (i = 0; i < 4; i++) {
	for (j = 0; j < 4; j++) {
		vgClearPath(path0, VG_PATH_CAPABILITY_ALL);
		vguArc(path0, 0.0f, 0.0f, 2.0f, 2.0f, 0.0f, (i * 4 + j) / 16.0f * 450.0f, VGU_ARC_OPEN);
		vgLoadIdentity();
		vgTranslate(j * 64.0f + 32.0f, i * 64.0f + 32.0f);
		vgDrawPath(path0, VG_STROKE_PATH);
	}
}
saveDrawingSurface(f, "draw_stroke_18.png", "Test correct smooth interpolation on the internal stroking side (large stroke width).", 0, 0, 256, 256);
eglSwapBuffers(display, surface);


vgClear(0, 0, 256, 256);
vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
vgSetf(VG_STROKE_LINE_WIDTH, 36.0f);
vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_BEVEL);
for (i = 0; i < 4; i++) {
	for (j = 0; j < 4; j++) {
		vgClearPath(path0, VG_PATH_CAPABILITY_ALL);
		vguArc(path0, 0.0f, 0.0f, 20.0f, 20.0f, 0.0f, (i * 4 + j) / 16.0f * 450.0f, VGU_ARC_OPEN);
		vgLoadIdentity();
		vgTranslate(j * 64.0f + 32.0f, i * 64.0f + 32.0f);
		vgDrawPath(path0, VG_STROKE_PATH);
	}
}
saveDrawingSurface(f, "draw_stroke_19.png", "Test correct smooth interpolation on the internal stroking side (medium stroke width).", 0, 0, 256, 256);
eglSwapBuffers(display, surface);


vgClear(0, 0, 256, 256);
vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
vgSetf(VG_STROKE_LINE_WIDTH, 16.0f);
vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_BEVEL);
for (i = 0; i < 4; i++) {
	for (j = 0; j < 4; j++) {
		vgClearPath(path0, VG_PATH_CAPABILITY_ALL);
		vguArc(path0, 0.0f, 0.0f, 40.0f, 40.0f, 0.0f, (i * 4 + j) / 16.0f * 450.0f, VGU_ARC_OPEN);
		vgLoadIdentity();
		vgTranslate(j * 64.0f + 32.0f, i * 64.0f + 32.0f);
		vgDrawPath(path0, VG_STROKE_PATH);
	}
}
saveDrawingSurface(f, "draw_stroke_20.png", "Test correct smooth interpolation on the internal stroking side (small stroke width).", 0, 0, 256, 256);
eglSwapBuffers(display, surface);


vgClearPath(path0, VG_PATH_CAPABILITY_ALL);
vgClear(0, 0, 256, 256);
vgSetf(VG_STROKE_LINE_WIDTH, 200.0f);
vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND);
vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
vgLoadIdentity();
j = 0;
k = 4;
for (i = 0; i < k; ++i) {
	pathData[j++] = 20.0f * (VGfloat)cos((i / (VGfloat)k) * 1.7) + 128.0f;
	pathData[j++] = 20.0f * (VGfloat)sin((i / (VGfloat)k) * 1.7) + 128.0f;
}
vguPolygon(path0, pathData, k, VG_FALSE);
vgDrawPath(path0, VG_STROKE_PATH);
saveDrawingSurface(f, "draw_stroke_21.png", "Test 'real' joins between curve segments (case 1).", 0, 0, 256, 256);
eglSwapBuffers(display, surface);


vgClearPath(path0, VG_PATH_CAPABILITY_ALL);
vgClear(0, 0, 256, 256);
vgSetf(VG_STROKE_LINE_WIDTH, 300.0f);
vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND);
vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
vgLoadIdentity();
j = 0;
k = 8;
for (i = 0; i < k; ++i) {
	pathData[j++] = 100.0f * (VGfloat)cos((i / (VGfloat)k) * 3.5) + 128.0f;
	pathData[j++] = 100.0f * (VGfloat)sin((i / (VGfloat)k) * 3.5) + 128.0f;
}
vguPolygon(path0, pathData, k, VG_FALSE);
vgDrawPath(path0, VG_STROKE_PATH);
saveDrawingSurface(f, "draw_stroke_22.png", "Test 'real' joins between curve segments (case 2).", 0, 0, 256, 256);
eglSwapBuffers(display, surface);


vgClearPath(path0, VG_PATH_CAPABILITY_ALL);
vgClear(0, 0, 256, 256);
vgSetf(VG_STROKE_LINE_WIDTH, 70.0f);
vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND);
vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
vgLoadIdentity();
j = 0;
k = 5;
for (i = 0; i < k; ++i) {
	pathData[j++] = 40.0f * (VGfloat)cos((i / (VGfloat)k) * 3.5) + 128.0f;
	pathData[j++] = 40.0f * (VGfloat)sin((i / (VGfloat)k) * 3.5) + 128.0f;
}
vguPolygon(path0, pathData, k, VG_FALSE);
vgDrawPath(path0, VG_STROKE_PATH);
saveDrawingSurface(f, "draw_stroke_23.png", "Test 'real' joins between curve segments (case 3).", 0, 0, 256, 256);
eglSwapBuffers(display, surface);


vgClearPath(path0, VG_PATH_CAPABILITY_ALL);
vgClear(0, 0, 256, 256);
vgSetf(VG_STROKE_LINE_WIDTH, 230.0f);
vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND);
vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
vgLoadIdentity();
j = 0;
k = 256;
for (i = 0; i < k; ++i) {
	pathData[j++] = 0.01f * (VGfloat)cos((i / (VGfloat)k) * 20.0) + 128.0f;
	pathData[j++] = 0.01f * (VGfloat)sin((i / (VGfloat)k) * 20.0) + 128.0f;
}
vguPolygon(path0, pathData, k, VG_FALSE);
vgDrawPath(path0, VG_STROKE_PATH);
saveDrawingSurface(f, "draw_stroke_24.png", "Test 'real' joins between curve segments (case 4).", 0, 0, 256, 256);
eglSwapBuffers(display, surface);


vgClearPath(path0, VG_PATH_CAPABILITY_ALL);
vgClear(0, 0, 256, 256);
vgSetf(VG_STROKE_LINE_WIDTH, 56.0f);
vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_BUTT);
vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND);
pathSegs[0] = VG_MOVE_TO_ABS;
pathData[0] = -200.0f; pathData[1] = 30.0f;
pathSegs[1] = VG_QUAD_TO_ABS;
pathData[2] = -100.0f; pathData[3] = 200.0f; pathData[4] = 0.0f; pathData[5] = 30.0f;
pathSegs[2] = VG_QUAD_TO_ABS;
pathData[6] = 100.0f; pathData[7] = 100.0f; pathData[8] = 200.0f; pathData[9] = 30.0f;
pathSegs[3] = VG_MOVE_TO_ABS;
pathData[10] = 200.0f; pathData[11] = -30.0f;
pathSegs[4] = VG_QUAD_TO_ABS;
pathData[12] = 100.0f; pathData[13] = -200.0f; pathData[14] = 0.0f; pathData[15] = -30.0f;
pathSegs[5] = VG_QUAD_TO_ABS;
pathData[16] = -100.0f; pathData[17] = -100.0f; pathData[18] = -200.0f; pathData[19] = -30.0f;
vgAppendPathData(path0, 6, pathSegs, pathData);
vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
vgLoadIdentity();
vgTranslate(128.0f, 128.0f);
vgScale(0.5f, 0.75f);
vgDrawPath(path0, VG_STROKE_PATH);
saveDrawingSurface(f, "draw_stroke_25.png", "Test 'real' and smooth interpolated joins.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);


vgDestroyPath(path0);
vgDestroyPath(path1);
vgDestroyPath(path2);
vgDestroyPath(path3);
vgDestroyPath(path4);
vgDestroyPath(path5);
vgDestroyPaint(strokePaint);