src/lottie/lottieitem.h

   1 #ifndef LOTTIEITEM_H
   2 #define LOTTIEITEM_H
   3
   4 #include<lottiemodel.h>
   5 #include<sstream>
   6 #include<memory>
   7
   8 #include"vmatrix.h"
   9 #include"vpath.h"
  10 #include"vpoint.h"
  11 #include"vpathmesure.h"
  12 #include"lottiecommon.h"
  13 #include"lottieanimation.h"
  14 #include"vpainter.h"
  15 #include"vdrawable.h"
  16
  17 V_USE_NAMESPACE
  18
  19 enum class DirtyFlagBit : uchar
  20 {
  21    None   = 0x00,
  22    Matrix = 0x01,
  23    Alpha  = 0x02,
  24    All    = (Matrix | Alpha)
  25 };
  26
  27 class LOTLayerItem;
  28 class LOTMaskItem;
  29 class VDrawable;
  30
  31 class LOTCompItem
  32 {
  33 public:
  34    LOTCompItem(LOTModel *model);
  35    static std::unique_ptr<LOTLayerItem> createLayerItem(LOTLayerData *layerData);
  36    bool update(int frameNo);
  37    void resize(const VSize &size);
  38    VSize size() const;
  39    const std::vector<LOTNode *>& renderList()const;
  40    void buildRenderList();
  41    void buildRenderTree();
  42    const LOTLayerNode * renderTree()const;
  43    bool render(const lottie::Surface &surface);
  44 private:
  45    VMatrix                                    mScaleMatrix;
  46    VSize                                      mViewSize;
  47    LOTModel                                   *mRootModel;
  48    LOTCompositionData                         *mCompData;
  49    std::unique_ptr<LOTLayerItem>               mRootLayer;
  50    bool                                        mUpdateViewBox;
  51    int                                         mCurFrameNo;
  52    std::vector<LOTNode *>                      mRenderList;
  53    std::vector<VDrawable *>                    mDrawableList;
  54 };
  55
  56 typedef vFlag<DirtyFlagBit> DirtyFlag;
  57 class LOTLayerItem
  58 {
  59 public:
  60    LOTLayerItem(LOTLayerData *layerData);
  61    virtual ~LOTLayerItem()= default;
  62    int id() const {return mLayerData->id();}
  63    int parentId() const {return mLayerData->parentId();}
  64    void setParentLayer(LOTLayerItem *parent){mParentLayer = parent;}
  65    void setPrecompLayer(LOTLayerItem *precomp){mPrecompLayer = precomp;}
  66    virtual void update(int frameNo, const VMatrix &parentMatrix, float parentAlpha);
  67    VMatrix matrix(int frameNo) const;
  68    virtual void renderList(std::vector<VDrawable *> &){}
  69    virtual void updateStaticProperty();
  70    virtual void render(VPainter *painter, const VRle &mask, const VRle &inheritMatte, LOTLayerItem *matteSource);
  71    bool hasMatte() { if (mLayerData->mMatteType == MatteType::None) return false; return true; }
  72    MatteType matteType() const { return mLayerData->mMatteType;}
  73    bool visible() const;
  74    virtual void buildLayerNode();
  75    LOTLayerNode * layerNode() const {return mLayerCNode.get();}
  76 protected:
  77    virtual void updateContent() = 0;
  78    inline VMatrix combinedMatrix() const {return mCombinedMatrix;}
  79    inline int frameNo() const {return mFrameNo;}
  80    inline float combinedAlpha() const {return mCombinedAlpha;}
  81    inline bool isStatic() const {return mStatic;}
  82    float opacity(int frameNo) const;
  83    inline DirtyFlag flag() const {return mDirtyFlag;}
  84    VRle maskRle(const VRect &clipRect);
  85    bool hasMask() const {return !mMasks.empty();}
  86 protected:
  87    std::vector<LOTMask>                        mMasksCNode;
  88    std::unique_ptr<LOTLayerNode>               mLayerCNode;
  89    std::vector<VDrawable *>                    mDrawableList;
  90    std::vector<std::unique_ptr<LOTMaskItem>>   mMasks;
  91    LOTLayerData                               *mLayerData{nullptr};
  92    LOTLayerItem                               *mParentLayer{nullptr};
  93    LOTLayerItem                               *mPrecompLayer{nullptr};
  94    VMatrix                                     mCombinedMatrix;
  95    float                                       mCombinedAlpha{0.0};
  96    int                                         mFrameNo{-1};
  97    DirtyFlag                                   mDirtyFlag{DirtyFlagBit::All};
  98    bool                                        mStatic;
  99 };
 100
 101 class LOTCompLayerItem: public LOTLayerItem
 102 {
 103 public:
 104    LOTCompLayerItem(LOTLayerData *layerData);
 105    void renderList(std::vector<VDrawable *> &list)final;
 106    void updateStaticProperty() final;
 107    void render(VPainter *painter, const VRle &mask, const VRle &inheritMatte, LOTLayerItem *matteSource) final;
 108    void buildLayerNode() final;
 109 protected:
 110    void updateContent() final;
 111 private:
 112    std::vector<LOTLayerNode *>                  mLayersCNode;
 113    std::vector<std::unique_ptr<LOTLayerItem>>   mLayers;
 114    int                                          mLastFrame;
 115 };
 116
 117 class LOTSolidLayerItem: public LOTLayerItem
 118 {
 119 public:
 120    LOTSolidLayerItem(LOTLayerData *layerData);
 121    void buildLayerNode() final;
 122 protected:
 123    void updateContent() final;
 124    void renderList(std::vector<VDrawable *> &list) final;
 125 private:
 126    std::vector<LOTNode *>       mCNodeList;
 127    std::unique_ptr<VDrawable>   mRenderNode;
 128 };
 129
 130 class LOTContentItem;
 131 class LOTContentGroupItem;
 132 class LOTShapeLayerItem: public LOTLayerItem
 133 {
 134 public:
 135    LOTShapeLayerItem(LOTLayerData *layerData);
 136    static std::unique_ptr<LOTContentItem> createContentItem(LOTData *contentData);
 137    void renderList(std::vector<VDrawable *> &list)final;
 138    void buildLayerNode() final;
 139 protected:
 140    void updateContent() final;
 141    std::vector<LOTNode *>               mCNodeList;
 142    std::unique_ptr<LOTContentGroupItem> mRoot;
 143 };
 144
 145 class LOTNullLayerItem: public LOTLayerItem
 146 {
 147 public:
 148    LOTNullLayerItem(LOTLayerData *layerData);
 149 protected:
 150    void updateContent() final;
 151 };
 152
 153 class LOTMaskItem
 154 {
 155 public:
 156     LOTMaskItem(LOTMaskData *data): mData(data), mCombinedAlpha(0){}
 157     void update(int frameNo, const VMatrix &parentMatrix, float parentAlpha, const DirtyFlag &flag);
 158     LOTMaskData::Mode maskMode() const { return mData->mMode;}
 159     VRle rle();
 160 public:
 161     LOTMaskData             *mData;
 162     float                    mCombinedAlpha;
 163     VMatrix                  mCombinedMatrix;
 164     VPath                    mLocalPath;
 165     VPath                    mFinalPath;
 166     std::future<VRle>        mRleTask;
 167     VRle                     mRle;
 168 };
 169
 170 class LOTDrawable : public VDrawable
 171 {
 172 public:
 173     void sync();
 174 public:
 175     std::unique_ptr<LOTNode>  mCNode;
 176
 177     ~LOTDrawable() {
 178         if (mCNode && mCNode->mGradient.stopPtr)
 179           free(mCNode->mGradient.stopPtr);
 180     }
 181 };
 182
 183 class LOTPathDataItem;
 184 class LOTPaintDataItem;
 185 class LOTTrimItem;
 186
 187 class LOTContentItem
 188 {
 189 public:
 190    virtual ~LOTContentItem()= default;
 191    virtual void update(int frameNo, const VMatrix &parentMatrix, float parentAlpha, const DirtyFlag &flag) = 0;
 192    virtual void renderList(std::vector<VDrawable *> &){}
 193    void setParent(LOTContentItem *parent) {mParent = parent;}
 194    LOTContentItem *parent() const {return mParent;}
 195 private:
 196    LOTContentItem *mParent{nullptr};
 197 };
 198
 199 class LOTContentGroupItem: public LOTContentItem
 200 {
 201 public:
 202     LOTContentGroupItem(){}
 203    LOTContentGroupItem(LOTGroupData *data);
 204    void addChildren(LOTGroupData *data);
 205    void update(int frameNo, const VMatrix &parentMatrix, float parentAlpha, const DirtyFlag &flag);
 206    void applyTrim();
 207    void processTrimItems(std::vector<LOTPathDataItem *> &list);
 208    void processPaintItems(std::vector<LOTPathDataItem *> &list);
 209    void renderList(std::vector<VDrawable *> &list) final;
 210    const VMatrix & matrix() const { return mMatrix;}
 211 protected:
 212    LOTGroupData                                  *mData{nullptr};
 213    std::vector<std::unique_ptr<LOTContentItem>>   mContents;
 214    VMatrix                                        mMatrix;
 215 };
 216
 217 class LOTPathDataItem : public LOTContentItem
 218 {
 219 public:
 220    LOTPathDataItem(bool staticPath): mStaticPath(staticPath){}
 221    void update(int frameNo, const VMatrix &parentMatrix, float parentAlpha, const DirtyFlag &flag) final;
 222    bool dirty() const {return mPathChanged;}
 223    const VPath &localPath() const {return mTemp;}
 224    const VPath &finalPath();
 225    void updatePath(const VPath &path) {mTemp.clone(path); mPathChanged = true; mNeedUpdate = true;}
 226    bool staticPath() const { return mStaticPath; }
 227 protected:
 228    virtual void updatePath(VPath& path, int frameNo) = 0;
 229    virtual bool hasChanged(int prevFrame, int curFrame) = 0;
 230 private:
 231    bool hasChanged(int frameNo) {
 232        int prevFrame = mFrameNo;
 233        mFrameNo = frameNo;
 234        if (prevFrame == -1) return true;
 235        if (mStaticPath ||
 236            (prevFrame == frameNo)) return false;
 237        return hasChanged(prevFrame, frameNo);
 238    }
 239    VPath                                   mLocalPath;
 240    VPath                                   mTemp;
 241    VPath                                   mFinalPath;
 242    int                                     mFrameNo{-1};
 243    bool                                    mPathChanged{true};
 244    bool                                    mNeedUpdate{true};
 245    bool                                    mStaticPath;
 246 };
 247
 248 class LOTRectItem: public LOTPathDataItem
 249 {
 250 public:
 251    LOTRectItem(LOTRectData *data);
 252 protected:
 253    void updatePath(VPath& path, int frameNo) final;
 254    LOTRectData           *mData;
 255
 256    bool hasChanged(int prevFrame, int curFrame) final {
 257        return (mData->mPos.changed(prevFrame, curFrame) ||
 258                mData->mSize.changed(prevFrame, curFrame) ||
 259                mData->mRound.changed(prevFrame, curFrame)) ? true : false;
 260    }
 261 };
 262
 263 class LOTEllipseItem: public LOTPathDataItem
 264 {
 265 public:
 266    LOTEllipseItem(LOTEllipseData *data);
 267 private:
 268    void updatePath(VPath& path, int frameNo) final;
 269    LOTEllipseData           *mData;
 270    bool hasChanged(int prevFrame, int curFrame) final {
 271        return (mData->mPos.changed(prevFrame, curFrame) ||
 272                mData->mSize.changed(prevFrame, curFrame)) ? true : false;
 273    }
 274 };
 275
 276 class LOTShapeItem: public LOTPathDataItem
 277 {
 278 public:
 279    LOTShapeItem(LOTShapeData *data);
 280 private:
 281    void updatePath(VPath& path, int frameNo) final;
 282    LOTShapeData             *mData;
 283    bool hasChanged(int prevFrame, int curFrame) final {
 284        return mData->mShape.changed(prevFrame, curFrame);
 285    }
 286 };
 287
 288 class LOTPolystarItem: public LOTPathDataItem
 289 {
 290 public:
 291    LOTPolystarItem(LOTPolystarData *data);
 292 private:
 293    void updatePath(VPath& path, int frameNo) final;
 294    LOTPolystarData             *mData;
 295
 296    bool hasChanged(int prevFrame, int curFrame) final {
 297        return (mData->mPos.changed(prevFrame, curFrame) ||
 298                mData->mPointCount.changed(prevFrame, curFrame) ||
 299                mData->mInnerRadius.changed(prevFrame, curFrame) ||
 300                mData->mOuterRadius.changed(prevFrame, curFrame) ||
 301                mData->mInnerRoundness.changed(prevFrame, curFrame) ||
 302                mData->mOuterRoundness.changed(prevFrame, curFrame) ||
 303                mData->mRotation.changed(prevFrame, curFrame)) ? true : false;
 304    }
 305 };
 306
 307
 308
 309 class LOTPaintDataItem : public LOTContentItem
 310 {
 311 public:
 312    LOTPaintDataItem(bool staticContent);
 313    void addPathItems(std::vector<LOTPathDataItem *> &list, int startOffset);
 314    void update(int frameNo, const VMatrix &parentMatrix, float parentAlpha, const DirtyFlag &flag) override;
 315    void renderList(std::vector<VDrawable *> &list) final;
 316 protected:
 317    virtual void updateContent(int frameNo) = 0;
 318    virtual void updateRenderNode();
 319    inline float parentAlpha() const {return mParentAlpha;}
 320 public:
 321    float                            mParentAlpha;
 322    VPath                            mPath;
 323    DirtyFlag                        mFlag;
 324    int                              mFrameNo;
 325    std::vector<LOTPathDataItem *>   mPathItems;
 326    std::unique_ptr<VDrawable>       mDrawable;
 327    bool                             mStaticContent;
 328    bool                             mRenderNodeUpdate{true};
 329 };
 330
 331 class LOTFillItem : public LOTPaintDataItem
 332 {
 333 public:
 334    LOTFillItem(LOTFillData *data);
 335 protected:
 336    void updateContent(int frameNo) final;
 337    void updateRenderNode() final;
 338 private:
 339    LOTFillData             *mData;
 340    VColor                  mColor;
 341    FillRule                mFillRule;
 342 };
 343
 344 class LOTGFillItem : public LOTPaintDataItem
 345 {
 346 public:
 347    LOTGFillItem(LOTGFillData *data);
 348 protected:
 349    void updateContent(int frameNo) final;
 350    void updateRenderNode() final;
 351 private:
 352    LOTGFillData                 *mData;
 353    std::unique_ptr<VGradient>    mGradient;
 354    FillRule                      mFillRule;
 355 };
 356
 357 class LOTStrokeItem : public LOTPaintDataItem
 358 {
 359 public:
 360    LOTStrokeItem(LOTStrokeData *data);
 361 protected:
 362    void updateContent(int frameNo) final;
 363    void updateRenderNode() final;
 364 private:
 365    LOTStrokeData             *mData;
 366    CapStyle                  mCap;
 367    JoinStyle                 mJoin;
 368    float                     mMiterLimit;
 369    VColor                    mColor;
 370    float                     mWidth;
 371    float                     mDashArray[6];
 372    int                       mDashArraySize;
 373 };
 374
 375 class LOTGStrokeItem : public LOTPaintDataItem
 376 {
 377 public:
 378    LOTGStrokeItem(LOTGStrokeData *data);
 379 protected:
 380    void updateContent(int frameNo) final;
 381    void updateRenderNode() final;
 382 private:
 383    LOTGStrokeData               *mData;
 384    std::unique_ptr<VGradient>    mGradient;
 385    CapStyle                      mCap;
 386    JoinStyle                     mJoin;
 387    float                         mMiterLimit;
 388    VColor                        mColor;
 389    float                         mWidth;
 390    float                         mDashArray[6];
 391    int                           mDashArraySize;
 392 };
 393
 394
 395 // Trim Item
 396
 397 class LOTTrimItem : public LOTContentItem
 398 {
 399 public:
 400    LOTTrimItem(LOTTrimData *data);
 401    void update(int frameNo, const VMatrix &parentMatrix, float parentAlpha, const DirtyFlag &flag) final;
 402    void update();
 403    void addPathItems(std::vector<LOTPathDataItem *> &list, int startOffset);
 404 private:
 405    bool pathDirty() const {
 406        for (auto &i : mPathItems) {
 407            if (i->dirty())
 408                return true;
 409        }
 410        return false;
 411    }
 412    struct Cache {
 413         int                     mFrameNo{-1};
 414         LOTTrimData::Segment    mSegment{};
 415    };
 416    Cache                            mCache;
 417    std::vector<LOTPathDataItem *>   mPathItems;
 418    LOTTrimData                     *mData;
 419    bool                             mDirty{true};
 420 };
 421
 422 class LOTRepeaterItem : public LOTContentGroupItem
 423 {
 424 public:
 425    LOTRepeaterItem(LOTRepeaterData *data);
 426    void update(int frameNo, const VMatrix &parentMatrix, float parentAlpha, const DirtyFlag &flag) final;
 427 private:
 428    LOTRepeaterData             *mData;
 429 };
 430
 431
 432 #endif // LOTTIEITEM_H
 433
 434