Added trim paths props

Change-Id: I1c2bc75078a22c105da496e1141d6f2d2e7794ae

diff --git a/example/demo.cpp b/example/demo.cpp
index fe31e28639fd3e1ce3699879d78d55bf02c8a76a..4898081e7dd86f5a728a064163b0f47ed95c78ce 100644 (file)
--- a/example/demo.cpp
+++ b/example/demo.cpp
@@ -207,6 +207,10 @@ public:
                          return rlottie::Color(1, 0, 0);
                      }
                  });
+            view8->player()->setValue<rlottie::Property::TrimEnd>("Shape Layer 2.Trim Paths 1",
+                [](const rlottie::FrameInfo& info) {
+                     return rlottie::Point(0, 30);
+                 });
         }
         view8->setPos(2100, 0);
         view8->setSize(300, 300);

diff --git a/inc/rlottie.h b/inc/rlottie.h
index 67565691c3a2d9cf45a7605d9f1bdb6fd545cc27..ec50d2dba0671d0d1706f3e7ae7d005611c171e2 100644 (file)
--- a/inc/rlottie.h
+++ b/inc/rlottie.h
@@ -113,7 +113,9 @@ enum class Property {
     TrPosition,    /*!< Transform Position property of Layer and Group object , value type is rlottie::Point */
     TrScale,       /*!< Transform Scale property of Layer and Group object , value type is rlottie::Size. range[0 ..100] */
     TrRotation,    /*!< Transform Rotation property of Layer and Group object , value type is float. range[0 .. 360] in degrees*/
-    TrOpacity      /*!< Transform Opacity property of Layer and Group object , value type is float [ 0 .. 100] */
+    TrOpacity,     /*!< Transform Opacity property of Layer and Group object , value type is float [ 0 .. 100] */
+    TrimStart,     /*!< Trim Start property of Shape object , value type is float [ 0 .. 100] */
+    TrimEnd        /*!< Trim End property of Shape object , value type is rlottie::Point [ 0 .. 100] */
 };
 
 struct Color_Type{};
@@ -518,8 +520,8 @@ template<> struct MapType<std::integral_constant<Property, Property::TrOpacity>>
 template<> struct MapType<std::integral_constant<Property, Property::TrAnchor>>: Point_Type{};
 template<> struct MapType<std::integral_constant<Property, Property::TrPosition>>: Point_Type{};
 template<> struct MapType<std::integral_constant<Property, Property::TrScale>>: Size_Type{};
-
-
+template<> struct MapType<std::integral_constant<Property, Property::TrimStart>>: Float_Type{};
+template<> struct MapType<std::integral_constant<Property, Property::TrimEnd>>: Point_Type{};
 }  // namespace lotplayer
 
 #endif  // _RLOTTIE_H_

diff --git a/inc/rlottie_capi.h b/inc/rlottie_capi.h
index 80907ae67654a4e96c38fa014a684cdcfc3ecb22..bf91ae41a8beb5eac0364ffed41254b7a33fb0fc 100644 (file)
--- a/inc/rlottie_capi.h
+++ b/inc/rlottie_capi.h
@@ -41,7 +41,9 @@ typedef enum {
     LOTTIE_ANIMATION_PROPERTY_TR_POSITION,    /*!< Transform Position property of Layer and Group object , value type is int */
     LOTTIE_ANIMATION_PROPERTY_TR_SCALE,       /*!< Transform Scale property of Layer and Group object , value type is float range[0 ..100] */
     LOTTIE_ANIMATION_PROPERTY_TR_ROTATION,    /*!< Transform Scale property of Layer and Group object , value type is float. range[0 .. 360] in degrees*/
-    LOTTIE_ANIMATION_PROPERTY_TR_OPACITY      /*!< Transform Opacity property of Layer and Group object , value type is float [ 0 .. 100] */
+    LOTTIE_ANIMATION_PROPERTY_TR_OPACITY,      /*!< Transform Opacity property of Layer and Group object , value type is float [ 0 .. 100] */
+    LOTTIE_ANIMATION_PROPERTY_TRIM_PATH_START, /*!< Trim Path Start property of Shape object , value type is float [0 .. 100] */
+    LOTTIE_ANIMATION_PROPERTY_TRIM_PATH_END    /*!< Trim Path End property of Shape object , value type is float [0 .. 100] */
 }Lottie_Animation_Property;
 
 typedef struct Lottie_Animation_S Lottie_Animation;

diff --git a/src/binding/c/lottieanimation_capi.cpp b/src/binding/c/lottieanimation_capi.cpp
index 53ca7bda544a4401e35da5b3029a6a073389dbd7..e93b055493fa22ecda4a0a683ddc915a1f4f6215 100644 (file)
--- a/src/binding/c/lottieanimation_capi.cpp
+++ b/src/binding/c/lottieanimation_capi.cpp
@@ -212,9 +212,11 @@ lottie_animation_property_override(Lottie_Animation_S *animation,
                               case LOTTIE_ANIMATION_PROPERTY_STROKEOPACITY:
                               case LOTTIE_ANIMATION_PROPERTY_STROKEWIDTH:
                               case LOTTIE_ANIMATION_PROPERTY_TR_ROTATION:
+                              case LOTTIE_ANIMATION_PROPERTY_TRIM_PATH_START:
                                 return 1;
                               case LOTTIE_ANIMATION_PROPERTY_TR_POSITION:
                               case LOTTIE_ANIMATION_PROPERTY_TR_SCALE:
+                              case LOTTIE_ANIMATION_PROPERTY_TRIM_PATH_END:
                                 return 2;
                               default:
                                 return 0;
@@ -278,6 +280,19 @@ lottie_animation_property_override(Lottie_Animation_S *animation,
         animation->mAnimation->setValue<rlottie::Property::TrRotation>(keypath, (float)r);
         break;
     }
+    case LOTTIE_ANIMATION_PROPERTY_TRIM_PATH_START: {
+        double start = v[0];
+        if (start < 0 || start > 100) break;
+        animation->mAnimation->setValue<rlottie::Property::TrimStart>(keypath, (float)start);
+        break;
+    }
+    case LOTTIE_ANIMATION_PROPERTY_TRIM_PATH_END: {
+        double start = v[0];
+        double end = v[1];
+        if (start < 0 || start > 100 || end < 0 || end > 100) break;
+        animation->mAnimation->setValue<rlottie::Property::TrimEnd>(keypath, rlottie::Point((float)start, (float)end));
+        break;
+    }
     case LOTTIE_ANIMATION_PROPERTY_TR_ANCHOR:
     case LOTTIE_ANIMATION_PROPERTY_TR_OPACITY:
         //@TODO handle propery update.

diff --git a/src/lottie/lottiefiltermodel.h b/src/lottie/lottiefiltermodel.h
index 4f78c11a3aafd9cf45ba0759174646ff3ed339c8..015e9cb4d1db8ff81e7fd363016d3f77cc4dba1b 100644 (file)
--- a/src/lottie/lottiefiltermodel.h
+++ b/src/lottie/lottiefiltermodel.h
@@ -425,6 +425,25 @@ public:
     }
 };
 
+template <>
+class Filter<model::Trim>: public FilterBase<model::Trim>
+{
+public:
+    Filter(model::Trim* model) : FilterBase<model::Trim>(model) {}
+
+    model::Trim::Segment segment(int frameNo) const
+    {
+        if (this->hasFilter(rlottie::Property::TrimStart)) {
+            this->model_->updateTrimStartValue(this->filter()->value(rlottie::Property::TrimStart, frameNo));
+        }
+        if (this->hasFilter(rlottie::Property::TrimEnd)) {
+            this->model_->updateTrimEndValue(this->filter()->point(rlottie::Property::TrimEnd, frameNo));
+        }
+        model::Trim::Segment segment = this->model()->segment(frameNo);
+        return segment;
+    }
+};
+
 
 }  // namespace model
 

diff --git a/src/lottie/lottieitem.cpp b/src/lottie/lottieitem.cpp
index d7b707840ee71a7ab5cbf1eb88836071023563b2..02e9477b557b8ded7af8610208550adad762b234 100644 (file)
--- a/src/lottie/lottieitem.cpp
+++ b/src/lottie/lottieitem.cpp
@@ -72,6 +72,17 @@ static bool strokeProp(rlottie::Property prop)
     }
 }
 
+static bool trimProp(rlottie::Property prop)
+{
+    switch (prop) {
+    case rlottie::Property::TrimStart:
+    case rlottie::Property::TrimEnd:
+        return true;
+    default:
+        return false;
+    }
+}
+
 static renderer::Layer *createLayerItem(model::Layer *layerData,
                                         VArenaAlloc * allocator)
 {
@@ -1376,6 +1387,21 @@ bool renderer::GradientStroke::updateContent(int frameNo, const VMatrix &matrix,
     return !vIsZero(combinedAlpha);
 }
 
+bool renderer::Trim::resolveKeyPath(LOTKeyPath &keyPath, uint32_t depth,
+                                      LOTVariant &value)
+{
+    if (!keyPath.matches(mModel.name(), depth)) {
+        return false;
+    }
+
+    if (keyPath.fullyResolvesTo(mModel.name(), depth) &&
+        trimProp(value.property())) {
+        mModel.filter()->addValue(value);
+        return true;
+    }
+    return false;
+}
+
 void renderer::Trim::update(int frameNo, const VMatrix & /*parentMatrix*/,
                             float /*parentAlpha*/, const DirtyFlag & /*flag*/)
 {
@@ -1383,7 +1409,7 @@ void renderer::Trim::update(int frameNo, const VMatrix & /*parentMatrix*/,
 
     if (mCache.mFrameNo == frameNo) return;
 
-    model::Trim::Segment segment = mData->segment(frameNo);
+    model::Trim::Segment segment = mModel.segment(frameNo);
 
     if (!(vCompare(mCache.mSegment.start, segment.start) &&
           vCompare(mCache.mSegment.end, segment.end))) {

diff --git a/src/lottie/lottieitem.h b/src/lottie/lottieitem.h
index a1c6a1a4d4e937e3d8db03b17525eda4e3a97296..04066973807d377bb103dec88b829078fc627caf 100644 (file)
--- a/src/lottie/lottieitem.h
+++ b/src/lottie/lottieitem.h
@@ -584,13 +584,16 @@ private:
 
 class Trim final : public Object {
 public:
-    explicit Trim(model::Trim *data) : mData(data) {}
+    explicit Trim(model::Trim *data) : mData(data), mModel(data) {}
     void update(int frameNo, const VMatrix &parentMatrix, float parentAlpha,
                 const DirtyFlag &flag) final;
     Object::Type type() const final { return Object::Type::Trim; }
     void         update();
     void         addPathItems(std::vector<Shape *> &list, size_t startOffset);
 
+protected:
+    bool resolveKeyPath(LOTKeyPath &keyPath, uint32_t depth,
+                        LOTVariant &value) final;
 private:
     bool pathDirty() const
     {
@@ -608,6 +611,8 @@ private:
     model::Trim *        mData{nullptr};
     VPathMesure          mPathMesure;
     bool                 mDirty{true};
+
+    model::Filter<model::Trim> mModel;
 };
 
 class Repeater final : public Group {

diff --git a/src/lottie/lottiemodel.h b/src/lottie/lottiemodel.h
index 745571e2c2a5775623c4efa1756db018c47ef159..b8ca1baa5f2e94f7da5f7f7187e7a52c0ffa01d0 100644 (file)
--- a/src/lottie/lottiemodel.h
+++ b/src/lottie/lottiemodel.h
@@ -1009,6 +1009,20 @@ public:
     };
     enum class TrimType { Simultaneously, Individually };
     Trim() : Object(Object::Type::Trim) {}
+
+    void updateTrimStartValue(float start)
+    {
+        mStart.value() = start;
+    }
+
+    void updateTrimEndValue(VPointF pos)
+    {
+        for (auto &keyFrame : mEnd.animation().frames_) {
+            keyFrame.value_.start_ = pos.x();
+            keyFrame.value_.end_ = pos.y();
+        }
+    }
+
     /*
      * if start > end vector trims the path as a loop ( 2 segment)
      * if start < end vector trims the path without loop ( 1 segment).