| /* |
| * 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/codec/SkCodec.h" |
| #include "include/core/SkCanvas.h" |
| #include "include/core/SkFontMgr.h" |
| #include "include/core/SkImage.h" |
| #include "include/core/SkStream.h" |
| #include "include/core/SkString.h" |
| #include "include/core/SkTypes.h" |
| #include "include/private/base/SkOnce.h" |
| #include "modules/canvaskit/WasmCommon.h" |
| #include "modules/skottie/include/Skottie.h" |
| #include "modules/skottie/include/SkottieProperty.h" |
| #include "modules/skottie/include/SlotManager.h" |
| #include "modules/skottie/utils/SkottieUtils.h" |
| #include "modules/skottie/utils/TextEditor.h" |
| #include "modules/skparagraph/include/Paragraph.h" |
| #include "modules/skresources/include/SkResources.h" |
| #include "modules/sksg/include/SkSGInvalidationController.h" |
| #include "modules/skshaper/utils/FactoryHelpers.h" |
| #include "modules/skunicode/include/SkUnicode.h" |
| #include "src/base/SkUTF.h" |
| #include "src/ports/SkTypeface_FreeType.h" |
| #include "tools/skui/InputState.h" |
| #include "tools/skui/ModifierKey.h" |
| |
| #include <string> |
| #include <vector> |
| #include <emscripten.h> |
| #include <emscripten/bind.h> |
| |
| #if defined(SK_CODEC_DECODES_GIF) |
| #include "include/codec/SkGifDecoder.h" |
| #endif |
| #if defined(SK_CODEC_DECODES_JPEG) |
| #include "include/codec/SkJpegDecoder.h" |
| #endif |
| #if defined(SK_CODEC_DECODES_PNG) |
| #include "include/codec/SkPngDecoder.h" |
| #endif |
| #if defined(SK_CODEC_DECODES_WEBP) |
| #include "include/codec/SkWebpDecoder.h" |
| #endif |
| |
| #if !defined(CK_NO_FONTS) |
| #include "include/ports/SkFontMgr_empty.h" |
| #endif |
| |
| using namespace emscripten; |
| namespace para = skia::textlayout; |
| namespace { |
| |
| struct SimpleSlottableTextProperty { |
| sk_sp<SkTypeface> typeface; |
| std::string text; |
| |
| float textSize; |
| float minTextSize; |
| float maxTextSize; |
| float strokeWidth; |
| float lineHeight; |
| float lineShift; |
| float ascent; |
| float maxLines; |
| |
| para::TextAlign horizAlign; |
| skottie::Shaper::VAlign vertAlign; |
| skottie::Shaper::ResizePolicy resize; |
| SkUnicode::LineBreakType lineBreak; |
| para::TextDirection direction; |
| SkPaint::Join strokeJoin; |
| |
| WASMPointerF32 boundingBoxPtr; |
| WASMPointerF32 fillColorPtr; |
| WASMPointerF32 strokeColorPtr; |
| |
| operator skottie::TextPropertyValue() const { |
| skottie::TextPropertyValue textProperty; |
| |
| textProperty.fTypeface = this->typeface; |
| textProperty.fText = SkString(this->text); |
| textProperty.fTextSize = this->textSize; |
| textProperty.fMinTextSize = this->minTextSize; |
| textProperty.fMaxTextSize = this->maxTextSize; |
| textProperty.fStrokeWidth = this->strokeWidth; |
| textProperty.fLineHeight = this->lineHeight; |
| textProperty.fLineShift = this->lineShift; |
| textProperty.fAscent = this->ascent; |
| textProperty.fMaxLines = this->maxLines; |
| |
| switch (this->horizAlign) { |
| case para::TextAlign::kLeft: |
| textProperty.fHAlign = SkTextUtils::Align::kLeft_Align; |
| break; |
| case para::TextAlign::kCenter: |
| textProperty.fHAlign = SkTextUtils::Align::kCenter_Align; |
| break; |
| case para::TextAlign::kRight: |
| textProperty.fHAlign = SkTextUtils::Align::kRight_Align; |
| break; |
| default: |
| textProperty.fHAlign = SkTextUtils::Align::kLeft_Align; |
| break; |
| } |
| |
| textProperty.fVAlign = this->vertAlign; |
| textProperty.fResize = this->resize; |
| |
| if (this->lineBreak == SkUnicode::LineBreakType::kSoftLineBreak) { |
| textProperty.fLineBreak = skottie::Shaper::LinebreakPolicy::kParagraph; |
| } else { |
| textProperty.fLineBreak = skottie::Shaper::LinebreakPolicy::kExplicit; |
| } |
| |
| if (this->direction == para::TextDirection::kRtl) { |
| textProperty.fDirection = skottie::Shaper::Direction::kRTL; |
| } else { |
| textProperty.fDirection = skottie::Shaper::Direction::kLTR; |
| } |
| |
| textProperty.fStrokeJoin = this->strokeJoin; |
| |
| textProperty.fBox = reinterpret_cast<SkRect*>(this->boundingBoxPtr)[0]; |
| textProperty.fFillColor = ptrToSkColor4f(this->fillColorPtr).toSkColor(); |
| textProperty.fStrokeColor = ptrToSkColor4f(this->strokeColorPtr).toSkColor(); |
| |
| return textProperty; |
| } |
| }; |
| |
| // WebTrack wraps a JS object that has a 'seek' method. |
| // Playback logic is kept there. |
| class WebTrack final : public skresources::ExternalTrackAsset { |
| public: |
| explicit WebTrack(emscripten::val player) : fPlayer(std::move(player)) {} |
| |
| private: |
| void seek(float t) override { |
| fPlayer.call<void>("seek", val(t)); |
| } |
| |
| const emscripten::val fPlayer; |
| }; |
| |
| 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, emscripten::val soundMap) { |
| return sk_sp<SkottieAssetProvider>(new SkottieAssetProvider(std::move(assets), |
| std::move(soundMap))); |
| } |
| |
| 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)) { |
| auto codec = DecodeImageData(data); |
| if (!codec) { |
| return nullptr; |
| } |
| return skresources::MultiFrameImageAsset::Make(std::move(codec)); |
| } |
| |
| return nullptr; |
| } |
| |
| sk_sp<skresources::ExternalTrackAsset> loadAudioAsset(const char[] /* path */, |
| const char[] /* name */, |
| const char id[]) override { |
| emscripten::val player = this->findSoundAsset(id); |
| if (player.as<bool>()) { |
| return sk_make_sp<WebTrack>(std::move(player)); |
| } |
| |
| return nullptr; |
| } |
| |
| sk_sp<SkTypeface> loadTypeface(const char name[], const char[] /* url */) const override { |
| sk_sp<SkData> faceData = this->findAsset(name); |
| if (!faceData) { |
| return nullptr; |
| } |
| auto stream = std::make_unique<SkMemoryStream>(faceData); |
| return SkTypeface_FreeType::MakeFromStream(std::move(stream), SkFontArguments()); |
| } |
| |
| sk_sp<SkData> load(const char[]/*path*/, const char name[]) const override { |
| // Ignore paths. |
| return this->findAsset(name); |
| } |
| |
| private: |
| explicit SkottieAssetProvider(AssetVec assets, emscripten::val soundMap) |
| : fAssets(std::move(assets)) |
| , fSoundMap(std::move(soundMap)) {} |
| |
| 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; |
| } |
| |
| emscripten::val findSoundAsset(const char name[]) const { |
| if (fSoundMap.as<bool>() && fSoundMap.hasOwnProperty("getPlayer")) { |
| emscripten::val player = fSoundMap.call<emscripten::val>("getPlayer", val(name)); |
| if (player.as<bool>() && player.hasOwnProperty("seek")) { |
| return player; |
| } |
| } |
| return emscripten::val::null(); |
| } |
| |
| const AssetVec fAssets; |
| const emscripten::val fSoundMap; |
| }; |
| |
| // Wraps a JS object with 'onError' and 'onWarning' methods. |
| class JSLogger final : public skottie::Logger { |
| public: |
| static sk_sp<JSLogger> Make(emscripten::val logger) { |
| return logger.as<bool>() |
| && logger.hasOwnProperty(kWrnFunc) |
| && logger.hasOwnProperty(kErrFunc) |
| ? sk_sp<JSLogger>(new JSLogger(std::move(logger))) |
| : nullptr; |
| } |
| |
| private: |
| explicit JSLogger(emscripten::val logger) : fLogger(std::move(logger)) {} |
| |
| void log(Level lvl, const char msg[], const char* json) override { |
| const auto* func = lvl == Level::kError ? kErrFunc : kWrnFunc; |
| fLogger.call<void>(func, std::string(msg), std::string(json)); |
| } |
| |
| inline static constexpr char kWrnFunc[] = "onWarning", |
| kErrFunc[] = "onError"; |
| |
| const emscripten::val fLogger; |
| }; |
| |
| class ManagedAnimation final : public SkRefCnt { |
| public: |
| static sk_sp<ManagedAnimation> Make(const std::string& json, |
| sk_sp<skottie::ResourceProvider> rp, |
| std::string prop_prefix, |
| emscripten::val logger) { |
| auto mgr = std::make_unique<skottie_utils::CustomPropertyManager>( |
| skottie_utils::CustomPropertyManager::Mode::kCollapseProperties, |
| prop_prefix.c_str()); |
| static constexpr char kInterceptPrefix[] = "__"; |
| auto pinterceptor = |
| sk_make_sp<skottie_utils::ExternalAnimationPrecompInterceptor>(rp, kInterceptPrefix); |
| skottie::Animation::Builder builder; |
| builder.setMarkerObserver(mgr->getMarkerObserver()) |
| .setPropertyObserver(mgr->getPropertyObserver()) |
| .setResourceProvider(rp) |
| .setPrecompInterceptor(std::move(pinterceptor)) |
| .setTextShapingFactory(SkShapers::BestAvailable()) |
| .setLogger(JSLogger::Make(std::move(logger))); |
| auto animation = builder.make(json.c_str(), json.size()); |
| auto slotManager = builder.getSlotManager(); |
| |
| return animation |
| ? sk_sp<ManagedAnimation>(new ManagedAnimation(std::move(animation), std::move(mgr), |
| std::move(slotManager), std::move(rp))) |
| : 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; |
| } |
| |
| JSArray getTextProps() const { |
| JSArray props = emscripten::val::array(); |
| |
| for (const auto& key : fPropMgr->getTextProps()) { |
| const auto txt = fPropMgr->getText(key); |
| JSObject txt_val = emscripten::val::object(); |
| txt_val.set("text", txt.fText.c_str()); |
| txt_val.set("size", txt.fTextSize); |
| |
| JSObject prop = emscripten::val::object(); |
| prop.set("key", key); |
| prop.set("value", std::move(txt_val)); |
| |
| props.call<void>("push", prop); |
| } |
| |
| return props; |
| } |
| |
| JSArray getTransformProps() const { |
| JSArray props = emscripten::val::array(); |
| |
| for (const auto& key : fPropMgr->getTransformProps()) { |
| const auto transform = fPropMgr->getTransform(key); |
| JSObject trans_val = emscripten::val::object(); |
| const float anchor[] = {transform.fAnchorPoint.fX, transform.fAnchorPoint.fY}; |
| const float position[] = {transform.fPosition.fX, transform.fPosition.fY}; |
| const float scale[] = {transform.fScale.fX, transform.fScale.fY}; |
| trans_val.set("anchor", MakeTypedArray(2, anchor)); |
| trans_val.set("position", MakeTypedArray(2, position)); |
| trans_val.set("scale", MakeTypedArray(2, scale)); |
| trans_val.set("rotation", transform.fRotation); |
| trans_val.set("skew", transform.fSkew); |
| trans_val.set("skew_axis", transform.fSkewAxis); |
| |
| JSObject prop = emscripten::val::object(); |
| prop.set("key", key); |
| prop.set("value", trans_val); |
| 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); |
| } |
| |
| bool setText(const std::string& key, std::string text, float size) { |
| // preserve all other text fields |
| auto t = fPropMgr->getText(key); |
| |
| t.fText = SkString(text); |
| t.fTextSize = size; |
| |
| return fPropMgr->setText(key, t); |
| } |
| |
| bool setTransform(const std::string& key, SkScalar anchorX, SkScalar anchorY, |
| SkScalar posX, SkScalar posY, |
| SkScalar scaleX, SkScalar scaleY, |
| SkScalar rotation, SkScalar skew, SkScalar skewAxis) { |
| skottie::TransformPropertyValue transform; |
| transform.fAnchorPoint = {anchorX, anchorY}; |
| transform.fPosition = {posX, posY}; |
| transform.fScale = {scaleX, scaleY}; |
| transform.fRotation = rotation; |
| transform.fSkew = skew; |
| transform.fSkewAxis = skewAxis; |
| return fPropMgr->setTransform(key, transform); |
| } |
| |
| 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; |
| } |
| |
| JSArray copyStringArrayToJSArray(skia_private::TArray<SkString> slotIDs) const { |
| JSArray retVal = emscripten::val::array(); |
| for (auto slotID : slotIDs) { |
| retVal.call<void>("push", emscripten::val(slotID.c_str())); |
| } |
| return retVal; |
| } |
| |
| // Slot Manager API |
| JSObject getSlotInfo() const { |
| JSObject slotInfoJS = emscripten::val::object(); |
| auto slotInfo = fSlotMgr->getSlotInfo(); |
| |
| slotInfoJS.set("colorSlotIDs", copyStringArrayToJSArray(slotInfo.fColorSlotIDs)); |
| slotInfoJS.set("scalarSlotIDs", copyStringArrayToJSArray(slotInfo.fScalarSlotIDs)); |
| slotInfoJS.set("vec2SlotIDs", copyStringArrayToJSArray(slotInfo.fVec2SlotIDs)); |
| slotInfoJS.set("imageSlotIDs", copyStringArrayToJSArray(slotInfo.fImageSlotIDs)); |
| slotInfoJS.set("textSlotIDs", copyStringArrayToJSArray(slotInfo.fTextSlotIDs)); |
| |
| return slotInfoJS; |
| } |
| |
| void getColorSlot(const std::string& slotID, WASMPointerF32 outPtr) { |
| SkColor4f c4f; |
| if (auto c = fSlotMgr->getColorSlot(SkString(slotID))) { |
| c4f = SkColor4f::FromColor(*c); |
| } else { |
| c4f = {-1, -1, -1, -1}; |
| } |
| memcpy(reinterpret_cast<float*>(outPtr), &c4f, 4 * sizeof(float)); |
| } |
| |
| emscripten::val getScalarSlot(const std::string& slotID) { |
| if (auto s = fSlotMgr->getScalarSlot(SkString(slotID))) { |
| return emscripten::val(*s); |
| } |
| return emscripten::val::null(); |
| } |
| |
| void getVec2Slot(const std::string& slotID, WASMPointerF32 outPtr) { |
| // [x, y, sentinel] |
| SkV3 vec3; |
| if (auto v = fSlotMgr->getVec2Slot(SkString(slotID))) { |
| vec3 = {v->x, v->y, 1}; |
| } else { |
| vec3 = {0, 0, -1}; |
| } |
| memcpy(reinterpret_cast<float*>(outPtr), vec3.ptr(), 3 * sizeof(float)); |
| } |
| |
| JSObject getTextSlot(const std::string& slotID) const { |
| if (auto textProp = fSlotMgr->getTextSlot(SkString(slotID))){ |
| JSObject text_val = emscripten::val::object(); |
| |
| text_val.set("typeface", textProp->fTypeface); |
| text_val.set("text", emscripten::val(textProp->fText.c_str())); |
| text_val.set("textSize", textProp->fTextSize); |
| text_val.set("minTextSize", textProp->fMinTextSize); |
| text_val.set("maxTextSize", textProp->fMaxTextSize); |
| text_val.set("strokeWidth", textProp->fStrokeWidth); |
| text_val.set("lineHeight", textProp->fLineHeight); |
| text_val.set("lineShift", textProp->fLineShift); |
| text_val.set("ascent", textProp->fAscent); |
| text_val.set("maxLines", textProp->fMaxLines); |
| |
| switch (textProp->fHAlign) { |
| case SkTextUtils::Align::kLeft_Align: |
| text_val.set("horizAlign", para::TextAlign::kLeft); |
| break; |
| case SkTextUtils::Align::kRight_Align: |
| text_val.set("horizAlign", para::TextAlign::kRight); |
| break; |
| case SkTextUtils::Align::kCenter_Align: |
| text_val.set("horizAlign", para::TextAlign::kCenter); |
| break; |
| default: |
| text_val.set("horizAlign", para::TextAlign::kLeft); |
| break; |
| } |
| |
| text_val.set("vertAlign", textProp->fVAlign); |
| text_val.set("resize", textProp->fResize); |
| |
| if (textProp->fLineBreak == skottie::Shaper::LinebreakPolicy::kParagraph) { |
| text_val.set("linebreak", SkUnicode::LineBreakType::kSoftLineBreak); |
| } else { |
| text_val.set("linebreak", SkUnicode::LineBreakType::kHardLineBreak); |
| } |
| |
| if (textProp->fDirection == skottie::Shaper::Direction::kLTR) { |
| text_val.set("direction", para::TextDirection::kLtr); |
| } else { |
| text_val.set("direction", para::TextDirection::kRtl); |
| } |
| text_val.set("strokeJoin", textProp->fStrokeJoin); |
| |
| text_val.set("fillColor", MakeTypedArray(4, SkColor4f::FromColor(textProp->fFillColor) |
| .vec())); |
| |
| text_val.set("strokeColor", MakeTypedArray(4, SkColor4f::FromColor(textProp->fStrokeColor) |
| .vec())); |
| |
| const float box[] = {textProp->fBox.fLeft, textProp->fBox.fTop, |
| textProp->fBox.fRight, textProp->fBox.fBottom}; |
| text_val.set("boundingBox", MakeTypedArray(4, box)); |
| return text_val; |
| } |
| return emscripten::val::null(); |
| } |
| |
| bool setImageSlot(const std::string& slotID, const std::string& assetName) { |
| // look for resource in preloaded SkottieAssetProvider |
| return fSlotMgr->setImageSlot(SkString(slotID), fResourceProvider->loadImageAsset(nullptr, |
| assetName.data(), |
| nullptr)); |
| } |
| |
| bool setColorSlot(const std::string& slotID, SkColor c) { |
| return fSlotMgr->setColorSlot(SkString(slotID), c); |
| } |
| |
| bool setScalarSlot(const std::string& slotID, float s) { |
| return fSlotMgr->setScalarSlot(SkString(slotID), s); |
| } |
| |
| bool setVec2Slot(const std::string& slotID, SkV2 v) { |
| return fSlotMgr->setVec2Slot(SkString(slotID), v); |
| } |
| |
| bool attachEditor(const std::string& layerID, size_t layerIndex) { |
| if (fTextEditor) { |
| fTextEditor->setEnabled(false); |
| fTextEditor = nullptr; |
| } |
| |
| if (layerID.empty()) { |
| return true; |
| } |
| |
| auto txt_handle = fPropMgr->getTextHandle(layerID, layerIndex); |
| if (!txt_handle) { |
| return false; |
| } |
| |
| std::vector<std::unique_ptr<skottie::TextPropertyHandle>> deps; |
| for (size_t i = 0; ; ++i) { |
| if (i == layerIndex) { |
| continue; |
| } |
| |
| auto dep_handle = fPropMgr->getTextHandle(layerID, i); |
| if (!dep_handle) { |
| break; |
| } |
| deps.push_back(std::move(dep_handle)); |
| } |
| |
| fTextEditor = sk_make_sp<skottie_utils::TextEditor>(std::move(txt_handle), |
| std::move(deps)); |
| return true; |
| } |
| |
| void enableEditor(bool enable) { |
| if (fTextEditor) { |
| fTextEditor->setEnabled(enable); |
| } |
| } |
| |
| bool dispatchEditorKey(const std::string& key) { |
| // Map some useful keys to the current (odd) text editor bindings. |
| // TODO: Add support for custom bindings in the editor. |
| auto key2char = [](const std::string& key) -> SkUnichar { |
| // Special keys. |
| if (key == "ArrowLeft") return '['; |
| if (key == "ArrowRight") return ']'; |
| if (key == "Backspace") return '\\'; |
| |
| const char* str = key.c_str(); |
| const char* end = str + key.size(); |
| const SkUnichar uch = SkUTF::NextUTF8(&str, end); |
| |
| // Pass through single code points, ignore everything else. |
| return str == end ? uch : -1; |
| }; |
| |
| if (fTextEditor) { |
| const auto uch = key2char(key); |
| if (uch != -1) { |
| return fTextEditor->onCharInput(uch); |
| } |
| } |
| |
| return false; |
| } |
| |
| bool dispatchEditorPointer(float x, float y, skui::InputState state, skui::ModifierKey mod) { |
| return fTextEditor |
| ? fTextEditor->onMouseInput(x, y, state, mod) |
| : false; |
| } |
| |
| void setEditorCursorWeight(float w) { |
| if (fTextEditor) { |
| fTextEditor->setCursorWeight(w); |
| } |
| } |
| |
| bool setTextSlot(const std::string& slotID, SimpleSlottableTextProperty t) { |
| return fSlotMgr->setTextSlot(SkString(slotID), t); |
| } |
| |
| private: |
| ManagedAnimation(sk_sp<skottie::Animation> animation, |
| std::unique_ptr<skottie_utils::CustomPropertyManager> propMgr, |
| sk_sp<skottie::SlotManager> slotMgr, |
| sk_sp<skresources::ResourceProvider> rp) |
| : fAnimation(std::move(animation)) |
| , fPropMgr(std::move(propMgr)) |
| , fSlotMgr(std::move(slotMgr)) |
| , fResourceProvider(std::move(rp)) |
| {} |
| |
| const sk_sp<skottie::Animation> fAnimation; |
| const std::unique_ptr<skottie_utils::CustomPropertyManager> fPropMgr; |
| const sk_sp<skottie::SlotManager> fSlotMgr; |
| const sk_sp<skresources::ResourceProvider> fResourceProvider; |
| |
| sk_sp<skottie_utils::TextEditor> fTextEditor; |
| }; |
| |
| } // anonymous ns |
| |
| 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", optional_override([](skottie::Animation& self, |
| WASMPointerF32 oPtr)->void { |
| SkSize* output = reinterpret_cast<SkSize*>(oPtr); |
| *output = self.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, |
| WASMPointerF32 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); |
| |
| class_<ManagedAnimation>("ManagedAnimation") |
| .smart_ptr<sk_sp<ManagedAnimation>>("sk_sp<ManagedAnimation>") |
| .function("version" , &ManagedAnimation::version) |
| .function("_size", optional_override([](ManagedAnimation& self, |
| WASMPointerF32 oPtr)->void { |
| SkSize* output = reinterpret_cast<SkSize*>(oPtr); |
| *output = self.size(); |
| })) |
| .function("duration" , &ManagedAnimation::duration) |
| .function("fps" , &ManagedAnimation::fps) |
| .function("_render", optional_override([](ManagedAnimation& self, SkCanvas* canvas, |
| WASMPointerF32 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, |
| WASMPointerF32 fPtr) { |
| SkRect* damageRect = reinterpret_cast<SkRect*>(fPtr); |
| damageRect[0] = self.seek(t); |
| })) |
| .function("_seekFrame", optional_override([](ManagedAnimation& self, double frame, |
| WASMPointerF32 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, WASMPointerF32 cPtr) { |
| float* fourFloats = reinterpret_cast<float*>(cPtr); |
| SkColor4f color = { fourFloats[0], fourFloats[1], fourFloats[2], fourFloats[3] }; |
| return self.setColor(key, color.toSkColor()); |
| })) |
| .function("_setTransform" , optional_override([](ManagedAnimation& self, |
| const std::string& key, |
| WASMPointerF32 transformData) { |
| // transform value info is passed in as an array of 9 scalars in the following order: |
| // anchor xy, position xy, scalexy, rotation, skew, skew axis |
| auto transform = reinterpret_cast<SkScalar*>(transformData); |
| return self.setTransform(key, transform[0], transform[1], transform[2], transform[3], |
| transform[4], transform[5], transform[6], transform[7], transform[8]); |
| })) |
| .function("getMarkers" , &ManagedAnimation::getMarkers) |
| .function("getColorProps" , &ManagedAnimation::getColorProps) |
| .function("getOpacityProps" , &ManagedAnimation::getOpacityProps) |
| .function("setOpacity" , &ManagedAnimation::setOpacity) |
| .function("getTextProps" , &ManagedAnimation::getTextProps) |
| .function("setText" , &ManagedAnimation::setText) |
| .function("getTransformProps", &ManagedAnimation::getTransformProps) |
| .function("getSlotInfo" , &ManagedAnimation::getSlotInfo) |
| .function("_getColorSlot" , &ManagedAnimation::getColorSlot) |
| .function("_setColorSlot" , optional_override([](ManagedAnimation& self, const std::string& key, WASMPointerF32 cPtr) { |
| SkColor4f color = ptrToSkColor4f(cPtr); |
| return self.setColorSlot(key, color.toSkColor()); |
| })) |
| .function("_getVec2Slot" , &ManagedAnimation::getVec2Slot) |
| .function("_setVec2Slot" , optional_override([](ManagedAnimation& self, const std::string& key, WASMPointerF32 vPtr) { |
| float* twoFloats = reinterpret_cast<float*>(vPtr); |
| SkV2 vec2 = {twoFloats[0], twoFloats[1]}; |
| return self.setVec2Slot(key, vec2); |
| })) |
| .function("getScalarSlot" , &ManagedAnimation::getScalarSlot) |
| .function("setScalarSlot" , &ManagedAnimation::setScalarSlot) |
| .function("attachEditor" , &ManagedAnimation::attachEditor) |
| .function("enableEditor" , &ManagedAnimation::enableEditor) |
| .function("dispatchEditorKey" , &ManagedAnimation::dispatchEditorKey) |
| .function("dispatchEditorPointer", &ManagedAnimation::dispatchEditorPointer) |
| .function("setEditorCursorWeight", &ManagedAnimation::setEditorCursorWeight) |
| .function("getTextSlot" , &ManagedAnimation::getTextSlot) |
| .function("_setTextSlot" , &ManagedAnimation::setTextSlot) |
| .function("setImageSlot" , &ManagedAnimation::setImageSlot); |
| |
| function("_MakeManagedAnimation", optional_override([](std::string json, |
| size_t assetCount, |
| WASMPointerU32 nptr, |
| WASMPointerU32 dptr, |
| WASMPointerU32 sptr, |
| std::string prop_prefix, |
| emscripten::val soundMap, |
| emscripten::val logger) |
| ->sk_sp<ManagedAnimation> { |
| 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))); |
| } |
| |
| // DataURIResourceProviderProxy needs codecs registered to try to process Base64 encoded |
| // images. |
| static SkOnce once; |
| once([] { |
| #if defined(SK_CODEC_DECODES_PNG) |
| SkCodecs::Register(SkPngDecoder::Decoder()); |
| #endif |
| #if defined(SK_CODEC_DECODES_JPEG) |
| SkCodecs::Register(SkJpegDecoder::Decoder()); |
| #endif |
| #if defined(SK_CODEC_DECODES_GIF) |
| SkCodecs::Register(SkGifDecoder::Decoder()); |
| #endif |
| #if defined(SK_CODEC_DECODES_WEBP) |
| SkCodecs::Register(SkWebpDecoder::Decoder()); |
| #endif |
| }); |
| |
| sk_sp<SkFontMgr> fontmgr; |
| #if !defined(CK_NO_FONTS) |
| fontmgr = SkFontMgr_New_Custom_Empty(); |
| #endif |
| |
| return ManagedAnimation::Make(json, |
| skresources::DataURIResourceProviderProxy::Make( |
| SkottieAssetProvider::Make(std::move(assets), |
| std::move(soundMap)), |
| skresources::ImageDecodeStrategy::kPreDecode, |
| std::move(fontmgr)), |
| prop_prefix, std::move(logger)); |
| })); |
| |
| enum_<skui::InputState>("InputState") |
| .value("Down", skui::InputState::kDown) |
| .value("Up", skui::InputState::kUp) |
| .value("Move", skui::InputState::kMove) |
| .value("Right", skui::InputState::kRight) |
| .value("Left", skui::InputState::kLeft); |
| |
| enum_<skui::ModifierKey>("ModifierKey") |
| .value("None", skui::ModifierKey::kNone) |
| .value("Shift", skui::ModifierKey::kShift) |
| .value("Control", skui::ModifierKey::kControl) |
| .value("Option", skui::ModifierKey::kOption) |
| .value("Command", skui::ModifierKey::kCommand) |
| .value("FirstPress", skui::ModifierKey::kFirstPress); |
| |
| enum_<skottie::Shaper::VAlign>("VerticalTextAlign") |
| .value("Top", skottie::Shaper::VAlign::kTop) |
| .value("TopBaseline", skottie::Shaper::VAlign::kTopBaseline) |
| .value("VisualTop", skottie::Shaper::VAlign::kVisualTop) |
| .value("VisualCenter", skottie::Shaper::VAlign::kVisualCenter) |
| .value("VisualBottom", skottie::Shaper::VAlign::kVisualBottom); |
| |
| enum_<skottie::Shaper::ResizePolicy>("ResizePolicy") |
| .value("None", skottie::Shaper::ResizePolicy::kNone) |
| .value("ScaleToFit", skottie::Shaper::ResizePolicy::kScaleToFit) |
| .value("DownscaleToFit", skottie::Shaper::ResizePolicy::kDownscaleToFit); |
| |
| value_object<SimpleSlottableTextProperty>("SlottableTextProperty") |
| .field("typeface", &SimpleSlottableTextProperty::typeface) |
| .field("text", &SimpleSlottableTextProperty::text) |
| .field("textSize", &SimpleSlottableTextProperty::textSize) |
| .field("minTextSize", &SimpleSlottableTextProperty::minTextSize) |
| .field("maxTextSize", &SimpleSlottableTextProperty::maxTextSize) |
| .field("strokeWidth", &SimpleSlottableTextProperty::strokeWidth) |
| .field("lineHeight", &SimpleSlottableTextProperty::lineHeight) |
| .field("lineShift", &SimpleSlottableTextProperty::lineShift) |
| .field("ascent", &SimpleSlottableTextProperty::ascent) |
| .field("maxLines", &SimpleSlottableTextProperty::maxLines) |
| .field("horizAlign", &SimpleSlottableTextProperty::horizAlign) |
| .field("vertAlign", &SimpleSlottableTextProperty::vertAlign) |
| .field("strokeJoin", &SimpleSlottableTextProperty::strokeJoin) |
| .field("direction", &SimpleSlottableTextProperty::direction) |
| .field("linebreak", &SimpleSlottableTextProperty::lineBreak) |
| .field("resize", &SimpleSlottableTextProperty::resize) |
| .field("_fillColorPtr", &SimpleSlottableTextProperty::fillColorPtr) |
| .field("_strokeColorPtr", &SimpleSlottableTextProperty::strokeColorPtr) |
| .field("_boundingBoxPtr", &SimpleSlottableTextProperty::boundingBoxPtr); |
| |
| constant("managed_skottie", true); |
| } |
