2017-12-30 17:27:00 +00:00
|
|
|
/*
|
|
|
|
* Copyright 2017 Google Inc.
|
|
|
|
*
|
|
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
|
|
* found in the LICENSE file.
|
|
|
|
*/
|
|
|
|
|
2019-04-23 17:05:21 +00:00
|
|
|
#include "tools/viewer/SkottieSlide.h"
|
2017-12-30 17:27:00 +00:00
|
|
|
|
2018-05-26 13:49:28 +00:00
|
|
|
#if defined(SK_ENABLE_SKOTTIE)
|
|
|
|
|
2019-04-23 17:05:21 +00:00
|
|
|
#include "include/core/SkCanvas.h"
|
|
|
|
#include "include/core/SkFont.h"
|
|
|
|
#include "modules/skottie/include/Skottie.h"
|
|
|
|
#include "modules/skottie/utils/SkottieUtils.h"
|
|
|
|
#include "src/utils/SkOSPath.h"
|
2019-07-11 20:32:53 +00:00
|
|
|
#include "tools/timer/TimeUtils.h"
|
2017-12-30 17:27:00 +00:00
|
|
|
|
2018-05-29 17:46:54 +00:00
|
|
|
#include <cmath>
|
|
|
|
|
2018-08-23 00:37:04 +00:00
|
|
|
static void draw_stats_box(SkCanvas* canvas, const skottie::Animation::Builder::Stats& stats) {
|
2018-04-30 14:32:18 +00:00
|
|
|
static constexpr SkRect kR = { 10, 10, 280, 120 };
|
|
|
|
static constexpr SkScalar kTextSize = 20;
|
|
|
|
|
|
|
|
SkPaint paint;
|
|
|
|
paint.setAntiAlias(true);
|
|
|
|
paint.setColor(0xffeeeeee);
|
2019-01-08 14:38:02 +00:00
|
|
|
|
|
|
|
SkFont font(nullptr, kTextSize);
|
2018-04-30 14:32:18 +00:00
|
|
|
|
|
|
|
canvas->drawRect(kR, paint);
|
|
|
|
|
|
|
|
paint.setColor(SK_ColorBLACK);
|
|
|
|
|
|
|
|
const auto json_size = SkStringPrintf("Json size: %lu bytes",
|
|
|
|
stats.fJsonSize);
|
2019-01-08 14:38:02 +00:00
|
|
|
canvas->drawString(json_size, kR.x() + 10, kR.y() + kTextSize * 1, font, paint);
|
2018-04-30 14:32:18 +00:00
|
|
|
const auto animator_count = SkStringPrintf("Animator count: %lu",
|
|
|
|
stats.fAnimatorCount);
|
2019-01-08 14:38:02 +00:00
|
|
|
canvas->drawString(animator_count, kR.x() + 10, kR.y() + kTextSize * 2, font, paint);
|
2018-04-30 14:32:18 +00:00
|
|
|
const auto json_parse_time = SkStringPrintf("Json parse time: %.3f ms",
|
|
|
|
stats.fJsonParseTimeMS);
|
2019-01-08 14:38:02 +00:00
|
|
|
canvas->drawString(json_parse_time, kR.x() + 10, kR.y() + kTextSize * 3, font, paint);
|
2018-04-30 14:32:18 +00:00
|
|
|
const auto scene_parse_time = SkStringPrintf("Scene build time: %.3f ms",
|
|
|
|
stats.fSceneParseTimeMS);
|
2019-01-08 14:38:02 +00:00
|
|
|
canvas->drawString(scene_parse_time, kR.x() + 10, kR.y() + kTextSize * 4, font, paint);
|
2018-04-30 14:32:18 +00:00
|
|
|
const auto total_load_time = SkStringPrintf("Total load time: %.3f ms",
|
|
|
|
stats.fTotalLoadTimeMS);
|
2019-01-08 14:38:02 +00:00
|
|
|
canvas->drawString(total_load_time, kR.x() + 10, kR.y() + kTextSize * 5, font, paint);
|
2018-04-30 14:32:18 +00:00
|
|
|
|
|
|
|
paint.setStyle(SkPaint::kStroke_Style);
|
|
|
|
canvas->drawRect(kR, paint);
|
|
|
|
}
|
|
|
|
|
2018-01-16 22:04:30 +00:00
|
|
|
SkottieSlide::SkottieSlide(const SkString& name, const SkString& path)
|
2017-12-30 17:27:00 +00:00
|
|
|
: fPath(path) {
|
|
|
|
fName = name;
|
|
|
|
}
|
|
|
|
|
2018-02-09 16:15:32 +00:00
|
|
|
void SkottieSlide::load(SkScalar w, SkScalar h) {
|
2018-10-02 16:48:00 +00:00
|
|
|
class Logger final : public skottie::Logger {
|
|
|
|
public:
|
|
|
|
struct LogEntry {
|
|
|
|
SkString fMessage,
|
|
|
|
fJSON;
|
|
|
|
};
|
|
|
|
|
|
|
|
void log(skottie::Logger::Level lvl, const char message[], const char json[]) override {
|
|
|
|
auto& log = lvl == skottie::Logger::Level::kError ? fErrors : fWarnings;
|
|
|
|
log.push_back({ SkString(message), json ? SkString(json) : SkString() });
|
|
|
|
}
|
|
|
|
|
|
|
|
void report() const {
|
|
|
|
SkDebugf("Animation loaded with %lu error%s, %lu warning%s.\n",
|
|
|
|
fErrors.size(), fErrors.size() == 1 ? "" : "s",
|
|
|
|
fWarnings.size(), fWarnings.size() == 1 ? "" : "s");
|
|
|
|
|
|
|
|
const auto& show = [](const LogEntry& log, const char prefix[]) {
|
|
|
|
SkDebugf("%s%s", prefix, log.fMessage.c_str());
|
|
|
|
if (!log.fJSON.isEmpty())
|
|
|
|
SkDebugf(" : %s", log.fJSON.c_str());
|
|
|
|
SkDebugf("\n");
|
|
|
|
};
|
|
|
|
|
|
|
|
for (const auto& err : fErrors) show(err, " !! ");
|
|
|
|
for (const auto& wrn : fWarnings) show(wrn, " ?? ");
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
std::vector<LogEntry> fErrors,
|
|
|
|
fWarnings;
|
|
|
|
};
|
|
|
|
|
|
|
|
auto logger = sk_make_sp<Logger>();
|
2018-08-23 00:37:04 +00:00
|
|
|
skottie::Animation::Builder builder;
|
2018-10-02 16:48:00 +00:00
|
|
|
|
2018-11-09 21:19:44 +00:00
|
|
|
fAnimation = builder
|
|
|
|
.setLogger(logger)
|
|
|
|
.setResourceProvider(
|
|
|
|
skottie_utils::FileResourceProvider::Make(SkOSPath::Dirname(fPath.c_str())))
|
|
|
|
.makeFromFile(fPath.c_str());
|
2018-08-23 00:37:04 +00:00
|
|
|
fAnimationStats = builder.getStats();
|
|
|
|
fWinSize = SkSize::Make(w, h);
|
|
|
|
fTimeBase = 0; // force a time reset
|
2017-12-30 17:27:00 +00:00
|
|
|
|
|
|
|
if (fAnimation) {
|
2018-01-09 20:51:21 +00:00
|
|
|
fAnimation->setShowInval(fShowAnimationInval);
|
2018-10-02 16:48:00 +00:00
|
|
|
SkDebugf("Loaded Bodymovin animation v: %s, size: [%f %f]\n",
|
2017-12-30 17:27:00 +00:00
|
|
|
fAnimation->version().c_str(),
|
|
|
|
fAnimation->size().width(),
|
2018-05-31 20:45:29 +00:00
|
|
|
fAnimation->size().height());
|
2018-10-02 16:48:00 +00:00
|
|
|
logger->report();
|
2017-12-30 17:27:00 +00:00
|
|
|
} else {
|
|
|
|
SkDebugf("failed to load Bodymovin animation: %s\n", fPath.c_str());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-16 22:04:30 +00:00
|
|
|
void SkottieSlide::unload() {
|
2017-12-30 17:27:00 +00:00
|
|
|
fAnimation.reset();
|
|
|
|
}
|
|
|
|
|
2018-01-16 22:04:30 +00:00
|
|
|
SkISize SkottieSlide::getDimensions() const {
|
2018-02-09 16:15:32 +00:00
|
|
|
// We always scale to fill the window.
|
|
|
|
return fWinSize.toCeil();
|
2017-12-30 17:27:00 +00:00
|
|
|
}
|
|
|
|
|
2018-01-16 22:04:30 +00:00
|
|
|
void SkottieSlide::draw(SkCanvas* canvas) {
|
2017-12-30 17:27:00 +00:00
|
|
|
if (fAnimation) {
|
2018-01-02 19:37:37 +00:00
|
|
|
SkAutoCanvasRestore acr(canvas, true);
|
2018-02-09 16:15:32 +00:00
|
|
|
const auto dstR = SkRect::MakeSize(fWinSize);
|
2018-01-08 13:25:27 +00:00
|
|
|
fAnimation->render(canvas, &dstR);
|
2018-04-30 14:32:18 +00:00
|
|
|
|
|
|
|
if (fShowAnimationStats) {
|
|
|
|
draw_stats_box(canvas, fAnimationStats);
|
|
|
|
}
|
2017-12-30 17:27:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-07-11 20:32:53 +00:00
|
|
|
bool SkottieSlide::animate(double nanos) {
|
|
|
|
SkMSec msec = TimeUtils::NanosToMSec(nanos);
|
2017-12-30 17:27:00 +00:00
|
|
|
if (fTimeBase == 0) {
|
|
|
|
// Reset the animation time.
|
2019-07-11 20:32:53 +00:00
|
|
|
fTimeBase = msec;
|
2017-12-30 17:27:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (fAnimation) {
|
2019-07-11 20:32:53 +00:00
|
|
|
const auto t = msec - fTimeBase;
|
2018-05-29 17:46:54 +00:00
|
|
|
const auto d = fAnimation->duration() * 1000;
|
|
|
|
fAnimation->seek(std::fmod(t, d) / d);
|
2017-12-30 17:27:00 +00:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-01-16 22:04:30 +00:00
|
|
|
bool SkottieSlide::onChar(SkUnichar c) {
|
2017-12-30 17:27:00 +00:00
|
|
|
switch (c) {
|
|
|
|
case 'I':
|
2018-04-30 14:32:18 +00:00
|
|
|
fShowAnimationStats = !fShowAnimationStats;
|
2017-12-30 17:27:00 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return INHERITED::onChar(c);
|
|
|
|
}
|
2018-02-20 21:49:20 +00:00
|
|
|
|
2019-07-08 20:07:57 +00:00
|
|
|
bool SkottieSlide::onMouse(SkScalar x, SkScalar y, sk_app::Window::InputState state, ModifierKey) {
|
2018-02-20 21:49:20 +00:00
|
|
|
switch (state) {
|
|
|
|
case sk_app::Window::kUp_InputState:
|
|
|
|
fShowAnimationInval = !fShowAnimationInval;
|
2018-04-30 14:32:18 +00:00
|
|
|
fShowAnimationStats = !fShowAnimationStats;
|
2018-02-20 21:49:20 +00:00
|
|
|
fAnimation->setShowInval(fShowAnimationInval);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2018-02-21 18:03:41 +00:00
|
|
|
return false;
|
2018-02-20 21:49:20 +00:00
|
|
|
}
|
2018-05-26 13:49:28 +00:00
|
|
|
|
|
|
|
#endif // SK_ENABLE_SKOTTIE
|