skottie_bindings.cpp File Reference

#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>
#include "include/ports/SkFontMgr_empty.h"

Go to the source code of this file.

Functions
	EMSCRIPTEN_BINDINGS (Skottie)

Function Documentation

EMSCRIPTEN_BINDINGS()

EMSCRIPTEN_BINDINGS

(

Skottie

)

Definition at line 656 of file skottie_bindings.cpp.

                             {
    // 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);
}