skia2/modules/skottie/gm/SkottieGM.cpp
Brian Salomon 9fa47cc1c6 Make class members that are static constexpr also be inline.
This is in prep for compiling with -std=c++14 and -Wno-c++17-extensions
when building with clang. Chrome has encountered problems with
third_party headers that are included both in Skia and other Chrome
sources that produce different code based on whether preprocessor macros
indicate a C++14 or C++17 compilation.

In C++17 they are already inline implicitly. When compiling with C++14
we can get linker errors unless they're explicitly inlined or defined
outside the class. With -Wno-c++17-extensions we can explicitly inline
them in the C++14 build because the warning that would be generated
about using a C++17 language extension is suppressed.

We cannot do this in public headers because we support compiling with
C++14 without suppressing the C++17 language extension warnings.

Bug: chromium:1257145
Change-Id: Iaf5f4c62a398f98dd4ca9b7dfb86f2d5cab21d66
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/457498
Reviewed-by: Ben Wagner <bungeman@google.com>
Reviewed-by: Herb Derby <herb@google.com>
Commit-Queue: Brian Salomon <bsalomon@google.com>
2021-10-11 16:22:59 +00:00

243 lines
7.1 KiB
C++

/*
* 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 "gm/gm.h"
#include "include/core/SkColor.h"
#include "include/utils/SkAnimCodecPlayer.h"
#include "modules/skottie/include/Skottie.h"
#include "modules/skottie/include/SkottieProperty.h"
#include "modules/skottie/utils/SkottieUtils.h"
#include "modules/skresources/include/SkResources.h"
#include "tools/Resources.h"
#include <cmath>
#include <vector>
namespace {
static constexpr char kWebFontResource[] = "fonts/Roboto-Regular.ttf";
static constexpr char kSkottieResource[] = "skottie/skottie_sample_webfont.json";
// Mock web font loader which serves a single local font (checked in under resources/).
class FakeWebFontProvider final : public skresources::ResourceProvider {
public:
FakeWebFontProvider()
: fTypeface(SkTypeface::MakeFromData(GetResourceAsData(kWebFontResource))) {}
sk_sp<SkTypeface> loadTypeface(const char[], const char[]) const override {
return fTypeface;
}
private:
sk_sp<SkTypeface> fTypeface;
using INHERITED = skresources::ResourceProvider;
};
} // namespace
class SkottieWebFontGM : public skiagm::GM {
public:
protected:
SkString onShortName() override {
return SkString("skottie_webfont");
}
SkISize onISize() override {
return SkISize::Make(kSize, kSize);
}
void onOnceBeforeDraw() override {
if (auto stream = GetResourceAsStream(kSkottieResource)) {
fAnimation = skottie::Animation::Builder()
.setResourceProvider(sk_make_sp<FakeWebFontProvider>())
.make(stream.get());
}
}
DrawResult onDraw(SkCanvas* canvas, SkString* errorMsg) override {
if (!fAnimation) {
*errorMsg = "No animation";
return DrawResult::kFail;
}
auto dest = SkRect::MakeWH(kSize, kSize);
fAnimation->render(canvas, &dest);
return DrawResult::kOk;
}
bool onAnimate(double nanos) override {
if (!fAnimation) {
return false;
}
const auto duration = fAnimation->duration();
fAnimation->seek(std::fmod(1e-9 * nanos, duration) / duration);
return true;
}
private:
inline static constexpr SkScalar kSize = 800;
sk_sp<skottie::Animation> fAnimation;
using INHERITED = skiagm::GM;
};
DEF_GM(return new SkottieWebFontGM;)
class SkottieColorizeGM : public skiagm::GM {
public:
SkottieColorizeGM(const char* name, const char* resource)
: fName(name)
, fResource(resource)
{}
protected:
SkString onShortName() override {
return SkStringPrintf("skottie_colorize_%s", fName);
}
SkISize onISize() override {
return SkISize::Make(kSize, kSize);
}
void onOnceBeforeDraw() override {
if (auto stream = GetResourceAsStream(fResource)) {
fPropManager = std::make_unique<skottie_utils::CustomPropertyManager>();
fAnimation = skottie::Animation::Builder()
.setPropertyObserver(fPropManager->getPropertyObserver())
.make(stream.get());
fColorProps = fPropManager->getColorProps();
fTextProps = fPropManager->getTextProps();
}
}
DrawResult onDraw(SkCanvas* canvas, SkString* errorMsg) override {
if (!fAnimation) {
*errorMsg = "No animation";
return DrawResult::kFail;
}
auto dest = SkRect::MakeWH(kSize, kSize);
fAnimation->render(canvas, &dest);
return DrawResult::kOk;
}
bool onAnimate(double nanos) override {
if (!fAnimation) {
return false;
}
const auto duration = fAnimation->duration();
fAnimation->seek(std::fmod(1e-9 * nanos, duration) / duration);
return true;
}
bool onChar(SkUnichar uni) override {
static constexpr SkColor kColors[] = {
SK_ColorBLACK,
SK_ColorRED,
SK_ColorGREEN,
SK_ColorYELLOW,
SK_ColorCYAN,
};
if (uni == 'c') {
fColorIndex = (fColorIndex + 1) % SK_ARRAY_COUNT(kColors);
for (const auto& prop : fColorProps) {
fPropManager->setColor(prop, kColors[fColorIndex]);
}
for (const auto& prop : fTextProps) {
auto txtval = fPropManager->getText(prop);
txtval.fFillColor = kColors[fColorIndex];
fPropManager->setText(prop, txtval);
}
return true;
}
return false;
}
private:
inline static constexpr SkScalar kSize = 800;
const char* fName;
const char* fResource;
sk_sp<skottie::Animation> fAnimation;
std::unique_ptr<skottie_utils::CustomPropertyManager> fPropManager;
std::vector<skottie_utils::CustomPropertyManager::PropKey> fColorProps,
fTextProps;
size_t fColorIndex = 0;
using INHERITED = skiagm::GM;
};
DEF_GM(return new SkottieColorizeGM("color", "skottie/skottie_sample_search.json");)
DEF_GM(return new SkottieColorizeGM("text" , "skottie/skottie-text-animator-5.json");)
class SkottieMultiFrameGM : public skiagm::GM {
public:
protected:
SkString onShortName() override {
return SkString("skottie_multiframe");
}
SkISize onISize() override {
return SkISize::Make(kSize, kSize);
}
void onOnceBeforeDraw() override {
if (auto stream = GetResourceAsStream("skottie/skottie_sample_multiframe.json")) {
fAnimation = skottie::Animation::Builder()
.setResourceProvider(sk_make_sp<MultiFrameResourceProvider>())
.make(stream.get());
fAnimation->seek(0);
}
}
DrawResult onDraw(SkCanvas* canvas, SkString* errorMsg) override {
if (!fAnimation) {
*errorMsg = "No animation";
return DrawResult::kFail;
}
auto dest = SkRect::MakeWH(kSize, kSize);
fAnimation->render(canvas, &dest);
return DrawResult::kOk;
}
bool onAnimate(double nanos) override {
if (!fAnimation) {
return false;
}
const auto duration = fAnimation->duration();
fAnimation->seek(std::fmod(1e-9 * nanos, duration) / duration);
return true;
}
private:
class MultiFrameResourceProvider final : public skresources::ResourceProvider {
public:
sk_sp<skresources::ImageAsset> loadImageAsset(const char[], const char[],
const char[]) const override {
return skresources::MultiFrameImageAsset::Make(
GetResourceAsData("images/flightAnim.gif"));
}
};
inline static constexpr SkScalar kSize = 800;
sk_sp<skottie::Animation> fAnimation;
using INHERITED = skiagm::GM;
};
DEF_GM(return new SkottieMultiFrameGM;)