vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_BETTER);
vgSeti(VG_IMAGE_QUALITY, VG_IMAGE_QUALITY_BETTER);
vgSeti(VG_BLEND_MODE, VG_BLEND_SRC);
// clear with a simple color
vgSeti(VG_SCISSORING, VG_FALSE);
vgSeti(VG_MASKING, VG_FALSE);
col[0] = 1.0f; col[1] = 1.0f; col[2] = 1.0f; col[3] = 1.0f;
vgSetfv(VG_CLEAR_COLOR, 4, col);
vgClear(0, 0, 256, 256);
vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
vgLoadIdentity();

// 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] = 40.0f; pathData[1] = 40.0f;
pathSegs[1] = VG_LINE_TO_ABS;
pathData[2] = 236.0f; pathData[3] = 170.0f;
pathSegs[2] = VG_LINE_TO_ABS;
pathData[4] = 20.0f; pathData[5] = 170.0f;
pathSegs[3] = VG_LINE_TO_ABS;
pathData[6] = 216.0f; pathData[7] = 40.0f;
pathSegs[4] = VG_LINE_TO_ABS;
pathData[8] = 128.0f; pathData[9] = 236.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] = 40.0f; pathData[1] = 40.0f;
pathSegs[1] = VG_LINE_TO_ABS;
pathData[2] = 216.0f; pathData[3] = 40.0f;
pathSegs[2] = VG_LINE_TO_ABS;
pathData[4] = 216.0f; pathData[5] = 216.0f;
pathSegs[3] = VG_LINE_TO_ABS;
pathData[6] = 40.0f; pathData[7] = 216.0f;
pathSegs[4] = VG_CLOSE_PATH;
pathSegs[5] = VG_MOVE_TO_ABS;
pathData[8] = 156.0f; pathData[9] = 156.0f;
pathSegs[6] = VG_LINE_TO_ABS;
pathData[10] = 100.0f; pathData[11] = 156.0f;
pathSegs[7] = VG_LINE_TO_ABS;
pathData[12] = 100.0f; pathData[13] = 100.0f;
pathSegs[8] = VG_LINE_TO_ABS;
pathData[14] = 156.0f; pathData[15] = 100.0f;
pathSegs[9] = VG_CLOSE_PATH;
vgAppendPathData(path1, 10, pathSegs, pathData);


// create and set a paint for fill
fillPaint = vgCreatePaint();
vgSetParameteri(fillPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
col[0] = 0.0f; col[1] = 0.0f; col[2] = 0.0f; col[3] = 1.0f;
vgSetParameterfv(fillPaint, VG_PAINT_COLOR, 4, col);
vgSetPaint(fillPaint, VG_FILL_PATH);

// test even-odd fill rule
vgSeti(VG_FILL_RULE, VG_EVEN_ODD);
vgDrawPath(path0, VG_FILL_PATH);
saveDrawingSurface(f, "draw_fillrule_evenodd_00.png", "Test EVEN-ODD fillrule #1.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);

vgClear(0, 0, 256, 256);
vgDrawPath(path1, VG_FILL_PATH);
saveDrawingSurface(f, "draw_fillrule_evenodd_01.png", "Test EVEN-ODD fillrule #2.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);

// test non-zero fill rule
vgClear(0, 0, 256, 256);
vgSeti(VG_FILL_RULE, VG_NON_ZERO);
vgDrawPath(path0, VG_FILL_PATH);
saveDrawingSurface(f, "draw_fillrule_nonzero_00.png", "Test NON-ZERO fillrule #1.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);

vgClear(0, 0, 256, 256);
vgDrawPath(path1, VG_FILL_PATH);
saveDrawingSurface(f, "draw_fillrule_nonzero_01.png", "Test NON-ZERO fillrule #2.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);

vgSeti(VG_FILL_RULE, VG_EVEN_ODD);
// random intersections
path2 = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 0, 0, VG_PATH_CAPABILITY_ALL);
j = 0;
srand(117);
for (i = 0; i < 512; ++i) {
	pathData[j++] = (rand() / (VGfloat)RAND_MAX) * 768.0f - 256.0f;
	pathData[j++] = (rand() / (VGfloat)RAND_MAX) * 768.0f - 256.0f;
}
vguPolygon(path2, pathData, j / 2, VG_TRUE);
// draw random intersections using different qualitites
vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_NONANTIALIASED);
vgClear(0, 0, 256, 256);
vgDrawPath(path2, VG_FILL_PATH);
saveDrawingSurface(f, "draw_random_intersections_noaa.png", "Test random intersections, non-antialiased quality.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);
vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_FASTER);
vgClear(0, 0, 256, 256);
vgDrawPath(path2, VG_FILL_PATH);
saveDrawingSurface(f, "draw_random_intersections_faster.png", "Test random intersections, faster quality.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);
vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_BETTER);
vgClear(0, 0, 256, 256);
vgDrawPath(path2, VG_FILL_PATH);
saveDrawingSurface(f, "draw_random_intersections_better.png", "Test random intersections, better quality.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);

// ordered intersections
path3 = 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 < 64; ++i) {
	pathData[j++] = (VGfloat)(i * 4);
	pathData[j++] = 0.0f;
	pathData[j++] = (VGfloat)(i * 4);
	pathData[j++] = 256.0f;
}
for (i = 0; i < 64; ++i) {
	pathData[j++] = 0.0f;
	pathData[j++] = (VGfloat)(256 - i * 4 - 4);
	pathData[j++] = 256.0f;
	pathData[j++] = (VGfloat)(256 - i * 4 - 4);
}
vguPolygon(path3, pathData, j / 2, VG_TRUE);
// draw ordered intersections using different qualitites
vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_NONANTIALIASED);
vgClear(0, 0, 256, 256);
vgDrawPath(path3, VG_FILL_PATH);
saveDrawingSurface(f, "draw_ordered_intersections_noaa.png", "Test ordered intersections, non-antialiased quality.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);
vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_FASTER);
vgClear(0, 0, 256, 256);
vgDrawPath(path3, VG_FILL_PATH);
saveDrawingSurface(f, "draw_ordered_intersections_faster.png", "Test ordered intersections, faster quality.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);
vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_BETTER);
vgClear(0, 0, 256, 256);
vgDrawPath(path3, VG_FILL_PATH);
saveDrawingSurface(f, "draw_ordered_intersections_better.png", "Test ordered intersections, better quality.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);

// test Siemens star
path4 = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 0, 0, VG_PATH_CAPABILITY_ALL);
j = 0;
k = 48;
for (i = 0; i < k * 2; i += 2) {
	pathData[j++] = 128.0f;
	pathData[j++] = 128.0f;
	pathData[j++] = (VGfloat)(127.0f * cos(6.2831853 * (double)i / (double)(k * 2))) + 128.0f;
	pathData[j++] = (VGfloat)(127.0f * sin(6.2831853 * (double)i / (double)(k * 2))) + 128.0f;
	pathData[j++] = (VGfloat)(127.0f * cos(6.2831853 * (double)(i + 1) / (double)(k * 2))) + 128.0f;
	pathData[j++] = (VGfloat)(127.0f * sin(6.2831853 * (double)(i + 1) / (double)(k * 2))) + 128.0f;
}
vguPolygon(path4, pathData, j / 2, VG_TRUE);
// draw Siemens star using different qualitites
vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_NONANTIALIASED);
vgClear(0, 0, 256, 256);
vgDrawPath(path4, VG_FILL_PATH);
saveDrawingSurface(f, "draw_siemens_star_noaa.png", "Test Siemens star, non-antialiased quality.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);
vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_FASTER);
vgClear(0, 0, 256, 256);
vgDrawPath(path4, VG_FILL_PATH);
saveDrawingSurface(f, "draw_siemens_star_faster.png", "Test Siemens star, faster quality.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);
vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_BETTER);
vgClear(0, 0, 256, 256);
vgDrawPath(path4, VG_FILL_PATH);
saveDrawingSurface(f, "draw_siemens_star_better.png", "Test Siemens star, better quality.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);

// recursive squares
path5 = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 0, 0, VG_PATH_CAPABILITY_ALL);
j = 0;
k = 0;
tmpF = 256.0f;
alpha = 0.0f;
for (i = 0; i < 64; ++i) {

	VGfloat x, y, c, s, u, v;
	
	alpha += 0.06f;
	c = (VGfloat)cos(alpha);
	s = (VGfloat)sin(alpha);
	tmpF = tmpF / (VGfloat)(sqrt(2.0 * sin(0.06) * cos(0.06) + 1.0));
	
	x = -tmpF * 0.5f;
	y = -tmpF * 0.5f;
	u = c * x + s * y;
	v = -s * x + c * y;
	pathSegs[k++] = VG_MOVE_TO_ABS;
	pathData[j++] = u + 128.0f;
	pathData[j++] = v + 128.0f;

	x = +tmpF * 0.5f;
	y = -tmpF * 0.5f;
	u = c * x + s * y;
	v = -s * x + c * y;
	pathSegs[k++] = VG_LINE_TO_ABS;
	pathData[j++] = u + 128.0f;
	pathData[j++] = v + 128.0f;
	
	x = +tmpF * 0.5f;
	y = +tmpF * 0.5f;
	u = c * x + s * y;
	v = -s * x + c * y;
	pathSegs[k++] = VG_LINE_TO_ABS;
	pathData[j++] = u + 128.0f;
	pathData[j++] = v + 128.0f;
	
	x = -tmpF * 0.5f;
	y = +tmpF * 0.5f;
	u = c * x + s * y;
	v = -s * x + c * y;
	pathSegs[k++] = VG_LINE_TO_ABS;
	pathData[j++] = u + 128.0f;
	pathData[j++] = v + 128.0f;
	
	pathSegs[k++] = VG_CLOSE_PATH;
	
}
vgAppendPathData(path5, k, pathSegs, pathData);
// draw recursive squares using different qualitites
vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_NONANTIALIASED);
vgClear(0, 0, 256, 256);
vgDrawPath(path5, VG_FILL_PATH);
saveDrawingSurface(f, "draw_recursive_squares_noaa.png", "Test recursive squares, non-antialiased quality.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);
vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_FASTER);
vgClear(0, 0, 256, 256);
vgDrawPath(path5, VG_FILL_PATH);
saveDrawingSurface(f, "draw_recursive_squares_faster.png", "Test recursive squares, faster quality.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);
vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_BETTER);
vgClear(0, 0, 256, 256);
vgDrawPath(path5, VG_FILL_PATH);
saveDrawingSurface(f, "draw_recursive_squares_better.png", "Test recursive squares, better quality.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);

// subpixel squares
path6 = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 0, 0, VG_PATH_CAPABILITY_ALL);
k = 0;
w = 0;
for (i = 0; i < 85; ++i) {
	for (j = 0; j < 85; ++j) {

		VGfloat x = (VGfloat)(j * 3);
		VGfloat y = (VGfloat)(i * 3);
	
		pathSegs[k++] = VG_MOVE_TO_ABS;
		pathData[w++] = x + 0.125f;
		pathData[w++] = y + 0.125f;
		pathSegs[k++] = VG_LINE_TO_ABS;
		pathData[w++] = x + 1.375f;
		pathData[w++] = y + 0.125f;
		pathSegs[k++] = VG_LINE_TO_ABS;
		pathData[w++] = x + 1.375f;
		pathData[w++] = y + 1.625f;
		pathSegs[k++] = VG_LINE_TO_ABS;
		pathData[w++] = x + 0.125f;
		pathData[w++] = y + 1.125f;
		
		pathSegs[k++] = VG_MOVE_TO_ABS;
		pathData[w++] = x + 1.625f;
		pathData[w++] = y + 0.125f;
		pathSegs[k++] = VG_LINE_TO_ABS;
		pathData[w++] = x + 1.625f;
		pathData[w++] = y + 1.125f;
		pathSegs[k++] = VG_LINE_TO_ABS;
		pathData[w++] = x + 2.875f;
		pathData[w++] = y + 1.625f;
		pathSegs[k++] = VG_LINE_TO_ABS;
		pathData[w++] = x + 2.875f;
		pathData[w++] = y + 0.125f;
		
		pathSegs[k++] = VG_MOVE_TO_ABS;
		pathData[w++] = x + 0.125f;
		pathData[w++] = y + 1.375f;
		pathSegs[k++] = VG_LINE_TO_ABS;
		pathData[w++] = x + 0.125f;
		pathData[w++] = y + 2.875f;
		pathSegs[k++] = VG_LINE_TO_ABS;
		pathData[w++] = x + 1.375f;
		pathData[w++] = y + 2.875f;
		pathSegs[k++] = VG_LINE_TO_ABS;
		pathData[w++] = x + 1.375f;
		pathData[w++] = y + 1.875f;
		
		pathSegs[k++] = VG_MOVE_TO_ABS;
		pathData[w++] = x + 1.625f;
		pathData[w++] = y + 1.375f;
		pathSegs[k++] = VG_LINE_TO_ABS;
		pathData[w++] = x + 2.875f;
		pathData[w++] = y + 1.875f;
		pathSegs[k++] = VG_LINE_TO_ABS;
		pathData[w++] = x + 2.875f;
		pathData[w++] = y + 2.875f;
		pathSegs[k++] = VG_LINE_TO_ABS;
		pathData[w++] = x + 1.625f;
		pathData[w++] = y + 2.875f;
	}
}
vgAppendPathData(path6, k, pathSegs, pathData);
// draw subpixel squares using different qualitites
vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_NONANTIALIASED);
vgClear(0, 0, 256, 256);
vgDrawPath(path6, VG_FILL_PATH);
saveDrawingSurface(f, "draw_subpixel_squares_noaa.png", "Test subpixel squares, non-antialiased quality.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);
vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_FASTER);
vgClear(0, 0, 256, 256);
vgDrawPath(path6, VG_FILL_PATH);
saveDrawingSurface(f, "draw_subpixel_squares_faster.png", "Test subpixel squares, faster quality.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);
vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_BETTER);
vgClear(0, 0, 256, 256);
vgDrawPath(path6, VG_FILL_PATH);
saveDrawingSurface(f, "draw_subpixel_squares_better.png", "Test subpixel squares, better quality.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);

// auto erasing figure made of overlapping rectangles
path7 = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 0, 0, VG_PATH_CAPABILITY_ALL);
k = 0;
w = 0;
for (i = 0; i < 64; ++i) {

		VGfloat x = (VGfloat)(i * 4);
		VGfloat y = (VGfloat)(i * 4);
	
		pathSegs[k++] = VG_MOVE_TO_ABS;
		pathData[w++] = x + 1.0f;
		pathData[w++] = y;
		pathSegs[k++] = VG_LINE_TO_ABS;
		pathData[w++] = 254.0f - x;
		pathData[w++] = y + 1.0f;
		pathSegs[k++] = VG_LINE_TO_ABS;
		pathData[w++] = 253.0f - x;
		pathData[w++] = 254.0f - y;
		pathSegs[k++] = VG_LINE_TO_ABS;
		pathData[w++] = x;
		pathData[w++] = 253.0f - y;

		pathSegs[k++] = VG_MOVE_TO_ABS;
		pathData[w++] = x + 1.0f;
		pathData[w++] = y;
		pathSegs[k++] = VG_LINE_TO_ABS;
		pathData[w++] = 254.0f - x;
		pathData[w++] = y + 1.0f;
		pathSegs[k++] = VG_LINE_TO_ABS;
		pathData[w++] = 253.0f - x;
		pathData[w++] = 254.0f - y;
		pathSegs[k++] = VG_LINE_TO_ABS;
		pathData[w++] = x;
		pathData[w++] = 253.0f - y;
}
vgAppendPathData(path7, k, pathSegs, pathData);
vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_NONANTIALIASED);
vgClear(0, 0, 256, 256);
vgDrawPath(path7, VG_FILL_PATH);
saveDrawingSurface(f, "draw_auto_erasing_noaa.png", "Test auto erasing figure, non-antialiased quality.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);
vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_FASTER);
vgClear(0, 0, 256, 256);
vgDrawPath(path7, VG_FILL_PATH);
saveDrawingSurface(f, "draw_auto_erasing_faster.png", "Test auto erasing figure, faster quality.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);
vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_BETTER);
vgClear(0, 0, 256, 256);
vgDrawPath(path7, VG_FILL_PATH);
saveDrawingSurface(f, "draw_auto_erasing_better.png", "Test auto erasing figure, better quality.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);


// scissoring
srand(113);
j = 0;
for (i = 0; i < 64; ++i) {
	scissorRects[j++] = (rand() / (VGfloat)RAND_MAX) * 384.0f - 64.0f;
	scissorRects[j++] = (rand() / (VGfloat)RAND_MAX) * 384.0f - 64.0f;
	scissorRects[j++] = (rand() / (VGfloat)RAND_MAX) * 64.0f + 16.0f;
	scissorRects[j++] = (rand() / (VGfloat)RAND_MAX) * 64.0f + 16.0f;
}
vgSetfv(VG_SCISSOR_RECTS, j, scissorRects);
vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_BETTER);
vgSeti(VG_SCISSORING, VG_FALSE);
vgClear(0, 0, 256, 256);
vgSeti(VG_SCISSORING, VG_TRUE);
vgDrawPath(path5, VG_FILL_PATH);
saveDrawingSurface(f, "draw_scissors.png", "Test scissoring.", 0, 0, 256, 256);
eglSwapBuffers(display, surface);

vgDestroyPath(path0);
vgDestroyPath(path1);
vgDestroyPath(path2);
vgDestroyPath(path3);
vgDestroyPath(path4);
vgDestroyPath(path5);
vgDestroyPath(path6);
vgDestroyPath(path7);
vgDestroyPaint(fillPaint);