| /* | |
| * Copyright 2025 Rive | |
| */ | |
| #pragma once | |
| #include "rive/object_stream.hpp" | |
| #include "rive/refcnt.hpp" | |
| #include "rive/math/vec2d.hpp" | |
| #include "rive/viewmodel/runtime/viewmodel_runtime.hpp" | |
| #include <condition_variable> | |
| #include <cstdint> | |
| #include <functional> | |
| #include <mutex> | |
| #include <string> | |
| #include <vector> | |
| #include <unordered_map> | |
| #include "file_asset_loader.hpp" | |
| // Macros for defining and working with command buffer handles. | |
| #if INTPTR_MAX == INT64_MAX | |
| static_assert(sizeof(void*) == 8, "expected a 64-bit environment"); | |
| // Define handles as pointers to forward-declared types for type safety. | |
| #define RIVE_DEFINE_HANDLE(NAME) using NAME = struct NAME##_HandlePlaceholder*; | |
| #define RIVE_NULL_HANDLE nullptr | |
| #elif INTPTR_MAX == INT32_MAX | |
| static_assert(sizeof(void*) == 4, "expected a 32-bit environment"); | |
| #define RIVE_DEFINE_HANDLE(NAME) using NAME = uint64_t; | |
| #define RIVE_NULL_HANDLE 0 | |
| #else | |
| #error "environment not 32 or 64-bit." | |
| #endif | |
| namespace rive | |
| { | |
| class Factory; | |
| class File; | |
| class ArtboardInstance; | |
| class StateMachineInstance; | |
| class CommandServer; | |
| RIVE_DEFINE_HANDLE(FontHandle); | |
| RIVE_DEFINE_HANDLE(FileHandle); | |
| RIVE_DEFINE_HANDLE(ArtboardHandle); | |
| RIVE_DEFINE_HANDLE(AudioSourceHandle); | |
| RIVE_DEFINE_HANDLE(RenderImageHandle); | |
| RIVE_DEFINE_HANDLE(StateMachineHandle); | |
| RIVE_DEFINE_HANDLE(ViewModelInstanceHandle); | |
| RIVE_DEFINE_HANDLE(DrawKey); | |
| // Function poimter that gets called back from the server thread. | |
| using CommandServerCallback = std::function<void(CommandServer*)>; | |
| using CommandServerDrawCallback = std::function<void(DrawKey, CommandServer*)>; | |
| struct ViewModelEnum | |
| { | |
| std::string name; | |
| std::vector<std::string> enumerants; | |
| }; | |
| // Client-side recorder for commands that will be executed by a | |
| // CommandServer. | |
| class CommandQueue : public RefCnt<CommandQueue> | |
| { | |
| public: | |
| template <typename ListenerType, typename HandleType> class ListenerBase | |
| { | |
| public: | |
| friend class CommandQueue; | |
| ListenerBase(const ListenerBase&) = delete; | |
| ListenerBase& operator=(const ListenerBase&) = delete; | |
| ListenerBase(ListenerBase&& other) : | |
| m_owningQueue(std::move(other.m_owningQueue)), | |
| m_handle(std::move(other.m_handle)) | |
| { | |
| if (m_owningQueue) | |
| { | |
| m_owningQueue->unregisterListener( | |
| m_handle, | |
| static_cast<ListenerType*>(&other)); | |
| m_owningQueue->registerListener( | |
| m_handle, | |
| static_cast<ListenerType*>(this)); | |
| } | |
| } | |
| ~ListenerBase() | |
| { | |
| if (m_owningQueue) | |
| m_owningQueue->unregisterListener( | |
| m_handle, | |
| static_cast<ListenerType*>(this)); | |
| } | |
| ListenerBase() : m_handle(RIVE_NULL_HANDLE) {} | |
| private: | |
| rcp<CommandQueue> m_owningQueue; | |
| HandleType m_handle; | |
| }; | |
| class FileListener | |
| : public CommandQueue::ListenerBase<FileListener, FileHandle> | |
| { | |
| public: | |
| virtual void onFileError(const FileHandle, | |
| uint64_t requestId, | |
| std::string error) | |
| {} | |
| virtual void onFileDeleted(const FileHandle, uint64_t requestId) {} | |
| virtual void onFileLoaded(const FileHandle, uint64_t requestId) {} | |
| virtual void onArtboardsListed(const FileHandle, | |
| uint64_t requestId, | |
| std::vector<std::string> artboardNames) | |
| {} | |
| virtual void onViewModelsListed(const FileHandle, | |
| uint64_t requestId, | |
| std::vector<std::string> viewModelNames) | |
| {} | |
| virtual void onViewModelInstanceNamesListed( | |
| const FileHandle, | |
| uint64_t requestId, | |
| std::string viewModelName, | |
| std::vector<std::string> instanceNames) | |
| {} | |
| struct ViewModelPropertyData | |
| { | |
| DataType type = DataType::none; | |
| std::string name = ""; | |
| std::string metaData = ""; | |
| }; | |
| virtual void onViewModelPropertiesListed( | |
| const FileHandle, | |
| uint64_t requestId, | |
| std::string viewModelName, | |
| std::vector<ViewModelPropertyData> properties) | |
| {} | |
| virtual void onViewModelEnumsListed(const FileHandle, | |
| uint64_t requestId, | |
| std::vector<ViewModelEnum> enums) | |
| {} | |
| }; | |
| class RenderImageListener | |
| : public CommandQueue::ListenerBase<RenderImageListener, | |
| RenderImageHandle> | |
| { | |
| public: | |
| virtual void onRenderImageDecoded(const RenderImageHandle, | |
| uint64_t requestId) | |
| {} | |
| virtual void onRenderImageError(const RenderImageHandle, | |
| uint64_t requestId, | |
| std::string error) | |
| {} | |
| virtual void onRenderImageDeleted(const RenderImageHandle, | |
| uint64_t requestId) | |
| {} | |
| }; | |
| class AudioSourceListener | |
| : public CommandQueue::ListenerBase<AudioSourceListener, | |
| AudioSourceHandle> | |
| { | |
| public: | |
| virtual void onAudioSourceDecoded(const AudioSourceHandle, | |
| uint64_t requestId) | |
| {} | |
| virtual void onAudioSourceError(const AudioSourceHandle, | |
| uint64_t requestId, | |
| std::string error) | |
| {} | |
| virtual void onAudioSourceDeleted(const AudioSourceHandle, | |
| uint64_t requestId) | |
| {} | |
| }; | |
| class FontListener | |
| : public CommandQueue::ListenerBase<FontListener, FontHandle> | |
| { | |
| public: | |
| virtual void onFontDecoded(const FontHandle, uint64_t requestId) {} | |
| virtual void onFontError(const FontHandle, | |
| uint64_t requestId, | |
| std::string error) | |
| {} | |
| virtual void onFontDeleted(const FontHandle, uint64_t requestId) {} | |
| }; | |
| class ArtboardListener | |
| : public CommandQueue::ListenerBase<ArtboardListener, ArtboardHandle> | |
| { | |
| public: | |
| virtual void onArtboardError(const ArtboardHandle, | |
| uint64_t requestId, | |
| std::string error) | |
| {} | |
| virtual void onDefaultViewModelInfoReceived(const ArtboardHandle, | |
| uint64_t requestId, | |
| std::string viewModelName, | |
| std::string instanceName) | |
| {} | |
| virtual void onArtboardDeleted(const ArtboardHandle, uint64_t requestId) | |
| {} | |
| virtual void onStateMachinesListed( | |
| const ArtboardHandle, | |
| uint64_t requestId, | |
| std::vector<std::string> stateMachineNames) | |
| {} | |
| }; | |
| struct ViewModelInstanceData | |
| { | |
| // The path and type of this property | |
| PropertyData metaData; | |
| // The specific value of this property, you must use the correct union | |
| // member base on type in metaData, both enumType and string use | |
| // stringValue | |
| // std::string is non trival, so it stays outside the union | |
| std::string stringValue; | |
| union | |
| { | |
| bool boolValue; | |
| float numberValue; | |
| ColorInt colorValue; | |
| }; | |
| }; | |
| class ViewModelInstanceListener | |
| : public CommandQueue::ListenerBase<ViewModelInstanceListener, | |
| ViewModelInstanceHandle> | |
| { | |
| public: | |
| virtual void onViewModelInstanceError(const ViewModelInstanceHandle, | |
| uint64_t requestId, | |
| std::string error) | |
| {} | |
| virtual void onViewModelDeleted(const ViewModelInstanceHandle, | |
| uint64_t requestId) | |
| {} | |
| virtual void onViewModelDataReceived(const ViewModelInstanceHandle, | |
| uint64_t requestId, | |
| ViewModelInstanceData) | |
| {} | |
| virtual void onViewModelListSizeReceived(const ViewModelInstanceHandle, | |
| uint64_t requestId, | |
| std::string path, | |
| size_t size) | |
| {} | |
| }; | |
| class StateMachineListener | |
| : public CommandQueue::ListenerBase<StateMachineListener, | |
| StateMachineHandle> | |
| { | |
| public: | |
| virtual void onStateMachineError(const StateMachineHandle, | |
| uint64_t requestId, | |
| std::string error) | |
| {} | |
| virtual void onStateMachineDeleted(const StateMachineHandle, | |
| uint64_t requestId) | |
| {} | |
| // requestId in this case is the specific request that caused the | |
| // statemachine to settle | |
| virtual void onStateMachineSettled(const StateMachineHandle, | |
| uint64_t requestId) | |
| {} | |
| }; | |
| CommandQueue(); | |
| ~CommandQueue(); | |
| FileHandle loadFile(std::vector<uint8_t> rivBytes, | |
| FileListener* listener = nullptr, | |
| uint64_t requestId = 0); | |
| void deleteFile(FileHandle, uint64_t requestId = 0); | |
| void addGlobalImageAsset(std::string name, | |
| RenderImageHandle, | |
| uint64_t requestId = 0); | |
| void addGlobalFontAsset(std::string name, | |
| FontHandle, | |
| uint64_t requestId = 0); | |
| void addGlobalAudioAsset(std::string name, | |
| AudioSourceHandle, | |
| uint64_t requestId = 0); | |
| void removeGlobalImageAsset(std::string name, uint64_t requestId = 0); | |
| void removeGlobalFontAsset(std::string name, uint64_t requestId = 0); | |
| void removeGlobalAudioAsset(std::string name, uint64_t requestId = 0); | |
| ArtboardHandle instantiateArtboardNamed( | |
| FileHandle, | |
| std::string name, | |
| ArtboardListener* listener = nullptr, | |
| uint64_t requestId = 0); | |
| ArtboardHandle instantiateDefaultArtboard( | |
| FileHandle fileHandle, | |
| ArtboardListener* listener = nullptr, | |
| uint64_t requestId = 0) | |
| { | |
| return instantiateArtboardNamed(fileHandle, "", listener, requestId); | |
| } | |
| void deleteArtboard(ArtboardHandle, uint64_t requestId = 0); | |
| ViewModelInstanceHandle instantiateBlankViewModelInstance( | |
| FileHandle fileHandle, | |
| ArtboardHandle artboardHandle, | |
| ViewModelInstanceListener* listener = nullptr, | |
| uint64_t requestId = 0); | |
| ViewModelInstanceHandle instantiateBlankViewModelInstance( | |
| FileHandle fileHandle, | |
| std::string viewModelName, | |
| ViewModelInstanceListener* listener = nullptr, | |
| uint64_t requestId = 0); | |
| ViewModelInstanceHandle instantiateDefaultViewModelInstance( | |
| FileHandle fileHandle, | |
| ArtboardHandle artboardHandle, | |
| ViewModelInstanceListener* listener = nullptr, | |
| uint64_t requestId = 0) | |
| { | |
| return instantiateViewModelInstanceNamed(fileHandle, | |
| artboardHandle, | |
| "", | |
| listener, | |
| requestId); | |
| } | |
| ViewModelInstanceHandle instantiateDefaultViewModelInstance( | |
| FileHandle fileHandle, | |
| std::string viewModelName, | |
| ViewModelInstanceListener* listener = nullptr, | |
| uint64_t requestId = 0) | |
| { | |
| return instantiateViewModelInstanceNamed(fileHandle, | |
| viewModelName, | |
| "", | |
| listener, | |
| requestId); | |
| } | |
| ViewModelInstanceHandle instantiateViewModelInstanceNamed( | |
| FileHandle, | |
| ArtboardHandle, | |
| std::string viewModelInstanceName, | |
| ViewModelInstanceListener* listener = nullptr, | |
| uint64_t requestId = 0); | |
| ViewModelInstanceHandle instantiateViewModelInstanceNamed( | |
| FileHandle, | |
| std::string viewModelName, | |
| std::string viewModelInstanceName, | |
| ViewModelInstanceListener* listener = nullptr, | |
| uint64_t requestId = 0); | |
| ViewModelInstanceHandle referenceNestedViewModelInstance( | |
| ViewModelInstanceHandle, | |
| std::string path, | |
| ViewModelInstanceListener* listener = nullptr, | |
| uint64_t requestId = 0); | |
| ViewModelInstanceHandle referenceListViewModelInstance( | |
| ViewModelInstanceHandle, | |
| std::string path, | |
| int index, | |
| ViewModelInstanceListener* listener = nullptr, | |
| uint64_t requestId = 0); | |
| void fireViewModelTrigger(ViewModelInstanceHandle, | |
| std::string path, | |
| uint64_t requestId = 0); | |
| void setViewModelInstanceBool(ViewModelInstanceHandle, | |
| std::string path, | |
| bool value, | |
| uint64_t requestId = 0); | |
| void setViewModelInstanceNumber(ViewModelInstanceHandle, | |
| std::string path, | |
| float value, | |
| uint64_t requestId = 0); | |
| void setViewModelInstanceColor(ViewModelInstanceHandle, | |
| std::string path, | |
| ColorInt value, | |
| uint64_t requestId = 0); | |
| void setViewModelInstanceEnum(ViewModelInstanceHandle, | |
| std::string path, | |
| std::string value, | |
| uint64_t requestId = 0); | |
| void setViewModelInstanceString(ViewModelInstanceHandle, | |
| std::string path, | |
| std::string value, | |
| uint64_t requestId = 0); | |
| void setViewModelInstanceImage(ViewModelInstanceHandle, | |
| std::string path, | |
| RenderImageHandle value, | |
| uint64_t requestId = 0); | |
| void setViewModelInstanceArtboard(ViewModelInstanceHandle, | |
| std::string path, | |
| ArtboardHandle value, | |
| uint64_t requestId = 0); | |
| void setViewModelInstanceNestedViewModel(ViewModelInstanceHandle, | |
| std::string path, | |
| ViewModelInstanceHandle value, | |
| uint64_t requestId = 0); | |
| void insertViewModelInstanceListViewModel(ViewModelInstanceHandle, | |
| std::string path, | |
| ViewModelInstanceHandle value, | |
| int index, | |
| uint64_t requestId = 0); | |
| void appendViewModelInstanceListViewModel(ViewModelInstanceHandle handle, | |
| std::string path, | |
| ViewModelInstanceHandle value, | |
| uint64_t requestId = 0) | |
| { | |
| insertViewModelInstanceListViewModel(handle, | |
| std::move(path), | |
| value, | |
| -1, | |
| requestId); | |
| } | |
| void removeViewModelInstanceListViewModel( | |
| ViewModelInstanceHandle, | |
| std::string path, | |
| int index, | |
| ViewModelInstanceHandle value = RIVE_NULL_HANDLE, | |
| uint64_t requestId = 0); | |
| void removeViewModelInstanceListViewModel(ViewModelInstanceHandle handle, | |
| std::string path, | |
| ViewModelInstanceHandle value, | |
| uint64_t requestId = 0) | |
| { | |
| removeViewModelInstanceListViewModel(handle, | |
| std::move(path), | |
| -1, | |
| value, | |
| requestId); | |
| } | |
| void swapViewModelInstanceListValues(ViewModelInstanceHandle handle, | |
| std::string path, | |
| int indexa, | |
| int indexb, | |
| uint64_t requestId = 0); | |
| void subscribeToViewModelProperty(ViewModelInstanceHandle handle, | |
| std::string path, | |
| DataType type, | |
| uint64_t requestId = 0); | |
| void unsubscribeToViewModelProperty(ViewModelInstanceHandle handle, | |
| std::string path, | |
| DataType type, | |
| uint64_t requestId = 0); | |
| void deleteViewModelInstance(ViewModelInstanceHandle, | |
| uint64_t requestId = 0); | |
| StateMachineHandle instantiateStateMachineNamed( | |
| ArtboardHandle, | |
| std::string name, | |
| StateMachineListener* listener = nullptr, | |
| uint64_t requestId = 0); | |
| StateMachineHandle instantiateDefaultStateMachine( | |
| ArtboardHandle artboardHandle, | |
| StateMachineListener* listener = nullptr, | |
| uint64_t requestId = 0) | |
| { | |
| return instantiateStateMachineNamed(artboardHandle, | |
| "", | |
| listener, | |
| requestId); | |
| } | |
| void bindViewModelInstance(StateMachineHandle, | |
| ViewModelInstanceHandle, | |
| uint64_t requestId = 0); | |
| void advanceStateMachine(StateMachineHandle, | |
| float timeToAdvance, | |
| uint64_t requestId = 0); | |
| // Pointer events | |
| struct PointerEvent | |
| { | |
| Fit fit = Fit::none; // the fit the artboard is drawn with | |
| Alignment alignment; // the alignment the artboard is drawn with | |
| Vec2D screenBounds; // the bounds of coordinate system of the cursor | |
| Vec2D position; // the cursor position | |
| float scaleFactor = 1.0f; // scale factor for things like retina display | |
| }; | |
| // All pointer events will automatically convert between artboard and screen | |
| // space for you based on the values passed in the PointerEvent struct. | |
| void pointerMove(StateMachineHandle, PointerEvent, uint64_t requestId = 0); | |
| void pointerDown(StateMachineHandle, PointerEvent, uint64_t requestId = 0); | |
| void pointerUp(StateMachineHandle, PointerEvent, uint64_t requestId = 0); | |
| void pointerExit(StateMachineHandle, PointerEvent, uint64_t requestId = 0); | |
| void deleteStateMachine(StateMachineHandle, uint64_t requestId = 0); | |
| RenderImageHandle decodeImage(std::vector<uint8_t> imageEncodedBytes, | |
| RenderImageListener* listener = nullptr, | |
| uint64_t requestId = 0); | |
| // This is needed for unreal rhi because all images come pre-decoded and | |
| // uploaded to gpu. | |
| RenderImageHandle addExternalImage(rcp<RenderImage> externalImage, | |
| RenderImageListener* listener = nullptr, | |
| uint64_t requestId = 0); | |
| void deleteImage(RenderImageHandle, uint64_t requestId = 0); | |
| AudioSourceHandle decodeAudio(std::vector<uint8_t> imageEncodedBytes, | |
| AudioSourceListener* listener = nullptr, | |
| uint64_t requestId = 0); | |
| AudioSourceHandle addExternalAudio(rcp<AudioSource> externalAudio, | |
| AudioSourceListener* listener = nullptr, | |
| uint64_t requestId = 0); | |
| void deleteAudio(AudioSourceHandle, uint64_t requestId = 0); | |
| FontHandle decodeFont(std::vector<uint8_t> imageEncodedBytes, | |
| FontListener* listener = nullptr, | |
| uint64_t requestId = 0); | |
| FontHandle addExternalFont(rcp<Font> externalFont, | |
| FontListener* listener = nullptr, | |
| uint64_t requestId = 0); | |
| void deleteFont(FontHandle, uint64_t requestId = 0); | |
| // Create unique draw key for draw. | |
| DrawKey createDrawKey(); | |
| // Executes a one-time callback on the server. This may eventualy become a | |
| // testing-only method. | |
| void runOnce(CommandServerCallback); | |
| // Run draw function for given draw key, only the latest function passed | |
| // will be run per pollCommands. | |
| void draw(DrawKey, CommandServerDrawCallback); | |
| #ifdef TESTING | |
| // Sends a commandLoopBreak command to the server. This will cause the | |
| // processCommands to return even if there are more commands to consume. | |
| // This does not shutdown the server, it only causes processCommands to | |
| // return. To continue processing commands, another call to processCommands | |
| // is required. | |
| void testing_commandLoopBreak(); | |
| FileListener* testing_getFileListener(FileHandle); | |
| ArtboardListener* testing_getArtboardListener(ArtboardHandle); | |
| StateMachineListener* testing_getStateMachineListener(StateMachineHandle); | |
| #endif | |
| void disconnect(); | |
| void requestViewModelNames(FileHandle, uint64_t requestId = 0); | |
| void requestArtboardNames(FileHandle, uint64_t requestId = 0); | |
| void requestViewModelEnums(FileHandle, uint64_t requestId = 0); | |
| void requestViewModelPropertyDefinitions(FileHandle, | |
| std::string viewModelName, | |
| uint64_t requestId = 0); | |
| void requestViewModelInstanceNames(FileHandle, | |
| std::string viewModelName, | |
| uint64_t requestId = 0); | |
| void requestViewModelInstanceBool(ViewModelInstanceHandle, | |
| std::string path, | |
| uint64_t requestId = 0); | |
| void requestViewModelInstanceNumber(ViewModelInstanceHandle, | |
| std::string path, | |
| uint64_t requestId = 0); | |
| void requestViewModelInstanceColor(ViewModelInstanceHandle, | |
| std::string path, | |
| uint64_t requestId = 0); | |
| void requestViewModelInstanceEnum(ViewModelInstanceHandle, | |
| std::string path, | |
| uint64_t requestId = 0); | |
| void requestViewModelInstanceString(ViewModelInstanceHandle, | |
| std::string path, | |
| uint64_t requestId = 0); | |
| void requestViewModelInstanceListSize(ViewModelInstanceHandle, | |
| std::string path, | |
| uint64_t requestId = 0); | |
| void requestStateMachineNames(ArtboardHandle, uint64_t requestId = 0); | |
| void requestDefaultViewModelInfo(ArtboardHandle, | |
| FileHandle, | |
| uint64_t requestId = 0); | |
| // Consume all messages received from the server. | |
| void processMessages(); | |
| void setGlobalFileListener(FileListener* listener) | |
| { | |
| m_globalFileListener = listener; | |
| } | |
| void setGlobalArtboardListener(ArtboardListener* listener) | |
| { | |
| m_globalArtboardListener = listener; | |
| } | |
| void setGlobalStateMachineListener(StateMachineListener* listener) | |
| { | |
| m_globalStateMachineListener = listener; | |
| } | |
| void setGlobalViewModelInstanceListener(ViewModelInstanceListener* listener) | |
| { | |
| m_globalViewModelListener = listener; | |
| } | |
| void setGlobalRenderImageListener(RenderImageListener* listener) | |
| { | |
| m_globalImageListener = listener; | |
| } | |
| void setGlobalAudioSourceListener(AudioSourceListener* listener) | |
| { | |
| m_globalAudioListener = listener; | |
| } | |
| void setGlobalFontListener(FontListener* listener) | |
| { | |
| m_globalFontListener = listener; | |
| } | |
| private: | |
| void registerListener(FileHandle handle, FileListener* listener) | |
| { | |
| assert(listener); | |
| assert(m_fileListeners.find(handle) == m_fileListeners.end()); | |
| m_fileListeners.insert({handle, listener}); | |
| } | |
| void registerListener(RenderImageHandle handle, | |
| RenderImageListener* listener) | |
| { | |
| assert(listener); | |
| assert(m_imageListeners.find(handle) == m_imageListeners.end()); | |
| m_imageListeners.insert({handle, listener}); | |
| } | |
| void registerListener(AudioSourceHandle handle, | |
| AudioSourceListener* listener) | |
| { | |
| assert(listener); | |
| assert(m_audioListeners.find(handle) == m_audioListeners.end()); | |
| m_audioListeners.insert({handle, listener}); | |
| } | |
| void registerListener(FontHandle handle, FontListener* listener) | |
| { | |
| assert(listener); | |
| assert(m_fontListeners.find(handle) == m_fontListeners.end()); | |
| m_fontListeners.insert({handle, listener}); | |
| } | |
| void registerListener(ArtboardHandle handle, ArtboardListener* listener) | |
| { | |
| assert(listener); | |
| assert(m_artboardListeners.find(handle) == m_artboardListeners.end()); | |
| m_artboardListeners.insert({handle, listener}); | |
| } | |
| void registerListener(ViewModelInstanceHandle handle, | |
| ViewModelInstanceListener* listener) | |
| { | |
| assert(listener); | |
| assert(m_viewModelListeners.find(handle) == m_viewModelListeners.end()); | |
| m_viewModelListeners.insert({handle, listener}); | |
| } | |
| void registerListener(StateMachineHandle handle, | |
| StateMachineListener* listener) | |
| { | |
| assert(listener); | |
| assert(m_stateMachineListeners.find(handle) == | |
| m_stateMachineListeners.end()); | |
| m_stateMachineListeners.insert({handle, listener}); | |
| } | |
| // On 32-bit architectures, Handles are all uint64_t (not unique types), so | |
| // it will think we are re-declaring unregisterListener 3 times if we don't | |
| // add the listener pointer (even though it is not needed). | |
| void unregisterListener(FileHandle handle, FileListener* listener) | |
| { | |
| m_fileListeners.erase(handle); | |
| } | |
| void unregisterListener(RenderImageHandle handle, | |
| RenderImageListener* listener) | |
| { | |
| m_imageListeners.erase(handle); | |
| } | |
| void unregisterListener(AudioSourceHandle handle, | |
| AudioSourceListener* listener) | |
| { | |
| m_audioListeners.erase(handle); | |
| } | |
| void unregisterListener(FontHandle handle, FontListener* listener) | |
| { | |
| m_fontListeners.erase(handle); | |
| } | |
| void unregisterListener(ArtboardHandle handle, ArtboardListener* listener) | |
| { | |
| m_artboardListeners.erase(handle); | |
| } | |
| void unregisterListener(ViewModelInstanceHandle handle, | |
| ViewModelInstanceListener* listener) | |
| { | |
| m_viewModelListeners.erase(handle); | |
| } | |
| void unregisterListener(StateMachineHandle handle, | |
| StateMachineListener* listener) | |
| { | |
| m_stateMachineListeners.erase(handle); | |
| } | |
| enum class Command | |
| { | |
| loadFile, | |
| deleteFile, | |
| decodeImage, | |
| externalImage, | |
| decodeAudio, | |
| externalAudio, | |
| decodeFont, | |
| externalFont, | |
| deleteImage, | |
| deleteAudio, | |
| deleteFont, | |
| addImageFileAsset, | |
| addAudioFileAsset, | |
| addFontFileAsset, | |
| removeImageFileAsset, | |
| removeAudioFileAsset, | |
| removeFontFileAsset, | |
| instantiateArtboard, | |
| deleteArtboard, | |
| instantiateViewModel, | |
| refNestedViewModel, | |
| refListViewModel, | |
| instantiateBlankViewModel, | |
| instantiateViewModelForArtboard, | |
| instantiateBlankViewModelForArtboard, | |
| setViewModelInstanceValue, | |
| addViewModelListValue, | |
| removeViewModelListValue, | |
| swapViewModelListValue, | |
| subscribeViewModelProperty, | |
| unsubscribeViewModelProperty, | |
| deleteViewModel, | |
| instantiateStateMachine, | |
| deleteStateMachine, | |
| advanceStateMachine, | |
| bindViewModelInstance, | |
| runOnce, | |
| draw, | |
| pointerMove, | |
| pointerDown, | |
| pointerUp, | |
| pointerExit, | |
| disconnect, | |
| // This will cause processCommands to return once received. We want to | |
| // ensure that we do not indefinetly block the calling thread. This is | |
| // how we achieve that. | |
| commandLoopBreak, | |
| // messages | |
| listViewModelEnums, | |
| listArtboards, | |
| listStateMachines, | |
| getDefaultViewModel, | |
| listViewModels, | |
| listViewModelInstanceNames, | |
| listViewModelProperties, | |
| listViewModelPropertyValue, | |
| getViewModelListSize | |
| }; | |
| enum class Message | |
| { | |
| // Same as commandLoopBreak for processMessages | |
| messageLoopBreak, | |
| viewModelEnumsListed, | |
| artboardsListed, | |
| stateMachinesListed, | |
| defaultViewModelReceived, | |
| viewModelsListend, | |
| viewModelInstanceNamesListed, | |
| viewModelPropertiesListed, | |
| viewModelPropertyValueReceived, | |
| viewModelListSizeReceived, | |
| fileLoaded, | |
| fileDeleted, | |
| imageDecoded, | |
| imageDeleted, | |
| audioDecoded, | |
| audioDeleted, | |
| fontDecoded, | |
| fontDeleted, | |
| artboardDeleted, | |
| viewModelDeleted, | |
| stateMachineDeleted, | |
| stateMachineSettled, | |
| fileError, | |
| artboardError, | |
| viewModelError, | |
| imageError, | |
| audioError, | |
| fontError, | |
| stateMachineError | |
| }; | |
| friend class CommandServer; | |
| uint64_t m_currentFileHandleIdx = 0; | |
| uint64_t m_currentListHandleIdx = 0; | |
| uint64_t m_currentFontHandleIdx = 0; | |
| uint64_t m_currentArtboardHandleIdx = 0; | |
| uint64_t m_currentViewModelHandleIdx = 0; | |
| uint64_t m_currentRenderImageHandleIdx = 0; | |
| uint64_t m_currentAudioSourceHandleIdx = 0; | |
| uint64_t m_currentStateMachineHandleIdx = 0; | |
| uint64_t m_currentDrawKeyIdx = 0; | |
| std::mutex m_commandMutex; | |
| std::condition_variable m_commandConditionVariable; | |
| PODStream m_commandStream; | |
| ObjectStream<rcp<RenderImage>> m_externalImages; | |
| ObjectStream<rcp<AudioSource>> m_externalAudioSources; | |
| ObjectStream<rcp<Font>> m_externalFonts; | |
| ObjectStream<std::vector<uint8_t>> m_byteVectors; | |
| ObjectStream<PointerEvent> m_pointerEvents; | |
| ObjectStream<std::string> m_names; | |
| ObjectStream<CommandServerCallback> m_callbacks; | |
| ObjectStream<CommandServerDrawCallback> m_drawCallbacks; | |
| // Messages streams | |
| std::mutex m_messageMutex; | |
| PODStream m_messageStream; | |
| ObjectStream<std::string> m_messageNames; | |
| // Listeners | |
| FileListener* m_globalFileListener = nullptr; | |
| RenderImageListener* m_globalImageListener = nullptr; | |
| AudioSourceListener* m_globalAudioListener = nullptr; | |
| FontListener* m_globalFontListener = nullptr; | |
| ArtboardListener* m_globalArtboardListener = nullptr; | |
| ViewModelInstanceListener* m_globalViewModelListener = nullptr; | |
| StateMachineListener* m_globalStateMachineListener = nullptr; | |
| std::unordered_map<FileHandle, FileListener*> m_fileListeners; | |
| std::unordered_map<RenderImageHandle, RenderImageListener*> | |
| m_imageListeners; | |
| std::unordered_map<AudioSourceHandle, AudioSourceListener*> | |
| m_audioListeners; | |
| std::unordered_map<FontHandle, FontListener*> m_fontListeners; | |
| std::unordered_map<ArtboardHandle, ArtboardListener*> m_artboardListeners; | |
| std::unordered_map<ViewModelInstanceHandle, ViewModelInstanceListener*> | |
| m_viewModelListeners; | |
| std::unordered_map<StateMachineHandle, StateMachineListener*> | |
| m_stateMachineListeners; | |
| }; | |
| }; // namespace rive |