// set a tile color
tileFillColor[0] = 0.21f;
tileFillColor[1] = -0.1f;
tileFillColor[2] = 1.1f;
tileFillColor[3] = 0.82f;
// set a clear color
clearColor[0] = 0.65f;
clearColor[1] = -0.4f;
clearColor[2] = 5.1f;
clearColor[3] = 0.15f;
// set a dash pattern
dashPattern[0] = 1.57f;
dashPattern[1] = -10.1f;
dashPattern[2] = 10.35f;
dashPattern[3] = 5.82f;
dashPattern[4] = -30.82f;
// set 3 scissor rectangles (x, y, width, height)
scissorRects[0] = 10.1f;
scissorRects[1] = -20.1f;
scissorRects[2] = 100.3f;
scissorRects[3] = 115.8f;
scissorRects[4] = -130.82f;
scissorRects[5] = 11.57f;
scissorRects[6] = -100.1f;
scissorRects[7] = 200.35f;
scissorRects[8] = 15.62f;
scissorRects[9] = -30.82f;
scissorRects[10] = 400.57f;
scissorRects[11] = 512.1f;


// set matrix mode
vgSeti(VG_MATRIX_MODE, VG_MATRIX_FILL_PAINT_TO_USER);
iVal = vgGeti(VG_MATRIX_MODE);
writeInt(f, iVal, "vgGeti(VG_MATRIX_MODE)");
fVal = vgGetf(VG_MATRIX_MODE);
writeFloat(f, fVal, "vgGetf(VG_MATRIX_MODE)");

// set fill rule
vgSeti(VG_FILL_RULE, VG_NON_ZERO);
iVal = vgGeti(VG_FILL_RULE);
writeInt(f, iVal, "vgGeti(VG_FILL_RULE)");
fVal = vgGetf(VG_FILL_RULE);
writeFloat(f, fVal, "vgGetf(VG_FILL_RULE)");

// set image quality
vgSeti(VG_IMAGE_QUALITY, VG_IMAGE_QUALITY_BETTER);
iVal = vgGeti(VG_IMAGE_QUALITY);
writeInt(f, iVal, "vgGeti(VG_IMAGE_QUALITY)");
fVal = vgGetf(VG_IMAGE_QUALITY);
writeFloat(f, fVal, "vgGetf(VG_IMAGE_QUALITY)");

// set rendering quality
vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_FASTER);
iVal = vgGeti(VG_RENDERING_QUALITY);
writeInt(f, iVal, "vgGeti(VG_RENDERING_QUALITY)");
fVal = vgGetf(VG_RENDERING_QUALITY);
writeFloat(f, fVal, "vgGetf(VG_RENDERING_QUALITY)");

// set blend mode
vgSeti(VG_BLEND_MODE, VG_BLEND_MULTIPLY);
iVal = vgGeti(VG_BLEND_MODE);
writeInt(f, iVal, "vgGeti(VG_BLEND_MODE)");
fVal = vgGetf(VG_BLEND_MODE);
writeFloat(f, fVal, "vgGetf(VG_BLEND_MODE)");

// set image mode
vgSeti(VG_IMAGE_MODE, VG_DRAW_IMAGE_MULTIPLY);
iVal = vgGeti(VG_IMAGE_MODE);
writeInt(f, iVal, "vgGeti(VG_IMAGE_MODE)");
fVal = vgGetf(VG_IMAGE_MODE);
writeFloat(f, fVal, "vgGetf(VG_IMAGE_MODE)");

// set (three) scissor rectangles
vgSetfv(VG_SCISSOR_RECTS, 12, scissorRects);
iVal = vgGetVectorSize(VG_SCISSOR_RECTS);
writeInt(f, iVal, "vgGetVectorSize(VG_SCISSOR_RECTS)");
vgGetiv(VG_SCISSOR_RECTS, iVal, iVals);
writeInts(f, iVals, iVal, "vgGetiv(VG_SCISSOR_RECTS)");
vgGetfv(VG_SCISSOR_RECTS, iVal, fVals);
writeFloats(f, fVals, iVal, "vgGetfv(VG_SCISSOR_RECTS)");

// set stroke line width
vgSetf(VG_STROKE_LINE_WIDTH, 10.3f);
fVal = vgGetf(VG_STROKE_LINE_WIDTH);
writeFloat(f, fVal, "vgGetf(VG_STROKE_LINE_WIDTH)");
iVal = vgGeti(VG_STROKE_LINE_WIDTH);
writeInt(f, iVal, "vgGeti(VG_STROKE_LINE_WIDTH)");

// set stroke cap style
vgSeti(VG_STROKE_CAP_STYLE, VG_CAP_ROUND);
iVal = vgGeti(VG_STROKE_CAP_STYLE);
writeInt(f, iVal, "vgGeti(VG_STROKE_CAP_STYLE)");
fVal = vgGetf(VG_STROKE_CAP_STYLE);
writeFloat(f, fVal, "vgGetf(VG_STROKE_CAP_STYLE)");

// set stroke join style
vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND);
iVal = vgGeti(VG_STROKE_JOIN_STYLE);
writeInt(f, iVal, "vgGeti(VG_STROKE_JOIN_STYLE)");
fVal = vgGetf(VG_STROKE_JOIN_STYLE);
writeFloat(f, fVal, "vgGetf(VG_STROKE_JOIN_STYLE)");

// set stroke miter limit
vgSetf(VG_STROKE_MITER_LIMIT, 5.8f);
fVal = vgGetf(VG_STROKE_MITER_LIMIT);
writeFloat(f, fVal, "vgGetf(VG_STROKE_MITER_LIMIT)");
iVal = vgGeti(VG_STROKE_MITER_LIMIT);
writeInt(f, iVal, "vgGeti(VG_STROKE_MITER_LIMIT)");

// set dash pattern
vgSetfv(VG_STROKE_DASH_PATTERN, 5, dashPattern);
iVal = vgGetVectorSize(VG_STROKE_DASH_PATTERN);
writeInt(f, iVal, "vgGetVectorSize(VG_STROKE_DASH_PATTERN)");
vgGetfv(VG_STROKE_DASH_PATTERN, iVal, fVals);
writeFloats(f, fVals, iVal, "vgGetfv(VG_STROKE_DASH_PATTERN)");
vgGetiv(VG_STROKE_DASH_PATTERN, iVal, iVals);
writeInts(f, iVals, iVal, "vgGetiv(VG_STROKE_DASH_PATTERN)");

// set stroke dash phase
vgSetf(VG_STROKE_DASH_PHASE, -1.4f);
fVal = vgGetf(VG_STROKE_DASH_PHASE);
writeFloat(f, fVal, "vgGetf(VG_STROKE_DASH_PHASE)");
iVal = vgGeti(VG_STROKE_DASH_PHASE);
writeInt(f, iVal, "vgGeti(VG_STROKE_DASH_PHASE)");

// set tile color
vgSetfv(VG_TILE_FILL_COLOR, 4, tileFillColor);
vgGetfv(VG_TILE_FILL_COLOR, 4, fVals);
writeFloats(f, fVals, 4, "vgGetfv(VG_TILE_FILL_COLOR)");
vgGetiv(VG_TILE_FILL_COLOR, 4, iVals);
writeInts(f, iVals, 4, "vgGetiv(VG_TILE_FILL_COLOR)");

// set clear color
vgSetfv(VG_CLEAR_COLOR, 4, clearColor);
vgGetfv(VG_CLEAR_COLOR, 4, fVals);
writeFloats(f, fVals, 4, "vgGetfv(VG_CLEAR_COLOR)");
vgGetiv(VG_CLEAR_COLOR, 4, iVals);
writeInts(f, iVals, 4, "vgGetiv(VG_CLEAR_COLOR)");

// set masking
vgSeti(VG_MASKING, VG_TRUE);
iVal = vgGeti(VG_MASKING);
writeInt(f, iVal, "vgGeti(VG_MASKING)");
fVal = vgGetf(VG_MASKING);
writeFloat(f, fVal, "vgGetf(VG_MASKING)");

// set scissoring
vgSeti(VG_SCISSORING, VG_TRUE);
iVal = vgGeti(VG_SCISSORING);
writeInt(f, iVal, "vgGeti(VG_SCISSORING)");
fVal = vgGetf(VG_SCISSORING);
writeFloat(f, fVal, "vgGetf(VG_SCISSORING)");

// set pixel layout
vgSeti(VG_PIXEL_LAYOUT, VG_PIXEL_LAYOUT_RGB_HORIZONTAL);
iVal = vgGeti(VG_PIXEL_LAYOUT);
writeInt(f, iVal, "vgGeti(VG_PIXEL_LAYOUT)");
fVal = vgGetf(VG_PIXEL_LAYOUT);
writeFloat(f, fVal, "vgGetf(VG_PIXEL_LAYOUT)");

// set filter format linear flag
vgSeti(VG_FILTER_FORMAT_LINEAR, VG_FALSE);
iVal = vgGeti(VG_FILTER_FORMAT_LINEAR);
writeInt(f, iVal, "vgGeti(VG_FILTER_FORMAT_LINEAR)");
fVal = vgGetf(VG_FILTER_FORMAT_LINEAR);
writeFloat(f, fVal, "vgGetf(VG_FILTER_FORMAT_LINEAR)");

// set filter format premultiplied flag
vgSeti(VG_FILTER_FORMAT_PREMULTIPLIED, VG_TRUE);
iVal = vgGeti(VG_FILTER_FORMAT_PREMULTIPLIED);
writeInt(f, iVal, "vgGeti(VG_FILTER_FORMAT_PREMULTIPLIED)");
fVal = vgGetf(VG_FILTER_FORMAT_PREMULTIPLIED);
writeFloat(f, fVal, "vgGetf(VG_FILTER_FORMAT_PREMULTIPLIED)");

// set filter channel mask
vgSeti(VG_FILTER_CHANNEL_MASK, VG_RED | VG_ALPHA);
iVal = vgGeti(VG_FILTER_CHANNEL_MASK);
writeInt(f, iVal, "vgGeti(VG_FILTER_CHANNEL_MASK)");
fVal = vgGetf(VG_FILTER_CHANNEL_MASK);
writeFloat(f, fVal, "vgGetf(VG_FILTER_CHANNEL_MASK)");