Update to thorvg 0.15.12

Author: beicause

thirdparty/thorvg/src/loaders/lottie/tvgLottieBuilder.cpp

@@ -167,12 +167,8 @@ void LottieBuilder::updateTransform(LottieLayer* layer, float frameNo)
 
     _updateTransform(transform, frameNo, layer->autoOrient, matrix, layer->cache.opacity, exps);
 
-    if (parent) {
-        if (!identity((const Matrix*) &parent->cache.matrix)) {
-            if (identity((const Matrix*) &matrix)) layer->cache.matrix = parent->cache.matrix;
-            else layer->cache.matrix = parent->cache.matrix * matrix;
-        }
-    }
+    if (parent) layer->cache.matrix = parent->cache.matrix * matrix;
+
     layer->cache.frameNo = frameNo;
 }
 
@@ -182,25 +178,30 @@ void LottieBuilder::updateTransform(LottieGroup* parent, LottieObject** child, f
     auto transform = static_cast<LottieTransform*>(*child);
     if (!transform) return;
 
+    Matrix m;
     uint8_t opacity;
 
     if (parent->mergeable()) {
-        if (!ctx->transform) ctx->transform = (Matrix*)malloc(sizeof(Matrix));
-        _updateTransform(transform, frameNo, false, *ctx->transform, opacity, exps);
+        if (ctx->transform) {
+            _updateTransform(transform, frameNo, false, m, opacity, exps);
+            *ctx->transform *= m;
+        } else {
+            ctx->transform = new Matrix;
+            _updateTransform(transform, frameNo, false, *ctx->transform, opacity, exps);
+        }
         return;
     }
 
     ctx->merging = nullptr;
 
-    Matrix matrix;
-    if (!_updateTransform(transform, frameNo, false, matrix, opacity, exps)) return;
+    if (!_updateTransform(transform, frameNo, false, m, opacity, exps)) return;
 
-    ctx->propagator->transform(PP(ctx->propagator)->transform() * matrix);
+    ctx->propagator->transform(PP(ctx->propagator)->transform() * m);
     ctx->propagator->opacity(MULTIPLY(opacity, PP(ctx->propagator)->opacity));
 
     //FIXME: preserve the stroke width. too workaround, need a better design.
     if (P(ctx->propagator)->rs.strokeWidth() > 0.0f) {
-        auto denominator = sqrtf(matrix.e11 * matrix.e11 + matrix.e12 * matrix.e12);
+        auto denominator = sqrtf(m.e11 * m.e11 + m.e12 * m.e12);
         if (denominator > 1.0f) ctx->propagator->stroke(ctx->propagator->strokeWidth() / denominator);
     }
 }
@@ -1510,7 +1511,6 @@ void LottieBuilder::updateLayer(LottieComposition* comp, Scene* scene, LottieLay
 
     updateEffect(layer, frameNo);
 
-    //the given matte source was composited by the target earlier.
     if (!layer->matteSrc) scene->push(cast(layer->scene));
 }
 
@@ -1600,6 +1600,7 @@ static bool _buildComposition(LottieComposition* comp, LottieLayer* parent)
         }
 
         if (child->matteTarget) {
+            child->matteTarget->matteSrc = true;
             //parenting
             _buildHierarchy(parent, child->matteTarget);
             //precomp referencing

thirdparty/thorvg/src/loaders/lottie/tvgLottieBuilder.h

@@ -71,7 +71,7 @@ struct RenderContext
     ~RenderContext()
     {
         PP(propagator)->unref();
-        free(transform);
+        delete(transform);
         delete(roundness);
         delete(offsetPath);
     }
@@ -84,6 +84,10 @@ struct RenderContext
         this->repeaters = rhs.repeaters;
         if (rhs.roundness) this->roundness = new LottieRoundnessModifier(rhs.roundness->r);
         if (rhs.offsetPath) this->offsetPath = new LottieOffsetModifier(rhs.offsetPath->offset, rhs.offsetPath->miterLimit, rhs.offsetPath->join);
+        if (rhs.transform) {
+            transform = new Matrix;
+            *transform = *rhs.transform;
+        }
     }
 };
 

thirdparty/thorvg/src/loaders/lottie/tvgLottieExpressions.cpp

@@ -68,6 +68,25 @@ static ExpContent* _expcontent(LottieExpression* exp, float frameNo, LottieObjec
 }
 
 
+static float _rand()
+{
+    return (float)(rand() % 10000001) * 0.0000001f;
+}
+
+
+static jerry_value_t _point2d(const Point& pt)
+{
+    auto obj = jerry_object();
+    auto v1 = jerry_number(pt.x);
+    auto v2 = jerry_number(pt.y);
+    jerry_object_set_index(obj, 0, v1);
+    jerry_object_set_index(obj, 1, v2);
+    jerry_value_free(v1);
+    jerry_value_free(v2);
+    return obj;
+}
+
+
 static void contentFree(void *native_p, struct jerry_object_native_info_t *info_p)
 {
     free(native_p);
@@ -603,8 +622,7 @@ static jerry_value_t _length(const jerry_call_info_t* info, const jerry_value_t
 
 static jerry_value_t _random(const jerry_call_info_t* info, const jerry_value_t args[], const jerry_length_t argsCnt)
 {
-    auto val = (float)(rand() % 10000001);
-    return jerry_number(val * 0.0000001f);
+    return jerry_number(_rand());
 }
 
 
@@ -821,6 +839,32 @@ static jerry_value_t _speedAtTime(const jerry_call_info_t* info, const jerry_val
 }
 
 
+
+static jerry_value_t _wiggle(const jerry_call_info_t* info, const jerry_value_t args[], const jerry_length_t argsCnt)
+{
+    auto data = static_cast<ExpContent*>(jerry_object_get_native_ptr(info->function, &freeCb));
+    auto freq = jerry_value_as_number(args[0]);
+    auto amp = jerry_value_as_number(args[1]);
+    auto octaves = (argsCnt > 2) ? jerry_value_as_int32(args[2]) : 1;
+    auto ampm = (argsCnt > 3) ? jerry_value_as_number(args[3]) : 5.0f;
+    auto time = (argsCnt > 4) ? jerry_value_as_number(args[4]) : data->exp->comp->timeAtFrame(data->frameNo);
+
+    Point result = {100.0f, 100.0f};
+
+    for (int o = 0; o < octaves; ++o) {
+        auto repeat = int(time * freq);
+        auto frac = (time * freq - float(repeat)) * 1.25f;
+        for (int i = 0; i < repeat; ++i) {
+            result.x += (_rand() * 2.0f - 1.0f) * amp * frac;
+            result.y += (_rand() * 2.0f - 1.0f) * amp * frac;
+        }
+        freq *= 2.0f;
+        amp *= ampm;
+    }
+    return _point2d(result);
+}
+
+
 static bool _loopOutCommon(LottieExpression* exp, const jerry_value_t args[], const jerry_length_t argsCnt)
 {
     exp->loop.mode = LottieExpression::LoopMode::OutCycle;
@@ -1044,7 +1088,11 @@ static void _buildProperty(float frameNo, jerry_value_t context, LottieExpressio
     jerry_object_set_native_ptr(speedAtTime, nullptr, exp);
     jerry_value_free(speedAtTime);
 
-    //wiggle(freq, amp, octaves=1, amp_mult=.5, t=time)
+    auto wiggle = jerry_function_external(_wiggle);
+    jerry_object_set_sz(context, "wiggle", wiggle);
+    jerry_object_set_native_ptr(wiggle, &freeCb, _expcontent(exp, frameNo, exp->object));
+    jerry_value_free(wiggle);
+
     //temporalWiggle(freq, amp, octaves=1, amp_mult=.5, t=time)
     //smooth(width=.2, samples=5, t=time)
 

thirdparty/thorvg/src/loaders/lottie/tvgLottieModel.cpp

@@ -201,9 +201,7 @@ void LottieFont::prepare()
 {
     if (!data.b64src || !name) return;
 
-    TaskScheduler::async(false);
     Text::load(name, data.b64src, data.size, "ttf", false);
-    TaskScheduler::async(true);
 }
 
 
@@ -214,13 +212,9 @@ void LottieImage::prepare()
     auto picture = Picture::gen().release();
 
     //force to load a picture on the same thread
-    TaskScheduler::async(false);
-
     if (data.size > 0) picture->load((const char*)data.b64Data, data.size, data.mimeType, false);
     else picture->load(data.path);
 
-    TaskScheduler::async(true);
-
     picture->size(data.width, data.height);
     PP(picture)->ref();
 
@@ -231,13 +225,11 @@ void LottieImage::prepare()
 void LottieImage::update()
 {
     //Update the picture data
-    TaskScheduler::async(false);
     for (auto p = pooler.begin(); p < pooler.end(); ++p) {
         if (data.size > 0) (*p)->load((const char*)data.b64Data, data.size, data.mimeType, false);
         else (*p)->load(data.path);
         (*p)->size(data.width, data.height);
     }
-    TaskScheduler::async(true);
 }
 
 
@@ -434,7 +426,7 @@ void LottieGroup::prepare(LottieObject::Type type)
 
         /* Figure out if this group is a simple path drawing.
            In that case, the rendering context can be sharable with the parent's. */
-        if (allowMerge && (child->type == LottieObject::Group || !child->mergeable())) allowMerge = false;
+        if (allowMerge && !child->mergeable()) allowMerge = false;
 
         //Figure out this group has visible contents
         switch (child->type) {

thirdparty/thorvg/src/loaders/lottie/tvgLottieModel.h

@@ -544,8 +544,7 @@ struct LottieTransform : LottieObject
 
     bool mergeable() override
     {
-        if (!opacity.frames && opacity.value == 255) return true;
-        return false;
+        return true;
     }
 
     LottieProperty* property(uint16_t ix) override

thirdparty/thorvg/src/loaders/lottie/tvgLottieProperty.h

@@ -947,18 +947,19 @@ struct LottieBitmap : LottieProperty
         if (shallow) {
             b64Data = rhs.b64Data;
             mimeType = rhs.mimeType;
+
+            rhs.b64Data = nullptr;
+            rhs.mimeType = nullptr;
         } else {
             //TODO: optimize here by avoiding data copy
             TVGLOG("LOTTIE", "Shallow copy of the image data!");
             b64Data = strdup(rhs.b64Data);
             mimeType = strdup(rhs.mimeType);
         }
+
         size = rhs.size;
         width = rhs.width;
         height = rhs.height;
-
-        rhs.b64Data = nullptr;
-        rhs.mimeType = nullptr;
     }
 };