1 #include "lottieitem.h"
9 * 1. time stretch is pre calculated and applied to all the properties of the lottilayer model and all its children
10 * 2. The frame property could be reversed using,time-reverse layer property in AE. which means (start frame > endFrame)
14 LOTCompItem::LOTCompItem(LOTModel *model):mRootModel(model), mUpdateViewBox(false),mCurFrameNo(-1)
16 // 1. build layer item list
17 mCompData = model->mRoot.get();
18 for(auto i : mCompData->mChildren) {
19 LOTLayerData *layerData = dynamic_cast<LOTLayerData *>(i.get());
21 LOTLayerItem *layerItem = LOTCompItem::createLayerItem(layerData);
23 mLayers.push_back(layerItem);
24 mLayerMap[layerItem->id()] = layerItem;
29 //2. update parent layer
30 for(auto i : mLayers) {
31 int id = i->parentId();
33 auto search = mLayerMap.find(id);
34 if (search != mLayerMap.end()) {
35 LOTLayerItem *parentLayer = search->second;
36 i->setParentLayer(parentLayer);
40 //3. update static property of each layer
41 for(auto i : mLayers) {
42 i->updateStaticProperty();
45 mViewSize = mCompData->size();
48 LOTCompItem::~LOTCompItem()
50 for(auto i : mLayers) {
56 LOTCompItem::createLayerItem(LOTLayerData *layerData)
58 switch(layerData->mLayerType) {
59 case LayerType::Precomp: {
60 return new LOTCompLayerItem(layerData);
63 case LayerType::Solid: {
64 return new LOTSolidLayerItem(layerData);
67 case LayerType::Shape: {
68 return new LOTShapeLayerItem(layerData);
71 case LayerType::Null: {
72 return new LOTNullLayerItem(layerData);
81 void LOTCompItem::resize(const VSize &size)
83 if (mViewSize == size) return;
85 mUpdateViewBox = true;
88 VSize LOTCompItem::size() const
93 bool LOTCompItem::update(int frameNo)
95 // check if cached frame is same as requested frame.
96 if (!mUpdateViewBox && (mCurFrameNo == frameNo)) return false;
99 * if viewbox dosen't scale exactly to the viewport
100 * we scale the viewbox keeping AspectRatioPreserved and then align the
101 * viewbox to the viewport using AlignCenter rule.
103 VSize viewPort = mViewSize;
104 VSize viewBox = mCompData->size();
106 float sx = float(viewPort.width()) / viewBox.width();
107 float sy = float(viewPort.height()) / viewBox.height();
108 float scale = fmin(sx, sy);
109 float tx = (viewPort.width() - viewBox.width() * scale) * 0.5;
110 float ty = (viewPort.height() - viewBox.height() * scale) * 0.5;
113 m.scale(scale, scale).translate(tx, ty);
115 // update the layer from back to front
116 for (auto i = mLayers.rbegin(); i != mLayers.rend(); ++i) {
117 LOTLayerItem *layer = *i;
118 layer->update(frameNo, m, 1.0);
121 mCurFrameNo = frameNo;
122 mUpdateViewBox = false;
126 void LOTCompItem::buildRenderList()
128 mDrawableList.clear();
129 for (auto i = mLayers.rbegin(); i != mLayers.rend(); ++i) {
130 LOTLayerItem *layer = *i;
131 layer->renderList(mDrawableList);
135 for(auto i : mDrawableList) {
136 LOTDrawable *lotDrawable = static_cast<LOTDrawable *>(i);
138 mRenderList.push_back(&lotDrawable->mCNode);
142 const std::vector<LOTNode *>& LOTCompItem::renderList() const
147 bool LOTCompItem::render(const LOTBuffer &buffer)
149 VBitmap bitmap((uchar *)buffer.buffer, buffer.width, buffer.height,
150 buffer.bytesPerLine, VBitmap::Format::ARGB32_Premultiplied, nullptr, nullptr);
152 /* schedule all preprocess task for this frame at once.
154 for (auto &e : mDrawableList) {
158 VPainter painter(&bitmap);
160 for (auto i = mLayers.rbegin(); i != mLayers.rend(); ++i) {
161 LOTLayerItem *layer = *i;
162 layer->render(&painter, mask);
168 void LOTMaskItem::update(int frameNo, const VMatrix &parentMatrix,
169 float parentAlpha, const DirtyFlag &flag)
171 if (mData->mShape.isStatic()) {
172 if (mLocalPath.isEmpty()) {
173 mLocalPath = mData->mShape.value(frameNo).toPath();
176 mLocalPath = mData->mShape.value(frameNo).toPath();
178 float opacity = mData->opacity(frameNo);
179 opacity = opacity * parentAlpha;
180 mCombinedAlpha = opacity;
182 VPath path = mLocalPath;
183 path.transform(parentMatrix);
185 mRleTask = VRaster::instance().generateFillInfo(path);
188 VRle LOTMaskItem::rle()
190 if (mRleTask.valid()) {
191 mRle = mRleTask.get();
192 if (!vCompare(mCombinedAlpha, 1.0f))
193 mRle = mRle * (mCombinedAlpha * 255);
200 void LOTLayerItem::render(VPainter *painter, const VRle &inheritMask)
202 std::vector<VDrawable *> list;
204 VRle mask = inheritMask;
207 mask = maskRle(painter->clipBoundingRect());
209 mask = mask & inheritMask;
213 painter->setBrush(i->mBrush);
214 if (!mask.isEmpty()) {
215 VRle rle = i->rle() & mask;
216 painter->drawRle(VPoint(), rle);
218 painter->drawRle(VPoint(), i->rle());
223 VRle LOTLayerItem::maskRle(const VRect &clipRect)
227 for (auto &i : mMasks) {
228 switch (i->maskMode()) {
229 case LOTMaskData::Mode::Add: {
230 rle = rle + i->rle();
233 case LOTMaskData::Mode::Substarct: {
234 if (rle.isEmpty() && !clipRect.isEmpty())
235 rle = VRle::toRle(clipRect);
236 rle = rle - i->rle();
239 case LOTMaskData::Mode::Intersect: {
240 rle = rle & i->rle();
250 LOTLayerItem::LOTLayerItem(LOTLayerData *layerData):mLayerData(layerData),
251 mParentLayer(nullptr),
252 mPrecompLayer(nullptr),
253 mCombinedAlpha(0.0f),
255 mDirtyFlag(DirtyFlagBit::All)
257 if (mLayerData->mHasMask) {
258 for (auto i : mLayerData->mMasks) {
259 mMasks.push_back(std::make_unique<LOTMaskItem>(i.get()));
264 void LOTLayerItem::updateStaticProperty()
267 mParentLayer->updateStaticProperty();
269 mStatic = mLayerData->isStatic();
270 mStatic = mParentLayer ? (mStatic & mParentLayer->isStatic()) : mStatic;
271 mStatic = mPrecompLayer ? (mStatic & mPrecompLayer->isStatic()) : mStatic;
274 void LOTLayerItem::update(int frameNo, const VMatrix &parentMatrix, float parentAlpha)
277 // 1. check if the layer is part of the current frame
278 if (!visible()) return;
280 // 2. calculate the parent matrix and alpha
281 VMatrix m = matrix(frameNo);
283 float alpha = parentAlpha * opacity(frameNo);
287 for (auto &i : mMasks)
288 i->update(frameNo, m, alpha, mDirtyFlag);
291 // 3. update the dirty flag based on the change
292 if (!mCombinedMatrix.fuzzyCompare(m)) {
293 mDirtyFlag |= DirtyFlagBit::Matrix;
295 if (!vCompare(mCombinedAlpha, alpha)) {
296 mDirtyFlag |= DirtyFlagBit::Alpha;
299 mCombinedAlpha = alpha;
301 // 4. if no parent property change and layer is static then nothing to do.
302 if ((flag() & DirtyFlagBit::None) && isStatic())
305 //5. update the content of the layer
308 //6. reset the dirty flag
309 mDirtyFlag = DirtyFlagBit::None;
313 LOTLayerItem::opacity(int frameNo) const
315 return mLayerData->mTransform->opacity(frameNo);
319 LOTLayerItem::matrix(int frameNo) const
322 return mLayerData->mTransform->matrix(frameNo) * mParentLayer->matrix(frameNo);
324 return mLayerData->mTransform->matrix(frameNo);
327 bool LOTLayerItem::visible() const
329 if (frameNo() >= mLayerData->inFrame() && frameNo() < mLayerData->outFrame())
337 LOTCompLayerItem::LOTCompLayerItem(LOTLayerData *layerModel):LOTLayerItem(layerModel)
339 for(auto i : mLayerData->mChildren) {
340 LOTLayerData *layerModel = dynamic_cast<LOTLayerData *>(i.get());
342 LOTLayerItem *layerItem = LOTCompItem::createLayerItem(layerModel);
344 mLayers.push_back(layerItem);
345 mLayerMap[layerItem->id()] = layerItem;
350 //2. update parent layer
351 for(auto i : mLayers) {
352 int id = i->parentId();
354 auto search = mLayerMap.find(id);
355 if (search != mLayerMap.end()) {
356 LOTLayerItem *parentLayer = search->second;
357 i->setParentLayer(parentLayer);
360 i->setPrecompLayer(this);
364 void LOTCompLayerItem::updateStaticProperty()
366 LOTLayerItem::updateStaticProperty();
368 for(auto i : mLayers) {
369 i->updateStaticProperty();
373 void LOTCompLayerItem::render(VPainter *painter, const VRle &inheritMask)
375 VRle mask = inheritMask;
379 mask = maskRle(painter->clipBoundingRect());
381 mask = mask & inheritMask;
384 for(auto i : mLayers) {
385 i->render(painter, mask);
389 LOTCompLayerItem::~LOTCompLayerItem()
391 for(auto i : mLayers) {
396 void LOTCompLayerItem::updateContent()
398 // update the layer from back to front
399 for (auto i = mLayers.rbegin(); i != mLayers.rend(); ++i) {
400 LOTLayerItem *layer = *i;
401 layer->update(frameNo(), combinedMatrix(), combinedAlpha());
405 void LOTCompLayerItem::renderList(std::vector<VDrawable *> &list)
407 if (!visible()) return;
409 // update the layer from back to front
410 for (auto i = mLayers.rbegin(); i != mLayers.rend(); ++i) {
411 LOTLayerItem *layer = *i;
412 layer->renderList(list);
416 LOTSolidLayerItem::LOTSolidLayerItem(LOTLayerData *layerData):LOTLayerItem(layerData)
421 void LOTSolidLayerItem::updateContent()
424 mRenderNode = std::make_unique<LOTDrawable>();
425 mRenderNode->mType = VDrawable::Type::Fill;
426 mRenderNode->mFlag |= VDrawable::DirtyState::All;
429 if (flag() & DirtyFlagBit::Matrix) {
431 path.addRect(VRectF(0, 0, mLayerData->solidWidth(), mLayerData->solidHeight()));
432 path.transform(combinedMatrix());
433 mRenderNode->mFlag |= VDrawable::DirtyState::Path;
434 mRenderNode->mPath = path;
436 if (flag() & DirtyFlagBit::Alpha) {
437 LottieColor color = mLayerData->solidColor();
438 VBrush brush(color.toColor(combinedAlpha()));
439 mRenderNode->setBrush(brush);
440 mRenderNode->mFlag |= VDrawable::DirtyState::Brush;
444 void LOTSolidLayerItem::renderList(std::vector<VDrawable *> &list)
446 if (!visible()) return;
448 list.push_back(mRenderNode.get());
451 LOTNullLayerItem::LOTNullLayerItem(LOTLayerData *layerData):LOTLayerItem(layerData)
455 void LOTNullLayerItem::updateContent()
461 LOTShapeLayerItem::LOTShapeLayerItem(LOTLayerData *layerData):LOTLayerItem(layerData)
463 mRoot = new LOTContentGroupItem(nullptr);
464 mRoot->addChildren(layerData);
465 mRoot->processPaintOperation();
466 if (layerData->hasPathOperator())
467 mRoot->processTrimOperation();
470 LOTShapeLayerItem::~LOTShapeLayerItem()
475 LOTContentItem * LOTShapeLayerItem::createContentItem(LOTData *contentData)
477 switch(contentData->type()) {
478 case LOTData::Type::ShapeGroup: {
479 return new LOTContentGroupItem(static_cast<LOTShapeGroupData *>(contentData));
482 case LOTData::Type::Rect: {
483 return new LOTRectItem(static_cast<LOTRectData *>(contentData));
486 case LOTData::Type::Ellipse: {
487 return new LOTEllipseItem(static_cast<LOTEllipseData *>(contentData));
490 case LOTData::Type::Shape: {
491 return new LOTShapeItem(static_cast<LOTShapeData *>(contentData));
494 case LOTData::Type::Polystar: {
495 return new LOTPolystarItem(static_cast<LOTPolystarData *>(contentData));
498 case LOTData::Type::Fill: {
499 return new LOTFillItem(static_cast<LOTFillData *>(contentData));
502 case LOTData::Type::GFill: {
503 return new LOTGFillItem(static_cast<LOTGFillData *>(contentData));
506 case LOTData::Type::Stroke: {
507 return new LOTStrokeItem(static_cast<LOTStrokeData *>(contentData));
510 case LOTData::Type::GStroke: {
511 return new LOTGStrokeItem(static_cast<LOTGStrokeData *>(contentData));
514 case LOTData::Type::Repeater: {
515 return new LOTRepeaterItem(static_cast<LOTRepeaterData *>(contentData));
518 case LOTData::Type::Trim: {
519 return new LOTTrimItem(static_cast<LOTTrimData *>(contentData));
528 void LOTShapeLayerItem::updateContent()
530 mRoot->update(frameNo(), combinedMatrix(), combinedAlpha(), flag());
533 void LOTShapeLayerItem::renderList(std::vector<VDrawable *> &list)
535 if (!visible()) return;
536 mRoot->renderList(list);
539 LOTContentGroupItem::LOTContentGroupItem(LOTShapeGroupData *data):mData(data)
544 void LOTContentGroupItem::addChildren(LOTGroupData *data)
548 for(auto i : data->mChildren) {
549 LOTData *data = i.get();
550 LOTContentItem *content = LOTShapeLayerItem::createContentItem(data);
552 mContents.push_back(content);
556 LOTContentGroupItem::~LOTContentGroupItem()
558 for(auto i : mContents) {
564 void LOTContentGroupItem::update(int frameNo, const VMatrix &parentMatrix, float parentAlpha, const DirtyFlag &flag)
566 VMatrix m = parentMatrix;
567 float alpha = parentAlpha;
568 DirtyFlag newFlag = flag;
571 // update the matrix and the flag
572 if ((flag & DirtyFlagBit::Matrix) || !mData->mTransform->staticMatrix() ) {
573 newFlag |= DirtyFlagBit::Matrix;
575 m = mData->mTransform->matrix(frameNo);
577 alpha *= mData->mTransform->opacity(frameNo);
579 if (!vCompare(alpha, parentAlpha)) {
580 newFlag |= DirtyFlagBit::Alpha;
584 for (auto i = mContents.rbegin(); i != mContents.rend(); ++i) {
585 (*i)->update(frameNo, m, alpha, newFlag);
589 void LOTContentGroupItem::renderList(std::vector<VDrawable *> &list)
591 for (auto i = mContents.rbegin(); i != mContents.rend(); ++i) {
592 (*i)->renderList(list);
596 void LOTContentGroupItem::processPaintOperation()
598 std::vector<LOTPaintDataItem *> list;
599 paintOperationHelper(list);
602 void LOTContentGroupItem::paintOperationHelper(std::vector<LOTPaintDataItem *> &list)
604 int curOpCount = list.size();
605 for (auto i = mContents.rbegin(); i != mContents.rend(); ++i) {
607 if (auto pathNode = dynamic_cast<LOTPathDataItem *>(child)) {
608 // the node is a path data node add the paint operation list to it.
609 pathNode->addPaintOperation(list, curOpCount);
610 } else if (auto paintNode = dynamic_cast<LOTPaintDataItem *>(child)) {
611 // add it to the paint operation list
612 list.push_back(paintNode);
613 } else if (auto groupNode = dynamic_cast<LOTContentGroupItem *>(child)) {
614 // update the groups node with current list
615 groupNode->paintOperationHelper(list);
618 list.erase(list.begin() + curOpCount, list.end());
621 void LOTPathDataItem::addPaintOperation(std::vector<LOTPaintDataItem *> &list, int externalCount)
623 for(auto paintItem : list) {
624 bool sameGroup = (externalCount-- > 0) ? false : true;
625 mNodeList.push_back(std::make_unique<LOTDrawable>());
626 mRenderList.push_back(LOTRenderNode(this, paintItem, mNodeList.back().get(), sameGroup));
630 void LOTContentGroupItem::processTrimOperation()
632 std::vector<LOTTrimItem *> list;
633 trimOperationHelper(list);
636 void LOTContentGroupItem::trimOperationHelper(std::vector<LOTTrimItem *> &list)
638 int curOpCount = list.size();
639 for (auto i = mContents.rbegin(); i != mContents.rend(); ++i) {
641 if (auto pathNode = dynamic_cast<LOTPathDataItem *>(child)) {
642 // the node is a path data node add the trim operation list to it.
643 pathNode->addTrimOperation(list);
644 } else if (auto trimNode = dynamic_cast<LOTTrimItem *>(child)) {
645 // add it to the trim operation list
646 list.push_back(trimNode);
647 } else if (auto groupNode = dynamic_cast<LOTContentGroupItem *>(child)) {
648 // update the groups node with current list
649 groupNode->trimOperationHelper(list);
652 list.erase(list.begin() + curOpCount, list.end());
655 void LOTPathDataItem::addTrimOperation(std::vector<LOTTrimItem *> &list)
657 for(auto trimItem : list) {
658 mTrimNodeRefs.push_back(trimItem);
662 void LOTPathDataItem::update(int frameNo, const VMatrix &parentMatrix, float parentAlpha, const DirtyFlag &flag)
666 mPathChanged = false;
667 mCombinedAlpha = parentAlpha;
669 // 1. update the local path if needed
670 if (!(mInit && mStaticPath)) {
671 mLocalPath = getPath(frameNo);
676 tempPath = mLocalPath;
678 // 2. apply path operation if needed
679 if (mTrimNodeRefs.size() > 0)
681 //TODO apply more than one trim path if necessary
683 float s = mTrimNodeRefs.front()->getStart(frameNo) / 100.0f;
684 float e = mTrimNodeRefs.front()->getEnd(frameNo) / 100.0f;
687 tempPath = pm.trim(tempPath);
691 // 3. compute the final path with parentMatrix
693 if ((flag & DirtyFlagBit::Matrix) || mPathChanged) {
694 mFinalPath = tempPath;
695 mFinalPath.transform(parentMatrix);
699 // 2. update the rendernode list
700 for (const auto &i : mRenderList) {
701 i.drawable->mFlag = VDrawable::DirtyState::None;
702 i.paintNodeRef->updateRenderNode(i.pathNodeRef, i.drawable, i.sameGroup);
704 i.drawable->mPath = mFinalPath;
705 i.drawable->mFlag |= VDrawable::DirtyState::Path;
710 void LOTPathDataItem::renderList(std::vector<VDrawable *> &list)
712 for (const auto &i : mRenderList) {
713 list.push_back(i.drawable);
717 VPath LOTPathDataItem::path() const
723 LOTRectItem::LOTRectItem(LOTRectData *data):LOTPathDataItem(data->isStatic()),mData(data)
727 VPath LOTRectItem::getPath(int frameNo)
729 VPointF pos = mData->mPos.value(frameNo);
730 VPointF size = mData->mSize.value(frameNo);
731 float radius = mData->mRound.value(frameNo);
732 VRectF r(pos.x() - size.x()/2, pos.y() - size.y()/2, size.x(), size.y());
735 path.addRoundRect(r, radius, radius, mData->direction());
740 LOTEllipseItem::LOTEllipseItem(LOTEllipseData *data):LOTPathDataItem(data->isStatic()),mData(data)
745 VPath LOTEllipseItem::getPath(int frameNo)
747 VPointF pos = mData->mPos.value(frameNo);
748 VPointF size = mData->mSize.value(frameNo);
749 VRectF r(pos.x() - size.x()/2, pos.y() - size.y()/2, size.x(), size.y());
752 path.addOval(r, mData->direction());
757 LOTShapeItem::LOTShapeItem(LOTShapeData *data):LOTPathDataItem(data->isStatic()),mData(data)
762 VPath LOTShapeItem::getPath(int frameNo)
764 return mData->mShape.value(frameNo).toPath();
768 LOTPolystarItem::LOTPolystarItem(LOTPolystarData *data):LOTPathDataItem(data->isStatic()),mData(data)
773 VPath LOTPolystarItem::getPath(int frameNo)
775 VPointF pos = mData->mPos.value(frameNo);
776 float points = mData->mPointCount.value(frameNo);
777 float innerRadius = mData->mInnerRadius.value(frameNo);
778 float outerRadius = mData->mOuterRadius.value(frameNo);
779 float innerRoundness = mData->mInnerRoundness.value(frameNo);
780 float outerRoundness = mData->mOuterRoundness.value(frameNo);
781 float rotation = mData->mRotation.value(frameNo);
786 if (mData->mType == LOTPolystarData::PolyType::Star) {
787 path.addPolystar(points, innerRadius, outerRadius,
788 innerRoundness, outerRoundness,
789 0.0, 0.0, 0.0, mData->direction());
791 path.addPolygon(points, outerRadius, outerRoundness,
792 0.0, 0.0, 0.0, mData->direction());
795 m.translate(pos.x(), pos.y()).rotate(rotation);
805 * PaintData Node handling
809 void LOTPaintDataItem::update(int frameNo, const VMatrix &parentMatrix, float parentAlpha, const DirtyFlag &flag)
811 mContentChanged = false;
812 mParentAlpha = parentAlpha;
813 mParentMatrix = parentMatrix;
816 // 1. update the local content if needed
817 // if (!(mInit && mStaticContent)) {
819 updateContent(frameNo);
820 mContentChanged = true;
825 LOTFillItem::LOTFillItem(LOTFillData *data):LOTPaintDataItem(data->isStatic()),mData(data)
829 void LOTFillItem::updateContent(int frameNo)
831 LottieColor c = mData->mColor.value(frameNo);
832 float opacity = mData->opacity(frameNo);
833 mColor = c.toColor(opacity);
834 mFillRule = mData->fillRule();
837 void LOTFillItem::updateRenderNode(LOTPathDataItem *pathNode, VDrawable *drawable, bool sameParent)
839 VColor color = mColor;
841 color.setAlpha(color.a * pathNode->combinedAlpha());
843 color.setAlpha(color.a * parentAlpha() * pathNode->combinedAlpha());
845 drawable->setBrush(brush);
846 drawable->setFillRule(mFillRule);
850 LOTGFillItem::LOTGFillItem(LOTGFillData *data):LOTPaintDataItem(data->isStatic()),mData(data)
854 void LOTGFillItem::updateContent(int frameNo)
856 mData->update(mGradient, frameNo);
857 mGradient->mMatrix = mParentMatrix;
858 mFillRule = mData->fillRule();
861 void LOTGFillItem::updateRenderNode(LOTPathDataItem *pathNode, VDrawable *drawable, bool sameParent)
863 drawable->setBrush(VBrush(mGradient.get()));
864 drawable->setFillRule(mFillRule);
867 LOTStrokeItem::LOTStrokeItem(LOTStrokeData *data):LOTPaintDataItem(data->isStatic()),mData(data)
872 void LOTStrokeItem::updateContent(int frameNo)
874 LottieColor c = mData->mColor.value(frameNo);
875 float opacity = mData->opacity(frameNo);
876 mColor = c.toColor(opacity);
877 mCap = mData->capStyle();
878 mJoin = mData->joinStyle();
879 mMiterLimit = mData->meterLimit();
880 mWidth = mData->width(frameNo);
881 if (mData->hasDashInfo()) {
882 mDashArraySize = mData->getDashInfo(frameNo, mDashArray);
886 static float getScale(const VMatrix &matrix)
888 constexpr float SQRT_2 = 1.41421;
890 VPointF p2(SQRT_2,SQRT_2);
893 VPointF final = p2 - p1;
895 return std::sqrt( final.x() * final.x() + final.y() * final.y());
898 void LOTStrokeItem::updateRenderNode(LOTPathDataItem *pathNode, VDrawable *drawable, bool sameParent)
900 VColor color = mColor;
902 color.setAlpha(color.a * pathNode->combinedAlpha());
904 color.setAlpha(color.a * parentAlpha() * pathNode->combinedAlpha());
907 drawable->setBrush(brush);
909 drawable->setStrokeInfo(mCap, mJoin, mMiterLimit, mWidth * getScale(mParentMatrix));
910 if (mDashArraySize) {
911 drawable->setDashInfo(mDashArray, mDashArraySize);
915 LOTGStrokeItem::LOTGStrokeItem(LOTGStrokeData *data):LOTPaintDataItem(data->isStatic()),mData(data)
920 void LOTGStrokeItem::updateContent(int frameNo)
922 mData->update(mGradient, frameNo);
923 mGradient->mMatrix = mParentMatrix;
924 mCap = mData->capStyle();
925 mJoin = mData->joinStyle();
926 mMiterLimit = mData->meterLimit();
927 mWidth = mData->width(frameNo);
928 if (mData->hasDashInfo()) {
929 mDashArraySize = mData->getDashInfo(frameNo, mDashArray);
933 void LOTGStrokeItem::updateRenderNode(LOTPathDataItem *pathNode, VDrawable *drawable, bool sameParent)
935 drawable->setBrush(VBrush(mGradient.get()));
936 drawable->setStrokeInfo(mCap, mJoin, mMiterLimit, mWidth * getScale(mParentMatrix));
937 if (mDashArraySize) {
938 drawable->setDashInfo(mDashArray, mDashArraySize);
942 LOTTrimItem::LOTTrimItem(LOTTrimData *data):mData(data)
946 void LOTTrimItem::update(int frameNo, const VMatrix &parentMatrix, float parentAlpha, const DirtyFlag &flag)
950 LOTRepeaterItem::LOTRepeaterItem(LOTRepeaterData *data):mData(data)
955 void LOTRepeaterItem::update(int frameNo, const VMatrix &parentMatrix, float parentAlpha, const DirtyFlag &flag)
960 void LOTRepeaterItem::renderList(std::vector<VDrawable *> &list)
965 void LOTDrawable::sync()
967 mCNode.mFlag = ChangeFlagNone;
968 if (mFlag & DirtyState::None) return;
970 if (mFlag & DirtyState::Path) {
971 const std::vector<VPath::Element> &elm = mPath.elements();
972 const std::vector<VPointF> &pts = mPath.points();
973 const float *ptPtr = reinterpret_cast<const float *>(pts.data());
974 const char *elmPtr = reinterpret_cast<const char *>(elm.data());
975 mCNode.mPath.elmPtr = elmPtr;
976 mCNode.mPath.elmCount = elm.size();
977 mCNode.mPath.ptPtr = ptPtr;
978 mCNode.mPath.ptCount = 2 * pts.size();
979 mCNode.mFlag |= ChangeFlagPath;
982 if (mStroke.enable) {
983 mCNode.mStroke.width = mStroke.width;
984 mCNode.mStroke.meterLimit = mStroke.meterLimit;
985 mCNode.mStroke.enable = 1;
988 case FillRule::EvenOdd:
989 mCNode.mFillRule = LOTNode::EvenOdd;
992 mCNode.mFillRule = LOTNode::Winding;
996 switch (mStroke.cap) {
998 mCNode.mStroke.cap = LOTNode::FlatCap;
1000 case CapStyle::Square:
1001 mCNode.mStroke.cap = LOTNode::SquareCap;
1003 case CapStyle::Round:
1004 mCNode.mStroke.cap = LOTNode::RoundCap;
1007 mCNode.mStroke.cap = LOTNode::FlatCap;
1011 switch (mStroke.join) {
1012 case JoinStyle::Miter:
1013 mCNode.mStroke.join = LOTNode::MiterJoin;
1015 case JoinStyle::Bevel:
1016 mCNode.mStroke.join = LOTNode::BevelJoin;
1018 case JoinStyle::Round:
1019 mCNode.mStroke.join = LOTNode::RoundJoin;
1022 mCNode.mStroke.join = LOTNode::MiterJoin;
1026 mCNode.mStroke.dashArray = mStroke.dashArray;
1027 mCNode.mStroke.dashArraySize = mStroke.dashArraySize;
1030 mCNode.mStroke.enable = 0;
1033 switch (mBrush.type()) {
1034 case VBrush::Type::Solid:
1035 mCNode.mType = LOTNode::BrushSolid;
1036 mCNode.mColor.r = mBrush.mColor.r;
1037 mCNode.mColor.g = mBrush.mColor.g;
1038 mCNode.mColor.b = mBrush.mColor.b;
1039 mCNode.mColor.a = mBrush.mColor.a;
1041 case VBrush::Type::LinearGradient:
1042 mCNode.mType = LOTNode::BrushGradient;
1043 mCNode.mGradient.type = LOTNode::Gradient::Linear;
1044 mCNode.mGradient.start.x = mBrush.mGradient->linear.x1;
1045 mCNode.mGradient.start.y = mBrush.mGradient->linear.y1;
1046 mCNode.mGradient.end.x = mBrush.mGradient->linear.x2;
1047 mCNode.mGradient.end.y = mBrush.mGradient->linear.y2;
1049 case VBrush::Type::RadialGradient:
1050 mCNode.mType = LOTNode::BrushGradient;
1051 mCNode.mGradient.type = LOTNode::Gradient::Radial;
1052 mCNode.mGradient.center.x = mBrush.mGradient->radial.cx;
1053 mCNode.mGradient.center.y = mBrush.mGradient->radial.cy;
1054 mCNode.mGradient.focal.x = mBrush.mGradient->radial.fx;
1055 mCNode.mGradient.focal.y = mBrush.mGradient->radial.fy;
1056 mCNode.mGradient.cradius = mBrush.mGradient->radial.cradius;
1057 mCNode.mGradient.fradius = mBrush.mGradient->radial.fradius;