From 418e658a6922923f8d1e1ce2cf00f0a0f6b18ff3 Mon Sep 17 00:00:00 2001 From: Florin Malita Date: Mon, 9 Jul 2018 16:20:47 -0400 Subject: [skottie] Apply fully opaque masks as clips We already have a clip optimization when there is only one opaque mask. Extend to cover multiple opaque masks, using Merge scene nodes. TBR= Change-Id: I24b61f0c0d080b13438c6777e98a8e2fefd09fdd Reviewed-on: https://skia-review.googlesource.com/140002 Reviewed-by: Florin Malita Commit-Queue: Florin Malita --- modules/skottie/src/Skottie.cpp | 71 +++++++++++++++++++++++++++++----------- modules/sksg/include/SkSGMerge.h | 16 +++++---- modules/sksg/src/SkSGMerge.cpp | 42 +++++++++++++++--------- 3 files changed, 89 insertions(+), 40 deletions(-) (limited to 'modules') diff --git a/modules/skottie/src/Skottie.cpp b/modules/skottie/src/Skottie.cpp index 6cfeddcfce..60009b9bc0 100644 --- a/modules/skottie/src/Skottie.cpp +++ b/modules/skottie/src/Skottie.cpp @@ -376,11 +376,21 @@ sk_sp AttachGradientStroke(const skjson::ObjectValue& jstroke, return AttachStroke(jstroke, ctx, AttachPaint(jstroke, ctx, AttachGradient(jstroke, ctx))); } +sk_sp Merge(std::vector>&& geos, sksg::Merge::Mode mode) { + std::vector merge_recs; + merge_recs.reserve(geos.size()); + + for (const auto& geo : geos) { + merge_recs.push_back( + {std::move(geo), merge_recs.empty() ? sksg::Merge::Mode::kMerge : mode}); + } + + return sksg::Merge::Make(std::move(merge_recs)); +} + std::vector> AttachMergeGeometryEffect( const skjson::ObjectValue& jmerge, AttachContext*, std::vector>&& geos) { - std::vector> merged; - static constexpr sksg::Merge::Mode gModes[] = { sksg::Merge::Mode::kMerge, // "mm": 1 sksg::Merge::Mode::kUnion, // "mm": 2 @@ -391,7 +401,9 @@ std::vector> AttachMergeGeometryEffect( const auto mode = gModes[SkTPin(ParseDefault(jmerge["mm"], 1) - 1, 0, SK_ARRAY_COUNT(gModes) - 1)]; - merged.push_back(sksg::Merge::Make(std::move(geos), mode)); + + std::vector> merged; + merged.push_back(Merge(std::move(geos), mode)); return merged; } @@ -410,7 +422,7 @@ std::vector> AttachTrimGeometryEffect( std::vector> inputs; if (mode == Mode::kMerged) { - inputs.push_back(sksg::Merge::Make(std::move(geos), sksg::Merge::Mode::kMerge)); + inputs.push_back(Merge(std::move(geos), sksg::Merge::Mode::kMerge)); } else { inputs = std::move(geos); } @@ -661,7 +673,7 @@ sk_sp AttachShape(const skjson::ArrayValue* jshape, AttachShap // If we still have multiple geos, reduce using 'merge'. auto geo = drawGeos.size() > 1 - ? sksg::Merge::Make(std::move(drawGeos), sksg::Merge::Mode::kMerge) + ? Merge(std::move(drawGeos), sksg::Merge::Mode::kMerge) : drawGeos[0]; SkASSERT(geo); @@ -974,17 +986,22 @@ private: }; struct MaskInfo { - SkBlendMode fBlendMode; - bool fInvertGeometry; + SkBlendMode fBlendMode; // used when masking with layers/blending + sksg::Merge::Mode fMergeMode; // used when clipping + bool fInvertGeometry; }; const MaskInfo* GetMaskInfo(char mode) { - static constexpr MaskInfo k_add_info = { SkBlendMode::kSrcOver , false }; - static constexpr MaskInfo k_int_info = { SkBlendMode::kSrcIn , false }; + static constexpr MaskInfo k_add_info = + { SkBlendMode::kSrcOver , sksg::Merge::Mode::kUnion , false }; + static constexpr MaskInfo k_int_info = + { SkBlendMode::kSrcIn , sksg::Merge::Mode::kIntersect , false }; // AE 'subtract' is the same as 'intersect' + inverted geometry // (draws the opacity-adjusted paint *outside* the shape). - static constexpr MaskInfo k_sub_info = { SkBlendMode::kSrcIn , true }; - static constexpr MaskInfo k_dif_info = { SkBlendMode::kDifference, false }; + static constexpr MaskInfo k_sub_info = + { SkBlendMode::kSrcIn , sksg::Merge::Mode::kIntersect , true }; + static constexpr MaskInfo k_dif_info = + { SkBlendMode::kDifference, sksg::Merge::Mode::kDifference, false }; switch (mode) { case 'a': return &k_add_info; @@ -1003,8 +1020,9 @@ sk_sp AttachMask(const skjson::ArrayValue* jmask, if (!jmask) return childNode; struct MaskRecord { - sk_sp mask_path; - sk_sp mask_paint; + sk_sp mask_path; // for clipping and masking + sk_sp mask_paint; // for masking + sksg::Merge::Mode merge_mode; // for clipping }; SkSTArray<4, MaskRecord, true> mask_stack; @@ -1055,17 +1073,32 @@ sk_sp AttachMask(const skjson::ArrayValue* jmask, mask_paint->setOpacity(o * 0.01f); }, &full_opacity); - mask_stack.push_back({mask_path, mask_paint}); + mask_stack.push_back({mask_path, mask_paint, mask_info->fMergeMode}); } if (mask_stack.empty()) return childNode; - if (mask_stack.count() == 1 && !has_opacity) { - // Single, fully-opaque mask => clip path. - return sksg::ClipEffect::Make(std::move(childNode), - std::move(mask_stack.front().mask_path), - true); + // If the masks are fully opaque, we can clip. + if (!has_opacity) { + sk_sp clip_node; + + if (mask_stack.count() == 1) { + // Single path -> just clip. + clip_node = std::move(mask_stack.front().mask_path); + } else { + // Multiple clip paths -> merge. + std::vector merge_recs; + merge_recs.reserve(SkToSizeT(mask_stack.count())); + + for (const auto& mask : mask_stack) { + const auto mode = merge_recs.empty() ? sksg::Merge::Mode::kMerge : mask.merge_mode; + merge_recs.push_back({std::move(mask.mask_path), mode}); + } + clip_node = sksg::Merge::Make(std::move(merge_recs)); + } + + return sksg::ClipEffect::Make(std::move(childNode), std::move(clip_node), true); } auto mask_group = sksg::Group::Make(); diff --git a/modules/sksg/include/SkSGMerge.h b/modules/sksg/include/SkSGMerge.h index 54924d6475..c4957f45a1 100644 --- a/modules/sksg/include/SkSGMerge.h +++ b/modules/sksg/include/SkSGMerge.h @@ -36,8 +36,13 @@ public: kXOR, }; - static sk_sp Make(std::vector>&& geos, Mode mode) { - return sk_sp(new Merge(std::move(geos), mode)); + struct Rec { + sk_sp fGeo; + Mode fMode; + }; + + static sk_sp Make(std::vector&& recs) { + return sk_sp(new Merge(std::move(recs))); } ~Merge() override; @@ -50,11 +55,10 @@ protected: SkPath onAsPath() const override; private: - Merge(std::vector>&& geos, Mode); + Merge(std::vector&& recs); - std::vector> fGeos; - SkPath fMerged; - Mode fMode; + const std::vector fRecs; + SkPath fMerged; using INHERITED = GeometryNode; }; diff --git a/modules/sksg/src/SkSGMerge.cpp b/modules/sksg/src/SkSGMerge.cpp index be1ff4123a..ff50021047 100644 --- a/modules/sksg/src/SkSGMerge.cpp +++ b/modules/sksg/src/SkSGMerge.cpp @@ -12,17 +12,16 @@ namespace sksg { -Merge::Merge(std::vector>&& geos, Mode mode) - : fGeos(std::move(geos)) - , fMode(mode) { - for (const auto& geo : fGeos) { - this->observeInval(geo); +Merge::Merge(std::vector&& recs) + : fRecs(std::move(recs)) { + for (const auto& rec : fRecs) { + this->observeInval(rec.fGeo); } } Merge::~Merge() { - for (const auto& geo : fGeos) { - this->unobserveInval(geo); + for (const auto& rec : fRecs) { + this->unobserveInval(rec.fGeo); } } @@ -60,21 +59,34 @@ static SkPathOp mode_to_op(Merge::Mode mode) { SkRect Merge::onRevalidate(InvalidationController* ic, const SkMatrix& ctm) { SkASSERT(this->hasInval()); - const auto op = mode_to_op(fMode); SkOpBuilder builder; fMerged.reset(); + bool in_builder = false; - for (const auto& geo : fGeos) { - geo->revalidate(ic, ctm); - if (fMode == Mode::kMerge) { - fMerged.addPath(geo->asPath()); - } else { - builder.add(geo->asPath(), geo == fGeos.front() ? kUnion_SkPathOp : op); + for (const auto& rec : fRecs) { + rec.fGeo->revalidate(ic, ctm); + + // Merge is not currently supported by SkOpBuidler. + if (rec.fMode == Mode::kMerge) { + if (in_builder) { + builder.resolve(&fMerged); + in_builder = false; + } + + fMerged.addPath(rec.fGeo->asPath()); + continue; } + + if (!in_builder) { + builder.add(fMerged, kUnion_SkPathOp); + in_builder = true; + } + + builder.add(rec.fGeo->asPath(), mode_to_op(rec.fMode)); } - if (fMode != Mode::kMerge) { + if (in_builder) { builder.resolve(&fMerged); } -- cgit v1.2.3