/*
* Copyright 2017 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkottieValue.h"
#include "SkColor.h"
#include "SkottieJson.h"
#include "SkottiePriv.h"
#include "SkNx.h"
#include "SkPoint.h"
#include "SkSize.h"
namespace skottie {
template <>
bool ValueTraits<ScalarValue>::FromJSON(const skjson::Value& jv, const internal::AnimationBuilder*,
ScalarValue* v) {
return Parse(jv, v);
}
template <>
bool ValueTraits<ScalarValue>::CanLerp(const ScalarValue&, const ScalarValue&) {
return true;
}
template <>
void ValueTraits<ScalarValue>::Lerp(const ScalarValue& v0, const ScalarValue& v1, float t,
ScalarValue* result) {
SkASSERT(t >= 0 && t <= 1);
*result = v0 + (v1 - v0) * t;
}
template <>
template <>
SkScalar ValueTraits<ScalarValue>::As<SkScalar>(const ScalarValue& v) {
return v;
}
template <>
bool ValueTraits<VectorValue>::FromJSON(const skjson::Value& jv, const internal::AnimationBuilder*,
VectorValue* v) {
return Parse(jv, v);
}
template <>
bool ValueTraits<VectorValue>::CanLerp(const VectorValue& v1, const VectorValue& v2) {
return v1.size() == v2.size();
}
template <>
void ValueTraits<VectorValue>::Lerp(const VectorValue& v0, const VectorValue& v1, float t,
VectorValue* result) {
SkASSERT(v0.size() == v1.size());
result->resize(v0.size());
for (size_t i = 0; i < v0.size(); ++i) {
ValueTraits<ScalarValue>::Lerp(v0[i], v1[i], t, &(*result)[i]);
}
}
template <>
template <>
SkColor ValueTraits<VectorValue>::As<SkColor>(const VectorValue& v) {
// best effort to turn this into a color
const auto r = v.size() > 0 ? v[0] : 0,
g = v.size() > 1 ? v[1] : 0,
b = v.size() > 2 ? v[2] : 0,
a = v.size() > 3 ? v[3] : 1;
return SkColorSetARGB(SkScalarRoundToInt(SkTPin(a, 0.0f, 1.0f) * 255),
SkScalarRoundToInt(SkTPin(r, 0.0f, 1.0f) * 255),
SkScalarRoundToInt(SkTPin(g, 0.0f, 1.0f) * 255),
SkScalarRoundToInt(SkTPin(b, 0.0f, 1.0f) * 255));
}
template <>
template <>
SkPoint ValueTraits<VectorValue>::As<SkPoint>(const VectorValue& vec) {
// best effort to turn this into a point
const auto x = vec.size() > 0 ? vec[0] : 0,
y = vec.size() > 1 ? vec[1] : 0;
return SkPoint::Make(x, y);
}
template <>
template <>
SkSize ValueTraits<VectorValue>::As<SkSize>(const VectorValue& vec) {
const auto pt = ValueTraits::As<SkPoint>(vec);
return SkSize::Make(pt.x(), pt.y());
}
namespace {
bool ParsePointVec(const skjson::Value& jv, std::vector<SkPoint>* pts) {
if (!jv.is<skjson::ArrayValue>())
return false;
const auto& av = jv.as<skjson::ArrayValue>();
pts->clear();
pts->reserve(av.size());
std::vector<float> vec;
for (size_t i = 0; i < av.size(); ++i) {
if (!Parse(av[i], &vec) || vec.size() != 2)
return false;
pts->push_back(SkPoint::Make(vec[0], vec[1]));
}
return true;
}
} // namespace
template <>
bool ValueTraits<ShapeValue>::FromJSON(const skjson::Value& jv,
const internal::AnimationBuilder* abuilder,
ShapeValue* v) {
SkASSERT(v->fVertices.empty());
// Some versions wrap values as single-element arrays.
if (const skjson::ArrayValue* av = jv) {
if (av->size() == 1) {
return FromJSON((*av)[0], abuilder, v);
}
}
if (!jv.is<skjson::ObjectValue>())
return false;
const auto& ov = jv.as<skjson::ObjectValue>();
std::vector<SkPoint> verts, // Cubic Bezier vertices.
inPts, // Cubic Bezier "in" control points, relative to vertices.
outPts; // Cubic Bezier "out" control points, relative to vertices.
if (!ParsePointVec(ov["v"], &verts)) {
// Vertices are required.
return false;
}
// In/out points are optional.
ParsePointVec(ov["i"], &inPts);
if (!inPts.empty() && inPts.size() != verts.size()) {
return false;
}
inPts.resize(verts.size(), { 0, 0 });
ParsePointVec(ov["o"], &outPts);
if (!outPts.empty() && outPts.size() != verts.size()) {
return false;
}
outPts.resize(verts.size(), { 0, 0 });
v->fVertices.reserve(inPts.size());
for (size_t i = 0; i < inPts.size(); ++i) {
v->fVertices.push_back(BezierVertex({inPts[i], outPts[i], verts[i]}));
}
v->fClosed = ParseDefault<bool>(ov["c"], false);
return true;
}
template <>
bool ValueTraits<ShapeValue>::CanLerp(const ShapeValue& v1, const ShapeValue& v2) {
return v1.fVertices.size() == v2.fVertices.size()
&& v1.fClosed == v2.fClosed;
}
static SkPoint lerp_point(const SkPoint& v0, const SkPoint& v1, const Sk2f& t) {
const auto v2f0 = Sk2f::Load(&v0),
v2f1 = Sk2f::Load(&v1);
SkPoint v;
(v2f0 + (v2f1 - v2f0) * t).store(&v);
return v;
}
template <>
void ValueTraits<ShapeValue>::Lerp(const ShapeValue& v0, const ShapeValue& v1, float t,
ShapeValue* result) {
SkASSERT(t >= 0 && t <= 1);
SkASSERT(v0.fVertices.size() == v1.fVertices.size());
SkASSERT(v0.fClosed == v1.fClosed);
result->fClosed = v0.fClosed;
result->fVolatile = true; // interpolated values are volatile
const auto t2f = Sk2f(t);
result->fVertices.resize(v0.fVertices.size());
for (size_t i = 0; i < v0.fVertices.size(); ++i) {
result->fVertices[i] = BezierVertex({
lerp_point(v0.fVertices[i].fInPoint , v1.fVertices[i].fInPoint , t2f),
lerp_point(v0.fVertices[i].fOutPoint, v1.fVertices[i].fOutPoint, t2f),
lerp_point(v0.fVertices[i].fVertex , v1.fVertices[i].fVertex , t2f)
});
}
}
template <>
template <>
SkPath ValueTraits<ShapeValue>::As<SkPath>(const ShapeValue& shape) {
SkPath path;
if (!shape.fVertices.empty()) {
// conservatively assume all cubics
path.incReserve(1 + SkToU32(shape.fVertices.size() * 3));
path.moveTo(shape.fVertices.front().fVertex);
}
const auto& addCubic = [&](size_t from, size_t to) {
const auto c0 = shape.fVertices[from].fVertex + shape.fVertices[from].fOutPoint,
c1 = shape.fVertices[to].fVertex + shape.fVertices[to].fInPoint;
if (c0 == shape.fVertices[from].fVertex &&
c1 == shape.fVertices[to].fVertex) {
// If the control points are coincident, we can power-reduce to a straight line.
// TODO: we could also do that when the controls are on the same line as the
// vertices, but it's unclear how common that case is.
path.lineTo(shape.fVertices[to].fVertex);
} else {
path.cubicTo(c0, c1, shape.fVertices[to].fVertex);
}
};
for (size_t i = 1; i < shape.fVertices.size(); ++i) {
addCubic(i - 1, i);
}
if (!shape.fVertices.empty() && shape.fClosed) {
addCubic(shape.fVertices.size() - 1, 0);
path.close();
}
path.setIsVolatile(shape.fVolatile);
path.shrinkToFit();
return path;
}
template <>
bool ValueTraits<TextValue>::FromJSON(const skjson::Value& jv,
const internal::AnimationBuilder* abuilder,
TextValue* v) {
const skjson::ObjectValue* jtxt = jv;
if (!jtxt) {
return false;
}
const skjson::StringValue* font_name = (*jtxt)["f"];
const skjson::StringValue* text = (*jtxt)["t"];
const skjson::NumberValue* text_size = (*jtxt)["s"];
if (!font_name || !text || !text_size ||
!(v->fTypeface = abuilder->findFont(SkString(font_name->begin(), font_name->size())))) {
return false;
}
v->fText.set(text->begin(), text->size());
v->fTextSize = **text_size;
static constexpr SkTextUtils::Align gAlignMap[] = {
SkTextUtils::kLeft_Align, // 'j': 0
SkTextUtils::kRight_Align, // 'j': 1
SkTextUtils::kCenter_Align // 'j': 2
};
v->fAlign = gAlignMap[SkTMin<size_t>(ParseDefault<size_t>((*jtxt)["j"], 0),
SK_ARRAY_COUNT(gAlignMap))];
const auto& parse_color = [] (const skjson::ArrayValue* jcolor,
const internal::AnimationBuilder* abuilder,
SkColor* c) {
if (!jcolor) {
return false;
}
VectorValue color_vec;
if (!ValueTraits<VectorValue>::FromJSON(*jcolor, abuilder, &color_vec)) {
return false;
}
*c = ValueTraits<VectorValue>::As<SkColor>(color_vec);
return true;
};
v->fHasFill = parse_color((*jtxt)["fc"], abuilder, &v->fFillColor);
v->fHasStroke = parse_color((*jtxt)["sc"], abuilder, &v->fStrokeColor);
if (v->fHasStroke) {
v->fStrokeWidth = ParseDefault((*jtxt)["s"], 0.0f);
}
return true;
}
template <>
bool ValueTraits<TextValue>::CanLerp(const TextValue&, const TextValue&) {
// Text values are never interpolated, but we pretend that they could be.
return true;
}
template <>
void ValueTraits<TextValue>::Lerp(const TextValue& v0, const TextValue&, float, TextValue* result) {
// Text value keyframes are treated as selectors, not as interpolated values.
*result = v0;
}
} // namespace skottie