| #ifndef _RIVE_FILE_HPP_ |
| #define _RIVE_FILE_HPP_ |
| |
| #include "rive/artboard.hpp" |
| #include "rive/backboard.hpp" |
| #include "rive/factory.hpp" |
| #include "rive/file_asset_resolver.hpp" |
| #include <vector> |
| |
| /// |
| /// Default namespace for Rive Cpp runtime code. |
| /// |
| namespace rive { |
| class BinaryReader; |
| class RuntimeHeader; |
| class Factory; |
| |
| /// |
| /// Tracks the success/failure result when importing a Rive file. |
| /// |
| enum class ImportResult { |
| /// Indicates that a file's been successfully imported. |
| success, |
| /// Indicates that the Rive file is not supported by this runtime. |
| unsupportedVersion, |
| /// Indicates that the there is a formatting problem in the file itself. |
| malformed |
| }; |
| |
| /// |
| /// A Rive file. |
| /// |
| class File { |
| public: |
| /// Major version number supported by the runtime. |
| static const int majorVersion = 7; |
| /// Minor version number supported by the runtime. |
| static const int minorVersion = 0; |
| |
| private: |
| /// The file's backboard. All Rive files have a single backboard |
| /// where the artboards live. |
| std::unique_ptr<Backboard> m_Backboard; |
| |
| /// We just keep these alive for the life of this File |
| std::vector<std::unique_ptr<FileAsset>> m_FileAssets; |
| |
| /// List of artboards in the file. Each artboard encapsulates a set of |
| /// Rive components and animations. |
| std::vector<std::unique_ptr<Artboard>> m_Artboards; |
| |
| Factory* m_Factory; |
| |
| /// The helper used to resolve assets when they're not provided in-band |
| /// with the file. |
| FileAssetResolver* m_AssetResolver; |
| |
| File(Factory*, FileAssetResolver*); |
| |
| public: |
| ~File(); |
| |
| /// |
| /// Imports a Rive file from a binary buffer. |
| /// @param data the raw date of the file. |
| /// @param result is an optional status result. |
| /// @param assetResolver is an optional helper to resolve assets which |
| /// cannot be found in-band. |
| /// @returns a pointer to the file, or null on failure. |
| static std::unique_ptr<File> import(Span<const uint8_t> data, |
| Factory*, |
| ImportResult* result = nullptr, |
| FileAssetResolver* assetResolver = nullptr); |
| |
| /// @returns the file's backboard. All files have exactly one backboard. |
| Backboard* backboard() const { return m_Backboard.get(); } |
| |
| /// @returns the number of artboards in the file. |
| size_t artboardCount() const { return m_Artboards.size(); } |
| std::string artboardNameAt(size_t index) const; |
| |
| // Instances |
| std::unique_ptr<ArtboardInstance> artboardDefault() const; |
| std::unique_ptr<ArtboardInstance> artboardAt(size_t index) const; |
| std::unique_ptr<ArtboardInstance> artboardNamed(std::string name) const; |
| |
| Artboard* artboard() const; |
| |
| /// @returns the named artboard. If no artboard is found with that name, |
| /// the null pointer is returned. |
| Artboard* artboard(std::string name) const; |
| |
| /// @returns the artboard at the specified index, or the nullptr if the |
| /// index is out of range. |
| Artboard* artboard(size_t index) const; |
| |
| private: |
| ImportResult read(BinaryReader&, const RuntimeHeader&); |
| }; |
| } // namespace rive |
| #endif |