*/
mDrawableList.clear();
mRootLayer->renderList(mDrawableList);
+ VRect clip(0, 0, surface.width(), surface.height());
for (auto &e : mDrawableList) {
- e->preprocess();
+ e->preprocess(clip);
}
VPainter painter(&bitmap);
VMatrix LOTLayerItem::matrix(int frameNo) const
{
if (mParentLayer)
- return mLayerData->mTransform->matrix(frameNo) *
+ return mLayerData->mTransform->matrix(frameNo, mLayerData->autoOrient()) *
mParentLayer->matrix(frameNo);
else
- return mLayerData->mTransform->matrix(frameNo);
+ return mLayerData->mTransform->matrix(frameNo, mLayerData->autoOrient());
}
bool LOTLayerItem::visible() const
size.y());
path.reset();
- path.addRoundRect(r, roundness, roundness, mData->direction());
+ path.addRoundRect(r, roundness, mData->direction());
updateCache(frameNo, pos, size, roundness);
}
void LOTGFillItem::updateRenderNode()
{
+ mGradient->setAlpha(parentAlpha());
mDrawable->setBrush(VBrush(mGradient.get()));
mDrawable->setFillRule(mFillRule);
}
void LOTGStrokeItem::updateRenderNode()
{
float scale = getScale(mGradient->mMatrix);
+ mGradient->setAlpha(parentAlpha());
mDrawable->setBrush(VBrush(mGradient.get()));
mDrawable->setStrokeInfo(mCap, mJoin, mMiterLimit,
mWidth * scale);
// when both path and trim are not dirty
if (!(mDirty || pathDirty())) return;
- //@TODO take the offset and trim type into account.
- for (auto &i : mPathItems) {
- VPathMesure pm;
- pm.setStart(mCache.mStart);
- pm.setEnd(mCache.mEnd);
- pm.setOffset(mCache.mOffset);
- i->updatePath(pm.trim(i->localPath()));
+ if (vCompare(mCache.mStart, mCache.mEnd)) {
+ for (auto &i : mPathItems) {
+ i->updatePath(VPath());
+ }
+ return;
}
+
+
+ if (mData->type() == LOTTrimData::TrimType::Simultaneously) {
+ for (auto &i : mPathItems) {
+ VPathMesure pm;
+ pm.setStart(mCache.mStart);
+ pm.setEnd(mCache.mEnd);
+ pm.setOffset(mCache.mOffset);
+ i->updatePath(pm.trim(i->localPath()));
+ }
+ } else { // LOTTrimData::TrimType::Individually
+ float totalLength = 0.0;
+ for (auto &i : mPathItems) {
+ totalLength += i->localPath().length();
+ }
+ float offset = totalLength * mCache.mOffset;
+ float start = totalLength * mCache.mStart;
+ float end = totalLength * mCache.mEnd;
+ start += offset;
+ end +=offset;
+ // normalize start, end value to 0 - totalLength
+ if (fabs(start) > totalLength) start = fmod(start, totalLength);
+ if (fabs(end) > totalLength) end = fmod(end, totalLength);
+
+ if (start >= 0 && end >= 0) {
+ if (start > end) std::swap(start, end);
+ } else if ( start < 0 && end < 0) {
+ start += totalLength;
+ end += totalLength;
+ if (start > end) std::swap(start, end);
+ } else {
+ // one is +ve and one is -ve so the
+ // segment will be wrapped from end segment to start segment.
+ // we need to split it in two segment.
+ //@TODO
+ return;
+ }
+
+ if (start < end ) {
+ float curLen = 0.0;
+ for (auto &i : mPathItems) {
+ if (curLen > end) {
+ // update with empty path.
+ i->updatePath(VPath());
+ continue;
+ }
+ float len = i->localPath().length();
+
+ if (curLen < start && curLen + len < start) {
+ curLen += len;
+ // update with empty path.
+ i->updatePath(VPath());
+ continue;
+ } else if (start <= curLen && end >= curLen + len) {
+ // inside segment
+ curLen += len;
+ continue;
+ } else {
+ float local_start = start > curLen ? start - curLen : 0;
+ local_start /= len;
+ float local_end = curLen + len < end ? len : end - curLen;
+ local_end /= len;
+ VPathMesure pm;
+ pm.setStart(local_start);
+ pm.setEnd(local_end);
+ VPath p = pm.trim(i->localPath());
+ i->updatePath(p);
+ curLen += len;
+ }
+ }
+ }
+ }
+
}
void LOTRepeaterItem::renderList(std::vector<VDrawable *> &/*list*/) {}
+static void updateGStops(LOTNode *n, const VGradient *grad)
+{
+ if (grad->mStops.size() != n->mGradient.stopCount) {
+ if (n->mGradient.stopCount)
+ free(n->mGradient.stopPtr);
+ n->mGradient.stopCount = grad->mStops.size();
+ n->mGradient.stopPtr = (LOTGradientStop *) malloc(n->mGradient.stopCount * sizeof(LOTGradientStop));
+ }
+
+ LOTGradientStop *ptr = n->mGradient.stopPtr;
+ for (const auto &i : grad->mStops) {
+ ptr->pos = i.first;
+ ptr->a = i.second.alpha() * grad->alpha();
+ ptr->r = i.second.red();
+ ptr->g = i.second.green();
+ ptr->b = i.second.blue();
+ ptr++;
+ }
+
+}
+
void LOTDrawable::sync()
{
- if (!mCNode) mCNode = std::make_unique<LOTNode>();
+ if (!mCNode) {
+ mCNode = std::make_unique<LOTNode>();
+ mCNode->mGradient.stopPtr = nullptr;
+ mCNode->mGradient.stopCount = 0;
+ }
mCNode->mFlag = ChangeFlagNone;
if (mFlag & DirtyState::None) return;
switch (mBrush.type()) {
case VBrush::Type::Solid:
- mCNode->mType = LOTBrushType::BrushSolid;
+ mCNode->mBrushType = LOTBrushType::BrushSolid;
mCNode->mColor.r = mBrush.mColor.r;
mCNode->mColor.g = mBrush.mColor.g;
mCNode->mColor.b = mBrush.mColor.b;
mCNode->mColor.a = mBrush.mColor.a;
break;
- case VBrush::Type::LinearGradient:
- mCNode->mType = LOTBrushType::BrushGradient;
+ case VBrush::Type::LinearGradient: {
+ mCNode->mBrushType = LOTBrushType::BrushGradient;
mCNode->mGradient.type = LOTGradientType::GradientLinear;
- mCNode->mGradient.start.x = mBrush.mGradient->linear.x1;
- mCNode->mGradient.start.y = mBrush.mGradient->linear.y1;
- mCNode->mGradient.end.x = mBrush.mGradient->linear.x2;
- mCNode->mGradient.end.y = mBrush.mGradient->linear.y2;
+ VPointF s = mBrush.mGradient->mMatrix.map({mBrush.mGradient->linear.x1,
+ mBrush.mGradient->linear.y1});
+ VPointF e = mBrush.mGradient->mMatrix.map({mBrush.mGradient->linear.x2,
+ mBrush.mGradient->linear.y2});
+ mCNode->mGradient.start.x = s.x();
+ mCNode->mGradient.start.y = s.y();
+ mCNode->mGradient.end.x = e.x();
+ mCNode->mGradient.end.y = e.y();
+ updateGStops(mCNode.get(), mBrush.mGradient);
break;
- case VBrush::Type::RadialGradient:
- mCNode->mType = LOTBrushType::BrushGradient;
+ }
+ case VBrush::Type::RadialGradient: {
+ mCNode->mBrushType = LOTBrushType::BrushGradient;
mCNode->mGradient.type = LOTGradientType::GradientRadial;
- mCNode->mGradient.center.x = mBrush.mGradient->radial.cx;
- mCNode->mGradient.center.y = mBrush.mGradient->radial.cy;
- mCNode->mGradient.focal.x = mBrush.mGradient->radial.fx;
- mCNode->mGradient.focal.y = mBrush.mGradient->radial.fy;
- mCNode->mGradient.cradius = mBrush.mGradient->radial.cradius;
- mCNode->mGradient.fradius = mBrush.mGradient->radial.fradius;
+ VPointF c = mBrush.mGradient->mMatrix.map({mBrush.mGradient->radial.cx,
+ mBrush.mGradient->radial.cy});
+ VPointF f = mBrush.mGradient->mMatrix.map({mBrush.mGradient->radial.fx,
+ mBrush.mGradient->radial.fy});
+ mCNode->mGradient.center.x = c.x();
+ mCNode->mGradient.center.y = c.y();
+ mCNode->mGradient.focal.x = f.x();
+ mCNode->mGradient.focal.y = f.y();
+
+ float scale = getScale(mBrush.mGradient->mMatrix);
+ mCNode->mGradient.cradius = mBrush.mGradient->radial.cradius * scale;
+ mCNode->mGradient.fradius = mBrush.mGradient->radial.fradius * scale;
+ updateGStops(mCNode.get(), mBrush.mGradient);
break;
+ }
default:
break;
}