example/lottieview.cpp

   1 /*
   2  * Copyright (c) 2018 Samsung Electronics Co., Ltd. All rights reserved.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  17  */
  18
  19 #include"lottieview.h"
  20
  21 using namespace lottie;
  22
  23 static Eina_Bool
  24 animator(void *data , double pos)
  25 {
  26     LottieView *view = static_cast<LottieView *>(data);
  27
  28     view->seek(pos);
  29     if (pos == 1.0) {
  30       view->mAnimator = NULL;
  31       view->finished();
  32       return EINA_FALSE;
  33     }
  34     return EINA_TRUE;
  35 }
  36
  37 void LottieView::createVgNode(LOTNode *node, Efl_VG *root)
  38 {
  39     Efl_VG *shape = evas_vg_shape_add(root);
  40
  41     //0: Path
  42     const float *data = node->mPath.ptPtr;
  43     if (!data) return;
  44
  45     for (int i = 0; i < node->mPath.elmCount; i++) {
  46         switch (node->mPath.elmPtr[i]) {
  47         case 0:
  48             evas_vg_shape_append_move_to(shape, data[0], data[1]);
  49             data += 2;
  50             break;
  51         case 1:
  52             evas_vg_shape_append_line_to(shape, data[0], data[1]);
  53             data += 2;
  54             break;
  55         case 2:
  56             evas_vg_shape_append_cubic_to(shape, data[0], data[1], data[2], data[3], data[4], data[5]);
  57             data += 6;
  58             break;
  59         case 3:
  60             evas_vg_shape_append_close(shape);
  61             break;
  62         default:
  63             break;
  64         }
  65     }
  66
  67     //1: Stroke
  68     if (node->mStroke.enable) {
  69         //Stroke Width
  70         evas_vg_shape_stroke_width_set(shape, node->mStroke.width);
  71
  72         //Stroke Cap
  73         Efl_Gfx_Cap cap;
  74         switch (node->mStroke.cap) {
  75         case CapFlat: cap = EFL_GFX_CAP_BUTT; break;
  76         case CapSquare: cap = EFL_GFX_CAP_SQUARE; break;
  77         case CapRound: cap = EFL_GFX_CAP_ROUND; break;
  78         default: cap = EFL_GFX_CAP_BUTT; break;
  79         }
  80         evas_vg_shape_stroke_cap_set(shape, cap);
  81
  82         //Stroke Join
  83         Efl_Gfx_Join join;
  84         switch (node->mStroke.join) {
  85         case JoinMiter: join = EFL_GFX_JOIN_MITER; break;
  86         case JoinBevel: join = EFL_GFX_JOIN_BEVEL; break;
  87         case JoinRound: join = EFL_GFX_JOIN_ROUND; break;
  88         default: join = EFL_GFX_JOIN_MITER; break;
  89         }
  90         evas_vg_shape_stroke_join_set(shape, join);
  91
  92         //Stroke Dash
  93         if (node->mStroke.dashArraySize > 0) {
  94             int size = (node->mStroke.dashArraySize / 2);
  95             Efl_Gfx_Dash *dash = static_cast<Efl_Gfx_Dash*>(malloc(sizeof(Efl_Gfx_Dash) * size));
  96             if (dash) {
  97                 for (int i = 0; i <= size; i+=2) {
  98                     dash[i].length = node->mStroke.dashArray[i];
  99                     dash[i].gap = node->mStroke.dashArray[i + 1];
 100                 }
 101                 evas_vg_shape_stroke_dash_set(shape, dash, size);
 102                 free(dash);
 103             }
 104         }
 105     }
 106
 107     //2: Fill Method
 108     switch (node->mBrushType) {
 109     case BrushSolid: {
 110         float pa = ((float)node->mColor.a) / 255;
 111         int r = (int)(((float) node->mColor.r) * pa);
 112         int g = (int)(((float) node->mColor.g) * pa);
 113         int b = (int)(((float) node->mColor.b) * pa);
 114         int a = node->mColor.a;
 115         if (node->mStroke.enable)
 116           evas_vg_shape_stroke_color_set(shape, r, g, b, a);
 117         else
 118           evas_vg_node_color_set(shape, r, g, b, a);
 119         break;
 120     }
 121     case BrushGradient: {
 122         Efl_VG* grad = NULL;
 123         if (node->mGradient.type == GradientLinear) {
 124             grad = evas_vg_gradient_linear_add(root);
 125             evas_vg_gradient_linear_start_set(grad, node->mGradient.start.x, node->mGradient.start.y);
 126             evas_vg_gradient_linear_end_set(grad, node->mGradient.end.x, node->mGradient.end.y);
 127
 128         }
 129         else if (node->mGradient.type == GradientRadial) {
 130             grad = evas_vg_gradient_radial_add(root);
 131             evas_vg_gradient_radial_center_set(grad, node->mGradient.center.x, node->mGradient.center.y);
 132             evas_vg_gradient_radial_focal_set(grad, node->mGradient.focal.x, node->mGradient.focal.y);
 133             evas_vg_gradient_radial_radius_set(grad, node->mGradient.cradius);
 134         }
 135
 136         if (grad) {
 137             //Gradient Stop
 138             Efl_Gfx_Gradient_Stop* stops = static_cast<Efl_Gfx_Gradient_Stop*>(malloc(sizeof(Efl_Gfx_Gradient_Stop) * node->mGradient.stopCount));
 139             if (stops) {
 140                 for (unsigned int i = 0; i < node->mGradient.stopCount; i++) {
 141                     stops[i].offset = node->mGradient.stopPtr[i].pos;
 142                     float pa = ((float)node->mGradient.stopPtr[i].a) / 255;
 143                     stops[i].r = (int)(((float)node->mGradient.stopPtr[i].r) * pa);
 144                     stops[i].g = (int)(((float)node->mGradient.stopPtr[i].g) * pa);
 145                     stops[i].b = (int)(((float)node->mGradient.stopPtr[i].b) * pa);
 146                     stops[i].a = node->mGradient.stopPtr[i].a;
 147                 }
 148                 evas_vg_gradient_stop_set(grad, stops, node->mGradient.stopCount);
 149                 free(stops);
 150             }
 151             if (node->mStroke.enable)
 152               evas_vg_shape_stroke_fill_set(shape, grad);
 153             else
 154               evas_vg_shape_fill_set(shape, grad);
 155         }
 156         break;
 157     }
 158     default:
 159       break;
 160     }
 161
 162     //3: Fill Rule
 163     if (node->mFillRule == FillEvenOdd)
 164       efl_gfx_shape_fill_rule_set(shape, EFL_GFX_FILL_RULE_ODD_EVEN);
 165     else if (node->mFillRule == FillWinding)
 166       efl_gfx_shape_fill_rule_set(shape, EFL_GFX_FILL_RULE_WINDING);
 167 }
 168
 169 void LottieView::update(const std::vector<LOTNode *> &renderList)
 170 {
 171     Efl_VG *root = evas_vg_container_add(mVg);
 172     for(auto i : renderList) {
 173         createVgNode(i, root);
 174     }
 175     evas_object_vg_root_node_set(mVg, root);
 176 }
 177
 178 void LottieView::updateTree(const LOTLayerNode * node)
 179 {
 180     Efl_VG *root = evas_vg_container_add(mVg);
 181     update(node, root);
 182     evas_object_vg_root_node_set(mVg, root);
 183 }
 184
 185 void LottieView::update(const LOTLayerNode * node, Efl_VG *parent)
 186 {
 187     // if the layer is invisible return
 188     if (!node->mVisible) return;
 189
 190     // check if this layer is a container layer
 191     bool hasMatte = false;
 192     if (node->mLayerList.size) {
 193         for (unsigned int i = 0; i < node->mLayerList.size; i++) {
 194             if (hasMatte) {
 195                 hasMatte = false;
 196                 continue;
 197             }
 198             // if the layer has matte then
 199             // the next layer has to be rendered using this layer
 200             // as matte source
 201             if (node->mLayerList.ptr[i]->mMatte != MatteNone) {
 202                 hasMatte = true;
 203                 printf("Matte is not supported Yet\n");
 204                 continue;
 205             }
 206             update(node->mLayerList.ptr[i], parent);
 207         }
 208     }
 209
 210     // check if this layer has drawable
 211     if (node->mNodeList.size) {
 212         for (unsigned int i = 0; i < node->mNodeList.size; i++) {
 213             createVgNode(node->mNodeList.ptr[i], parent);
 214         }
 215     }
 216 }
 217
 218 static void mImageDelCb(void *data, Evas *evas, Evas_Object *obj, void *)
 219 {
 220     LottieView *lottie = (LottieView *)data;
 221
 222     if (lottie->mImage != obj) return;
 223
 224     lottie->mImage = NULL;
 225     lottie->stop();
 226 }
 227
 228 static void mVgDelCb(void *data, Evas *evas, Evas_Object *obj, void *)
 229 {
 230     LottieView *lottie = (LottieView *)data;
 231     if (lottie->mVg != obj) return;
 232
 233     lottie->mVg = NULL;
 234     lottie->stop();
 235 }
 236
 237 void LottieView::initializeBufferObject(Evas *evas)
 238 {
 239     if (mRenderMode) {
 240         mImage = evas_object_image_filled_add(evas);
 241         evas_object_image_colorspace_set(mImage, EVAS_COLORSPACE_ARGB8888);
 242         evas_object_image_alpha_set(mImage, EINA_TRUE);
 243         evas_object_event_callback_add(mImage, EVAS_CALLBACK_DEL, mImageDelCb, this);
 244     } else {
 245         mVg = evas_object_vg_add(evas);
 246         evas_object_event_callback_add(mVg, EVAS_CALLBACK_DEL, mVgDelCb, this);
 247     }
 248 }
 249
 250 LottieView::LottieView(Evas *evas, bool renderMode, bool asyncRender):mVg(nullptr), mImage(nullptr)
 251 {
 252     mPlayer = nullptr;
 253     mPalying = false;
 254     mReverse = false;
 255     mRepeatCount = 0;
 256     mRepeatMode = LottieView::RepeatMode::Restart;
 257     mLoop = false;
 258     mSpeed = 1;
 259
 260     mEvas = evas;
 261     mRenderMode = renderMode;
 262     mAsyncRender = asyncRender;
 263
 264     initializeBufferObject(evas);
 265 }
 266
 267 LottieView::~LottieView()
 268 {
 269     if (mRenderTask.valid())
 270         mRenderTask.get();
 271
 272     if (mAnimator) ecore_animator_del(mAnimator);
 273     if (mVg) evas_object_del(mVg);
 274     if (mImage) evas_object_del(mImage);
 275 }
 276
 277 Evas_Object *LottieView::getImage() {
 278     if (mRenderMode) {
 279         return mImage;
 280     } else {
 281         return mVg;
 282     }
 283 }
 284
 285 void LottieView::show()
 286 {
 287     if (mRenderMode) {
 288         evas_object_show(mImage);
 289     } else {
 290         evas_object_show(mVg);
 291     }
 292     seek(0);
 293 }
 294
 295 void LottieView::hide()
 296 {
 297     if (mRenderMode) {
 298         evas_object_hide(mImage);
 299     } else {
 300         evas_object_hide(mVg);
 301     }
 302 }
 303
 304 void LottieView::seek(float pos)
 305 {
 306     if (!mPlayer) return;
 307
 308
 309     mPos = mapProgress(pos);
 310
 311     // check if the pos maps to the current frame
 312     if (mCurFrame == mPlayer->frameAtPos(mPos)) return;
 313
 314     mCurFrame = mPlayer->frameAtPos(mPos);
 315
 316     if (mRenderMode) {
 317         int width , height;
 318         evas_object_image_size_get(mImage, &width, &height);
 319         if (mAsyncRender) {
 320             if (mRenderTask.valid()) return;
 321             mDirty = true;
 322             auto buffer = (uint32_t *)evas_object_image_data_get(mImage, EINA_TRUE);
 323             size_t bytesperline =  evas_object_image_stride_get(mImage);
 324             lottie::Surface surface(buffer, width, height, bytesperline);
 325             mRenderTask = mPlayer->render(mCurFrame, surface);
 326             // to force a redraw
 327             evas_object_image_data_update_add(mImage, 0 , 0, surface.width(), surface.height());
 328         } else {
 329             auto buffer = (uint32_t *)evas_object_image_data_get(mImage, EINA_TRUE);
 330             size_t bytesperline =  evas_object_image_stride_get(mImage);
 331             lottie::Surface surface(buffer, width, height, bytesperline);
 332             mPlayer->renderSync(mCurFrame, surface);
 333             evas_object_image_data_set(mImage, surface.buffer());
 334             evas_object_image_data_update_add(mImage, 0 , 0, surface.width(), surface.height());
 335         }
 336     } else {
 337         const LOTLayerNode *root = mPlayer->renderTree(mCurFrame, mw, mh);
 338         updateTree(root);
 339     }
 340 }
 341
 342 float LottieView::getPos()
 343 {
 344    return mPos;
 345 }
 346
 347 void LottieView::render()
 348 {
 349     if (!mPlayer) return;
 350
 351     if (!mDirty) return;
 352     mDirty = false;
 353
 354     if (mRenderMode) {
 355         if (!mRenderTask.valid()) return;
 356         auto surface = mRenderTask.get();
 357         evas_object_image_data_set(mImage, surface.buffer());
 358         evas_object_image_data_update_add(mImage, 0 , 0, surface.width(), surface.height());
 359     }
 360 }
 361
 362 void LottieView::setFilePath(const char *filePath)
 363 {
 364     if (mPlayer = Animation::loadFromFile(filePath)) {
 365         mFrameRate = mPlayer->frameRate();
 366         mTotalFrame = mPlayer->totalFrame();
 367     } else {
 368         printf("load failed file %s\n", filePath);
 369     }
 370 }
 371
 372 void LottieView::loadFromData(const std::string &jsonData, const std::string &key)
 373 {
 374     if (mPlayer = Animation::loadFromData(jsonData, key)) {
 375         mFrameRate = mPlayer->frameRate();
 376         mTotalFrame = mPlayer->totalFrame();
 377     } else {
 378         printf("load failed from data key : %s\n", key.c_str());
 379     }
 380 }
 381
 382 void LottieView::setSize(int w, int h)
 383 {
 384     mw = w; mh = h;
 385
 386     if (mRenderMode) {
 387         evas_object_resize(mImage, w, h);
 388         evas_object_image_size_set(mImage, w, h);
 389     } else {
 390         evas_object_resize(mVg, w, h);
 391     }
 392 }
 393 void LottieView::setPos(int x, int y)
 394 {
 395     if (mRenderMode) {
 396         evas_object_move(mImage, x, y);
 397     } else {
 398         evas_object_move(mVg, x, y);
 399     }
 400 }
 401
 402 void LottieView::finished()
 403 {
 404     restart();
 405 }
 406
 407 void LottieView::loop(bool loop)
 408 {
 409     mLoop = loop;
 410 }
 411
 412 void LottieView::setRepeatCount(int count)
 413 {
 414     mRepeatCount = count;
 415 }
 416
 417 void LottieView::setRepeatMode(LottieView::RepeatMode mode)
 418 {
 419     mRepeatMode = mode;
 420 }
 421
 422 void LottieView::play()
 423 {
 424     if (!mPlayer) return;
 425
 426     if (mAnimator) ecore_animator_del(mAnimator);
 427     mAnimator = ecore_animator_timeline_add(duration()/mSpeed, animator, this);
 428     mReverse = false;
 429     mCurCount = mRepeatCount;
 430     mPalying = true;
 431 }
 432
 433 void LottieView::pause()
 434 {
 435
 436 }
 437
 438 void LottieView::stop()
 439 {
 440     mPalying = false;
 441     if (mAnimator) {
 442         ecore_animator_del(mAnimator);
 443         mAnimator = NULL;
 444     }
 445 }
 446
 447 void LottieView::restart()
 448 {
 449     if (!mPlayer) return;
 450
 451     mCurCount--;
 452     if (mLoop || mRepeatCount) {
 453         if (mRepeatMode == LottieView::RepeatMode::Reverse)
 454             mReverse = !mReverse;
 455         else
 456             mReverse = false;
 457
 458         if (mAnimator) ecore_animator_del(mAnimator);
 459         mAnimator = ecore_animator_timeline_add(duration()/mSpeed, animator, this);
 460     }
 461 }