skottie Namespace Reference

Namespaces
namespace	internal

Classes
class	Animation
class	ColorValue
class	ExpressionEvaluator
class	ExpressionManager
class	ExternalLayer
class	GlyphDecorator
class	Logger
class	MarkerObserver
class	PrecompInterceptor
class	PropertyHandle
class	PropertyObserver
class	Shaper
class	ShapeValue
class	SlotManager
struct	TextPropertyValue
struct	TransformPropertyValue
class	VectorValue

Typedefs
using	ImageAsset = skresources::ImageAsset
using	ResourceProvider = skresources::ResourceProvider
using	ColorPropertyValue = SkColor
using	OpacityPropertyValue = float
using	ColorPropertyHandle = PropertyHandle< ColorPropertyValue, sksg::Color >
using	OpacityPropertyHandle = PropertyHandle< OpacityPropertyValue, sksg::OpacityEffect >
using	TextPropertyHandle = PropertyHandle< TextPropertyValue, internal::TextAdapter >
using	TransformPropertyHandle = PropertyHandle< TransformPropertyValue, internal::TransformAdapter2D >
using	ScalarValue = SkScalar
using	Vec2Value = SkV2
typedef TextPropertyValue	TextValue

Enumerations
enum class	TextPaintOrder : uint8_t { kFillStroke , kStrokeFill }
enum	ShapeEncodingInfo : size_t {   kX_Index = 0 , kY_Index = 1 , kInX_Index = 2 , kInY_Index = 3 ,   kOutX_Index = 4 , kOutY_Index = 5 , kFloatsPerVertex = 6 }

Functions
static size_t	shape_encoding_len (size_t vertex_count)
static const skjson::ObjectValue *	shape_root (const skjson::Value &jv)
static bool	parse_encoding_len (const skjson::Value &jv, size_t *len)
static bool	parse_encoding_data (const skjson::Value &jv, size_t data_len, float data[])
static bool	parse_array (const skjson::ArrayValue *ja, float *a, size_t count)
template<>
bool	Parse< SkScalar > (const Value &v, SkScalar *s)
template<>
bool	Parse< bool > (const Value &v, bool *b)
template<typename T >
bool	ParseIntegral (const Value &v, T *result)
template<>
bool	Parse< int > (const Value &v, int *i)
template<>
bool	Parse< size_t > (const Value &v, size_t *sz)
template<>
bool	Parse< SkString > (const Value &v, SkString *s)
template<>
bool	Parse< SkV2 > (const Value &v, SkV2 *v2)
template<>
bool	Parse< SkPoint > (const Value &v, SkPoint *pt)
template<>
bool	Parse< VectorValue > (const Value &v, VectorValue *vec)
const skjson::StringValue *	ParseSlotID (const skjson::ObjectValue *jobj)
template<typename T >
bool	Parse (const skjson::Value &, T *)
template<typename T >
T	ParseDefault (const skjson::Value &v, const T &defaultValue)

Typedef Documentation

ColorPropertyHandle

using skottie::ColorPropertyHandle = typedef PropertyHandle<ColorPropertyValue, sksg::Color>

Definition at line 152 of file SkottieProperty.h.

ColorPropertyValue

using skottie::ColorPropertyValue = typedef SkColor

Definition at line 43 of file SkottieProperty.h.

ImageAsset

using skottie::ImageAsset = typedef skresources::ImageAsset

Definition at line 45 of file Skottie.h.

OpacityPropertyHandle

using skottie::OpacityPropertyHandle = typedef PropertyHandle<OpacityPropertyValue, sksg::OpacityEffect>

Definition at line 154 of file SkottieProperty.h.

OpacityPropertyValue

using skottie::OpacityPropertyValue = typedef float

Definition at line 44 of file SkottieProperty.h.

ResourceProvider

using skottie::ResourceProvider = typedef skresources::ResourceProvider

Definition at line 46 of file Skottie.h.

ScalarValue

using skottie::ScalarValue = typedef SkScalar

Definition at line 22 of file SkottieValue.h.

TextPropertyHandle

using skottie::TextPropertyHandle = typedef PropertyHandle<TextPropertyValue, internal::TextAdapter>

Definition at line 156 of file SkottieProperty.h.

TextValue

typedef TextPropertyValue skottie::TextValue

Definition at line 16 of file TextValue.h.

TransformPropertyHandle

using skottie::TransformPropertyHandle = typedef PropertyHandle<TransformPropertyValue, internal::TransformAdapter2D>

Definition at line 158 of file SkottieProperty.h.

Vec2Value

using skottie::Vec2Value = typedef SkV2

Definition at line 23 of file SkottieValue.h.

Enumeration Type Documentation

ShapeEncodingInfo

enum skottie::ShapeEncodingInfo : size_t

Enumerator
kX_Index
kY_Index
kInX_Index
kInY_Index
kOutX_Index
kOutY_Index
kFloatsPerVertex

Definition at line 38 of file ShapeKeyframeAnimator.cpp.

                       : size_t {
            kX_Index = 0,
            kY_Index = 1,
          kInX_Index = 2,
          kInY_Index = 3,
         kOutX_Index = 4,
         kOutY_Index = 5,
 
    kFloatsPerVertex = 6
};

TextPaintOrder

enum class skottie::TextPaintOrder : uint8_t

strong

Enumerator
kFillStroke
kStrokeFill

Definition at line 46 of file SkottieProperty.h.

                          : uint8_t {
    kFillStroke,
    kStrokeFill,
};

Function Documentation

Parse()

template<typename T >

bool skottie::Parse	(	const skjson::Value &	,
		T *
	)

Parse< bool >()

template<>

bool skottie::Parse< bool >	(	const Value &	v,
		bool *	b
	)

Definition at line 43 of file SkottieJson.cpp.

                                          {
    switch(v.getType()) {
    case Value::Type::kNumber:
        *b = SkToBool(*v.as<NumberValue>());
        return true;
    case Value::Type::kBool:
        *b = *v.as<BoolValue>();
        return true;
    default:
        break;
    }
 
    return false;
}

Parse< int >()

template<>

bool skottie::Parse< int >	(	const Value &	v,
		int *	i
	)

Definition at line 75 of file SkottieJson.cpp.

                                        {
    return ParseIntegral(v, i);
}

Parse< size_t >()

template<>

bool skottie::Parse< size_t >	(	const Value &	v,
		size_t *	sz
	)

Definition at line 80 of file SkottieJson.cpp.

                                               {
    return ParseIntegral(v, sz);
}

Parse< SkPoint >()

template<>

bool skottie::Parse< SkPoint >	(	const Value &	v,
		SkPoint *	pt
	)

Definition at line 107 of file SkottieJson.cpp.

                                                 {
    if (!v.is<ObjectValue>())
        return false;
    const auto& ov = v.as<ObjectValue>();
 
    return Parse<SkScalar>(ov["x"], &pt->fX)
        && Parse<SkScalar>(ov["y"], &pt->fY);
}

Parse< SkScalar >()

template<>

bool skottie::Parse< SkScalar >	(	const Value &	v,
		SkScalar *	s
	)

Definition at line 26 of file SkottieJson.cpp.

                                                  {
    // Some versions wrap values as single-element arrays.
    if (const skjson::ArrayValue* array = v) {
        if (array->size() > 0) {
            return Parse((*array)[0], s);
        }
    }
 
    if (const skjson::NumberValue* num = v) {
        *s = static_cast<SkScalar>(**num);
        return true;
    }
 
    return false;
}

Parse< SkString >()

template<>

bool skottie::Parse< SkString >	(	const Value &	v,
		SkString *	s
	)

Definition at line 85 of file SkottieJson.cpp.

                                                  {
    if (const skjson::StringValue* sv = v) {
        s->set(sv->begin(), sv->size());
        return true;
    }
 
    return false;
}

Parse< SkV2 >()

template<>

bool skottie::Parse< SkV2 >	(	const Value &	v,
		SkV2 *	v2
	)

Definition at line 95 of file SkottieJson.cpp.

                                           {
    if (!v.is<ArrayValue>())
        return false;
    const auto& av = v.as<ArrayValue>();
 
    // We need at least two scalars (BM sometimes exports a third value == 0).
    return av.size() >= 2
        && Parse<SkScalar>(av[0], &v2->x)
        && Parse<SkScalar>(av[1], &v2->y);
}

Parse< VectorValue >()

template<>

bool skottie::Parse< VectorValue >	(	const Value &	v,
		VectorValue *	vec
	)

Definition at line 117 of file SkottieJson.cpp.

                                                          {
    if (!v.is<ArrayValue>())
        return false;
    const auto& av = v.as<ArrayValue>();
 
    vec->resize(av.size());
    for (size_t i = 0; i < av.size(); ++i) {
        if (!Parse(av[i], vec->data() + i)) {
            return false;
        }
    }
 
    return true;
}

parse_array()

static bool skottie::parse_array ( const skjson::ArrayValue *  ja, float *  a, size_t  count  )

static

Definition at line 37 of file VectorKeyframeAnimator.cpp.

                                                                            {
    if (!ja || ja->size() != count) {
        return false;
    }
 
    for (size_t i = 0; i < count; ++i) {
        if (!Parse((*ja)[i], a + i)) {
            return false;
        }
    }
 
    return true;
}

parse_encoding_data()

static bool skottie::parse_encoding_data ( const skjson::Value &  jv, size_t  data_len, float  data[]  )

static

Definition at line 74 of file ShapeKeyframeAnimator.cpp.

                                                                                      {
    const auto* jshape = shape_root(jv);
    if (!jshape) {
        return false;
    }
 
    // vertices are required, in/out tangents are optional
    const skjson::ArrayValue* jvs = (*jshape)["v"]; // vertex points
    const skjson::ArrayValue* jis = (*jshape)["i"]; // in-tangent points
    const skjson::ArrayValue* jos = (*jshape)["o"]; // out-tangent points
 
    if (!jvs || data_len != shape_encoding_len(jvs->size())) {
        return false;
    }
 
    auto parse_point = [](const skjson::ArrayValue* ja, size_t i, float* x, float* y) {
        SkASSERT(ja);
        const skjson::ArrayValue* jpt = (*ja)[i];
 
        if (!jpt || jpt->size() != 2ul) {
            return false;
        }
 
        return Parse((*jpt)[0], x) && Parse((*jpt)[1], y);
    };
 
    auto parse_optional_point = [&parse_point](const skjson::ArrayValue* ja, size_t i,
                                               float* x, float* y) {
        if (!ja || i >= ja->size()) {
            // default control point
            *x = *y = 0;
            return true;
        }
 
        return parse_point(*ja, i, x, y);
    };
 
    for (size_t i = 0; i < jvs->size(); ++i) {
        float* dst = data + i * kFloatsPerVertex;
        SkASSERT(dst + kFloatsPerVertex <= data + data_len);
 
        if (!parse_point         (jvs, i, dst +    kX_Index, dst +    kY_Index) ||
            !parse_optional_point(jis, i, dst +  kInX_Index, dst +  kInY_Index) ||
            !parse_optional_point(jos, i, dst + kOutX_Index, dst + kOutY_Index)) {
            return false;
        }
    }
 
    // "closed" flag
    data[data_len - 1] = ParseDefault<bool>((*jshape)["c"], false);
 
    return true;
}

parse_encoding_len()

static bool skottie::parse_encoding_len ( const skjson::Value &  jv, size_t *  len  )

static

Definition at line 64 of file ShapeKeyframeAnimator.cpp.

                                                                   {
    if (const auto* jshape = shape_root(jv)) {
        if (const skjson::ArrayValue* jvs = (*jshape)["v"]) {
            *len = shape_encoding_len(jvs->size());
            return true;
        }
    }
    return false;
}

ParseDefault()

template<typename T >

T skottie::ParseDefault	(	const skjson::Value &	v,
		const T &	defaultValue
	)

Definition at line 23 of file SkottieJson.h.

                                                            {
    T res;
    if (!Parse<T>(v, &res)) {
        res = defaultValue;
    }
    return res;
}

ParseIntegral()

template<typename T >

bool skottie::ParseIntegral	(	const Value &	v,
		T *	result
	)

Definition at line 59 of file SkottieJson.cpp.

                                              {
    if (const skjson::NumberValue* num = v) {
        const auto dbl = **num;
        if (dbl > static_cast<double>(std::numeric_limits<T>::max()) ||
            dbl < static_cast<double>(std::numeric_limits<T>::min())) {
            return false;
        }
 
        *result = static_cast<T>(dbl);
        return true;
    }
 
    return false;
}

ParseSlotID()

const skjson::StringValue * skottie::ParseSlotID

(

const skjson::ObjectValue *

jobj

)

Definition at line 132 of file SkottieJson.cpp.

                                                                    {
    if (jobj) {
        if (const skjson::StringValue* sid = (*jobj)["sid"]) {
            return sid;
        }
    }
    return nullptr;
}

shape_encoding_len()

static size_t skottie::shape_encoding_len ( size_t  vertex_count )

static

Definition at line 49 of file ShapeKeyframeAnimator.cpp.

                                                      {
    return vertex_count * kFloatsPerVertex + 1;
}

shape_root()

static const skjson::ObjectValue * skottie::shape_root ( const skjson::Value &  jv )

static

Definition at line 54 of file ShapeKeyframeAnimator.cpp.

                                                                  {
    if (const skjson::ArrayValue* av = jv) {
        if (av->size() == 1) {
            return (*av)[0];
        }
    }
 
    return jv;
}