f8823b5726
This is a reland of bdc214a50e
The CPU version of SkottieWasm is timing out for reasons unknown,
but the GPU version is happy. I think we can get rid of the CPU
version of the job since it has been more or less superseded by
the SkottieFrames one (and the latter is more stable).
Original change's description:
> [canvaskit] Change SkRects to be arrays, not objects.
>
> This changes several APIs, so there are lots of breaking
> notes in the Changelog.
>
> This made the "draw 100 colored regions" benchmark about
> 20% faster (1ms -> .8ms).
>
> In theory, rendering should stay the same.
>
> Change-Id: Ib80b15e2d980ad5d568fff4460d2b529766c1b36
> Reviewed-on: https://skia-review.googlesource.com/c/skia/+/312491
> Reviewed-by: Nathaniel Nifong <nifong@google.com>
Change-Id: I674aba85ecfb30b72e94cbaf89b2d97bfae3b7a4
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/315142
Reviewed-by: Nathaniel Nifong <nifong@google.com>
282 lines
11 KiB
C++
282 lines
11 KiB
C++
/*
|
|
* Copyright 2019 Google LLC
|
|
*
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
#include "include/core/SkCanvas.h"
|
|
#include "include/core/SkImage.h"
|
|
#include "include/core/SkString.h"
|
|
#include "include/core/SkTypes.h"
|
|
#include "modules/skottie/include/Skottie.h"
|
|
#include "modules/sksg/include/SkSGInvalidationController.h"
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include <emscripten.h>
|
|
#include <emscripten/bind.h>
|
|
#include "modules/canvaskit/WasmCommon.h"
|
|
|
|
#if SK_INCLUDE_MANAGED_SKOTTIE
|
|
#include "modules/skottie/include/SkottieProperty.h"
|
|
#include "modules/skottie/utils/SkottieUtils.h"
|
|
#include "modules/skresources/include/SkResources.h"
|
|
#endif // SK_INCLUDE_MANAGED_SKOTTIE
|
|
|
|
using namespace emscripten;
|
|
|
|
#if SK_INCLUDE_MANAGED_SKOTTIE
|
|
namespace {
|
|
|
|
class SkottieAssetProvider : public skottie::ResourceProvider {
|
|
public:
|
|
~SkottieAssetProvider() override = default;
|
|
|
|
// Tried using a map, but that gave strange errors like
|
|
// https://emscripten.org/docs/porting/guidelines/function_pointer_issues.html
|
|
// Not entirely sure why, but perhaps the iterator in the map was
|
|
// confusing enscripten.
|
|
using AssetVec = std::vector<std::pair<SkString, sk_sp<SkData>>>;
|
|
|
|
static sk_sp<SkottieAssetProvider> Make(AssetVec assets) {
|
|
if (assets.empty()) {
|
|
return nullptr;
|
|
}
|
|
|
|
return sk_sp<SkottieAssetProvider>(new SkottieAssetProvider(std::move(assets)));
|
|
}
|
|
|
|
sk_sp<skottie::ImageAsset> loadImageAsset(const char[] /* path */,
|
|
const char name[],
|
|
const char[] /* id */) const override {
|
|
// For CK/Skottie we ignore paths & IDs, and identify images based solely on name.
|
|
if (auto data = this->findAsset(name)) {
|
|
return skresources::MultiFrameImageAsset::Make(std::move(data));
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
sk_sp<SkData> loadFont(const char name[], const char[] /* url */) const override {
|
|
// Same as images paths, we ignore font URLs.
|
|
return this->findAsset(name);
|
|
}
|
|
|
|
sk_sp<SkData> load(const char[]/*path*/, const char name[]) const override {
|
|
// Ignore paths.
|
|
return this->findAsset(name);
|
|
}
|
|
|
|
private:
|
|
explicit SkottieAssetProvider(AssetVec assets) : fAssets(std::move(assets)) {}
|
|
|
|
sk_sp<SkData> findAsset(const char name[]) const {
|
|
for (const auto& asset : fAssets) {
|
|
if (asset.first.equals(name)) {
|
|
return asset.second;
|
|
}
|
|
}
|
|
|
|
SkDebugf("Could not find %s\n", name);
|
|
return nullptr;
|
|
}
|
|
|
|
const AssetVec fAssets;
|
|
};
|
|
|
|
class ManagedAnimation final : public SkRefCnt {
|
|
public:
|
|
static sk_sp<ManagedAnimation> Make(const std::string& json,
|
|
sk_sp<skottie::ResourceProvider> rp,
|
|
std::string prop_prefix) {
|
|
auto mgr = std::make_unique<skottie_utils::CustomPropertyManager>(
|
|
skottie_utils::CustomPropertyManager::Mode::kCollapseProperties,
|
|
prop_prefix.empty() ? nullptr : prop_prefix.c_str());
|
|
static constexpr char kInterceptPrefix[] = "__";
|
|
auto pinterceptor =
|
|
sk_make_sp<skottie_utils::ExternalAnimationPrecompInterceptor>(rp, kInterceptPrefix);
|
|
auto animation = skottie::Animation::Builder()
|
|
.setMarkerObserver(mgr->getMarkerObserver())
|
|
.setPropertyObserver(mgr->getPropertyObserver())
|
|
.setResourceProvider(std::move(rp))
|
|
.setPrecompInterceptor(std::move(pinterceptor))
|
|
.make(json.c_str(), json.size());
|
|
|
|
return animation
|
|
? sk_sp<ManagedAnimation>(new ManagedAnimation(std::move(animation), std::move(mgr)))
|
|
: nullptr;
|
|
}
|
|
|
|
~ManagedAnimation() override = default;
|
|
|
|
// skottie::Animation API
|
|
void render(SkCanvas* canvas, const SkRect* dst) const { fAnimation->render(canvas, dst); }
|
|
// Returns a damage rect.
|
|
SkRect seek(SkScalar t) {
|
|
sksg::InvalidationController ic;
|
|
fAnimation->seek(t, &ic);
|
|
return ic.bounds();
|
|
}
|
|
// Returns a damage rect.
|
|
SkRect seekFrame(double t) {
|
|
sksg::InvalidationController ic;
|
|
fAnimation->seekFrame(t, &ic);
|
|
return ic.bounds();
|
|
}
|
|
double duration() const { return fAnimation->duration(); }
|
|
double fps() const { return fAnimation->fps(); }
|
|
const SkSize& size() const { return fAnimation->size(); }
|
|
std::string version() const { return std::string(fAnimation->version().c_str()); }
|
|
|
|
// CustomPropertyManager API
|
|
JSArray getColorProps() const {
|
|
JSArray props = emscripten::val::array();
|
|
|
|
for (const auto& cp : fPropMgr->getColorProps()) {
|
|
JSObject prop = emscripten::val::object();
|
|
prop.set("key", cp);
|
|
prop.set("value", fPropMgr->getColor(cp));
|
|
props.call<void>("push", prop);
|
|
}
|
|
|
|
return props;
|
|
}
|
|
|
|
JSArray getOpacityProps() const {
|
|
JSArray props = emscripten::val::array();
|
|
|
|
for (const auto& op : fPropMgr->getOpacityProps()) {
|
|
JSObject prop = emscripten::val::object();
|
|
prop.set("key", op);
|
|
prop.set("value", fPropMgr->getOpacity(op));
|
|
props.call<void>("push", prop);
|
|
}
|
|
|
|
return props;
|
|
}
|
|
|
|
bool setColor(const std::string& key, SkColor c) {
|
|
return fPropMgr->setColor(key, c);
|
|
}
|
|
|
|
bool setOpacity(const std::string& key, float o) {
|
|
return fPropMgr->setOpacity(key, o);
|
|
}
|
|
|
|
JSArray getMarkers() const {
|
|
JSArray markers = emscripten::val::array();
|
|
for (const auto& m : fPropMgr->markers()) {
|
|
JSObject marker = emscripten::val::object();
|
|
marker.set("name", m.name);
|
|
marker.set("t0" , m.t0);
|
|
marker.set("t1" , m.t1);
|
|
markers.call<void>("push", marker);
|
|
}
|
|
return markers;
|
|
}
|
|
|
|
private:
|
|
ManagedAnimation(sk_sp<skottie::Animation> animation,
|
|
std::unique_ptr<skottie_utils::CustomPropertyManager> propMgr)
|
|
: fAnimation(std::move(animation))
|
|
, fPropMgr(std::move(propMgr)) {}
|
|
|
|
sk_sp<skottie::Animation> fAnimation;
|
|
std::unique_ptr<skottie_utils::CustomPropertyManager> fPropMgr;
|
|
};
|
|
|
|
} // anonymous ns
|
|
#endif // SK_INCLUDE_MANAGED_SKOTTIE
|
|
|
|
EMSCRIPTEN_BINDINGS(Skottie) {
|
|
// Animation things (may eventually go in own library)
|
|
class_<skottie::Animation>("Animation")
|
|
.smart_ptr<sk_sp<skottie::Animation>>("sk_sp<Animation>")
|
|
.function("version", optional_override([](skottie::Animation& self)->std::string {
|
|
return std::string(self.version().c_str());
|
|
}))
|
|
.function("size" , &skottie::Animation::size)
|
|
.function("duration", &skottie::Animation::duration)
|
|
.function("fps" , &skottie::Animation::fps)
|
|
.function("seek", optional_override([](skottie::Animation& self, SkScalar t)->void {
|
|
self.seek(t);
|
|
}))
|
|
.function("seekFrame", optional_override([](skottie::Animation& self, double t)->void {
|
|
self.seekFrame(t);
|
|
}))
|
|
.function("_render", optional_override([](skottie::Animation& self, SkCanvas* canvas,
|
|
uintptr_t /* float* */ fPtr)->void {
|
|
const SkRect* dst = reinterpret_cast<const SkRect*>(fPtr);
|
|
self.render(canvas, dst);
|
|
}), allow_raw_pointers());
|
|
|
|
function("MakeAnimation", optional_override([](std::string json)->sk_sp<skottie::Animation> {
|
|
return skottie::Animation::Make(json.c_str(), json.length());
|
|
}));
|
|
constant("skottie", true);
|
|
|
|
#if SK_INCLUDE_MANAGED_SKOTTIE
|
|
class_<ManagedAnimation>("ManagedAnimation")
|
|
.smart_ptr<sk_sp<ManagedAnimation>>("sk_sp<ManagedAnimation>")
|
|
.function("version" , &ManagedAnimation::version)
|
|
.function("size" , &ManagedAnimation::size)
|
|
.function("duration" , &ManagedAnimation::duration)
|
|
.function("fps" , &ManagedAnimation::fps)
|
|
.function("_render", optional_override([](ManagedAnimation& self, SkCanvas* canvas,
|
|
uintptr_t /* float* */ fPtr)->void {
|
|
const SkRect* dst = reinterpret_cast<const SkRect*>(fPtr);
|
|
self.render(canvas, dst);
|
|
}), allow_raw_pointers())
|
|
.function("_seek", optional_override([](ManagedAnimation& self, SkScalar t,
|
|
uintptr_t /* float* */ fPtr) {
|
|
SkRect* damageRect = reinterpret_cast<SkRect*>(fPtr);
|
|
damageRect[0] = self.seek(t);
|
|
}))
|
|
.function("_seekFrame", optional_override([](ManagedAnimation& self, double frame,
|
|
uintptr_t /* float* */ fPtr) {
|
|
SkRect* damageRect = reinterpret_cast<SkRect*>(fPtr);
|
|
damageRect[0] = self.seekFrame(frame);
|
|
}))
|
|
.function("seekFrame" , &ManagedAnimation::seekFrame)
|
|
.function("_setColor" , optional_override([](ManagedAnimation& self, const std::string& key, uintptr_t /* float* */ cPtr) {
|
|
float* fourFloats = reinterpret_cast<float*>(cPtr);
|
|
SkColor4f color = { fourFloats[0], fourFloats[1], fourFloats[2], fourFloats[3] };
|
|
self.setColor(key, color.toSkColor());
|
|
}))
|
|
.function("setOpacity", &ManagedAnimation::setOpacity)
|
|
.function("getMarkers", &ManagedAnimation::getMarkers)
|
|
.function("getColorProps" , &ManagedAnimation::getColorProps)
|
|
.function("getOpacityProps", &ManagedAnimation::getOpacityProps);
|
|
|
|
function("_MakeManagedAnimation", optional_override([](std::string json,
|
|
size_t assetCount,
|
|
uintptr_t /* char** */ nptr,
|
|
uintptr_t /* uint8_t** */ dptr,
|
|
uintptr_t /* size_t* */ sptr,
|
|
std::string prop_prefix)
|
|
->sk_sp<ManagedAnimation> {
|
|
// See the comment in canvaskit_bindings.cpp about the use of uintptr_t
|
|
const auto assetNames = reinterpret_cast<char** >(nptr);
|
|
const auto assetDatas = reinterpret_cast<uint8_t**>(dptr);
|
|
const auto assetSizes = reinterpret_cast<size_t* >(sptr);
|
|
|
|
SkottieAssetProvider::AssetVec assets;
|
|
assets.reserve(assetCount);
|
|
|
|
for (size_t i = 0; i < assetCount; i++) {
|
|
auto name = SkString(assetNames[i]);
|
|
auto bytes = SkData::MakeFromMalloc(assetDatas[i], assetSizes[i]);
|
|
assets.push_back(std::make_pair(std::move(name), std::move(bytes)));
|
|
}
|
|
|
|
return ManagedAnimation::Make(json,
|
|
skresources::DataURIResourceProviderProxy::Make(
|
|
SkottieAssetProvider::Make(std::move(assets))),
|
|
prop_prefix);
|
|
}));
|
|
constant("managed_skottie", true);
|
|
#endif // SK_INCLUDE_MANAGED_SKOTTIE
|
|
}
|