bool renderSync(float pos, LOTBuffer buffer, bool forceRender = false);
private:
- _LOT_PLAYER_DECLARE_PRIVATE(LOTPlayer);
+ _LOT_PLAYER_DECLARE_PRIVATE(LOTPlayer)
};
} // namespace lotplayer
}
void LOTMaskItem::update(int frameNo, const VMatrix &parentMatrix,
- float parentAlpha, const DirtyFlag &flag)
+ float parentAlpha, const DirtyFlag &/*flag*/)
{
if (mData->mShape.isStatic()) {
if (mLocalPath.isEmpty()) {
mFillRule = mData->fillRule();
}
-void LOTGFillItem::updateRenderNode(LOTPathDataItem *pathNode,
- VDrawable *drawable, bool sameParent)
+void LOTGFillItem::updateRenderNode(LOTPathDataItem */*pathNode*/,
+ VDrawable *drawable, bool /*sameParent*/)
{
drawable->setBrush(VBrush(mGradient.get()));
drawable->setFillRule(mFillRule);
}
}
-void LOTGStrokeItem::updateRenderNode(LOTPathDataItem *pathNode,
- VDrawable *drawable, bool sameParent)
+void LOTGStrokeItem::updateRenderNode(LOTPathDataItem */*pathNode*/,
+ VDrawable *drawable, bool /*sameParent*/)
{
float scale = getScale(mParentMatrix);
drawable->setBrush(VBrush(mGradient.get()));
LOTTrimItem::LOTTrimItem(LOTTrimData *data) : mData(data) {}
-void LOTTrimItem::update(int frameNo, const VMatrix &parentMatrix,
- float parentAlpha, const DirtyFlag &flag)
+void LOTTrimItem::update(int /*frameNo*/, const VMatrix &/*parentMatrix*/,
+ float /*parentAlpha*/, const DirtyFlag &/*flag*/)
{
}
LOTRepeaterItem::LOTRepeaterItem(LOTRepeaterData *data) : mData(data) {}
-void LOTRepeaterItem::update(int frameNo, const VMatrix &parentMatrix,
- float parentAlpha, const DirtyFlag &flag)
+void LOTRepeaterItem::update(int /*frameNo*/, const VMatrix &/*parentMatrix*/,
+ float /*parentAlpha*/, const DirtyFlag &/*flag*/)
{
}
-void LOTRepeaterItem::renderList(std::vector<VDrawable *> &list) {}
+void LOTRepeaterItem::renderList(std::vector<VDrawable *> &/*list*/) {}
void LOTDrawable::sync()
{
void setPrecompLayer(LOTLayerItem *precomp){mPrecompLayer = precomp;}
virtual void update(int frameNo, const VMatrix &parentMatrix, float parentAlpha);
VMatrix matrix(int frameNo) const;
- virtual void renderList(std::vector<VDrawable *> &list){}
+ virtual void renderList(std::vector<VDrawable *> &){}
virtual void updateStaticProperty();
virtual void render(VPainter *painter, const VRle &mask, const VRle &inheritMatte, LOTLayerItem *matteSource);
bool hasMatte() { if (mLayerData->mMatteType == MatteType::None) return false; return true; }
LOTContentItem(){}
virtual ~LOTContentItem(){}
virtual void update(int frameNo, const VMatrix &parentMatrix, float parentAlpha, const DirtyFlag &flag) = 0;
- virtual void renderList(std::vector<VDrawable *> &list){}
+ virtual void renderList(std::vector<VDrawable *> &){}
};
class LOTContentGroupItem: public LOTContentItem
private:
void updatePath(VPath& path, int frameNo) final;
LOTShapeData *mData;
- bool hasChanged(int frameNo) final { return true; }
+ bool hasChanged(int) final { return true; }
};
class LOTPolystarItem: public LOTPathDataItem
class LottieRepeaterProcesser : public LOTDataVisitor {
public:
LottieRepeaterProcesser() : mRepeaterFound(false) {}
- void visit(LOTCompositionData *obj) {}
- void visit(LOTLayerData *obj) {}
+ void visit(LOTCompositionData *) {}
+ void visit(LOTLayerData *) {}
void visit(LOTTransformData *) {}
- void visit(LOTShapeGroupData *obj) {}
+ void visit(LOTShapeGroupData *) {}
void visit(LOTShapeData *) {}
void visit(LOTRectData *) {}
void visit(LOTEllipseData *) {}
}
static inline Operator getOperator(const VSpanData * data,
- const VRle::Span *spans, int spanCount)
+ const VRle::Span *, int)
{
Operator op;
bool solidSource = false;
}
}
-void VSpanData::setup(const VBrush &brush, VPainter::CompositionMode mode,
- int alpha)
+void VSpanData::setup(const VBrush &brush, VPainter::CompositionMode /*mode*/,
+ int /*alpha*/)
{
switch (brush.type()) {
case VBrush::Type::NoBrush:
{
return VPointF(p1.mx + p2.mx, p1.my + p2.my);
}
- inline friend const bool fuzzyCompare(const VPointF &p1, const VPointF &p2);
+ inline friend bool fuzzyCompare(const VPointF &p1, const VPointF &p2);
inline friend VDebug & operator<<(VDebug &os, const VPointF &o);
friend inline VPointF operator-(const VPointF &p1, const VPointF &p2);
float my;
};
-inline const bool fuzzyCompare(const VPointF &p1, const VPointF &p2)
+inline bool fuzzyCompare(const VPointF &p1, const VPointF &p2)
{
return (vCompare(p1.mx, p2.mx) && vCompare(p1.my, p2.my));
}
inline void setHeight(float h) { y2 = y1 + h; }
inline void translate(float dx, float dy)
{
- x1 -= dx;
- x2 -= dx;
- y1 -= dx;
- y2 -= dx;
+ x1 += dx;
+ y1 += dy;
+ x2 += dx;
+ y2 += dy;
}
private: