| /* |
| * Copyright 2023 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "include/core/SkColor.h" |
| #include "include/core/SkPictureRecorder.h" |
| #include "include/core/SkStream.h" |
| #include "modules/skottie/include/Skottie.h" |
| #include "modules/skottie/include/SkottieProperty.h" |
| #include "tests/Test.h" |
| #include "tools/ToolUtils.h" |
| |
| using namespace skottie; |
| |
| namespace { |
| |
| TextPropertyValue make_text_prop(const char* str) { |
| TextPropertyValue prop; |
| |
| prop.fTypeface = ToolUtils::create_portable_typeface(); |
| prop.fText = SkString(str); |
| |
| return prop; |
| } |
| |
| class MockPropertyObserver final : public PropertyObserver { |
| public: |
| explicit MockPropertyObserver(bool override_props = false) : fOverrideProps(override_props) {} |
| |
| struct ColorInfo { |
| SkString node_name; |
| std::unique_ptr<skottie::ColorPropertyHandle> handle; |
| }; |
| |
| struct OpacityInfo { |
| SkString node_name; |
| std::unique_ptr<skottie::OpacityPropertyHandle> handle; |
| }; |
| |
| struct TextInfo { |
| SkString node_name; |
| std::unique_ptr<skottie::TextPropertyHandle> handle; |
| }; |
| |
| struct TransformInfo { |
| SkString node_name; |
| std::unique_ptr<skottie::TransformPropertyHandle> handle; |
| }; |
| |
| void onColorProperty(const char node_name[], |
| const PropertyObserver::LazyHandle<ColorPropertyHandle>& lh) override { |
| auto prop_handle = lh(); |
| if (fOverrideProps) { |
| static constexpr ColorPropertyValue kOverrideColor = 0xffffff00; |
| prop_handle->set(kOverrideColor); |
| } |
| fColors.push_back({SkString(node_name), std::move(prop_handle)}); |
| fColorsWithFullKeypath.push_back({SkString(fCurrentNode.c_str()), lh()}); |
| } |
| |
| void onOpacityProperty(const char node_name[], |
| const PropertyObserver::LazyHandle<OpacityPropertyHandle>& lh) override { |
| auto prop_handle = lh(); |
| if (fOverrideProps) { |
| static constexpr OpacityPropertyValue kOverrideOpacity = 0.75f; |
| prop_handle->set(kOverrideOpacity); |
| } |
| fOpacities.push_back({SkString(node_name), std::move(prop_handle)}); |
| } |
| |
| void onTextProperty(const char node_name[], |
| const PropertyObserver::LazyHandle<TextPropertyHandle>& lh) override { |
| auto prop_handle = lh(); |
| if (fOverrideProps) { |
| static const TextPropertyValue kOverrideText = make_text_prop("foo"); |
| prop_handle->set(kOverrideText); |
| } |
| fTexts.push_back({SkString(node_name), std::move(prop_handle)}); |
| } |
| |
| void onTransformProperty(const char node_name[], |
| const PropertyObserver::LazyHandle<TransformPropertyHandle>& lh) override { |
| auto prop_handle = lh(); |
| if (fOverrideProps) { |
| static constexpr TransformPropertyValue kOverrideTransform = { |
| { 100, 100 }, |
| { 200, 200 }, |
| { 2, 2 }, |
| 45, |
| 0, |
| 0, |
| }; |
| prop_handle->set(kOverrideTransform); |
| } |
| fTransforms.push_back({SkString(node_name), std::move(prop_handle)}); |
| } |
| |
| void onEnterNode(const char node_name[], PropertyObserver::NodeType node_type) override { |
| if (node_name == nullptr) { |
| return; |
| } |
| fCurrentNode = fCurrentNode.empty() ? node_name : fCurrentNode + "." + node_name; |
| } |
| |
| void onLeavingNode(const char node_name[], PropertyObserver::NodeType node_type) override { |
| if (node_name == nullptr) { |
| return; |
| } |
| auto length = strlen(node_name); |
| fCurrentNode = |
| fCurrentNode.length() > length |
| ? fCurrentNode.substr(0, fCurrentNode.length() - strlen(node_name) - 1) |
| : ""; |
| } |
| |
| const std::vector<ColorInfo>& colors() const { return fColors; } |
| const std::vector<OpacityInfo>& opacities() const { return fOpacities; } |
| const std::vector<TextInfo>& texts() const { return fTexts; } |
| const std::vector<TransformInfo>& transforms() const { return fTransforms; } |
| const std::vector<ColorInfo>& colorsWithFullKeypath() const { |
| return fColorsWithFullKeypath; |
| } |
| |
| private: |
| const bool fOverrideProps; |
| std::vector<ColorInfo> fColors; |
| std::vector<OpacityInfo> fOpacities; |
| std::vector<TextInfo> fTexts; |
| std::vector<TransformInfo> fTransforms; |
| std::string fCurrentNode; |
| std::vector<ColorInfo> fColorsWithFullKeypath; |
| }; |
| |
| // Returns a single specified typeface for all requests. |
| class MockFontMgr : public SkFontMgr { |
| public: |
| MockFontMgr(sk_sp<SkTypeface> test_font) : fTestFont(test_font) {} |
| |
| int onCountFamilies() const override { return 1; } |
| void onGetFamilyName(int index, SkString* familyName) const override {} |
| sk_sp<SkFontStyleSet> onCreateStyleSet(int index) const override { return nullptr; } |
| sk_sp<SkFontStyleSet> onMatchFamily(const char familyName[]) const override { |
| return nullptr; |
| } |
| sk_sp<SkTypeface> onMatchFamilyStyle(const char familyName[], |
| const SkFontStyle& fontStyle) const override { |
| return nullptr; |
| } |
| sk_sp<SkTypeface> onMatchFamilyStyleCharacter(const char familyName[], const SkFontStyle&, |
| const char* bcp47[], int bcp47Count, |
| SkUnichar character) const override { |
| return nullptr; |
| } |
| sk_sp<SkTypeface> onMakeFromData(sk_sp<SkData>, int ttcIndex) const override { |
| return fTestFont; |
| } |
| sk_sp<SkTypeface> onMakeFromStreamIndex(std::unique_ptr<SkStreamAsset>, |
| int ttcIndex) const override { |
| return fTestFont; |
| } |
| sk_sp<SkTypeface> onMakeFromStreamArgs(std::unique_ptr<SkStreamAsset>, |
| const SkFontArguments&) const override { |
| return fTestFont; |
| } |
| sk_sp<SkTypeface> onMakeFromFile(const char path[], int ttcIndex) const override { |
| return fTestFont; |
| } |
| sk_sp<SkTypeface> onLegacyMakeTypeface(const char familyName[], SkFontStyle) const override { |
| return fTestFont; |
| } |
| private: |
| sk_sp<SkTypeface> fTestFont; |
| }; |
| |
| static const char gTestJson[] = R"({ |
| "v": "5.2.1", |
| "w": 100, |
| "h": 100, |
| "fr": 1, |
| "ip": 0, |
| "op": 1, |
| "fonts": { |
| "list": [ |
| { |
| "fName": "test_font", |
| "fFamily": "test-family", |
| "fStyle": "TestFontStyle" |
| } |
| ] |
| }, |
| "layers": [ |
| { |
| "ty": 4, |
| "nm": "layer_0", |
| "ind": 0, |
| "ip": 0, |
| "op": 1, |
| "ks": { |
| "o": { "a": 0, "k": 50 } |
| }, |
| "ef": [{ |
| "ef": [ |
| {}, |
| {}, |
| { "v": { "a": 0, "k": [ 0, 1, 0 ] }}, |
| {}, |
| {}, |
| {}, |
| { "v": { "a": 0, "k": 1 }} |
| ], |
| "nm": "fill_effect_0", |
| "mn": "ADBE Fill", |
| "ty": 21 |
| }], |
| "shapes": [ |
| { |
| "ty": "el", |
| "nm": "geometry_0", |
| "p": { "a": 0, "k": [ 50, 50 ] }, |
| "s": { "a": 0, "k": [ 50, 50 ] } |
| }, |
| { |
| "ty": "fl", |
| "nm": "fill_0", |
| "c": { "a": 0, "k": [ 1, 0, 0] } |
| }, |
| { |
| "ty": "tr", |
| "nm": "shape_transform_0", |
| "o": { "a": 0, "k": 100 }, |
| "s": { "a": 0, "k": [ 50, 50 ] } |
| } |
| ] |
| }, |
| { |
| "ty": 5, |
| "nm": "layer_1", |
| "ip": 0, |
| "op": 1, |
| "ks": { |
| "p": { "a": 0, "k": [25, 25] } |
| }, |
| "t": { |
| "d": { |
| "k": [ |
| { |
| "t": 0, |
| "s": { |
| "f": "test_font", |
| "s": 100, |
| "t": "inline_text", |
| "lh": 120, |
| "ls": 12 |
| } |
| } |
| ] |
| } |
| } |
| } |
| ] |
| })"; |
| |
| } // anonymous namespace |
| |
| DEF_TEST(Skottie_Props, reporter) { |
| auto test_typeface = ToolUtils::create_portable_typeface(); |
| REPORTER_ASSERT(reporter, test_typeface); |
| auto test_font_manager = sk_make_sp<MockFontMgr>(test_typeface); |
| |
| SkMemoryStream stream(gTestJson, strlen(gTestJson)); |
| auto observer = sk_make_sp<MockPropertyObserver>(); |
| |
| auto animation = skottie::Animation::Builder() |
| .setPropertyObserver(observer) |
| .setFontManager(test_font_manager) |
| .make(&stream); |
| |
| REPORTER_ASSERT(reporter, animation); |
| |
| const auto& colors = observer->colors(); |
| REPORTER_ASSERT(reporter, colors.size() == 2); |
| REPORTER_ASSERT(reporter, colors[0].node_name.equals("fill_0")); |
| REPORTER_ASSERT(reporter, colors[0].handle->get() == 0xffff0000); |
| REPORTER_ASSERT(reporter, colors[1].node_name.equals("fill_effect_0")); |
| REPORTER_ASSERT(reporter, colors[1].handle->get() == 0xff00ff00); |
| |
| const auto& colorsWithFullKeypath = observer->colorsWithFullKeypath(); |
| REPORTER_ASSERT(reporter, colorsWithFullKeypath.size() == 2); |
| REPORTER_ASSERT(reporter, colorsWithFullKeypath[0].node_name.equals("layer_0.fill_0")); |
| REPORTER_ASSERT(reporter, colorsWithFullKeypath[0].handle->get() == 0xffff0000); |
| REPORTER_ASSERT(reporter, colorsWithFullKeypath[1].node_name.equals("layer_0.fill_effect_0")); |
| REPORTER_ASSERT(reporter, colorsWithFullKeypath[1].handle->get() == 0xff00ff00); |
| |
| const auto& opacities = observer->opacities(); |
| REPORTER_ASSERT(reporter, opacities.size() == 3); |
| REPORTER_ASSERT(reporter, opacities[0].node_name.equals("shape_transform_0")); |
| REPORTER_ASSERT(reporter, SkScalarNearlyEqual(opacities[0].handle->get(), 100)); |
| REPORTER_ASSERT(reporter, opacities[1].node_name.equals("layer_0")); |
| REPORTER_ASSERT(reporter, SkScalarNearlyEqual(opacities[1].handle->get(), 50)); |
| |
| const auto& transforms = observer->transforms(); |
| REPORTER_ASSERT(reporter, transforms.size() == 3); |
| REPORTER_ASSERT(reporter, transforms[0].node_name.equals("layer_0")); |
| REPORTER_ASSERT(reporter, transforms[0].handle->get() == skottie::TransformPropertyValue({ |
| SkPoint::Make(0, 0), |
| SkPoint::Make(0, 0), |
| SkVector::Make(100, 100), |
| 0, |
| 0, |
| 0 |
| })); |
| REPORTER_ASSERT(reporter, transforms[1].node_name.equals("layer_1")); |
| REPORTER_ASSERT(reporter, transforms[1].handle->get() == skottie::TransformPropertyValue({ |
| SkPoint::Make(0, 0), |
| SkPoint::Make(25, 25), |
| SkVector::Make(100, 100), |
| 0, |
| 0, |
| 0 |
| })); |
| REPORTER_ASSERT(reporter, transforms[2].node_name.equals("shape_transform_0")); |
| REPORTER_ASSERT(reporter, transforms[2].handle->get() == skottie::TransformPropertyValue({ |
| SkPoint::Make(0, 0), |
| SkPoint::Make(0, 0), |
| SkVector::Make(50, 50), |
| 0, |
| 0, |
| 0 |
| })); |
| |
| const auto& texts = observer->texts(); |
| REPORTER_ASSERT(reporter, texts.size() == 1); |
| REPORTER_ASSERT(reporter, texts[0].node_name.equals("layer_1")); |
| REPORTER_ASSERT(reporter, texts[0].handle->get() == skottie::TextPropertyValue({ |
| test_typeface, |
| SkString("inline_text"), |
| 100, |
| 0, 100, |
| 0, |
| 120, |
| 12, |
| 0, |
| 0, |
| SkTextUtils::kLeft_Align, |
| Shaper::VAlign::kTopBaseline, |
| Shaper::ResizePolicy::kNone, |
| Shaper::LinebreakPolicy::kExplicit, |
| Shaper::Direction::kLTR, |
| Shaper::Capitalization::kNone, |
| SkRect::MakeEmpty(), |
| SK_ColorTRANSPARENT, |
| SK_ColorTRANSPARENT, |
| TextPaintOrder::kFillStroke, |
| SkPaint::Join::kDefault_Join, |
| false, |
| false, |
| nullptr |
| })); |
| } |
| |
| DEF_TEST(Skottie_Props_Revalidation, reporter) { |
| auto test_typeface = ToolUtils::create_portable_typeface(); |
| REPORTER_ASSERT(reporter, test_typeface); |
| auto test_font_manager = sk_make_sp<MockFontMgr>(test_typeface); |
| |
| SkMemoryStream stream(gTestJson, strlen(gTestJson)); |
| auto observer = sk_make_sp<MockPropertyObserver>(true); |
| |
| auto animation = skottie::Animation::Builder() |
| .setPropertyObserver(observer) |
| .setFontManager(test_font_manager) |
| .make(&stream); |
| |
| REPORTER_ASSERT(reporter, animation); |
| |
| SkPictureRecorder recorder; |
| // Rendering without seek() should not trigger revalidation asserts. |
| animation->render(recorder.beginRecording(100, 100)); |
| |
| // Mutate all props. |
| for (const auto& c : observer->colors()) { |
| c.handle->set(SK_ColorGRAY); |
| } |
| for (const auto& o : observer->opacities()) { |
| o.handle->set(0.25f); |
| } |
| for (const auto& t : observer->texts()) { |
| t.handle->set(make_text_prop("bar")); |
| } |
| for (const auto& t : observer->transforms()) { |
| t.handle->set({ |
| { 1000, 1000 }, |
| { 2000, 2000 }, |
| { 20, 20 }, |
| 5, |
| 0, |
| 0, |
| }); |
| } |
| |
| // Rendering without seek() after property mutation should not trigger revalidation asserts. |
| animation->render(recorder.beginRecording(100, 100)); |
| } |
| |