Playable as a high-level api

include/rive/playable.hpp

diff --git a/include/rive/playable.hpp b/include/rive/playable.hpp
new file mode 100644
index 0000000..2b834a7
--- /dev/null
+++ b/include/rive/playable.hpp
@@ -0,0 +1,70 @@
+#ifndef _RIVE_PLAYABLE_HPP_
+#define _RIVE_PLAYABLE_HPP_
+
+#include "rive/math/aabb.hpp"
+#include "rive/span.hpp"
+
+namespace rive {
+    class Factory;
+    class FileAssetResolver;
+    class Renderer;
+
+    class ArtboardInstance;
+    class File;
+    class LinearAnimationInstance;
+    class StateMachineInstance;
+
+    class SMIInput;
+    class SMIBool;
+    class SMINumber;
+    class SMITrigger;
+
+    class Playable {
+    private:
+        std::unique_ptr<File> m_File;
+        std::unique_ptr<ArtboardInstance> m_ABI;
+        std::unique_ptr<LinearAnimationInstance> m_LAI;
+        std::unique_ptr<StateMachineInstance> m_SMI;
+    
+        Playable();
+
+    public:
+        static std::unique_ptr<Playable> import(Span<const uint8_t>,
+                                                Factory*,
+                                                FileAssetResolver* = nullptr);
+
+        static std::unique_ptr<Playable>
+        animationAt(File*, size_t artboardIndex, size_t animationIndex);
+    
+        static std::unique_ptr<Playable>
+        stateMachineAt(File*, size_t artboardIndex, size_t machineIndex);
+    
+        ~Playable();
+
+        AABB bounds() const;
+
+        // returns -1 for continuous
+        float durationSeconds() const;
+
+        // returns true if draw() should be called
+        bool advance(float elapsedSeconds);
+
+        void draw(Renderer*);
+
+        enum class PointerState {
+            kDown,      // pointer changed from 'up' to 'down'
+            kUp,        // pointer changed from 'down' to 'up'
+            kMoved,     // pointer position changed
+        };
+        void pointerEvent(Vec2D, PointerState);
+
+        size_t inputCount() const;
+        SMIInput* inputAt(size_t index) const;
+        SMIBool* boolNamed(const std::string&) const;
+        SMINumber* numberNamed(const std::string&) const;
+        SMITrigger* triggerNamed(const std::string&) const;
+    };
+
+} // namespace rive
+
+#endif

src/playable.cpp

diff --git a/src/playable.cpp b/src/playable.cpp
new file mode 100644
index 0000000..7c2e072
--- /dev/null
+++ b/src/playable.cpp
@@ -0,0 +1,126 @@
+#include "rive/artboard.hpp"
+#include "rive/file.hpp"
+#include "rive/file_asset_resolver.hpp"
+#include "rive/playable.hpp"
+#include "rive/animation/linear_animation_instance.hpp"
+#include "rive/animation/state_machine_instance.hpp"
+
+using namespace rive;
+
+Playable::Playable() {}
+
+Playable::~Playable() {}
+
+std::unique_ptr<Playable> Playable::animationAt(File* file,
+                                                size_t artboardIndex,
+                                                size_t animationIndex) {
+    auto abi = file->artboardAt(artboardIndex);
+    if (abi) {
+        auto lai = abi->animationAt(animationIndex);
+        if (lai) {
+            std::unique_ptr<Playable> play(new Playable);
+            play->m_ABI = std::move(abi);
+            play->m_LAI = std::move(lai);
+            return play;
+        }
+    }
+    return nullptr;
+}
+
+std::unique_ptr<Playable> Playable::stateMachineAt(File* file,
+                                                   size_t artboardIndex,
+                                                   size_t machineIndex) {
+    auto abi = file->artboardAt(artboardIndex);
+    if (abi) {
+        auto smi = abi->stateMachineAt(machineIndex);
+        if (smi) {
+            std::unique_ptr<Playable> play(new Playable);
+            play->m_ABI = std::move(abi);
+            play->m_SMI = std::move(smi);
+            return play;
+        }
+    }
+    return nullptr;
+}
+
+std::unique_ptr<Playable> Playable::import(Span<const uint8_t> bytes,
+                                           Factory* factory,
+                                           FileAssetResolver* resolver)
+{
+    auto file = File::import(bytes, factory, nullptr, resolver);
+    if (!file) {
+        return nullptr;
+    }
+
+    auto play = Playable::stateMachineAt(file.get(), 0, 0);
+    if (!play) {
+        play = Playable::animationAt(file.get(), 0, 0);
+    }
+    if (play) {
+        play->m_File = std::move(file);
+    }
+    return play;
+}
+
+AABB Playable::bounds() const {
+    return m_ABI->bounds();
+}
+
+float Playable::durationSeconds() const {
+    return m_SMI ? -1 : m_LAI->durationSeconds();
+}
+
+// returns true if draw() should be called
+bool Playable::advance(float elapsedSeconds) {
+    bool needsRedraw;
+    if (m_SMI) {
+        needsRedraw = m_SMI->advance(elapsedSeconds);
+    } else {
+        needsRedraw = m_LAI->advance(elapsedSeconds);
+        m_LAI->apply();
+    }
+    return needsRedraw;
+}
+
+void Playable::draw(Renderer* renderer) {
+    m_ABI->draw(renderer);
+}
+
+void Playable::pointerEvent(Vec2D pos, PointerState state) {
+    if (m_SMI) {
+        switch (state) {
+            case PointerState::kDown:
+                m_SMI->pointerDown(pos);
+                break;
+            case PointerState::kMoved:
+                m_SMI->pointerMove(pos);
+                break;
+            case PointerState::kUp:
+                m_SMI->pointerUp(pos);
+                break;
+        }
+    }
+    // else the animation just ignores the pointer events
+}
+
+// StateMachine Inputs
+
+size_t Playable::inputCount() const {
+    return m_SMI ? m_SMI->inputCount() : 0;
+}
+
+SMIInput* Playable::inputAt(size_t index) const {
+    return m_SMI ? m_SMI->input(index) : nullptr;
+}
+
+SMIBool* Playable::boolNamed(const std::string& name) const {
+    return m_SMI ? m_SMI->getBool(name) : nullptr;
+}
+
+SMINumber* Playable::numberNamed(const std::string& name) const {
+    return m_SMI ? m_SMI->getNumber(name) : nullptr;
+}
+
+SMITrigger* Playable::triggerNamed(const std::string& name) const {
+    return m_SMI ? m_SMI->getTrigger(name) : nullptr;
+}