/**
* @brief create new context for surface
- * @param drawing operation output surface
+ * @param drawing operations output surface
* @return newly created context pointer
*/
VkvgContext vkvg_create(VkvgSurface surf)
free(ctx->vertexCache);
free(ctx->indexCache);
+ //TODO:check this for source counter
//vkh_image_destroy (ctx->source);
free(ctx->selectedFont.fontFile);
void vkvg_new_path (VkvgContext ctx){
_clear_path(ctx);
}
-//path closing is done by setting the endpoint of the path to the same index
-//as the start point.
-//I'll test if closing by adding a new point with the same x,y as the start point
-//would not make more sense.
/**
* @brief Close current path if at least 3 points are present
* @param context pointer
_add_point(ctx,x,y);
}
/**
- * @brief Draw arc
+ * @brief Draw arc in clockwise order following angles of the trigonometric circle.
* @param context pointer
* @param center x coordinate
* @param center y coordinate
_add_point (ctx, v.x, v.y);
_set_curve_end(ctx);
}
+/**
+ * @brief Draw arc in counter clockwise order following angles of the trigonometric circle.
+ * @param context pointer
+ * @param center x coordinate
+ * @param center y coordinate
+ * @param radius
+ * @param start angle of arc
+ * @param end angle of arc
+ */
void vkvg_arc_negative (VkvgContext ctx, float xc, float yc, float radius, float a1, float a2) {
while (a2 > a1)
a2 -= 2.f*M_PIF;
_add_point (ctx, v.x, v.y);
_set_curve_end(ctx);
}
+/**
+ * @brief move pen relative to the current point.
+ * @param ctx
+ * @param delta in the horizontal direction
+ * @param delta in the vertical direction
+ */
void vkvg_rel_move_to (VkvgContext ctx, float x, float y)
{
if (_current_path_is_empty(ctx)){
vec2 cp = _get_current_position(ctx);
vkvg_move_to(ctx, cp.x + x, cp.y + y);
}
+/**
+ * @brief move pen to the position given in argument
+ * @param ctx
+ * @param new x position of the pen
+ * @param new y position of the pen
+ */
void vkvg_move_to (VkvgContext ctx, float x, float y)
{
_finish_path(ctx);
_start_sub_path(ctx, x, y);
}
+
void vkvg_curve_to (VkvgContext ctx, float x1, float y1, float x2, float y2, float x3, float y3) {
if (_current_path_is_empty(ctx))
vkvg_move_to(ctx, x1, y1);
ctx->pathes[ctx->pathPtr+ctx->curvePtr+1] = (ctx->pointCount - 1);
ctx->pathes[ctx->pathPtr-1] |= PATH_HAS_CURVES_BIT;
}
-//set curve end point and set path has curve bit
+//set curve end point and set path is curve bit
void _set_curve_end (VkvgContext ctx) {
ctx->pathes[ctx->pathPtr+ctx->curvePtr+2] = (ctx->pointCount - 1)|PATH_IS_CURVE_BIT;
ctx->curvePtr+=2;
continue;
}
//close path
- ctx->pathes[ptrPath] |= PATH_CLOSED_BIT;// ctx->pathes[ptrPath];//close path by setting start and end equal
+ ctx->pathes[ptrPath] |= PATH_CLOSED_BIT;
uint32_t firstPtIdx = ctx->pathes [ptrPath] & PATH_ELT_MASK;
- uint32_t lastPtIdx = ctx->pathes [ptrPath+1] & PATH_ELT_MASK;//_get_last_point_of_closed_path (ctx, ptrPath);
+ uint32_t lastPtIdx = ctx->pathes [ptrPath+1] & PATH_ELT_MASK;
uint32_t pathPointCount = lastPtIdx - firstPtIdx + 1;
VKVG_IBO_INDEX_TYPE firstVertIdx = ctx->vertCount;
//pathes array is a list of couple (start,end) point idx refering to point array
//it split points list in subpathes and tell if path is closed.
- //if path is closed, end index is the same as start.
- //(TODO: I should use a boolean or smthg else instead to keep last point in array)
uint32_t pathPtr; //pointer in the path array, even=start point;odd=end point
uint32_t* pathes;
size_t sizePathes;
_font_cache_t* cache = (_font_cache_t*)calloc(1, sizeof(_font_cache_t));
cache->config = FcInitLoadConfigAndFonts();
+ if (!cache->config) {
+ fprintf(stderr, "Font config initialisation failed, consider using 'FONTCONFIG_PATH' and 'FONTCONFIG_FILE' environmane\
+ variables to point to 'fonts.conf' needed for FontConfig startup");
+ assert(cache->config);
+ }
FT_CHECK_RESULT(FT_Init_FreeType(&cache->library));
FT_Error res = (f); \
if (res != 0) \
{ \
- printf("Fatal : FreeType error is %d in %s at line %d\n", res, __FILE__, __LINE__); \
+ fprintf(stderr,"Fatal : FreeType error is %d in %s at line %d\n", res, __FILE__, __LINE__); \
assert(res == 0); \
} \
}
+/*
+ * test template
+ */
+
#include "test.h"
void test(){
int main(int argc, char *argv[]) {
- perform_test (test, 600, 800);
+ perform_test (test, "custom test", 800, 600);
return 0;
}
#include "test.h"
+void draw_growing_circles (VkvgContext ctx, float y, int count) {
+ float x = 2;
+ for (int i=1; i<count; i++) {
+ x += 0.5*i;
+ //vkvg_set_source_rgb (ctx, 1,0,1);
+ vkvg_arc(ctx, x + 2, y, 0.5 * i, 0, M_PI*1.5);
+ //vkvg_set_source_rgb (ctx, 0,1,1);
+ //vkvg_arc_negative(ctx, x + 2, y, 0.5 * i, M_PI/2,0);
+ x += 0.5*i + 5;
+ }
+}
+
+void scaled_up() {
+ VkvgContext ctx = vkvg_create(surf);
+
+ vkvg_set_source_rgb (ctx, 1,1,1);
+ vkvg_paint(ctx);
+ vkvg_set_source_rgb (ctx, 0,0,0);
+
+ vkvg_scale(ctx,100,100);
+ vkvg_arc(ctx, 2, 2, 0.5, 0, M_PI/2);
+ vkvg_stroke(ctx);
+
+ vkvg_destroy(ctx);
+}
+void sizes() {
+ VkvgContext ctx = vkvg_create(surf);
+
+ vkvg_set_source_rgb (ctx, 1,1,1);
+ vkvg_paint(ctx);
+ vkvg_set_source_rgb (ctx, 0,0,0);
+
+ draw_growing_circles (ctx, 100, 40);
+ vkvg_stroke(ctx);
+
+ vkvg_destroy(ctx);
+}
void test(){
VkvgContext ctx = vkvg_create(surf);
- vkvg_set_line_width(ctx, 0.5);
vkvg_set_source_rgb (ctx, 1,1,1);
vkvg_paint(ctx);
vkvg_set_source_rgb (ctx, 0,0,0);
+ vkvg_set_source_rgb (ctx, 1,0,1);
+ vkvg_set_line_width(ctx, 5.0);
+ vkvg_arc(ctx, 100, 100, 20, 0, M_PI/2);
+ vkvg_stroke(ctx);
+
+ vkvg_set_source_rgb (ctx, 0,1,1);
+ vkvg_arc_negative(ctx, 100, 100, 20, 0, M_PI/2);
+ vkvg_stroke(ctx);
+
+ vkvg_set_source_rgb (ctx, 1,0,1);
+ vkvg_arc(ctx, 100, 200, 20, M_PI/2, 0);
+ vkvg_stroke(ctx);
+
+ vkvg_set_source_rgb (ctx, 0,1,1);
+ vkvg_arc_negative(ctx, 100, 200, 20, M_PI/2, 0);
+ vkvg_stroke(ctx);
+
+ vkvg_set_source_rgb (ctx, 0,0,1);
+ vkvg_set_line_width(ctx, 10.0);
+ vkvg_arc(ctx, 350, 100, 40, 0, M_PI*2);
+ vkvg_stroke(ctx);
+
+ vkvg_set_source_rgb (ctx, 0,1,0);
+ vkvg_set_line_width(ctx, 1.0);
+ vkvg_arc(ctx, 150, 100, 3.5, 0, M_PI*2);
+ vkvg_stroke(ctx);
+ vkvg_arc(ctx, 200, 200, 10, 0, M_PI*2);
+ vkvg_fill(ctx);
+
+ vkvg_set_source_rgb (ctx, 1,0,0);
vkvg_scale(ctx,3,3);
vkvg_arc(ctx, 150, 100, 3.5, 0, M_PI*2);
vkvg_stroke(ctx);
}
int main() {
-
- perform_test (test, 1024, 768);
-
+ PERFORM_TEST (sizes);
+ PERFORM_TEST (scaled_up);
+ PERFORM_TEST (test);
return 0;
}
#include "test.h"
-void test(){
+void draw_growing_circles (VkvgContext ctx, float y, int count) {
+ float x = 2;
+ for (int i=1; i<count; i++) {
+ x += 0.5*i;
+ vkvg_arc(ctx, x + 2, y, 0.5 * i, 0, M_PI*2);
+ x += 0.5*i + 5;
+ }
+}
+
+void scaled_up() {
VkvgContext ctx = vkvg_create(surf);
+ vkvg_set_source_rgb (ctx, 1,1,1);
+ vkvg_paint(ctx);
+ vkvg_set_source_rgb (ctx, 0,0,0);
+
+ vkvg_scale(ctx,100,100);
+ vkvg_arc(ctx, 2, 2, 0.5, 0, M_PI*2);
+ vkvg_stroke(ctx);
+
+ vkvg_destroy(ctx);
+}
+void sizes() {
+ VkvgContext ctx = vkvg_create(surf);
- vkvg_set_line_width(ctx, 1);
vkvg_set_source_rgb (ctx, 1,1,1);
vkvg_paint(ctx);
vkvg_set_source_rgb (ctx, 0,0,0);
- vkvg_scale(ctx,10.0f,10.0f);
- //vkvg_scale(ctx,2.0f,2.0f);
+ draw_growing_circles (ctx, 100, 40);
+ vkvg_fill (ctx);
- float x = 10;
- float r = 1;
- while (x < 600){
- vkvg_arc(ctx, x+0.5f, 10.5f, r, 0, M_PI*2);
- x += r;
- r ++;
- x += r + 5;
- }
+ draw_growing_circles (ctx, 200, 40);
+ vkvg_stroke(ctx);
+ vkvg_set_source_rgba (ctx, 0,0,1,0.4);
+ draw_growing_circles (ctx, 300, 40);
+ vkvg_fill_preserve (ctx);
+ vkvg_set_line_width(ctx,5);
vkvg_stroke(ctx);
vkvg_destroy(ctx);
}
int main() {
-
- perform_test (test, 1024, 768);
-
+ PERFORM_TEST (sizes);
+ PERFORM_TEST (scaled_up);
return 0;
}
vkvg_destroy(ctx);
}
int main(int argc, char *argv[]) {
-
- perform_test (test_clip2, 1024, 768);
-
+ PERFORM_TEST (test_clip);
+ PERFORM_TEST (test_clip2);
return 0;
}
int main(int argc, char *argv[]) {
- perform_test (test, 1024, 768);
+ PERFORM_TEST (test);
return 0;
}
VkvgSurface* surfaces;
#endif
-void perform_test (void(*testfunc)(void),uint32_t width, uint32_t height) {
+void perform_test (void(*testfunc)(void), const char *testName, uint32_t width, uint32_t height) {
//dumpLayerExts();
e = vkengine_create (VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU, VK_PRESENT_MODE_MAILBOX_KHR, width, height);
int i = 0;
+ vkengine_set_title(e, testName);
+
while (!vkengine_should_close (e) && i < iterations) {
glfwPollEvents();
# define MAX(a,b) (((a) > (b)) ? (a) : (b))
#endif
+#define PERFORM_TEST(testName) perform_test(testName, #testName, 1024, 768);
#if defined(_WIN32) || defined(_WIN64)
#define WIN32_LEAN_AND_MEAN
#define NOMINMAX
extern VkvgSurface surf;
//run test in one step
-void perform_test (void(*testfunc)(void),uint32_t width, uint32_t height);
+void perform_test (void(*testfunc)(void), const char* testName, uint32_t width, uint32_t height);
void randomize_color (VkvgContext ctx);
//run test in 3 step: init, run, clear.
void init_test (uint32_t width, uint32_t height);
-void run_test_func (void(*testfunc)(void),uint32_t width, uint32_t height);
+void run_test_func (void(*testfunc)(void), uint32_t width, uint32_t height);
void clear_test ();
inline bool vkengine_should_close (VkEngine e) {
return glfwWindowShouldClose (e->window);
}
-
+void vkengine_set_title (VkEngine e, const char* title) {
+ glfwSetWindowTitle(e->window, title);
+}
VkDevice vkengine_get_device (VkEngine e){
return e->dev->dev;
}
bool vkengine_should_close (VkEngine e);
void vkengine_close (VkEngine e);
void vkengine_dump_Infos (VkEngine e);
+void vkengine_set_title (VkEngine e, const char* title);
VkDevice vkengine_get_device (VkEngine e);
VkPhysicalDevice vkengine_get_physical_device(VkEngine e);
VkQueue vkengine_get_queue (VkEngine e);
#include "test.h"
-void test(){
+void compositing(){
vkvg_surface_clear(surf);
VkvgContext ctx = vkvg_create(surf);
}
int main(int argc, char *argv[]) {
-
- perform_test (test, 600, 800);
-
+ PERFORM_TEST (compositing);
return 0;
}
}
int main(int argc, char *argv[]) {
-
- perform_test (test, 1024, 768);
-
+ PERFORM_TEST (test);
return 0;
}
}
int main(int argc, char *argv[]) {
-
- perform_test (test, 1024, 768);
-
+ PERFORM_TEST (test);
return 0;
}
}
int main(int argc, char *argv[]) {
-
- perform_test (test, 1024, 768);
-
+ PERFORM_TEST (test);
return 0;
}
}
int main() {
-
- perform_test (test, 1024, 768);
-
+ PERFORM_TEST (test);
return 0;
}
}
int main(int argc, char *argv[]) {
-
- perform_test (test, 1024, 768);
-
+ PERFORM_TEST (test);
return 0;
}
}
int main(int argc, char *argv[]) {
-
- perform_test (test, 1024, 768);
-
+ PERFORM_TEST (test);
return 0;
}
}
int main(int argc, char *argv[]) {
-
- perform_test (test, 1024, 768);
-
+ PERFORM_TEST (test);
return 0;
}
#include "test.h"
-void test(){
- VkvgContext ctx = vkvg_create(surf);
-
- VkvgPattern pat = vkvg_pattern_create_linear(0,0,300,300);
- vkvg_set_line_width(ctx, 20);
+VkvgPattern create_grad (VkvgContext ctx) {
+ VkvgPattern pat = vkvg_pattern_create_linear(0,0,300,0);
vkvg_pattern_add_color_stop(pat, 0, 1, 0, 0, 1);
vkvg_pattern_add_color_stop(pat, 0.5, 0, 1, 0, 1);
vkvg_pattern_add_color_stop(pat, 1, 0, 0, 1, 1);
+ return pat;
+}
+
+void paint(){
+ VkvgContext ctx = vkvg_create(surf);
+ VkvgPattern pat = create_grad(ctx);
+ vkvg_pattern_set_extend(pat,VKVG_EXTEND_NONE);
+ vkvg_set_source (ctx, pat);
+ vkvg_paint(ctx);
+
+ vkvg_pattern_destroy (pat);
+ vkvg_destroy(ctx);
+}
+void paint_repeat(){
+ VkvgContext ctx = vkvg_create(surf);
+ VkvgPattern pat = create_grad(ctx);
+ vkvg_pattern_set_extend(pat,VKVG_EXTEND_REPEAT);
+ vkvg_set_source (ctx, pat);
+ vkvg_paint(ctx);
+
+ vkvg_pattern_destroy (pat);
+ vkvg_destroy(ctx);
+}
+
+void test(){
+ VkvgContext ctx = vkvg_create(surf);
+ VkvgPattern pat = create_grad(ctx);
vkvg_set_source (ctx, pat);
vkvg_rectangle(ctx,100,100,200,200);
+ vkvg_set_line_width(ctx, 20);
//vkvg_fill (ctx);
//vkvg_paint(ctx);
vkvg_stroke (ctx);
vkvg_destroy(ctx);
}
int main(int argc, char *argv[]) {
-
- perform_test (test, 1024, 768);
-
+ PERFORM_TEST(paint);
+ PERFORM_TEST(paint_repeat);
return 0;
}
}
int main(int argc, char *argv[]) {
-
- perform_test (test, 1024, 768);
-
+ PERFORM_TEST (test);
return 0;
}
int main(int argc, char *argv[]) {
- perform_test (test, 1024, 768);
+ PERFORM_TEST (test);
return 0;
}
#include "test.h"
+void paint () {
+ VkvgContext ctx = vkvg_create(surf);
+ VkvgSurface imgSurf = vkvg_surface_create_from_image(device, "data/miroir.jpg");
+
+ vkvg_set_source_surface(ctx, imgSurf, 00, 00);
+ vkvg_paint(ctx);
+
+ vkvg_surface_destroy(imgSurf);
+ vkvg_destroy(ctx);
+}
+void paint_offset () {
+ VkvgContext ctx = vkvg_create(surf);
+ VkvgSurface imgSurf = vkvg_surface_create_from_image(device, "data/miroir.jpg");
+
+ vkvg_set_source_surface(ctx, imgSurf, 100, 100);
+ vkvg_paint(ctx);
+
+ vkvg_surface_destroy(imgSurf);
+ vkvg_destroy(ctx);
+}
+void paint_pattern () {
+ VkvgContext ctx = vkvg_create(surf);
+ VkvgSurface imgSurf = vkvg_surface_create_from_image(device, "data/miroir.jpg");
+ VkvgPattern pat = vkvg_pattern_create_for_surface(imgSurf);
+ vkvg_set_source(ctx, pat);
+ vkvg_paint(ctx);
+ vkvg_pattern_destroy(pat);
+ vkvg_surface_destroy(imgSurf);
+ vkvg_destroy(ctx);
+}
+void paint_pattern_repeat () {
+ VkvgContext ctx = vkvg_create(surf);
+ VkvgSurface imgSurf = vkvg_surface_create_from_image(device, "data/miroir.jpg");
+ VkvgPattern pat = vkvg_pattern_create_for_surface(imgSurf);
+ vkvg_pattern_set_extend(pat,VKVG_EXTEND_REPEAT);
+ vkvg_set_source(ctx, pat);
+ vkvg_paint(ctx);
+ vkvg_pattern_destroy(pat);
+ vkvg_surface_destroy(imgSurf);
+ vkvg_destroy(ctx);
+}
+void paint_pattern_pad () {
+ VkvgContext ctx = vkvg_create(surf);
+ VkvgSurface imgSurf = vkvg_surface_create_from_image(device, "data/miroir.jpg");
+ VkvgPattern pat = vkvg_pattern_create_for_surface(imgSurf);
+ vkvg_pattern_set_extend(pat,VKVG_EXTEND_PAD);
+ vkvg_set_source(ctx, pat);
+ vkvg_paint(ctx);
+ vkvg_pattern_destroy(pat);
+ vkvg_surface_destroy(imgSurf);
+ vkvg_destroy(ctx);
+}
void test(){
VkvgContext ctx = vkvg_create(surf);
}
int main(int argc, char *argv[]) {
-
- perform_test (test, 1024, 768);
+ PERFORM_TEST (paint);
+ PERFORM_TEST (paint_offset);
+ PERFORM_TEST (paint_pattern);
+ PERFORM_TEST (paint_pattern_repeat);
+ PERFORM_TEST (paint_pattern_pad);
+ PERFORM_TEST (test);
return 0;
}
}
int main(int argc, char *argv[]) {
-
- perform_test (test, 1024, 768);
-
+ PERFORM_TEST (test);
return 0;
}
}
int main(int argc, char *argv[]) {
-
- perform_test (test, 1024, 768);
-
+ PERFORM_TEST (test);
return 0;
}
}
int main(int argc, char *argv[]) {
-
- perform_test (test, 1024, 768);
-
+ PERFORM_TEST (test);
return 0;
}
}
int main(int argc, char *argv[]) {
-
- perform_test (test, 1024, 768);
-
+ PERFORM_TEST(test);
return 0;
}
}
int main(int argc, char *argv[]) {
-
- perform_test (test, 1024, 768);
-
+ PERFORM_TEST(test);
return 0;
}
}
int main(int argc, char *argv[]) {
-
- perform_test (test, 1024, 768);
-
+ PERFORM_TEST (test);
return 0;
}
}
int main(int argc, char *argv[]) {
-
- perform_test (test, 1024, 768);
-
+ PERFORM_TEST(test);
return 0;
}
int main(int argc, char *argv[]) {
- perform_test (test, 800, 600);
+ PERFORM_TEST (test);
return 0;
}
VkvgContext ctx = vkvg_create(surf);
- //vkvg_set_fill_rule(ctx, VKVG_FILL_RULE_EVEN_ODD);
+ vkvg_set_fill_rule(ctx, VKVG_FILL_RULE_NON_ZERO);
vkvg_set_source_rgba(ctx,0,0,1,0.5);
vkvg_rectangle(ctx,100,100,200,200);
vkvg_destroy(ctx);
}
+void test_evenodd(){
+ vkvg_surface_clear(surf);
-int main(int argc, char *argv[]) {
+ VkvgContext ctx = vkvg_create(surf);
+
+ vkvg_set_fill_rule(ctx, VKVG_FILL_RULE_EVEN_ODD);
+
+ vkvg_set_source_rgba(ctx,0,0,1,0.5);
+ vkvg_rectangle(ctx,100,100,200,200);
+ vkvg_fill(ctx);
- perform_test (test, 1024, 768);
+ vkvg_rectangle(ctx,200,200,200,200);
+ vkvg_set_source_rgba(ctx,1,0,0,0.5);
+ vkvg_fill(ctx);
+
+ vkvg_destroy(ctx);
+}
+int main(int argc, char *argv[]) {
+ PERFORM_TEST (test);
+ PERFORM_TEST (test_evenodd);
return 0;
}
int main(int argc, char *argv[]) {
- perform_test (test, 600, 800);
+ PERFORM_TEST (test);
return 0;
}
#include "test.h"
-void test(){
+void paint(){
VkvgContext ctx = vkvg_create(surf);
vkvg_set_source_rgba(ctx,1,0,0,1);
vkvg_paint(ctx);
vkvg_destroy(ctx);
}
-
+void paint_with_rotation(){
+ VkvgContext ctx = vkvg_create(surf);
+ vkvg_rotate(ctx, 45);
+ vkvg_set_source_rgba(ctx,1,0,0,1);
+ vkvg_paint(ctx);
+ vkvg_destroy(ctx);
+}
+void paint_with_scale(){
+ VkvgContext ctx = vkvg_create(surf);
+ vkvg_scale (ctx, 0.2,0.2);
+ vkvg_set_source_rgba(ctx,1,0,0,1);
+ vkvg_paint(ctx);
+ vkvg_destroy(ctx);
+}
+void paint_rect(){
+ VkvgContext ctx = vkvg_create(surf);
+ vkvg_set_source_rgba(ctx,1,0,0,1);
+ vkvg_rectangle(ctx,100,100,300,200);
+ vkvg_paint(ctx);
+ vkvg_destroy(ctx);
+}
+//TODO:test failed: full screen paint instead of rotated rect
+void paint_rect_with_rotation(){
+ VkvgContext ctx = vkvg_create(surf);
+ vkvg_rotate(ctx, 45);
+ vkvg_set_source_rgba(ctx,1,0,0,1);
+ vkvg_rectangle(ctx,100,100,300,200);
+ vkvg_paint(ctx);
+ vkvg_destroy(ctx);
+}
+void paint_rect_with_scale(){
+ VkvgContext ctx = vkvg_create(surf);
+ vkvg_scale (ctx, 0.2,0.2);
+ vkvg_set_source_rgba(ctx,1,0,0,1);
+ vkvg_rectangle(ctx,100,100,300,200);
+ vkvg_paint(ctx);
+ vkvg_destroy(ctx);
+}
int main(int argc, char *argv[]) {
vkengine_dump_available_layers();
- perform_test (test, 1024, 768);
+ PERFORM_TEST (paint);
+ PERFORM_TEST (paint_with_rotation);
+ PERFORM_TEST (paint_with_scale);
+ PERFORM_TEST (paint_rect);
+ PERFORM_TEST (paint_rect_with_rotation);
+ PERFORM_TEST (paint_rect_with_scale);
return 0;
}
int main(int argc, char *argv[]) {
- perform_test (test, 1024, 768);
+ PERFORM_TEST (test);
return 0;
}
}
int main(int argc, char *argv[]) {
-
- perform_test (test_nsvg, 1024, 800);
+ PERFORM_TEST (test_nsvg);
return 0;
}
int main(int argc, char *argv[]) {
-
- perform_test (cairo_tests, 1024, 768);
+ PERFORM_TEST (cairo_tests);
return 0;
}
int main(int argc, char *argv[]) {
- perform_test (test2, 1024, 768);
- perform_test (test1, 1024, 768);
- perform_test (test, 1024, 768);
+ PERFORM_TEST (test);
+ PERFORM_TEST (test1);
+ PERFORM_TEST (test2);
return 0;
}
}
int main(int argc, char *argv[]) {
-
- perform_test (test, 1024, 768);
-
+ PERFORM_TEST (test);
return 0;
}
-Subproject commit d13ee198a63102ae2ec6feb3397a65a503dcc25e
+Subproject commit 97cd46b439c22abca509fd971cbe4405f8801524
home / projects / jp / vkvg.git / commitdiff