example/lottieview.cpp

   1 /*
   2  * Copyright (c) 2018 Samsung Electronics Co., Ltd. All rights reserved.
   3  *
   4  * Licensed under the Flora License, Version 1.1 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include"lottieview.h"
  18
  19 using namespace lottie;
  20
  21 static Eina_Bool
  22 animator(void *data , double pos)
  23 {
  24     LottieView *view = static_cast<LottieView *>(data);
  25     float nextPos = pos + view->mStartPos;
  26     if (nextPos > 1.0) nextPos = 1.0;
  27
  28     view->seek(nextPos);
  29     if (nextPos == 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     if (mPalying && mReverse)
 309         pos = 1.0 - pos;
 310
 311     mPos = pos;
 312
 313     // check if the pos maps to the current frame
 314     if (mCurFrame == mPlayer->frameAtPos(mPos)) return;
 315
 316     mCurFrame = mPlayer->frameAtPos(mPos);
 317
 318     if (mRenderMode) {
 319         int width , height;
 320         evas_object_image_size_get(mImage, &width, &height);
 321         if (mAsyncRender) {
 322             if (mRenderTask.valid()) return;
 323             mDirty = true;
 324             auto buffer = (uint32_t *)evas_object_image_data_get(mImage, EINA_TRUE);
 325             size_t bytesperline =  evas_object_image_stride_get(mImage);
 326             lottie::Surface surface(buffer, width, height, bytesperline);
 327             mRenderTask = mPlayer->render(mCurFrame, surface);
 328             // to force a redraw
 329             evas_object_image_data_update_add(mImage, 0 , 0, surface.width(), surface.height());
 330         } else {
 331             auto buffer = (uint32_t *)evas_object_image_data_get(mImage, EINA_TRUE);
 332             size_t bytesperline =  evas_object_image_stride_get(mImage);
 333             lottie::Surface surface(buffer, width, height, bytesperline);
 334             mPlayer->renderSync(mCurFrame, surface);
 335             evas_object_image_data_set(mImage, surface.buffer());
 336             evas_object_image_data_update_add(mImage, 0 , 0, surface.width(), surface.height());
 337         }
 338     } else {
 339         const LOTLayerNode *root = mPlayer->renderTree(mCurFrame, mw, mh);
 340         updateTree(root);
 341     }
 342 }
 343
 344 float LottieView::getPos()
 345 {
 346    return mPos;
 347 }
 348
 349 void LottieView::render()
 350 {
 351     if (!mPlayer) return;
 352
 353     if (!mDirty) return;
 354     mDirty = false;
 355
 356     if (mRenderMode) {
 357         if (!mRenderTask.valid()) return;
 358         auto surface = mRenderTask.get();
 359         evas_object_image_data_set(mImage, surface.buffer());
 360         evas_object_image_data_update_add(mImage, 0 , 0, surface.width(), surface.height());
 361     }
 362 }
 363
 364 void LottieView::setFilePath(const char *filePath)
 365 {
 366     if (mPlayer = Animation::loadFromFile(filePath)) {
 367         mFrameRate = mPlayer->frameRate();
 368         mTotalFrame = mPlayer->totalFrame();
 369     } else {
 370         printf("load failed file %s\n", filePath);
 371     }
 372 }
 373
 374 void LottieView::loadFromData(const std::string &jsonData, const std::string &key)
 375 {
 376     if (mPlayer = Animation::loadFromData(jsonData, key)) {
 377         mFrameRate = mPlayer->frameRate();
 378         mTotalFrame = mPlayer->totalFrame();
 379     } else {
 380         printf("load failed from data key : %s\n", key.c_str());
 381     }
 382 }
 383
 384 void LottieView::setSize(int w, int h)
 385 {
 386     mw = w; mh = h;
 387
 388     if (mRenderMode) {
 389         evas_object_resize(mImage, w, h);
 390         evas_object_image_size_set(mImage, w, h);
 391     } else {
 392         evas_object_resize(mVg, w, h);
 393     }
 394 }
 395 void LottieView::setPos(int x, int y)
 396 {
 397     if (mRenderMode) {
 398         evas_object_move(mImage, x, y);
 399     } else {
 400         evas_object_move(mVg, x, y);
 401     }
 402 }
 403
 404 void LottieView::finished()
 405 {
 406     restart();
 407 }
 408
 409 void LottieView::loop(bool loop)
 410 {
 411     mLoop = loop;
 412 }
 413
 414 void LottieView::setRepeatCount(int count)
 415 {
 416     mRepeatCount = count;
 417 }
 418
 419 void LottieView::setRepeatMode(LottieView::RepeatMode mode)
 420 {
 421     mRepeatMode = mode;
 422 }
 423
 424 void LottieView::play()
 425 {
 426     if (!mPlayer) return;
 427
 428     mStartPos = mPos;
 429     if (mAnimator) ecore_animator_del(mAnimator);
 430     mAnimator = ecore_animator_timeline_add(mPlayer->duration()/mSpeed, animator, this);
 431     mReverse = false;
 432     mCurCount = mRepeatCount;
 433     mPalying = true;
 434 }
 435
 436 void LottieView::pause()
 437 {
 438
 439 }
 440
 441 void LottieView::stop()
 442 {
 443     mPalying = false;
 444     if (mAnimator) {
 445         ecore_animator_del(mAnimator);
 446         mAnimator = NULL;
 447     }
 448 }
 449
 450 void LottieView::restart()
 451 {
 452     if (!mPlayer) return;
 453
 454     mCurCount--;
 455     if (mLoop || mRepeatCount) {
 456         if (mRepeatMode == LottieView::RepeatMode::Reverse)
 457             mReverse = !mReverse;
 458         else
 459             mReverse = false;
 460
 461         mStartPos = 0;
 462         if (mAnimator) ecore_animator_del(mAnimator);
 463         mAnimator = ecore_animator_timeline_add(mPlayer->duration()/mSpeed, animator, this);
 464     }
 465 }