1 #include "lottieitem.h"
10 * 1. time stretch is pre calculated and applied to all the properties of the
11 * lottilayer model and all its children
12 * 2. The frame property could be reversed using,time-reverse layer property in
13 * AE. which means (start frame > endFrame) 3.
16 LOTCompItem::LOTCompItem(LOTModel *model)
17 : mRootModel(model), mUpdateViewBox(false), mCurFrameNo(-1)
19 mCompData = model->mRoot.get();
20 mRootLayer = createLayerItem(mCompData->mRootLayer.get());
21 mRootLayer->updateStaticProperty();
22 mViewSize = mCompData->size();
25 std::unique_ptr<LOTLayerItem>
26 LOTCompItem::createLayerItem(LOTLayerData *layerData)
28 switch (layerData->mLayerType) {
29 case LayerType::Precomp: {
30 return std::make_unique<LOTCompLayerItem>(layerData);
33 case LayerType::Solid: {
34 return std::make_unique<LOTSolidLayerItem>(layerData);
37 case LayerType::Shape: {
38 return std::make_unique<LOTShapeLayerItem>(layerData);
41 case LayerType::Null: {
42 return std::make_unique<LOTNullLayerItem>(layerData);
51 void LOTCompItem::resize(const VSize &size)
53 if (mViewSize == size) return;
55 mUpdateViewBox = true;
58 VSize LOTCompItem::size() const
63 bool LOTCompItem::update(int frameNo)
65 // check if cached frame is same as requested frame.
66 if (!mUpdateViewBox && (mCurFrameNo == frameNo)) return false;
69 * if viewbox dosen't scale exactly to the viewport
70 * we scale the viewbox keeping AspectRatioPreserved and then align the
71 * viewbox to the viewport using AlignCenter rule.
73 VSize viewPort = mViewSize;
74 VSize viewBox = mCompData->size();
76 float sx = float(viewPort.width()) / viewBox.width();
77 float sy = float(viewPort.height()) / viewBox.height();
78 float scale = fmin(sx, sy);
79 float tx = (viewPort.width() - viewBox.width() * scale) * 0.5;
80 float ty = (viewPort.height() - viewBox.height() * scale) * 0.5;
83 m.scale(scale, scale).translate(tx, ty);
84 mRootLayer->update(frameNo, m, 1.0);
87 mCurFrameNo = frameNo;
88 mUpdateViewBox = false;
92 void LOTCompItem::buildRenderList()
94 mDrawableList.clear();
95 mRootLayer->renderList(mDrawableList);
98 for (auto &i : mDrawableList) {
99 LOTDrawable *lotDrawable = static_cast<LOTDrawable *>(i);
101 mRenderList.push_back(&lotDrawable->mCNode);
105 const std::vector<LOTNode *> &LOTCompItem::renderList() const
110 bool LOTCompItem::render(const LOTBuffer &buffer)
112 VBitmap bitmap((uchar *)buffer.buffer, buffer.width, buffer.height,
113 buffer.bytesPerLine, VBitmap::Format::ARGB32_Premultiplied,
116 /* schedule all preprocess task for this frame at once.
118 for (auto &e : mDrawableList) {
122 VPainter painter(&bitmap);
123 mRootLayer->render(&painter, {}, {}, nullptr);
128 void LOTMaskItem::update(int frameNo, const VMatrix &parentMatrix,
129 float parentAlpha, const DirtyFlag &/*flag*/)
131 if (mData->mShape.isStatic()) {
132 if (mLocalPath.isEmpty()) {
133 mData->mShape.value(frameNo).toPath(mLocalPath);
136 mData->mShape.value(frameNo).toPath(mLocalPath);
138 float opacity = mData->opacity(frameNo);
139 opacity = opacity * parentAlpha;
140 mCombinedAlpha = opacity;
142 VPath path = mLocalPath;
143 path.transform(parentMatrix);
145 mRleTask = VRaster::generateFillInfo(std::move(path), std::move(mRle));
149 VRle LOTMaskItem::rle()
151 if (mRleTask.valid()) {
152 mRle = mRleTask.get();
153 if (!vCompare(mCombinedAlpha, 1.0f))
154 mRle *= (mCombinedAlpha * 255);
155 if (mData->mInv) mRle.invert();
160 void LOTLayerItem::render(VPainter *painter, const VRle &inheritMask, const VRle &inheritMatte, LOTLayerItem *matteSource)
164 mDrawableList.clear();
165 matteSource->renderList(mDrawableList);
166 for (auto &i : mDrawableList) {
167 matteRle = matteRle + i->rle();
170 if (!inheritMatte.isEmpty())
171 matteRle = matteRle & inheritMatte;
173 matteRle = inheritMatte;
175 mDrawableList.clear();
176 renderList(mDrawableList);
180 mask = maskRle(painter->clipBoundingRect());
181 if (!inheritMask.isEmpty())
182 mask = mask & inheritMask;
183 // if resulting mask is empty then return.
190 for (auto &i : mDrawableList) {
191 painter->setBrush(i->mBrush);
193 if (!mask.isEmpty()) rle = rle & mask;
195 if (rle.isEmpty()) continue;
197 if (!matteRle.isEmpty()) {
198 if (mLayerData->mMatteType == MatteType::AlphaInv) {
199 rle = rle - matteRle;
201 rle = rle & matteRle;
204 painter->drawRle(VPoint(), rle);
208 VRle LOTLayerItem::maskRle(const VRect &clipRect)
211 for (auto &i : mMasks) {
212 switch (i->maskMode()) {
213 case LOTMaskData::Mode::Add: {
214 rle = rle + i->rle();
217 case LOTMaskData::Mode::Substarct: {
218 if (rle.isEmpty() && !clipRect.isEmpty())
219 rle = VRle::toRle(clipRect);
220 rle = rle - i->rle();
223 case LOTMaskData::Mode::Intersect: {
224 rle = rle & i->rle();
227 case LOTMaskData::Mode::Difference: {
228 rle = rle ^ i->rle();
238 LOTLayerItem::LOTLayerItem(LOTLayerData *layerData): mLayerData(layerData)
240 if (mLayerData->mHasMask) {
241 for (auto &i : mLayerData->mMasks) {
242 mMasks.push_back(std::make_unique<LOTMaskItem>(i.get()));
247 void LOTLayerItem::updateStaticProperty()
249 if (mParentLayer) mParentLayer->updateStaticProperty();
251 mStatic = mLayerData->isStatic();
252 mStatic = mParentLayer ? (mStatic & mParentLayer->isStatic()) : mStatic;
253 mStatic = mPrecompLayer ? (mStatic & mPrecompLayer->isStatic()) : mStatic;
256 void LOTLayerItem::update(int frameNo, const VMatrix &parentMatrix,
260 // 1. check if the layer is part of the current frame
261 if (!visible()) return;
263 // 2. calculate the parent matrix and alpha
264 VMatrix m = matrix(frameNo);
266 float alpha = parentAlpha * opacity(frameNo);
268 // 6. update the mask
270 for (auto &i : mMasks) i->update(frameNo, m, alpha, mDirtyFlag);
273 // 3. update the dirty flag based on the change
274 if (!mCombinedMatrix.fuzzyCompare(m)) {
275 mDirtyFlag |= DirtyFlagBit::Matrix;
277 if (!vCompare(mCombinedAlpha, alpha)) {
278 mDirtyFlag |= DirtyFlagBit::Alpha;
281 mCombinedAlpha = alpha;
283 // 4. if no parent property change and layer is static then nothing to do.
284 if ((flag() & DirtyFlagBit::None) && isStatic()) return;
286 // 5. update the content of the layer
289 // 6. reset the dirty flag
290 mDirtyFlag = DirtyFlagBit::None;
293 float LOTLayerItem::opacity(int frameNo) const
295 return mLayerData->mTransform->opacity(frameNo);
298 VMatrix LOTLayerItem::matrix(int frameNo) const
301 return mLayerData->mTransform->matrix(frameNo) *
302 mParentLayer->matrix(frameNo);
304 return mLayerData->mTransform->matrix(frameNo);
307 bool LOTLayerItem::visible() const
309 if (frameNo() >= mLayerData->inFrame() &&
310 frameNo() < mLayerData->outFrame())
316 LOTCompLayerItem::LOTCompLayerItem(LOTLayerData *layerModel)
317 : LOTLayerItem(layerModel)
319 for (auto &i : mLayerData->mChildren) {
320 LOTLayerData *layerModel = dynamic_cast<LOTLayerData *>(i.get());
322 auto layerItem = LOTCompItem::createLayerItem(layerModel);
323 if (layerItem) mLayers.push_back(std::move(layerItem));
327 // 2. update parent layer
328 for (auto &i : mLayers) {
329 int id = i->parentId();
331 auto search = std::find_if(mLayers.begin(), mLayers.end(),
332 [id](const auto& val){ return val->id() == id;});
333 if (search != mLayers.end()) i->setParentLayer((*search).get());
335 // update the precomp layer if its not the root layer.
336 if (!layerModel->root()) i->setPrecompLayer(this);
340 void LOTCompLayerItem::updateStaticProperty()
342 LOTLayerItem::updateStaticProperty();
344 for (auto &i : mLayers) {
345 i->updateStaticProperty();
349 void LOTCompLayerItem::render(VPainter *painter, const VRle &inheritMask, const VRle &inheritMatte, LOTLayerItem *matteSource)
353 mDrawableList.clear();
354 matteSource->renderList(mDrawableList);
355 for (auto &i : mDrawableList) {
356 matteRle = matteRle + i->rle();
359 if (!inheritMatte.isEmpty())
360 matteRle = matteRle & inheritMatte;
362 matteRle = inheritMatte;
367 mask = maskRle(painter->clipBoundingRect());
368 if (!inheritMask.isEmpty())
369 mask = mask & inheritMask;
370 // if resulting mask is empty then return.
377 LOTLayerItem *matteLayer = nullptr;
378 for (auto i = mLayers.rbegin(); i != mLayers.rend(); ++i) {
379 LOTLayerItem *layer = (*i).get();
381 if (!matteLayer && layer->hasMatte()) {
387 matteLayer->render(painter, mask, matteRle, layer);
388 matteLayer = nullptr;
390 layer->render(painter, mask, matteRle, nullptr);
395 void LOTCompLayerItem::updateContent()
397 // update the layer from back to front
398 for (auto i = mLayers.rbegin(); i != mLayers.rend(); ++i) {
399 (*i)->update(frameNo(), combinedMatrix(), combinedAlpha());
403 void LOTCompLayerItem::renderList(std::vector<VDrawable *> &list)
405 if (!visible()) return;
407 // update the layer from back to front
408 for (auto i = mLayers.rbegin(); i != mLayers.rend(); ++i) {
409 (*i)->renderList(list);
413 LOTSolidLayerItem::LOTSolidLayerItem(LOTLayerData *layerData)
414 : LOTLayerItem(layerData)
418 void LOTSolidLayerItem::updateContent()
421 mRenderNode = std::make_unique<LOTDrawable>();
422 mRenderNode->mType = VDrawable::Type::Fill;
423 mRenderNode->mFlag |= VDrawable::DirtyState::All;
426 if (flag() & DirtyFlagBit::Matrix) {
429 VRectF(0, 0, mLayerData->solidWidth(), mLayerData->solidHeight()));
430 path.transform(combinedMatrix());
431 mRenderNode->mFlag |= VDrawable::DirtyState::Path;
432 mRenderNode->mPath = path;
434 if (flag() & DirtyFlagBit::Alpha) {
435 LottieColor color = mLayerData->solidColor();
436 VBrush brush(color.toColor(combinedAlpha()));
437 mRenderNode->setBrush(brush);
438 mRenderNode->mFlag |= VDrawable::DirtyState::Brush;
442 void LOTSolidLayerItem::renderList(std::vector<VDrawable *> &list)
444 if (!visible()) return;
446 list.push_back(mRenderNode.get());
449 LOTNullLayerItem::LOTNullLayerItem(LOTLayerData *layerData)
450 : LOTLayerItem(layerData)
453 void LOTNullLayerItem::updateContent() {}
455 LOTShapeLayerItem::LOTShapeLayerItem(LOTLayerData *layerData)
456 : LOTLayerItem(layerData)
458 mRoot = std::make_unique<LOTContentGroupItem>(nullptr);
459 mRoot->addChildren(layerData);
461 std::vector<LOTPathDataItem *> list;
462 mRoot->processPathItems(list);
464 if (layerData->hasPathOperator()) mRoot->processTrimOperation();
467 std::unique_ptr<LOTContentItem>
468 LOTShapeLayerItem::createContentItem(LOTData *contentData)
470 switch (contentData->type()) {
471 case LOTData::Type::ShapeGroup: {
472 return std::make_unique<LOTContentGroupItem>(
473 static_cast<LOTShapeGroupData *>(contentData));
476 case LOTData::Type::Rect: {
477 return std::make_unique<LOTRectItem>(static_cast<LOTRectData *>(contentData));
480 case LOTData::Type::Ellipse: {
481 return std::make_unique<LOTEllipseItem>(static_cast<LOTEllipseData *>(contentData));
484 case LOTData::Type::Shape: {
485 return std::make_unique<LOTShapeItem>(static_cast<LOTShapeData *>(contentData));
488 case LOTData::Type::Polystar: {
489 return std::make_unique<LOTPolystarItem>(static_cast<LOTPolystarData *>(contentData));
492 case LOTData::Type::Fill: {
493 return std::make_unique<LOTFillItem>(static_cast<LOTFillData *>(contentData));
496 case LOTData::Type::GFill: {
497 return std::make_unique<LOTGFillItem>(static_cast<LOTGFillData *>(contentData));
500 case LOTData::Type::Stroke: {
501 return std::make_unique<LOTStrokeItem>(static_cast<LOTStrokeData *>(contentData));
504 case LOTData::Type::GStroke: {
505 return std::make_unique<LOTGStrokeItem>(static_cast<LOTGStrokeData *>(contentData));
508 case LOTData::Type::Repeater: {
509 return std::make_unique<LOTRepeaterItem>(static_cast<LOTRepeaterData *>(contentData));
512 case LOTData::Type::Trim: {
513 return std::make_unique<LOTTrimItem>(static_cast<LOTTrimData *>(contentData));
522 void LOTShapeLayerItem::updateContent()
524 mRoot->update(frameNo(), combinedMatrix(), combinedAlpha(), flag());
527 void LOTShapeLayerItem::renderList(std::vector<VDrawable *> &list)
529 if (!visible()) return;
530 mRoot->renderList(list);
533 LOTContentGroupItem::LOTContentGroupItem(LOTShapeGroupData *data) : mData(data)
538 void LOTContentGroupItem::addChildren(LOTGroupData *data)
542 for (auto &i : data->mChildren) {
543 auto content = LOTShapeLayerItem::createContentItem(i.get());
544 if (content) mContents.push_back(std::move(content));
548 void LOTContentGroupItem::update(int frameNo, const VMatrix &parentMatrix,
549 float parentAlpha, const DirtyFlag &flag)
551 VMatrix m = parentMatrix;
552 float alpha = parentAlpha;
553 DirtyFlag newFlag = flag;
556 // update the matrix and the flag
557 if ((flag & DirtyFlagBit::Matrix) ||
558 !mData->mTransform->staticMatrix()) {
559 newFlag |= DirtyFlagBit::Matrix;
561 m = mData->mTransform->matrix(frameNo);
563 alpha *= mData->mTransform->opacity(frameNo);
565 if (!vCompare(alpha, parentAlpha)) {
566 newFlag |= DirtyFlagBit::Alpha;
570 for (auto i = mContents.rbegin(); i != mContents.rend(); ++i) {
571 (*i)->update(frameNo, m, alpha, newFlag);
575 void LOTContentGroupItem::renderList(std::vector<VDrawable *> &list)
577 for (auto i = mContents.rbegin(); i != mContents.rend(); ++i) {
578 (*i)->renderList(list);
582 void LOTContentGroupItem::processPathItems(
583 std::vector<LOTPathDataItem *> &list)
585 int curOpCount = list.size();
586 for (auto &i : mContents) {
587 if (auto pathNode = dynamic_cast<LOTPathDataItem *>(i.get())) {
588 // add it to the list
589 list.push_back(pathNode);
590 } else if (auto paintNode = dynamic_cast<LOTPaintDataItem *>(i.get())) {
591 // the node is a paint data node update the path list of the paint item.
592 paintNode->addPathItems(list);
593 } else if (auto groupNode =
594 dynamic_cast<LOTContentGroupItem *>(i.get())) {
595 // update the groups node with current list
596 groupNode->processPathItems(list);
599 list.erase(list.begin() + curOpCount, list.end());
602 void LOTContentGroupItem::processTrimOperation()
604 std::vector<LOTTrimItem *> list;
605 trimOperationHelper(list);
608 void LOTContentGroupItem::trimOperationHelper(std::vector<LOTTrimItem *> &list)
610 int curOpCount = list.size();
611 for (auto i = mContents.rbegin(); i != mContents.rend(); ++i) {
612 auto child = (*i).get();
613 if (auto pathNode = dynamic_cast<LOTPathDataItem *>(child)) {
614 // the node is a path data node add the trim operation list to it.
615 pathNode->addTrimOperation(list);
616 } else if (auto trimNode = dynamic_cast<LOTTrimItem *>(child)) {
617 // add it to the trim operation list
618 list.push_back(trimNode);
619 } else if (auto groupNode =
620 dynamic_cast<LOTContentGroupItem *>(child)) {
621 // update the groups node with current list
622 groupNode->trimOperationHelper(list);
625 list.erase(list.begin() + curOpCount, list.end());
628 void LOTPathDataItem::addTrimOperation(std::vector<LOTTrimItem *> &list)
630 for (auto trimItem : list) {
631 mTrimNodeRefs.push_back(trimItem);
635 void LOTPathDataItem::update(int frameNo, const VMatrix &parentMatrix,
636 float, const DirtyFlag &flag)
640 mPathChanged = false;
642 // 1. update the local path if needed
643 if (!(mInit && mStaticPath) && hasChanged(frameNo)) {
644 updatePath(mLocalPath, frameNo);
649 tempPath = mLocalPath;
651 // 2. apply path operation if needed
652 if (mTrimNodeRefs.size() > 0) {
653 // TODO apply more than one trim path if necessary
655 float s = mTrimNodeRefs.front()->getStart(frameNo) / 100.0f;
656 float e = mTrimNodeRefs.front()->getEnd(frameNo) / 100.0f;
659 tempPath = pm.trim(tempPath);
663 // 3. compute the final path with parentMatrix
665 if ((flag & DirtyFlagBit::Matrix) || mPathChanged) {
666 mFinalPath.clone(tempPath);
667 mFinalPath.transform(parentMatrix);
672 LOTRectItem::LOTRectItem(LOTRectData *data)
673 : LOTPathDataItem(data->isStatic()), mData(data)
677 void LOTRectItem::updatePath(VPath& path, int frameNo)
679 VPointF pos = mData->mPos.value(frameNo);
680 VPointF size = mData->mSize.value(frameNo);
681 float roundness = mData->mRound.value(frameNo);
682 VRectF r(pos.x() - size.x() / 2, pos.y() - size.y() / 2, size.x(),
686 path.addRoundRect(r, roundness, roundness, mData->direction());
687 updateCache(frameNo, pos, size, roundness);
690 LOTEllipseItem::LOTEllipseItem(LOTEllipseData *data)
691 : LOTPathDataItem(data->isStatic()), mData(data)
695 void LOTEllipseItem::updatePath(VPath& path, int frameNo)
697 VPointF pos = mData->mPos.value(frameNo);
698 VPointF size = mData->mSize.value(frameNo);
699 VRectF r(pos.x() - size.x() / 2, pos.y() - size.y() / 2, size.x(),
703 path.addOval(r, mData->direction());
704 updateCache(frameNo, pos, size);
707 LOTShapeItem::LOTShapeItem(LOTShapeData *data)
708 : LOTPathDataItem(data->isStatic()), mData(data)
712 void LOTShapeItem::updatePath(VPath& path, int frameNo)
714 mData->mShape.value(frameNo).toPath(path);
717 LOTPolystarItem::LOTPolystarItem(LOTPolystarData *data)
718 : LOTPathDataItem(data->isStatic()), mData(data)
722 void LOTPolystarItem::updatePath(VPath& path, int frameNo)
724 VPointF pos = mData->mPos.value(frameNo);
725 float points = mData->mPointCount.value(frameNo);
726 float innerRadius = mData->mInnerRadius.value(frameNo);
727 float outerRadius = mData->mOuterRadius.value(frameNo);
728 float innerRoundness = mData->mInnerRoundness.value(frameNo);
729 float outerRoundness = mData->mOuterRoundness.value(frameNo);
730 float rotation = mData->mRotation.value(frameNo);
735 if (mData->mType == LOTPolystarData::PolyType::Star) {
736 path.addPolystar(points, innerRadius, outerRadius, innerRoundness,
737 outerRoundness, 0.0, 0.0, 0.0, mData->direction());
739 path.addPolygon(points, outerRadius, outerRoundness, 0.0, 0.0, 0.0,
743 m.translate(pos.x(), pos.y()).rotate(rotation);
746 updateCache(frameNo, pos, points, innerRadius, outerRadius,
747 innerRoundness, outerRoundness, rotation);
751 * PaintData Node handling
754 LOTPaintDataItem::LOTPaintDataItem(bool staticContent):mDrawable(std::make_unique<LOTDrawable>()),
755 mStaticContent(staticContent){}
757 void LOTPaintDataItem::update(int frameNo, const VMatrix &parentMatrix,
758 float parentAlpha, const DirtyFlag &flag)
760 mRenderNodeUpdate = true;
761 mParentAlpha = parentAlpha;
762 mParentMatrix = parentMatrix;
766 updateContent(frameNo);
769 void LOTPaintDataItem::updateRenderNode()
772 for (auto &i : mPathItems) {
782 for (auto &i : mPathItems) {
783 mPath.addPath(i->path());
785 mDrawable->setPath(mPath);
787 if (mDrawable->mFlag & VDrawable::DirtyState::Path)
788 mDrawable->mPath = mPath;
792 void LOTPaintDataItem::renderList(std::vector<VDrawable *> &list)
794 if (mRenderNodeUpdate) {
796 LOTPaintDataItem::updateRenderNode();
797 mRenderNodeUpdate = false;
799 list.push_back(mDrawable.get());
803 void LOTPaintDataItem::addPathItems(std::vector<LOTPathDataItem *> &list)
809 LOTFillItem::LOTFillItem(LOTFillData *data)
810 : LOTPaintDataItem(data->isStatic()), mData(data)
814 void LOTFillItem::updateContent(int frameNo)
816 LottieColor c = mData->mColor.value(frameNo);
817 float opacity = mData->opacity(frameNo);
818 mColor = c.toColor(opacity);
819 mFillRule = mData->fillRule();
822 void LOTFillItem::updateRenderNode()
824 VColor color = mColor;
826 color.setAlpha(color.a * parentAlpha());
828 mDrawable->setBrush(brush);
829 mDrawable->setFillRule(mFillRule);
832 LOTGFillItem::LOTGFillItem(LOTGFillData *data)
833 : LOTPaintDataItem(data->isStatic()), mData(data)
837 void LOTGFillItem::updateContent(int frameNo)
839 mData->update(mGradient, frameNo);
840 mGradient->mMatrix = mParentMatrix;
841 mFillRule = mData->fillRule();
844 void LOTGFillItem::updateRenderNode()
846 mDrawable->setBrush(VBrush(mGradient.get()));
847 mDrawable->setFillRule(mFillRule);
850 LOTStrokeItem::LOTStrokeItem(LOTStrokeData *data)
851 : LOTPaintDataItem(data->isStatic()), mData(data)
856 void LOTStrokeItem::updateContent(int frameNo)
858 LottieColor c = mData->mColor.value(frameNo);
859 float opacity = mData->opacity(frameNo);
860 mColor = c.toColor(opacity);
861 mCap = mData->capStyle();
862 mJoin = mData->joinStyle();
863 mMiterLimit = mData->meterLimit();
864 mWidth = mData->width(frameNo);
865 if (mData->hasDashInfo()) {
866 mDashArraySize = mData->getDashInfo(frameNo, mDashArray);
870 static float getScale(const VMatrix &matrix)
872 constexpr float SQRT_2 = 1.41421;
874 VPointF p2(SQRT_2, SQRT_2);
877 VPointF final = p2 - p1;
879 return std::sqrt(final.x() * final.x() + final.y() * final.y());
882 void LOTStrokeItem::updateRenderNode()
884 VColor color = mColor;
886 color.setAlpha(color.a * parentAlpha());
888 mDrawable->setBrush(brush);
889 float scale = getScale(mParentMatrix);
890 mDrawable->setStrokeInfo(mCap, mJoin, mMiterLimit,
892 if (mDashArraySize) {
893 for (int i = 0 ; i < mDashArraySize ; i++)
894 mDashArray[i] *= scale;
895 mDrawable->setDashInfo(mDashArray, mDashArraySize);
899 LOTGStrokeItem::LOTGStrokeItem(LOTGStrokeData *data)
900 : LOTPaintDataItem(data->isStatic()), mData(data)
905 void LOTGStrokeItem::updateContent(int frameNo)
907 mData->update(mGradient, frameNo);
908 mGradient->mMatrix = mParentMatrix;
909 mCap = mData->capStyle();
910 mJoin = mData->joinStyle();
911 mMiterLimit = mData->meterLimit();
912 mWidth = mData->width(frameNo);
913 if (mData->hasDashInfo()) {
914 mDashArraySize = mData->getDashInfo(frameNo, mDashArray);
918 void LOTGStrokeItem::updateRenderNode()
920 float scale = getScale(mParentMatrix);
921 mDrawable->setBrush(VBrush(mGradient.get()));
922 mDrawable->setStrokeInfo(mCap, mJoin, mMiterLimit,
924 if (mDashArraySize) {
925 for (int i = 0 ; i < mDashArraySize ; i++)
926 mDashArray[i] *= scale;
927 mDrawable->setDashInfo(mDashArray, mDashArraySize);
931 LOTTrimItem::LOTTrimItem(LOTTrimData *data) : mData(data) {}
933 void LOTTrimItem::update(int /*frameNo*/, const VMatrix &/*parentMatrix*/,
934 float /*parentAlpha*/, const DirtyFlag &/*flag*/)
938 LOTRepeaterItem::LOTRepeaterItem(LOTRepeaterData *data) : mData(data) {}
940 void LOTRepeaterItem::update(int /*frameNo*/, const VMatrix &/*parentMatrix*/,
941 float /*parentAlpha*/, const DirtyFlag &/*flag*/)
945 void LOTRepeaterItem::renderList(std::vector<VDrawable *> &/*list*/) {}
947 void LOTDrawable::sync()
949 mCNode.mFlag = ChangeFlagNone;
950 if (mFlag & DirtyState::None) return;
952 if (mFlag & DirtyState::Path) {
953 const std::vector<VPath::Element> &elm = mPath.elements();
954 const std::vector<VPointF> & pts = mPath.points();
955 const float *ptPtr = reinterpret_cast<const float *>(pts.data());
956 const char * elmPtr = reinterpret_cast<const char *>(elm.data());
957 mCNode.mPath.elmPtr = elmPtr;
958 mCNode.mPath.elmCount = elm.size();
959 mCNode.mPath.ptPtr = ptPtr;
960 mCNode.mPath.ptCount = 2 * pts.size();
961 mCNode.mFlag |= ChangeFlagPath;
964 if (mStroke.enable) {
965 mCNode.mStroke.width = mStroke.width;
966 mCNode.mStroke.meterLimit = mStroke.meterLimit;
967 mCNode.mStroke.enable = 1;
970 case FillRule::EvenOdd:
971 mCNode.mFillRule = LOTFillRule::FillEvenOdd;
974 mCNode.mFillRule = LOTFillRule::FillWinding;
978 switch (mStroke.cap) {
980 mCNode.mStroke.cap = LOTCapStyle::CapFlat;
982 case CapStyle::Square:
983 mCNode.mStroke.cap = LOTCapStyle::CapSquare;
985 case CapStyle::Round:
986 mCNode.mStroke.cap = LOTCapStyle::CapRound;
989 mCNode.mStroke.cap = LOTCapStyle::CapFlat;
993 switch (mStroke.join) {
994 case JoinStyle::Miter:
995 mCNode.mStroke.join = LOTJoinStyle::JoinMiter;
997 case JoinStyle::Bevel:
998 mCNode.mStroke.join = LOTJoinStyle::JoinBevel;
1000 case JoinStyle::Round:
1001 mCNode.mStroke.join = LOTJoinStyle::JoinRound;
1004 mCNode.mStroke.join = LOTJoinStyle::JoinMiter;
1008 mCNode.mStroke.dashArray = mStroke.mDash.data();
1009 mCNode.mStroke.dashArraySize = mStroke.mDash.size();
1012 mCNode.mStroke.enable = 0;
1015 switch (mBrush.type()) {
1016 case VBrush::Type::Solid:
1017 mCNode.mType = LOTBrushType::BrushSolid;
1018 mCNode.mColor.r = mBrush.mColor.r;
1019 mCNode.mColor.g = mBrush.mColor.g;
1020 mCNode.mColor.b = mBrush.mColor.b;
1021 mCNode.mColor.a = mBrush.mColor.a;
1023 case VBrush::Type::LinearGradient:
1024 mCNode.mType = LOTBrushType::BrushGradient;
1025 mCNode.mGradient.type = LOTGradientType::GradientLinear;
1026 mCNode.mGradient.start.x = mBrush.mGradient->linear.x1;
1027 mCNode.mGradient.start.y = mBrush.mGradient->linear.y1;
1028 mCNode.mGradient.end.x = mBrush.mGradient->linear.x2;
1029 mCNode.mGradient.end.y = mBrush.mGradient->linear.y2;
1031 case VBrush::Type::RadialGradient:
1032 mCNode.mType = LOTBrushType::BrushGradient;
1033 mCNode.mGradient.type = LOTGradientType::GradientRadial;
1034 mCNode.mGradient.center.x = mBrush.mGradient->radial.cx;
1035 mCNode.mGradient.center.y = mBrush.mGradient->radial.cy;
1036 mCNode.mGradient.focal.x = mBrush.mGradient->radial.fx;
1037 mCNode.mGradient.focal.y = mBrush.mGradient->radial.fy;
1038 mCNode.mGradient.cradius = mBrush.mGradient->radial.cradius;
1039 mCNode.mGradient.fradius = mBrush.mGradient->radial.fradius;