src/lottie/lottieitem.cpp

   1 #include "lottieitem.h"
   2 #include"vbitmap.h"
   3 #include"vpainter.h"
   4 #include"vraster.h"
   5 #include"vdasher.h"
   6 #include <cmath>
   7
   8
   9 VDrawable::VDrawable():mFlag(DirtyState::All),
  10                        mType(Type::Fill),
  11                        mFillRule(FillRule::Winding)
  12 {
  13     mStroke.dashArraySize = 0;
  14     mStroke.cap = CapStyle::Round;
  15     mStroke.join= JoinStyle::Round;
  16     mStroke.meterLimit = 10;
  17     mStroke.enable = false;
  18 }
  19
  20 void VDrawable::preprocess()
  21 {
  22     if (mFlag & (DirtyState::Path)) {
  23         if (mStroke.enable) {
  24             VPath newPath = mPath;
  25             if (mStroke.dashArraySize) {
  26                 VDasher dasher(mStroke.dashArray, mStroke.dashArraySize);
  27                 newPath = dasher.dashed(mPath);
  28             }
  29             FTOutline *outline = VRaster::toFTOutline(newPath);
  30             mRle = VRaster::instance().generateStrokeInfo(outline, mStroke.cap, mStroke.join,
  31                                                           mStroke.width, mStroke.meterLimit);
  32             VRaster::deleteFTOutline(outline);
  33         } else {
  34             FTOutline *outline = VRaster::toFTOutline(mPath);
  35             mRle = VRaster::instance().generateFillInfo(outline, mFillRule);
  36             VRaster::deleteFTOutline(outline);
  37         }
  38         mFlag &= ~DirtyFlag(DirtyState::Path);
  39     }
  40 }
  41
  42 void VDrawable::setStrokeInfo(CapStyle cap, JoinStyle join, float meterLimit, float strokeWidth)
  43 {
  44     mStroke.enable = true;
  45     mStroke.cap = cap;
  46     mStroke.join = join;
  47     mStroke.meterLimit = meterLimit;
  48     mStroke.width = strokeWidth;
  49     mFlag |= DirtyState::Path;
  50 }
  51 void VDrawable::setDashInfo(float *array, int size)
  52 {
  53     mStroke.dashArray = array;
  54     mStroke.dashArraySize = size;
  55     mFlag |= DirtyState::Path;
  56 }
  57
  58 void VDrawable::sync()
  59 {
  60     mCNode.mFlag = ChangeFlagNone;
  61     if (mFlag & DirtyState::None) return;
  62
  63     if (mFlag & DirtyState::Path) {
  64         const std::vector<VPath::Element> &elm = mPath.elements();
  65         const std::vector<VPointF> &pts  = mPath.points();
  66         const float *ptPtr = reinterpret_cast<const float *>(pts.data());
  67         const char *elmPtr = reinterpret_cast<const char *>(elm.data());
  68         mCNode.mPath.elmPtr = elmPtr;
  69         mCNode.mPath.elmCount = elm.size();
  70         mCNode.mPath.ptPtr = ptPtr;
  71         mCNode.mPath.ptCount = 2 * pts.size();
  72         mCNode.mFlag |= ChangeFlagPath;
  73     }
  74
  75     if (mStroke.enable) {
  76         mCNode.mStroke.width = mStroke.width;
  77         mCNode.mStroke.meterLimit = mStroke.meterLimit;
  78         mCNode.mStroke.enable = 1;
  79
  80         switch (mFillRule) {
  81         case FillRule::EvenOdd:
  82             mCNode.mFillRule = LOTNode::EvenOdd;
  83             break;
  84         default:
  85             mCNode.mFillRule = LOTNode::Winding;
  86             break;
  87         }
  88
  89         switch (mStroke.cap) {
  90         case CapStyle::Flat:
  91             mCNode.mStroke.cap = LOTNode::FlatCap;
  92             break;
  93         case CapStyle::Square:
  94             mCNode.mStroke.cap = LOTNode::SquareCap;
  95             break;
  96         case CapStyle::Round:
  97             mCNode.mStroke.cap = LOTNode::RoundCap;
  98             break;
  99         default:
 100             mCNode.mStroke.cap = LOTNode::FlatCap;
 101             break;
 102         }
 103
 104         switch (mStroke.join) {
 105         case JoinStyle::Miter:
 106             mCNode.mStroke.join = LOTNode::MiterJoin;
 107             break;
 108         case JoinStyle::Bevel:
 109             mCNode.mStroke.join = LOTNode::BevelJoin;
 110             break;
 111         case JoinStyle::Round:
 112             mCNode.mStroke.join = LOTNode::RoundJoin;
 113             break;
 114         default:
 115             mCNode.mStroke.join = LOTNode::MiterJoin;
 116             break;
 117         }
 118
 119         mCNode.mStroke.dashArray = mStroke.dashArray;
 120         mCNode.mStroke.dashArraySize = mStroke.dashArraySize;
 121
 122     } else {
 123         mCNode.mStroke.enable = 0;
 124     }
 125
 126     switch (mBrush.type()) {
 127     case VBrush::Type::Solid:
 128         mCNode.mType = LOTNode::BrushSolid;
 129         mCNode.mColor.r = mBrush.mColor.r;
 130         mCNode.mColor.g = mBrush.mColor.g;
 131         mCNode.mColor.b = mBrush.mColor.b;
 132         mCNode.mColor.a = mBrush.mColor.a;
 133         break;
 134     case VBrush::Type::LinearGradient:
 135         mCNode.mType = LOTNode::BrushGradient;
 136         mCNode.mGradient.type = LOTNode::Gradient::Linear;
 137         mCNode.mGradient.start.x = mBrush.mGradient->linear.x1;
 138         mCNode.mGradient.start.y = mBrush.mGradient->linear.y1;
 139         mCNode.mGradient.end.x = mBrush.mGradient->linear.x2;
 140         mCNode.mGradient.end.y = mBrush.mGradient->linear.y2;
 141         break;
 142     case VBrush::Type::RadialGradient:
 143         mCNode.mType = LOTNode::BrushGradient;
 144         mCNode.mGradient.type = LOTNode::Gradient::Radial;
 145         mCNode.mGradient.center.x = mBrush.mGradient->radial.cx;
 146         mCNode.mGradient.center.y = mBrush.mGradient->radial.cy;
 147         mCNode.mGradient.focal.x = mBrush.mGradient->radial.fx;
 148         mCNode.mGradient.focal.y = mBrush.mGradient->radial.fy;
 149         mCNode.mGradient.cradius = mBrush.mGradient->radial.cradius;
 150         mCNode.mGradient.fradius = mBrush.mGradient->radial.fradius;
 151         break;
 152     default:
 153         break;
 154     }
 155 }
 156
 157 /* Lottie Layer Rules
 158  * 1. time stretch is pre calculated and applied to all the properties of the lottilayer model and all its children
 159  * 2. The frame property could be reversed using,time-reverse layer property in AE. which means (start frame > endFrame)
 160  * 3.
 161  */
 162
 163 LOTCompItem::LOTCompItem(LOTModel *model):mRootModel(model), mUpdateViewBox(false),mCurFrameNo(-1)
 164 {
 165    // 1. build layer item list
 166    mCompData = model->mRoot.get();
 167    for(auto i : mCompData->mChildren) {
 168       LOTLayerData *layerData = dynamic_cast<LOTLayerData *>(i.get());
 169       if (layerData) {
 170          LOTLayerItem *layerItem = LOTCompItem::createLayerItem(layerData);
 171          if (layerItem) {
 172             mLayers.push_back(layerItem);
 173             mLayerMap[layerItem->id()] = layerItem;
 174          }
 175       }
 176    }
 177
 178    //2. update parent layer
 179    for(auto i : mLayers) {
 180       int id = i->parentId();
 181       if (id >=0) {
 182          auto search = mLayerMap.find(id);
 183          if (search != mLayerMap.end()) {
 184            LOTLayerItem *parentLayer = search->second;
 185            i->setParentLayer(parentLayer);
 186          }
 187       }
 188    }
 189    //3. update static property of each layer
 190    for(auto i : mLayers) {
 191       i->updateStaticProperty();
 192    }
 193
 194    mViewSize = mCompData->size();
 195 }
 196
 197 LOTCompItem::~LOTCompItem()
 198 {
 199     for(auto i : mLayers) {
 200        delete i;
 201     }
 202 }
 203
 204 LOTLayerItem *
 205 LOTCompItem::createLayerItem(LOTLayerData *layerData)
 206 {
 207     switch(layerData->mLayerType) {
 208         case LayerType::Precomp: {
 209             return new LOTCompLayerItem(layerData);
 210             break;
 211         }
 212         case LayerType::Solid: {
 213             return new LOTSolidLayerItem(layerData);
 214             break;
 215         }
 216         case LayerType::Shape: {
 217             return new LOTShapeLayerItem(layerData);
 218             break;
 219         }
 220         case LayerType::Null: {
 221             return new LOTNullLayerItem(layerData);
 222             break;
 223         }
 224         default:
 225             return nullptr;
 226             break;
 227     }
 228 }
 229
 230 void LOTCompItem::resize(const VSize &size)
 231 {
 232    if (mViewSize == size) return;
 233    mViewSize = size;
 234    mUpdateViewBox = true;
 235 }
 236
 237 VSize LOTCompItem::size() const
 238 {
 239    return mViewSize;
 240 }
 241
 242 bool LOTCompItem::update(int frameNo)
 243 {
 244    VMatrix m;
 245    float sx, sy;
 246
 247    // check if cached frame is same as requested frame.
 248    if (!mUpdateViewBox && (mCurFrameNo == frameNo)) return false;
 249
 250    sx = mViewSize.width() / float(mCompData->size().width());
 251    sy = mViewSize.height() / float(mCompData->size().height());
 252    float scale = fmin(sx, sy);
 253    m.scale(scale, scale);
 254
 255    // update the layer from back to front
 256    for (auto i = mLayers.rbegin(); i != mLayers.rend(); ++i) {
 257       LOTLayerItem *layer = *i;
 258       layer->update(frameNo, m, 1.0);
 259    }
 260    buildRenderList();
 261    mCurFrameNo = frameNo;
 262    mUpdateViewBox = false;
 263    return true;
 264 }
 265
 266 void LOTCompItem::buildRenderList()
 267 {
 268     mRenderList.clear();
 269     std::vector<VDrawable *> list;
 270     for (auto i = mLayers.rbegin(); i != mLayers.rend(); ++i) {
 271        LOTLayerItem *layer = *i;
 272        layer->renderList(list);
 273     }
 274
 275     for(auto i : list) {
 276         i->sync();
 277         mRenderList.push_back(&i->mCNode);
 278     }
 279 }
 280
 281 const std::vector<LOTNode *>& LOTCompItem::renderList() const
 282 {
 283     return mRenderList;
 284 }
 285
 286 bool LOTCompItem::render(const LOTBuffer &buffer)
 287 {
 288     VBitmap bitmap((uchar *)buffer.buffer, buffer.width, buffer.height,
 289                    buffer.bytesPerLine, VBitmap::Format::ARGB32_Premultiplied, nullptr, nullptr);
 290
 291     VPainter painter(&bitmap);
 292     VRle mask;
 293     for (auto i = mLayers.rbegin(); i != mLayers.rend(); ++i) {
 294        LOTLayerItem *layer = *i;
 295        layer->render(&painter, mask);
 296     }
 297
 298     return true;
 299 }
 300
 301 void LOTMaskItem::update(int frameNo, const VMatrix &parentMatrix,
 302                          float parentAlpha, const DirtyFlag &flag)
 303 {
 304     if (mData->mShape.isStatic()) {
 305         if (mLocalPath.isEmpty()) {
 306             mLocalPath = mData->mShape.value(frameNo).toPath();
 307         }
 308     } else {
 309         mLocalPath = mData->mShape.value(frameNo).toPath();
 310     }
 311     float opacity = mData->opacity(frameNo);
 312     opacity = opacity * parentAlpha;
 313
 314     VPath path = mLocalPath;
 315     path.transform(parentMatrix);
 316
 317     FTOutline *outline = VRaster::toFTOutline(path);
 318     mRle = VRaster::instance().generateFillInfo(outline);
 319     VRaster::deleteFTOutline(outline);
 320
 321     mRle = mRle * (opacity * 255);
 322
 323     if (mData->mInv) {
 324         mRle = ~mRle;
 325     }
 326 }
 327
 328 void LOTLayerItem::render(VPainter *painter, const VRle &inheritMask)
 329 {
 330     std::vector<VDrawable *> list;
 331     renderList(list);
 332     VRle mask = inheritMask;
 333     if (hasMask()) {
 334         if (mask.isEmpty())
 335             mask = maskRle();
 336         else
 337             mask = mask & inheritMask;
 338     }
 339     for(auto i : list) {
 340         i->preprocess();
 341         painter->setBrush(i->mBrush);
 342         if (!mask.isEmpty()) {
 343             VRle rle = i->mRle & mask;
 344             painter->drawRle(VPoint(), rle);
 345         } else {
 346             painter->drawRle(VPoint(), i->mRle);
 347         }
 348     }
 349 }
 350
 351 VRle LOTLayerItem::maskRle()
 352 {
 353     VRle rle;
 354     for (auto &i : mMasks) {
 355         switch (i->maskMode()) {
 356             case LOTMaskData::Mode::Add: {
 357                 rle = rle + i->mRle;
 358                 break;
 359             }
 360             case LOTMaskData::Mode::Substarct: {
 361                 if (rle.isEmpty() && !mBoundingRect.isEmpty())
 362                     rle = VRle::toRle(mBoundingRect);
 363                 rle = rle - i->mRle;
 364                 break;
 365             }
 366             case LOTMaskData::Mode::Intersect: {
 367                 rle = rle & i->mRle;
 368                 break;
 369             }
 370             default:
 371                 break;
 372         }
 373     }
 374     return rle;
 375 }
 376
 377 LOTLayerItem::LOTLayerItem(LOTLayerData *layerData):mLayerData(layerData),
 378                                                     mParentLayer(nullptr),
 379                                                     mPrecompLayer(nullptr),
 380                                                     mFrameNo(-1),
 381                                                     mDirtyFlag(DirtyFlagBit::All)
 382 {
 383     if (mLayerData->mHasMask) {
 384         for (auto i : mLayerData->mMasks) {
 385             mMasks.push_back(std::unique_ptr<LOTMaskItem>(new LOTMaskItem(i.get())));
 386         }
 387     }
 388 }
 389
 390 void LOTLayerItem::updateStaticProperty()
 391 {
 392    if (mParentLayer)
 393      mParentLayer->updateStaticProperty();
 394
 395    mStatic = mLayerData->isStatic();
 396    mStatic = mParentLayer ? (mStatic & mParentLayer->isStatic()) : mStatic;
 397    mStatic = mPrecompLayer ? (mStatic & mPrecompLayer->isStatic()) : mStatic;
 398 }
 399
 400 void LOTLayerItem::update(int frameNo, const VMatrix &parentMatrix, float parentAlpha)
 401 {
 402    mFrameNo = frameNo;
 403    // 1. check if the layer is part of the current frame
 404    if (!visible()) return;
 405
 406    // 2. calculate the parent matrix and alpha
 407    VMatrix m = matrix(frameNo) * parentMatrix;
 408    float alpha = parentAlpha * opacity(frameNo);
 409
 410    //6. update the mask
 411    if (hasMask()) {
 412        for (auto &i : mMasks)
 413            i->update(frameNo, m, alpha, mDirtyFlag);
 414    }
 415
 416    // 3. update the dirty flag based on the change
 417    if (!mCombinedMatrix.fuzzyCompare(m)) {
 418        mDirtyFlag |= DirtyFlagBit::Matrix;
 419    }
 420    if (!vCompare(mCombinedAlpha, alpha)) {
 421        mDirtyFlag |= DirtyFlagBit::Alpha;
 422    }
 423    mCombinedMatrix = m;
 424    mCombinedAlpha = alpha;
 425
 426    // 4. if no parent property change and layer is static then nothing to do.
 427    if ((flag() & DirtyFlagBit::None) && isStatic())
 428       return;
 429
 430    //5. update the content of the layer
 431    updateContent();
 432
 433    //6. reset the dirty flag
 434    mDirtyFlag = DirtyFlagBit::None;
 435 }
 436
 437 float
 438 LOTLayerItem::opacity(int frameNo) const
 439 {
 440    return mLayerData->mTransform->opacity(frameNo);
 441 }
 442
 443 VMatrix
 444 LOTLayerItem::matrix(int frameNo) const
 445 {
 446     if (mParentLayer)
 447         return mLayerData->mTransform->matrix(frameNo) * mParentLayer->matrix(frameNo);
 448     else
 449         return mLayerData->mTransform->matrix(frameNo);
 450 }
 451
 452 bool LOTLayerItem::visible() const
 453 {
 454    if (frameNo() >= mLayerData->inFrame() && frameNo() < mLayerData->outFrame())
 455       return true;
 456    else
 457       return false;
 458 }
 459
 460
 461
 462 LOTCompLayerItem::LOTCompLayerItem(LOTLayerData *layerModel):LOTLayerItem(layerModel)
 463 {
 464    for(auto i : mLayerData->mChildren) {
 465       LOTLayerData *layerModel = dynamic_cast<LOTLayerData *>(i.get());
 466       if (layerModel) {
 467          LOTLayerItem *layerItem = LOTCompItem::createLayerItem(layerModel);
 468          if (layerItem) {
 469             mLayers.push_back(layerItem);
 470             mLayerMap[layerItem->id()] = layerItem;
 471          }
 472       }
 473    }
 474
 475    //2. update parent layer
 476    for(auto i : mLayers) {
 477       int id = i->parentId();
 478       if (id >=0) {
 479          auto search = mLayerMap.find(id);
 480          if (search != mLayerMap.end()) {
 481            LOTLayerItem *parentLayer = search->second;
 482            i->setParentLayer(parentLayer);
 483          }
 484       }
 485       i->setPrecompLayer(this);
 486    }
 487 }
 488
 489 void LOTCompLayerItem::updateStaticProperty()
 490 {
 491     LOTLayerItem::updateStaticProperty();
 492
 493     for(auto i : mLayers) {
 494        i->updateStaticProperty();
 495     }
 496 }
 497
 498 void LOTCompLayerItem::render(VPainter *painter, const VRle &inheritMask)
 499 {
 500     VRle mask = inheritMask;
 501
 502     if (hasMask()) {
 503         if (mask.isEmpty())
 504             mask = maskRle();
 505         else
 506             mask = mask & inheritMask;
 507     }
 508
 509     for(auto i : mLayers) {
 510        i->render(painter, mask);
 511     }
 512 }
 513
 514 LOTCompLayerItem::~LOTCompLayerItem()
 515 {
 516     for(auto i : mLayers) {
 517        delete i;
 518     }
 519 }
 520
 521 void LOTCompLayerItem::updateContent()
 522 {
 523     // update the layer from back to front
 524     for (auto i = mLayers.rbegin(); i != mLayers.rend(); ++i) {
 525        LOTLayerItem *layer = *i;
 526        layer->update(frameNo(), combinedMatrix(), combinedAlpha());
 527     }
 528 }
 529
 530 void LOTCompLayerItem::renderList(std::vector<VDrawable *> &list)
 531 {
 532     if (!visible()) return;
 533
 534     // update the layer from back to front
 535     for (auto i = mLayers.rbegin(); i != mLayers.rend(); ++i) {
 536        LOTLayerItem *layer = *i;
 537        layer->renderList(list);
 538     }
 539 }
 540
 541 LOTSolidLayerItem::LOTSolidLayerItem(LOTLayerData *layerData):LOTLayerItem(layerData)
 542 {
 543
 544 }
 545
 546 void LOTSolidLayerItem::updateContent()
 547 {
 548    if (!mRenderNode) {
 549       mRenderNode = std::unique_ptr<VDrawable>(new VDrawable());
 550       mRenderNode->mType = VDrawable::Type::Fill;
 551       mRenderNode->mFlag |= VDrawable::DirtyState::All;
 552    }
 553
 554    if (flag() & DirtyFlagBit::Matrix) {
 555        VPath path;
 556        path.addRect(VRectF(0, 0, mLayerData->solidWidth(), mLayerData->solidHeight()));
 557        path.transform(combinedMatrix());
 558        mRenderNode->mFlag |= VDrawable::DirtyState::Path;
 559        mRenderNode->mPath = path;
 560    }
 561    if (flag() & DirtyFlagBit::Alpha) {
 562        LottieColor color = mLayerData->solidColor();
 563        VBrush brush(color.toColor(combinedAlpha()));
 564        mRenderNode->setBrush(brush);
 565        mRenderNode->mFlag |= VDrawable::DirtyState::Brush;
 566    }
 567 }
 568
 569 void LOTSolidLayerItem::renderList(std::vector<VDrawable *> &list)
 570 {
 571     if (!visible()) return;
 572
 573     list.push_back(mRenderNode.get());
 574 }
 575
 576 LOTNullLayerItem::LOTNullLayerItem(LOTLayerData *layerData):LOTLayerItem(layerData)
 577 {
 578
 579 }
 580 void LOTNullLayerItem::updateContent()
 581 {
 582
 583 }
 584
 585
 586 LOTShapeLayerItem::LOTShapeLayerItem(LOTLayerData *layerData):LOTLayerItem(layerData)
 587 {
 588     mRoot = new LOTContentGroupItem(nullptr);
 589     mRoot->addChildren(layerData);
 590     mRoot->processPaintOperation();
 591 }
 592
 593 LOTShapeLayerItem::~LOTShapeLayerItem()
 594 {
 595     delete mRoot;
 596 }
 597
 598 LOTContentItem * LOTShapeLayerItem::createContentItem(LOTData *contentData)
 599 {
 600     switch(contentData->type()) {
 601         case LOTData::Type::ShapeGroup: {
 602             return new LOTContentGroupItem(static_cast<LOTShapeGroupData *>(contentData));
 603             break;
 604         }
 605         case LOTData::Type::Rect: {
 606             return new LOTRectItem(static_cast<LOTRectData *>(contentData));
 607             break;
 608         }
 609         case LOTData::Type::Ellipse: {
 610             return new LOTEllipseItem(static_cast<LOTEllipseData *>(contentData));
 611             break;
 612         }
 613         case LOTData::Type::Shape: {
 614             return new LOTShapeItem(static_cast<LOTShapeData *>(contentData));
 615             break;
 616         }
 617         case LOTData::Type::Polystar: {
 618             return new LOTPolystarItem(static_cast<LOTPolystarData *>(contentData));
 619             break;
 620         }
 621         case LOTData::Type::Fill: {
 622             return new LOTFillItem(static_cast<LOTFillData *>(contentData));
 623             break;
 624         }
 625         case LOTData::Type::GFill: {
 626             return new LOTGFillItem(static_cast<LOTGFillData *>(contentData));
 627             break;
 628         }
 629         case LOTData::Type::Stroke: {
 630             return new LOTStrokeItem(static_cast<LOTStrokeData *>(contentData));
 631             break;
 632         }
 633         case LOTData::Type::GStroke: {
 634             return new LOTGStrokeItem(static_cast<LOTGStrokeData *>(contentData));
 635             break;
 636         }
 637         case LOTData::Type::Repeater: {
 638                 return new LOTRepeaterItem(static_cast<LOTRepeaterData *>(contentData));
 639                 break;
 640             }
 641         default:
 642             return nullptr;
 643             break;
 644     }
 645 }
 646
 647 void LOTShapeLayerItem::updateContent()
 648 {
 649    mRoot->update(frameNo(), combinedMatrix(), combinedAlpha(), flag());
 650 }
 651
 652 void LOTShapeLayerItem::renderList(std::vector<VDrawable *> &list)
 653 {
 654     if (!visible()) return;
 655     mRoot->renderList(list);
 656 }
 657
 658 LOTContentGroupItem::LOTContentGroupItem(LOTShapeGroupData *data):mData(data)
 659 {
 660    addChildren(mData);
 661 }
 662
 663 void LOTContentGroupItem::addChildren(LOTGroupData *data)
 664 {
 665    if (!data) return;
 666
 667    for(auto i : data->mChildren) {
 668       LOTData *data = i.get();
 669       LOTContentItem *content = LOTShapeLayerItem::createContentItem(data);
 670       if (content)
 671          mContents.push_back(content);
 672    }
 673 }
 674
 675 LOTContentGroupItem::~LOTContentGroupItem()
 676 {
 677     for(auto i : mContents) {
 678         delete i;
 679     }
 680 }
 681
 682
 683 void LOTContentGroupItem::update(int frameNo, const VMatrix &parentMatrix, float parentAlpha, const DirtyFlag &flag)
 684 {
 685    VMatrix m = parentMatrix;
 686    float alpha = parentAlpha;
 687    DirtyFlag newFlag = flag;
 688
 689    if (mData) {
 690       // update the matrix and the flag
 691       if ((flag & DirtyFlagBit::Matrix) || !mData->mTransform->staticMatrix() ) {
 692          newFlag |= DirtyFlagBit::Matrix;
 693       }
 694       m = mData->mTransform->matrix(frameNo) * parentMatrix;
 695       alpha *= mData->mTransform->opacity(frameNo);
 696
 697       if (!vCompare(alpha, parentAlpha)) {
 698          newFlag |= DirtyFlagBit::Alpha;
 699       }
 700    }
 701
 702    for (auto i = mContents.rbegin(); i != mContents.rend(); ++i) {
 703       (*i)->update(frameNo, m, alpha, newFlag);
 704    }
 705 }
 706
 707 void LOTContentGroupItem::renderList(std::vector<VDrawable *> &list)
 708 {
 709     for (auto i = mContents.rbegin(); i != mContents.rend(); ++i) {
 710        (*i)->renderList(list);
 711     }
 712 }
 713
 714 void LOTContentGroupItem::processPaintOperation()
 715 {
 716    std::vector<LOTPaintDataItem *> list;
 717    paintOperationHelper(list);
 718 }
 719
 720 void LOTContentGroupItem::paintOperationHelper(std::vector<LOTPaintDataItem *> &list)
 721 {
 722    int curOpCount = list.size();
 723    for (auto i = mContents.rbegin(); i != mContents.rend(); ++i) {
 724       auto child = *i;
 725       if (auto pathNode = dynamic_cast<LOTPathDataItem *>(child)) {
 726          // the node is a path data node add the paint operation list to it.
 727          pathNode->addPaintOperation(list, curOpCount);
 728       } else if (auto paintNode = dynamic_cast<LOTPaintDataItem *>(child)) {
 729          // add it to the paint operation list
 730          list.push_back(paintNode);
 731       } else if (auto groupNode = dynamic_cast<LOTContentGroupItem *>(child)) {
 732          // update the groups node with current list
 733          groupNode->paintOperationHelper(list);
 734       }
 735    }
 736    list.erase(list.begin() + curOpCount, list.end());
 737 }
 738
 739 void LOTPathDataItem::addPaintOperation(std::vector<LOTPaintDataItem *> &list, int externalCount)
 740 {
 741     for(auto paintItem : list) {
 742       bool sameGroup = (externalCount-- > 0) ? false : true;
 743       mNodeList.push_back(std::unique_ptr<VDrawable>(new VDrawable()));
 744       mRenderList.push_back(LOTRenderNode(this, paintItem, mNodeList.back().get(), sameGroup));
 745     }
 746 }
 747
 748
 749 void LOTPathDataItem::update(int frameNo, const VMatrix &parentMatrix, float parentAlpha, const DirtyFlag &flag)
 750 {
 751    mPathChanged = false;
 752    mCombinedAlpha = parentAlpha;
 753
 754    // 1. update the local path if needed
 755    if (!(mInit && mStaticPath)) {
 756       mLocalPath = getPath(frameNo);
 757       mInit = true;
 758       mPathChanged = true;
 759    }
 760
 761    // 2. apply path operation if needed
 762    // TODO
 763
 764    // 3. compute the final path with parentMatrix
 765    if ((flag & DirtyFlagBit::Matrix) || mPathChanged) {
 766       mFinalPath = mLocalPath;
 767       mFinalPath.transform(parentMatrix);
 768       mPathChanged = true;
 769    }
 770
 771    // 2. update the rendernode list
 772    for (const auto &i : mRenderList) {
 773       i.drawable->mFlag = VDrawable::DirtyState::None;
 774       i.paintNodeRef->updateRenderNode(i.pathNodeRef, i.drawable, i.sameGroup);
 775       if (mPathChanged) {
 776           i.drawable->mPath = mFinalPath;
 777           i.drawable->mFlag |= VDrawable::DirtyState::Path;
 778       }
 779    }
 780 }
 781
 782 void LOTPathDataItem::renderList(std::vector<VDrawable *> &list)
 783 {
 784    for (const auto &i : mRenderList) {
 785        list.push_back(i.drawable);
 786    }
 787 }
 788
 789 VPath LOTPathDataItem::path() const
 790 {
 791    return mFinalPath;
 792 }
 793
 794
 795 LOTRectItem::LOTRectItem(LOTRectData *data):LOTPathDataItem(data->isStatic()),mData(data)
 796 {
 797 }
 798
 799 VPath LOTRectItem::getPath(int frameNo)
 800 {
 801    VPointF pos = mData->mPos.value(frameNo);
 802    VPointF size = mData->mSize.value(frameNo);
 803    float radius = mData->mRound.value(frameNo);
 804    VRectF r(pos.x() - size.x()/2, pos.y() - size.y()/2, size.x(), size.y());
 805
 806    VPath path;
 807    path.addRoundRect(r, radius, radius, mData->direction());
 808
 809    return path;
 810 }
 811
 812 LOTEllipseItem::LOTEllipseItem(LOTEllipseData *data):LOTPathDataItem(data->isStatic()),mData(data)
 813 {
 814
 815 }
 816
 817 VPath LOTEllipseItem::getPath(int frameNo)
 818 {
 819    VPointF pos = mData->mPos.value(frameNo);
 820    VPointF size = mData->mSize.value(frameNo);
 821    VRectF r(pos.x() - size.x()/2, pos.y() - size.y()/2, size.x(), size.y());
 822
 823    VPath path;
 824    path.addOval(r, mData->direction());
 825
 826    return path;
 827 }
 828
 829 LOTShapeItem::LOTShapeItem(LOTShapeData *data):LOTPathDataItem(data->isStatic()),mData(data)
 830 {
 831
 832 }
 833
 834 VPath LOTShapeItem::getPath(int frameNo)
 835 {
 836     LottieShapeData shapeData = mData->mShape.value(frameNo);
 837
 838     if (shapeData.mPoints.empty())
 839      return VPath();
 840
 841     VPath path;
 842
 843     int size = shapeData.mPoints.size();
 844     const VPointF *points = shapeData.mPoints.data();
 845     path.moveTo(points[0]);
 846     for (int i = 1 ; i < size; i+=3) {
 847        path.cubicTo(points[i], points[i+1], points[i+2]);
 848     }
 849     if (shapeData.mClosed)
 850       path.close();
 851
 852    return path;
 853 }
 854
 855
 856 LOTPolystarItem::LOTPolystarItem(LOTPolystarData *data):LOTPathDataItem(data->isStatic()),mData(data)
 857 {
 858
 859 }
 860
 861 VPath LOTPolystarItem::getPath(int frameNo)
 862 {
 863    VPointF pos = mData->mPos.value(frameNo);
 864    float points = mData->mPointCount.value(frameNo);
 865    float innerRadius = mData->mInnerRadius.value(frameNo);
 866    float outerRadius = mData->mOuterRadius.value(frameNo);
 867    float innerRoundness = mData->mInnerRoundness.value(frameNo);
 868    float outerRoundness = mData->mOuterRoundness.value(frameNo);
 869    float rotation = mData->mRotation.value(frameNo);
 870
 871    VPath path;
 872    VMatrix m;
 873
 874    if (mData->mType == LOTPolystarData::PolyType::Star) {
 875         path.addPolystarStar(0.0, 0.0, 0.0, points,
 876                              innerRadius, outerRadius,
 877                              innerRoundness, outerRoundness,
 878                              mData->direction());
 879    } else {
 880         path.addPolystarPolygon(0.0, 0.0, 0.0, points,
 881                                 outerRadius, outerRoundness,
 882                                 mData->direction());
 883    }
 884
 885    m.translate(pos.x(), pos.y()).rotate(rotation);
 886    m.rotate(rotation);
 887    path.transform(m);
 888
 889    return path;
 890 }
 891
 892
 893
 894 /*
 895  * PaintData Node handling
 896  *
 897  */
 898
 899 void LOTPaintDataItem::update(int frameNo, const VMatrix &parentMatrix, float parentAlpha, const DirtyFlag &flag)
 900 {
 901    mContentChanged = false;
 902    mParentAlpha = parentAlpha;
 903    mParentMatrix = parentMatrix;
 904    mFlag = flag;
 905    mFrameNo = frameNo;
 906    // 1. update the local content if needed
 907   // if (!(mInit && mStaticContent)) {
 908       mInit = true;
 909       updateContent(frameNo);
 910       mContentChanged = true;
 911   // }
 912 }
 913
 914
 915 LOTFillItem::LOTFillItem(LOTFillData *data):LOTPaintDataItem(data->isStatic()),mData(data)
 916 {
 917 }
 918
 919 void LOTFillItem::updateContent(int frameNo)
 920 {
 921    LottieColor c = mData->mColor.value(frameNo);
 922    float opacity = mData->opacity(frameNo);
 923    mColor = c.toColor(opacity);
 924    mFillRule = mData->fillRule();
 925 }
 926
 927 void LOTFillItem::updateRenderNode(LOTPathDataItem *pathNode, VDrawable *drawable, bool sameParent)
 928 {
 929     VColor color = mColor;
 930     if (sameParent)
 931       color.setAlpha(color.a * pathNode->combinedAlpha());
 932     else
 933       color.setAlpha(color.a  * parentAlpha() * pathNode->combinedAlpha());
 934     VBrush brush(color);
 935     drawable->setBrush(brush);
 936     drawable->setFillRule(mFillRule);
 937 }
 938
 939
 940 LOTGFillItem::LOTGFillItem(LOTGFillData *data):LOTPaintDataItem(data->isStatic()),mData(data)
 941 {
 942 }
 943
 944 void LOTGFillItem::updateContent(int frameNo)
 945 {
 946     mData->update(mGradient, frameNo);
 947     mGradient->mMatrix = mParentMatrix;
 948     mFillRule = mData->fillRule();
 949 }
 950
 951 void LOTGFillItem::updateRenderNode(LOTPathDataItem *pathNode, VDrawable *drawable, bool sameParent)
 952 {
 953     drawable->setBrush(VBrush(mGradient.get()));
 954     drawable->setFillRule(mFillRule);
 955 }
 956
 957 LOTStrokeItem::LOTStrokeItem(LOTStrokeData *data):LOTPaintDataItem(data->isStatic()),mData(data)
 958 {
 959     mDashArraySize = 0;
 960 }
 961
 962 void LOTStrokeItem::updateContent(int frameNo)
 963 {
 964     LottieColor c = mData->mColor.value(frameNo);
 965     float opacity = mData->opacity(frameNo);
 966     mColor = c.toColor(opacity);
 967     mCap = mData->capStyle();
 968     mJoin = mData->joinStyle();
 969     mMiterLimit = mData->meterLimit();
 970     mWidth = mData->width(frameNo);
 971     if (mData->hasDashInfo()) {
 972         mDashArraySize = mData->getDashInfo(frameNo, mDashArray);
 973     }
 974 }
 975
 976 static float getScale(const VMatrix &matrix)
 977 {
 978     constexpr float SQRT_2 = 1.41421;
 979     VPointF p1(0,0);
 980     VPointF p2(SQRT_2,SQRT_2);
 981     p1 = matrix.map(p1);
 982     p2 = matrix.map(p2);
 983     VPointF final = p2 - p1;
 984
 985     return std::sqrt( final.x() * final.x() + final.y() * final.y());
 986 }
 987
 988 void LOTStrokeItem::updateRenderNode(LOTPathDataItem *pathNode, VDrawable *drawable, bool sameParent)
 989 {
 990     VColor color = mColor;
 991     if (sameParent)
 992       color.setAlpha(color.a * pathNode->combinedAlpha());
 993     else
 994       color.setAlpha(color.a  * parentAlpha() * pathNode->combinedAlpha());
 995
 996     VBrush brush(color);
 997     drawable->setBrush(brush);
 998
 999     drawable->setStrokeInfo(mCap, mJoin, mMiterLimit,  mWidth * getScale(mParentMatrix));
1000     if (mDashArraySize) {
1001         drawable->setDashInfo(mDashArray, mDashArraySize);
1002     }
1003 }
1004
1005 LOTGStrokeItem::LOTGStrokeItem(LOTGStrokeData *data):LOTPaintDataItem(data->isStatic()),mData(data)
1006 {
1007     mDashArraySize = 0;
1008 }
1009
1010 void LOTGStrokeItem::updateContent(int frameNo)
1011 {
1012     mData->update(mGradient, frameNo);
1013     mGradient->mMatrix = mParentMatrix;
1014     mCap = mData->capStyle();
1015     mJoin = mData->joinStyle();
1016     mMiterLimit = mData->meterLimit();
1017     mWidth = mData->width(frameNo);
1018     if (mData->hasDashInfo()) {
1019         mDashArraySize = mData->getDashInfo(frameNo, mDashArray);
1020     }
1021 }
1022
1023 void LOTGStrokeItem::updateRenderNode(LOTPathDataItem *pathNode, VDrawable *drawable, bool sameParent)
1024 {
1025     drawable->setBrush(VBrush(mGradient.get()));
1026     drawable->setStrokeInfo(mCap, mJoin, mMiterLimit,  mWidth * getScale(mParentMatrix));
1027     if (mDashArraySize) {
1028         drawable->setDashInfo(mDashArray, mDashArraySize);
1029     }
1030 }
1031
1032 LOTTrimItem::LOTTrimItem(LOTTrimData *data):mData(data)
1033 {
1034
1035 }
1036
1037 LOTRepeaterItem::LOTRepeaterItem(LOTRepeaterData *data):mData(data)
1038 {
1039
1040 }
1041
1042 void LOTRepeaterItem::update(int frameNo, const VMatrix &parentMatrix, float parentAlpha, const DirtyFlag &flag)
1043 {
1044
1045 }
1046
1047 void LOTRepeaterItem::renderList(std::vector<VDrawable *> &list)
1048 {
1049
1050 }
1051