| #include "rive/animation/animation.hpp" |
| #include "rive/animation/animation_state.hpp" |
| #include "rive/animation/any_state.hpp" |
| #include "rive/animation/entry_state.hpp" |
| #include "rive/animation/exit_state.hpp" |
| #include "rive/animation/linear_animation.hpp" |
| #include "rive/animation/linear_animation_instance.hpp" |
| #include "rive/animation/state_machine_bool.hpp" |
| #include "rive/animation/state_machine_input_instance.hpp" |
| #include "rive/animation/state_machine_instance.hpp" |
| #include "rive/animation/state_machine_number.hpp" |
| #include "rive/animation/state_machine_trigger.hpp" |
| #include "rive/artboard.hpp" |
| #include "rive/bones/bone.hpp" |
| #include "rive/bones/root_bone.hpp" |
| #include "rive/component.hpp" |
| #include "rive/constraints/constraint.hpp" |
| #include "rive/core.hpp" |
| #include "rive/core/binary_reader.hpp" |
| #include "rive/file.hpp" |
| #include "rive/layout.hpp" |
| #include "rive/math/mat2d.hpp" |
| #include "rive/node.hpp" |
| #include "rive/renderer.hpp" |
| #include "rive/shapes/cubic_vertex.hpp" |
| #include "rive/shapes/path.hpp" |
| #include "rive/transform_component.hpp" |
| |
| #include "js_alignment.hpp" |
| |
| #include <emscripten.h> |
| #include <emscripten/bind.h> |
| #include <emscripten/val.h> |
| #include <stdint.h> |
| #include <stdio.h> |
| #include <string> |
| #include <vector> |
| // #include <sanitizer/lsan_interface.h> |
| |
| using namespace emscripten; |
| |
| // We had to do this because binding the core class const defined types directly |
| // caused wasm-ld linker issues. See |
| // https://www.mail-archive.com/emscripten-discuss@googlegroups.com/msg09132.html |
| // for other people suffering our same pains. |
| const uint16_t stateMachineBoolTypeKey = rive::StateMachineBoolBase::typeKey; |
| |
| const uint16_t stateMachineNumberTypeKey = rive::StateMachineNumberBase::typeKey; |
| |
| const uint16_t stateMachineTriggerTypeKey = rive::StateMachineTriggerBase::typeKey; |
| |
| rive::Alignment convertAlignment(JsAlignment alignment) |
| { |
| switch (alignment) |
| { |
| case JsAlignment::topLeft: |
| return rive::Alignment::topLeft; |
| case JsAlignment::topCenter: |
| return rive::Alignment::topCenter; |
| case JsAlignment::topRight: |
| return rive::Alignment::topRight; |
| case JsAlignment::centerLeft: |
| return rive::Alignment::centerLeft; |
| case JsAlignment::center: |
| return rive::Alignment::center; |
| case JsAlignment::centerRight: |
| return rive::Alignment::centerRight; |
| case JsAlignment::bottomLeft: |
| return rive::Alignment::bottomLeft; |
| case JsAlignment::bottomCenter: |
| return rive::Alignment::bottomCenter; |
| case JsAlignment::bottomRight: |
| return rive::Alignment::bottomRight; |
| } |
| return rive::Alignment::center; |
| } |
| |
| rive::Mat2D computeAlignment(rive::Fit fit, JsAlignment alignment, rive::AABB orig, rive::AABB dest) |
| { |
| return rive::computeAlignment(fit, convertAlignment(alignment), orig, dest); |
| } |
| |
| rive::Vec2D mapXY(rive::Mat2D invertedMatrix, rive::Vec2D canvasVector) |
| { |
| return invertedMatrix * canvasVector; |
| } |
| |
| EMSCRIPTEN_KEEPALIVE |
| EMSCRIPTEN_BINDINGS(RiveWASM) |
| { |
| function("computeAlignment", &computeAlignment); |
| function("mapXY", &mapXY); |
| |
| #ifdef ENABLE_QUERY_FLAT_VERTICES |
| class_<rive::FlattenedPath>("FlattenedPath") |
| .function("length", optional_override([](rive::FlattenedPath& self) -> size_t { |
| return self.vertices().size(); |
| })) |
| .function("isCubic", optional_override([](rive::FlattenedPath& self, size_t index) -> bool { |
| if (index >= self.vertices().size()) |
| { |
| return false; |
| } |
| return self.vertices()[index]->is<rive::CubicVertex>(); |
| })) |
| .function("x", optional_override([](rive::FlattenedPath& self, size_t index) -> float { |
| return self.vertices()[index]->x(); |
| })) |
| .function("y", optional_override([](rive::FlattenedPath& self, size_t index) -> float { |
| return self.vertices()[index]->y(); |
| })) |
| .function("inX", optional_override([](rive::FlattenedPath& self, size_t index) -> float { |
| return self.vertices()[index]->as<rive::CubicVertex>()->renderIn()[0]; |
| })) |
| .function("inY", optional_override([](rive::FlattenedPath& self, size_t index) -> float { |
| return self.vertices()[index]->as<rive::CubicVertex>()->renderIn()[1]; |
| })) |
| .function("outX", optional_override([](rive::FlattenedPath& self, size_t index) -> float { |
| return self.vertices()[index]->as<rive::CubicVertex>()->renderOut()[0]; |
| })) |
| .function("outY", optional_override([](rive::FlattenedPath& self, size_t index) -> float { |
| return self.vertices()[index]->as<rive::CubicVertex>()->renderOut()[1]; |
| })); |
| #endif |
| |
| class_<rive::Vec2D>("Vec2D") |
| .constructor<float, float>() |
| // TODO: For next major verison, make these properties instead of methods to match |
| // patterns on other math-based Rive classes, such as Mat2D |
| .function("x", optional_override([](rive::Vec2D self) -> float { return self.x; })) |
| .function("y", optional_override([](rive::Vec2D self) -> float { return self.y; })); |
| |
| class_<rive::Mat2D>("Mat2D") |
| .constructor<>() |
| .property("xx", |
| select_overload<float() const>(&rive::Mat2D::xx), |
| select_overload<void(float)>(&rive::Mat2D::xx)) |
| .property("xy", |
| select_overload<float() const>(&rive::Mat2D::xy), |
| select_overload<void(float)>(&rive::Mat2D::xy)) |
| .property("yx", |
| select_overload<float() const>(&rive::Mat2D::yx), |
| select_overload<void(float)>(&rive::Mat2D::yx)) |
| .property("yy", |
| select_overload<float() const>(&rive::Mat2D::yy), |
| select_overload<void(float)>(&rive::Mat2D::yy)) |
| .property("tx", |
| select_overload<float() const>(&rive::Mat2D::tx), |
| select_overload<void(float)>(&rive::Mat2D::tx)) |
| .property("ty", |
| select_overload<float() const>(&rive::Mat2D::ty), |
| select_overload<void(float)>(&rive::Mat2D::ty)) |
| .function("invert", optional_override([](rive::Mat2D& self, rive::Mat2D& result) -> bool { |
| return self.invert(&result); |
| })) |
| .function("multiply", |
| optional_override([](rive::Mat2D& self, rive::Mat2D& result, rive::Mat2D& other) |
| -> void { result = rive::Mat2D::multiply(self, other); })); |
| |
| class_<rive::File>("File") |
| .function("defaultArtboard", |
| optional_override([](rive::File& self) -> rive::ArtboardInstance* { |
| return self.artboardAt(0).release(); |
| }), |
| allow_raw_pointers()) |
| .function("artboardByName", |
| optional_override([](const rive::File& self, |
| const std::string& name) -> rive::ArtboardInstance* { |
| return self.artboardNamed(name).release(); |
| }), |
| allow_raw_pointers()) |
| .function( |
| "artboardByIndex", |
| optional_override([](const rive::File& self, size_t index) -> rive::ArtboardInstance* { |
| return self.artboardAt(index).release(); |
| }), |
| allow_raw_pointers()) |
| .function("artboardCount", &rive::File::artboardCount); |
| |
| class_<rive::Artboard>("ArtboardBase"); |
| class_<rive::ArtboardInstance, base<rive::Artboard>>("Artboard") |
| #ifdef ENABLE_QUERY_FLAT_VERTICES |
| .function("flattenPath", |
| optional_override([](rive::Artboard& self, |
| size_t index, |
| bool transformToParent) -> rive::FlattenedPath* { |
| auto artboardObjects = self.objects(); |
| if (index >= artboardObjects.size()) |
| { |
| return nullptr; |
| } |
| auto object = artboardObjects[index]; |
| if (!object->is<rive::Path>()) |
| { |
| return nullptr; |
| } |
| auto path = object->as<rive::Path>(); |
| return path->makeFlat(transformToParent); |
| }), |
| allow_raw_pointers()) |
| #endif |
| .property("name", select_overload<const std::string&() const>(&rive::Artboard::name)) |
| .function("advance", |
| optional_override([](rive::ArtboardInstance& self, double seconds) -> bool { |
| return self.advance(seconds); |
| }), |
| allow_raw_pointers()) |
| .function("draw", |
| optional_override([](rive::ArtboardInstance& self, rive::Renderer* renderer) { |
| return self.draw(renderer, rive::Artboard::DrawOption::kNormal); |
| }), |
| allow_raw_pointers()) |
| .function("transformComponent", |
| optional_override([](rive::ArtboardInstance& self, const std::string& name) { |
| return self.find<rive::TransformComponent>(name); |
| }), |
| allow_raw_pointers()) |
| .function("node", |
| optional_override([](rive::ArtboardInstance& self, const std::string& name) { |
| return self.find<rive::Node>(name); |
| }), |
| allow_raw_pointers()) |
| .function("bone", |
| optional_override([](rive::ArtboardInstance& self, const std::string& name) { |
| return self.find<rive::Bone>(name); |
| }), |
| allow_raw_pointers()) |
| .function("rootBone", |
| optional_override([](rive::ArtboardInstance& self, const std::string& name) { |
| return self.find<rive::RootBone>(name); |
| }), |
| allow_raw_pointers()) |
| // Animations |
| .function("animationByIndex", |
| optional_override( |
| [](rive::ArtboardInstance& self, size_t index) -> rive::LinearAnimation* { |
| return self.animation(index); |
| }), |
| allow_raw_pointers()) |
| .function("animationByName", |
| optional_override([](rive::ArtboardInstance& self, const std::string& name) |
| -> rive::LinearAnimation* { return self.animation(name); }), |
| allow_raw_pointers()) |
| .function("animationCount", optional_override([](rive::ArtboardInstance& self) -> size_t { |
| return self.animationCount(); |
| })) |
| // State machines |
| .function("stateMachineByIndex", |
| optional_override( |
| [](rive::ArtboardInstance& self, size_t index) -> rive::StateMachine* { |
| return self.stateMachine(index); |
| }), |
| allow_raw_pointers()) |
| .function("stateMachineByName", |
| optional_override([](rive::ArtboardInstance& self, const std::string& name) |
| -> rive::StateMachine* { return self.stateMachine(name); }), |
| allow_raw_pointers()) |
| .function("stateMachineCount", |
| optional_override([](rive::ArtboardInstance& self) -> size_t { |
| return self.stateMachineCount(); |
| })) |
| .property("bounds", optional_override([](const rive::ArtboardInstance& self) -> rive::AABB { |
| return self.bounds(); |
| })) |
| .property("frameOrigin", |
| select_overload<bool() const>(&rive::Artboard::frameOrigin), |
| select_overload<void(bool)>(&rive::Artboard::frameOrigin)); |
| |
| class_<rive::TransformComponent>("TransformComponent") |
| .property("scaleX", |
| select_overload<float() const>(&rive::TransformComponent::scaleX), |
| select_overload<void(float)>(&rive::TransformComponent::scaleX)) |
| .property("scaleY", |
| select_overload<float() const>(&rive::TransformComponent::scaleY), |
| select_overload<void(float)>(&rive::TransformComponent::scaleY)) |
| .property("rotation", |
| select_overload<float() const>(&rive::TransformComponent::rotation), |
| select_overload<void(float)>(&rive::TransformComponent::rotation)) |
| .function("worldTransform", |
| optional_override([](rive::TransformComponent& self) -> rive::Mat2D& { |
| return self.mutableWorldTransform(); |
| }), |
| allow_raw_pointers()) |
| .function( |
| "parentWorldTransform", |
| optional_override([](rive::TransformComponent& self, rive::Mat2D& result) -> void { |
| result = rive::Mat2D(getParentWorld(self)); |
| }), |
| allow_raw_pointers()); |
| |
| class_<rive::Node, base<rive::TransformComponent>>("Node") |
| .property("x", |
| select_overload<float() const>(&rive::TransformComponent::x), |
| select_overload<void(float)>(&rive::Node::x)) |
| .property("y", |
| select_overload<float() const>(&rive::TransformComponent::y), |
| select_overload<void(float)>(&rive::Node::y)); |
| |
| class_<rive::Bone, base<rive::TransformComponent>>("Bone").property( |
| "length", |
| select_overload<float() const>(&rive::Bone::length), |
| select_overload<void(float)>(&rive::Bone::length)); |
| |
| class_<rive::RootBone, base<rive::Bone>>("RootBone") |
| .property("x", |
| select_overload<float() const>(&rive::TransformComponent::x), |
| select_overload<void(float)>(&rive::RootBone::x)) |
| .property("y", |
| select_overload<float() const>(&rive::TransformComponent::y), |
| select_overload<void(float)>(&rive::RootBone::y)); |
| |
| class_<rive::Animation>("Animation") |
| .property("name", select_overload<const std::string&() const>(&rive::AnimationBase::name)); |
| |
| class_<rive::LinearAnimation, base<rive::Animation>>("LinearAnimation") |
| .property("name", select_overload<const std::string&() const>(&rive::AnimationBase::name)) |
| .property("duration", |
| select_overload<uint32_t() const>(&rive::LinearAnimationBase::duration)) |
| .property("fps", select_overload<uint32_t() const>(&rive::LinearAnimationBase::fps)) |
| .property("workStart", |
| select_overload<uint32_t() const>(&rive::LinearAnimationBase::workStart)) |
| .property("workEnd", select_overload<uint32_t() const>(&rive::LinearAnimationBase::workEnd)) |
| .property("enableWorkArea", |
| select_overload<bool() const>(&rive::LinearAnimationBase::enableWorkArea)) |
| .property("loopValue", |
| select_overload<uint32_t() const>(&rive::LinearAnimationBase::loopValue)) |
| .property("speed", select_overload<float() const>(&rive::LinearAnimationBase::speed)) |
| .function("apply", &rive::LinearAnimation::apply, allow_raw_pointers()); |
| |
| class_<rive::LinearAnimationInstance>("LinearAnimationInstance") |
| .constructor<rive::LinearAnimation*, rive::ArtboardInstance*>() |
| .property("time", |
| select_overload<float() const>(&rive::LinearAnimationInstance::time), |
| select_overload<void(float)>(&rive::LinearAnimationInstance::time)) |
| .property("didLoop", &rive::LinearAnimationInstance::didLoop) |
| .function("advance", &rive::LinearAnimationInstance::advance) |
| .function("apply", &rive::LinearAnimationInstance::apply, allow_raw_pointers()); |
| |
| class_<rive::StateMachine, base<rive::Animation>>("StateMachine"); |
| |
| class_<rive::StateMachineInstance>("StateMachineInstance") |
| .constructor<rive::StateMachine*, rive::ArtboardInstance*>() |
| .function("advance", &rive::StateMachineInstance::advance, allow_raw_pointers()) |
| .function("inputCount", &rive::StateMachineInstance::inputCount) |
| .function("input", &rive::StateMachineInstance::input, allow_raw_pointers()) |
| .function("pointerDown", |
| optional_override([](rive::StateMachineInstance& self, double x, double y) { |
| self.pointerDown(rive::Vec2D((float)x, (float)y)); |
| })) |
| .function("pointerMove", |
| optional_override([](rive::StateMachineInstance& self, double x, double y) { |
| self.pointerMove(rive::Vec2D((float)x, (float)y)); |
| })) |
| .function("pointerUp", |
| optional_override([](rive::StateMachineInstance& self, double x, double y) { |
| self.pointerUp(rive::Vec2D((float)x, (float)y)); |
| })) |
| .function("stateChangedCount", &rive::StateMachineInstance::stateChangedCount) |
| .function( |
| "stateChangedNameByIndex", |
| optional_override([](rive::StateMachineInstance& self, size_t index) -> std::string { |
| const rive::LayerState* state = self.stateChangedByIndex(index); |
| if (state != nullptr) |
| switch (state->coreType()) |
| { |
| case rive::AnimationState::typeKey: |
| return state->as<rive::AnimationState>()->animation()->name(); |
| case rive::EntryState::typeKey: |
| return "entry"; |
| case rive::ExitState::typeKey: |
| return "exit"; |
| case rive::AnyState::typeKey: |
| return "any"; |
| } |
| return "unknown"; |
| }), |
| allow_raw_pointers()); |
| |
| class_<rive::SMIInput>("SMIInput") |
| .property("type", &rive::SMIInput::inputCoreType) |
| .property("name", &rive::SMIInput::name) |
| .class_property("bool", &stateMachineBoolTypeKey) |
| .class_property("number", &stateMachineNumberTypeKey) |
| .class_property("trigger", &stateMachineTriggerTypeKey) |
| .function("asBool", |
| optional_override([](rive::SMIInput& self) -> rive::SMIBool* { |
| if (self.inputCoreType() != stateMachineBoolTypeKey) |
| { |
| return nullptr; |
| } |
| return static_cast<rive::SMIBool*>(&self); |
| }), |
| allow_raw_pointers()) |
| .function("asNumber", |
| optional_override([](rive::SMIInput& self) -> rive::SMINumber* { |
| if (self.inputCoreType() != stateMachineNumberTypeKey) |
| { |
| return nullptr; |
| } |
| return static_cast<rive::SMINumber*>(&self); |
| }), |
| allow_raw_pointers()) |
| .function("asTrigger", |
| optional_override([](rive::SMIInput& self) -> rive::SMITrigger* { |
| if (self.inputCoreType() != stateMachineTriggerTypeKey) |
| { |
| return nullptr; |
| } |
| return static_cast<rive::SMITrigger*>(&self); |
| }), |
| allow_raw_pointers()); |
| |
| class_<rive::SMIBool, base<rive::SMIInput>>("SMIBool").property( |
| "value", |
| select_overload<bool() const>(&rive::SMIBool::value), |
| select_overload<void(bool)>(&rive::SMIBool::value)); |
| class_<rive::SMINumber, base<rive::SMIInput>>("SMINumber") |
| .property("value", |
| select_overload<float() const>(&rive::SMINumber::value), |
| select_overload<void(float)>(&rive::SMINumber::value)); |
| class_<rive::SMITrigger, base<rive::SMIInput>>("SMITrigger") |
| .function("fire", &rive::SMITrigger::fire); |
| |
| enum_<rive::Fit>("Fit") |
| .value("fill", rive::Fit::fill) |
| .value("contain", rive::Fit::contain) |
| .value("cover", rive::Fit::cover) |
| .value("fitWidth", rive::Fit::fitWidth) |
| .value("fitHeight", rive::Fit::fitHeight) |
| .value("none", rive::Fit::none) |
| .value("scaleDown", rive::Fit::scaleDown); |
| |
| enum_<JsAlignment>("Alignment") |
| .value("topLeft", JsAlignment::topLeft) |
| .value("topCenter", JsAlignment::topCenter) |
| .value("topRight", JsAlignment::topRight) |
| .value("centerLeft", JsAlignment::centerLeft) |
| .value("center", JsAlignment::center) |
| .value("centerRight", JsAlignment::centerRight) |
| .value("bottomLeft", JsAlignment::bottomLeft) |
| .value("bottomCenter", JsAlignment::bottomCenter) |
| .value("bottomRight", JsAlignment::bottomRight); |
| |
| value_object<rive::AABB>("AABB") |
| .field("minX", &rive::AABB::minX) |
| .field("minY", &rive::AABB::minY) |
| .field("maxX", &rive::AABB::maxX) |
| .field("maxY", &rive::AABB::maxY); |
| |
| // #ifdef DEBUG |
| // function("doLeakCheck", &__lsan_do_recoverable_leak_check); |
| // #endif |
| } |
