example/rive_viewer.cpp

   1 #include <thread>
   2 #include <Elementary.h>
   3 #include <rive_tizen.hpp>
   4
   5 #include "animation/linear_animation_instance.hpp"
   6 #include "artboard.hpp"
   7 #include "file.hpp"
   8 #include "thorvg_renderer.hpp"
   9
  10 using namespace std;
  11
  12 #define WIDTH 700
  13 #define HEIGHT 700
  14
  15 static unique_ptr<tvg::SwCanvas> canvas;
  16 static rive::Artboard* artboard = nullptr;
  17 static rive::LinearAnimationInstance* animationInstance = nullptr;
  18
  19 static void deleteWindow(void *data, Evas_Object *obj, void *ev)
  20 {
  21    elm_exit();
  22 }
  23
  24 static void drawToCanvas(void* data, Eo* obj)
  25 {
  26     if (canvas->draw() == tvg::Result::Success)
  27     {
  28         canvas->sync();
  29     }
  30 }
  31
  32 static void runExample(uint32_t* buffer)
  33 {
  34     //Create a Canvas
  35     canvas = tvg::SwCanvas::gen();
  36     canvas->target(buffer, WIDTH, WIDTH, HEIGHT, tvg::SwCanvas::ARGB8888);
  37
  38     // Load Rive File
  39     const char* filename = "../../example/shapes.riv";
  40     FILE* fp = fopen(filename, "r");
  41
  42     fseek(fp, 0, SEEK_END);
  43     size_t length = ftell(fp);
  44     fseek(fp, 0, SEEK_SET);
  45
  46     uint8_t* bytes = new uint8_t[length];
  47     if (fread(bytes, 1, length, fp) != length)
  48     {
  49        delete[] bytes;
  50        fprintf(stderr, "failed to read all of %s\n", filename);
  51        return;
  52     }
  53
  54     auto reader = rive::BinaryReader(bytes, length);
  55     rive::File* file = nullptr;
  56     auto result = rive::File::import(reader, &file);
  57     if (result != rive::ImportResult::success)
  58     {
  59        delete[] bytes;
  60        fprintf(stderr, "failed to import %s\n", filename);
  61        return;
  62     }
  63
  64     artboard = file->artboard();
  65
  66     delete animationInstance;
  67
  68     auto animation = artboard->firstAnimation<rive::LinearAnimation>();
  69     if (animation != nullptr)
  70     {
  71        animationInstance = new rive::LinearAnimationInstance(animation);
  72        animationInstance->advance(0);
  73     }
  74     else
  75     {
  76        animationInstance = nullptr;
  77     }
  78
  79     rive::TvgRenderer renderer(canvas.get());
  80
  81     renderer.save();
  82     artboard->advance(0);
  83     artboard->draw(&renderer);
  84     renderer.restore();
  85
  86     delete[] bytes;
  87     delete file;
  88 }
  89
  90
  91 static void cleanExample()
  92 {
  93     delete animationInstance;
  94 }
  95
  96
  97 static void setupScreen(uint32_t* buffer)
  98 {
  99     Eo* win = elm_win_util_standard_add(NULL, "Rive Viewer");
 100     evas_object_smart_callback_add(win, "delete,request", deleteWindow, 0);
 101
 102     Eo* view = evas_object_image_filled_add(evas_object_evas_get(win));
 103     evas_object_image_size_set(view, WIDTH, HEIGHT);
 104     evas_object_image_data_set(view, buffer);
 105     evas_object_image_pixels_get_callback_set(view, drawToCanvas, nullptr);
 106     evas_object_image_pixels_dirty_set(view, EINA_TRUE);
 107     evas_object_image_data_update_add(view, 0, 0, WIDTH, HEIGHT);
 108     evas_object_size_hint_weight_set(view, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 109     evas_object_show(view);
 110
 111     elm_win_resize_object_add(win, view);
 112     evas_object_resize(win, WIDTH, HEIGHT);
 113     evas_object_show(win);
 114 }
 115
 116 int main(int argc, char **argv)
 117 {
 118     static uint32_t buffer[WIDTH * HEIGHT];
 119
 120     tvg::Initializer::init(tvg::CanvasEngine::Sw, thread::hardware_concurrency());
 121
 122     elm_init(argc, argv);
 123
 124     setupScreen(buffer);
 125
 126     runExample(buffer);
 127
 128     elm_run();
 129
 130     cleanExample();
 131
 132     elm_shutdown();
 133
 134     tvg::Initializer::term(tvg::CanvasEngine::Sw);
 135
 136     return 0;
 137 }