unified samples app in c++, unit testing wip

1 files changed, 171 insertions, 0 deletions

diff --git a/samples/VkvgTest.cpp b/samples/VkvgTest.cpp
new file mode 100644
index 0000000..2617e45
--- /dev/null
+++ b/samples/VkvgTest.cpp
@@ -0,0 +1,171 @@
+#include "VkvgTest.hpp"
+
+
+std::vector<VkvgTest*> VkvgTest::tests;
+
+VkvgTest::VkvgTest(VkvgTestFunc testFunc, std::string _name) {
+    this->testFunc = testFunc;
+    this->name = _name;
+    VkvgTest::tests.push_back(this);
+}
+void VkvgTest::initTest(SampleApp* app) {
+    this->app = app;
+
+    vkvg_device_create_info_t info = {
+        app->samples, false,
+        vkh_app_get_inst(app->app), vkh_device_get_phy(app->vkhDev), vkh_device_get_vkdev(app->vkhDev), app->presentQIndex, 0, false};
+
+    device = vkvg_device_create(&info);
+    surf = vkvg_surface_create(device, app->width, app->height);
+    vkvg_device_set_dpy(device, 96, 96);
+
+    vkh_presenter_build_blit_cmd(app->renderer, vkvg_surface_get_vk_image(surf), app->width, app->height);
+
+    vkDeviceWaitIdle(vkh_device_get_vkdev(app->vkhDev));
+}
+void VkvgTest::performTest() {
+    testFunc(this);
+}
+void VkvgTest::cleanTest() {
+    vkDeviceWaitIdle(vkh_device_get_vkdev(app->vkhDev));
+    vkvg_surface_destroy(surf);
+    vkvg_device_destroy(device);
+    vkDeviceWaitIdle(vkh_device_get_vkdev(app->vkhDev));
+}
+
+void draw_growing_circles(VkvgContext ctx, float y, int count) {
+    float x = 2;
+    for (int i = 1; i < count; i++) {
+        x += 0.5f * i;
+        vkvg_arc(ctx, x + 2, y, 0.5f * i, 0, M_PIF * 1.5f);
+        x += 0.5f * i + 5;
+    }
+}
+/* common context init for several tests */
+vkvg_fill_rule_t fill_rule = VKVG_FILL_RULE_NON_ZERO;
+vkvg_line_cap_t  line_cap  = VKVG_LINE_CAP_BUTT;
+vkvg_line_join_t line_join = VKVG_LINE_JOIN_MITER;
+float            dashes[]  = {10.0f, 6.0f};
+// float		dashes[]	= {0.0f, 10.0f};
+uint32_t dashes_count = 0;
+float    dash_offset  = 0;
+float    line_width   = 2.f;
+
+/*VkvgContext _initCtx() {
+    VkvgContext ctx = vkvg_create(surf);
+
+    vkvg_set_line_width(ctx, line_width);
+    vkvg_set_line_join(ctx, line_join);
+    vkvg_set_line_cap(ctx, line_cap);
+    vkvg_set_dash(ctx, dashes, dashes_count, dash_offset);
+    vkvg_set_fill_rule(ctx, fill_rule);
+    return ctx;
+}*/
+
+const int star_points[11][2] = {{0, 85},    {75, 75},   {100, 10}, {125, 75}, {200, 85}, {150, 125},
+                                {160, 190}, {100, 150}, {40, 190}, {50, 125}, {0, 85}};
+void randomize_color(VkvgContext ctx) { vkvg_set_source_rgba(ctx, rndf(), rndf(), rndf(), rndf()); }
+
+void VkvgTest::draw_random_shape(VkvgContext ctx, shape_t shape, float sizeFact) {
+    float w = (float)app->width;
+    float h = (float)app->height;
+
+
+    float x, y, z, v, r;
+
+    randomize_color(ctx);
+
+    switch (shape) {
+    case SHAPE_LINE:
+        x = rndf() * w;
+        y = rndf() * h;
+        z = rndf() * w;
+        v = rndf() * h;
+
+        vkvg_move_to(ctx, x, y);
+        vkvg_line_to(ctx, z, v);
+        vkvg_stroke(ctx);
+        break;
+    case SHAPE_RECTANGLE:
+        z = truncf((sizeFact * w * rndf()) + 1.f);
+        v = truncf((sizeFact * h * rndf()) + 1.f);
+        x = truncf((w - z) * rndf());
+        y = truncf((h - v) * rndf());
+
+        vkvg_rectangle(ctx, x + 1, y + 1, z, v);
+        break;
+    case SHAPE_ROUNDED_RECTANGLE:
+        z = truncf((sizeFact * w * rndf()) + 1.f);
+        v = truncf((sizeFact * h * rndf()) + 1.f);
+        x = truncf((w - z) * rndf());
+        y = truncf((h - v) * rndf());
+        r = truncf((0.2f * z * rndf()) + 1.f);
+
+        if ((r > v / 2) || (r > z / 2))
+            r = MIN(v / 2, z / 2);
+
+        vkvg_move_to(ctx, x, y + r);
+        vkvg_arc(ctx, x + r, y + r, r, (float)M_PI, (float)-M_PI_2);
+        vkvg_line_to(ctx, x + z - r, y);
+        vkvg_arc(ctx, x + z - r, y + r, r, (float)-M_PI_2, 0);
+        vkvg_line_to(ctx, x + z, y + v - r);
+        vkvg_arc(ctx, x + z - r, y + v - r, r, 0, (float)M_PI_2);
+        vkvg_line_to(ctx, x + r, y + v);
+        vkvg_arc(ctx, x + r, y + v - r, r, (float)M_PI_2, (float)M_PI);
+        vkvg_line_to(ctx, x, y + r);
+        vkvg_close_path(ctx);
+        break;
+    case SHAPE_CIRCLE:
+        /*x = truncf((float)w * rnd()/RAND_MAX);
+        y = truncf((float)h * rnd()/RAND_MAX);
+        v = truncf((float)w * rnd()/RAND_MAX * 0.2f);*/
+        x = rndf() * w;
+        y = rndf() * h;
+
+        r = truncf((sizeFact * MIN(w, h) * rndf()) + 1.f);
+
+        /*float r = 0.5f*w*rand()/RAND_MAX;
+        float x = truncf(0.5f * w*rand()/RAND_MAX + r);
+        float y = truncf(0.5f * w*rand()/RAND_MAX + r);*/
+
+        vkvg_arc(ctx, x, y, r, 0, (float)M_PI * 2.0f);
+        break;
+    case SHAPE_TRIANGLE:
+    case SHAPE_STAR:
+        x = rndf() * w;
+        y = rndf() * h;
+        z = rndf() * sizeFact + 0.15f; // scale
+
+        vkvg_move_to(ctx, x + star_points[0][0] * z, y + star_points[0][1] * z);
+        for (int s = 1; s < 11; s++)
+            vkvg_line_to(ctx, x + star_points[s][0] * z, y + star_points[s][1] * z);
+        vkvg_close_path(ctx);
+        break;
+    case SHAPE_RANDOM:
+        draw_random_shape(ctx, (shape_t)(1 + (rndf() * 4)), sizeFact);
+        break;
+    }
+}
+void VkvgTest::draw_random_curve(VkvgContext ctx) {
+    float w = (float)app->width;
+    float h = (float)app->height;
+
+    float x2    = w * rndf();
+    float y2    = h * rndf();
+    float cp_x1 = w * rndf();
+    float cp_y1 = h * rndf();
+    float cp_x2 = w * rndf();
+    float cp_y2 = h * rndf();
+
+    vkvg_curve_to(ctx, cp_x1, cp_y1, cp_x2, cp_y2, x2, y2);
+}
+void VkvgTest::draw_random_square(VkvgContext ctx, float s) {
+    float w = (float)app->width;
+    float h = (float)app->height;
+    randomize_color(ctx);
+
+    float x = truncf(w * rndf());
+    float y = truncf(h * rndf());
+
+    vkvg_rectangle(ctx, x, y, s, s);
+}