skottie::internal::RangeSelector Class Reference

#include <RangeSelector.h>

Inheritance diagram for skottie::internal::RangeSelector:

Public Types
enum class	Units : uint8_t { kPercentage , kIndex }
enum class	Domain : uint8_t { kChars , kCharsExcludingSpaces , kWords , kLines }
enum class	Mode : uint8_t { kAdd }
enum class	Shape : uint8_t {   kSquare , kRampUp , kRampDown , kTriangle ,   kRound , kSmooth }

Public Member Functions
void	modulateCoverage (const TextAnimator::DomainMaps &, TextAnimator::ModulatorBuffer &) const
Public Member Functions inherited from SkNVRefCnt< RangeSelector >
	SkNVRefCnt ()
	~SkNVRefCnt ()
bool	unique () const
void	ref () const
void	unref () const
void	deref () const
bool	refCntGreaterThan (int32_t threadIsolatedTestCnt) const

Static Public Member Functions
static sk_sp< RangeSelector >	Make (const skjson::ObjectValue *, const AnimationBuilder *, AnimatablePropertyContainer *)

Detailed Description

Definition at line 26 of file RangeSelector.h.

Member Enumeration Documentation

Domain

enum class skottie::internal::RangeSelector::Domain : uint8_t

strong

Enumerator
kChars
kCharsExcludingSpaces
kWords
kLines

Definition at line 37 of file RangeSelector.h.

                      : uint8_t {
        kChars,                   // domain indices map to glyph indices
        kCharsExcludingSpaces,    // domain indices map to glyph indices (ignoring spaces)
        kWords,                   // domain indices map to word indices
        kLines,                   // domain indices map to line indices
    };

Mode

enum class skottie::internal::RangeSelector::Mode : uint8_t

strong

Enumerator
kAdd

Definition at line 44 of file RangeSelector.h.

                    : uint8_t {
        kAdd,
        // kSubtract,
        // kIntersect,
        // kMin,
        // kMax,
        // kDifference,
    };

Shape

enum class skottie::internal::RangeSelector::Shape : uint8_t

strong

Enumerator
kSquare
kRampUp
kRampDown
kTriangle
kRound
kSmooth

Definition at line 53 of file RangeSelector.h.

                     : uint8_t {
        kSquare,
        kRampUp,
        kRampDown,
        kTriangle,
        kRound,
        kSmooth,
    };

Units

enum class skottie::internal::RangeSelector::Units : uint8_t

strong

Enumerator
kPercentage
kIndex

Definition at line 32 of file RangeSelector.h.

                     : uint8_t {
        kPercentage,  // values are percentages of domain size
        kIndex,       // values are direct domain indices
    };

Member Function Documentation

Make()

sk_sp< RangeSelector > skottie::internal::RangeSelector::Make ( const skjson::ObjectValue *  jrange, const AnimationBuilder *  abuilder, AnimatablePropertyContainer *  acontainer  )

static

Definition at line 239 of file RangeSelector.cpp.

                                                                                  {
    if (!jrange) {
        return nullptr;
    }
 
    enum : int32_t {
             kRange_SelectorType = 0,
        kExpression_SelectorType = 1,
 
        // kWiggly_SelectorType = ? (not exported)
    };
 
    {
        const auto type = ParseDefault<int>((*jrange)["t"], kRange_SelectorType);
        if (type != kRange_SelectorType) {
            abuilder->log(Logger::Level::kWarning, nullptr,
                          "Ignoring unsupported selector type '%d'", type);
            return nullptr;
        }
    }
 
    static constexpr Units gUnitMap[] = {
        Units::kPercentage,  // 'r': 1
        Units::kIndex,       // 'r': 2
    };
 
    static constexpr Domain gDomainMap[] = {
        Domain::kChars,                 // 'b': 1
        Domain::kCharsExcludingSpaces,  // 'b': 2
        Domain::kWords,                 // 'b': 3
        Domain::kLines,                 // 'b': 4
    };
 
    static constexpr Mode gModeMap[] = {
        Mode::kAdd,          // 'm': 1
    };
 
    static constexpr Shape gShapeMap[] = {
        Shape::kSquare,      // 'sh': 1
        Shape::kRampUp,      // 'sh': 2
        Shape::kRampDown,    // 'sh': 3
        Shape::kTriangle,    // 'sh': 4
        Shape::kRound,       // 'sh': 5
        Shape::kSmooth,      // 'sh': 6
    };
 
    auto selector = sk_sp<RangeSelector>(
            new RangeSelector(ParseEnum<Units> (gUnitMap  , (*jrange)["r" ], abuilder, "units" ),
                              ParseEnum<Domain>(gDomainMap, (*jrange)["b" ], abuilder, "domain"),
                              ParseEnum<Mode>  (gModeMap  , (*jrange)["m" ], abuilder, "mode"  ),
                              ParseEnum<Shape> (gShapeMap , (*jrange)["sh"], abuilder, "shape" )));
 
    acontainer->bind(*abuilder, (*jrange)["s" ], &selector->fStart );
    acontainer->bind(*abuilder, (*jrange)["e" ], &selector->fEnd   );
    acontainer->bind(*abuilder, (*jrange)["o" ], &selector->fOffset);
    acontainer->bind(*abuilder, (*jrange)["a" ], &selector->fAmount);
    acontainer->bind(*abuilder, (*jrange)["ne"], &selector->fEaseLo);
    acontainer->bind(*abuilder, (*jrange)["xe"], &selector->fEaseHi);
 
    // Optional square "smoothness" prop.
    if (selector->fShape == Shape::kSquare) {
        acontainer->bind(*abuilder, (*jrange)["sm" ], &selector->fSmoothness);
    }
 
    return selector;
}

modulateCoverage()

void skottie::internal::RangeSelector::modulateCoverage	(	const TextAnimator::DomainMaps &	maps,
		TextAnimator::ModulatorBuffer &	mbuf
	)		const

Definition at line 355 of file RangeSelector.cpp.

                                                                              {
    const CoverageProcessor coverage_proc(maps, fDomain, fMode, mbuf);
    if (coverage_proc.size() == 0) {
        return;
    }
 
    // Amount, ease-low and ease-high are percentage-based [-100% .. 100%].
    const auto amount = SkTPin<float>(fAmount / 100, -1, 1),
              ease_lo = SkTPin<float>(fEaseLo / 100, -1, 1),
              ease_hi = SkTPin<float>(fEaseHi / 100, -1, 1);
 
    // Resolve to a float range in the given domain.
    const auto range = this->resolve(coverage_proc.size());
    auto          r0 = std::get<0>(range),
                 len = std::max(std::get<1>(range) - r0, std::numeric_limits<float>::epsilon());
 
    SkASSERT(static_cast<size_t>(fShape) < std::size(gShapeInfo));
    ShapeGenerator gen(gShapeInfo[static_cast<size_t>(fShape)], ease_lo, ease_hi);
 
    if (fShape == Shape::kSquare) {
        // Canonical square generators have collapsed ramps, but AE square selectors have
        // an additional "smoothness" property (0..1) which introduces a non-zero transition.
        // We achieve this by moving the range edges outward by |smoothness|/2, and adjusting
        // the generator cubic ramp size.
 
        // smoothness is percentage-based [0..100]
        const auto smoothness = SkTPin<float>(fSmoothness / 100, 0, 1);
 
        r0  -= smoothness / 2;
        len += smoothness;
 
        gen.crs += smoothness / len;
    }
 
    SkASSERT(len > 0);
    const auto dt = 1 / len;
          auto  t = (0.5f - r0) / len; // sampling bias: mid-unit
 
    for (size_t i = 0; i < coverage_proc.size(); ++i, t += dt) {
        coverage_proc(amount * gen(t), i, 1);
    }
}

---

The documentation for this class was generated from the following files:

• third_party/skia/modules/skottie/src/text/RangeSelector.h
• third_party/skia/modules/skottie/src/text/RangeSelector.cpp