feature: add support for relative view model data bind paths for nested artboards (#11344) 923b32059d

feature: add support for relative view model data bind paths

Co-authored-by: hernan <hernan@rive.app>

Author: bodymovin

.rive_head

@@ -1 +1 @@
-699b891b79a7af1220616e0900a3d4d5d1c40448
+923b32059d2ea012fdb47ae141b304f57095a48b

dev/defs/data_bind/data_bind_path.json

@@ -0,0 +1,29 @@
+{
+  "name": "DataBindPath",
+  "key": {
+    "int": 643,
+    "string": "databindpath"
+  },
+  "properties": {
+    "path": {
+      "type": "List<Id>",
+      "typeRuntime": "Bytes",
+      "encoded": true,
+      "initialValue": "[]",
+      "key": {
+        "int": 920,
+        "string": "path"
+      },
+      "description": "Path to the selected property"
+    },
+    "isRelative": {
+      "type": "bool",
+      "initialValue": "false",
+      "key": {
+        "int": 921,
+        "string": "isrelative"
+      },
+      "description": "Whether the data bind path is relative"
+    }
+  }
+}

dev/defs/nested_artboard.json

@@ -29,6 +29,16 @@
       },
       "description": "Path to the selected property."
     },
+    "isDataBindPathRelative": {
+      "type": "bool",
+      "initialValue": "false",
+      "key": {
+        "int": 916,
+        "string": "isdatabindpathrelative"
+      },
+      "description": "Whether the data bind path is relative",
+      "runtime": false
+    },
     "isPaused": {
       "type": "bool",
       "initialValue": "false",

include/rive/artboard_host.hpp

@@ -2,6 +2,7 @@
 #define _RIVE_ARTBOARD_HOST_HPP_
 #include "rive/refcnt.hpp"
 #include "rive/file.hpp"
+#include "rive/data_bind_path_referencer.hpp"
 #include <stdio.h>
 namespace rive
 {
@@ -10,12 +11,11 @@ class DataBind;
 class DataContext;
 class ViewModelInstance;
 
-class ArtboardHost
+class ArtboardHost : public DataBindPathReferencer
 {
 public:
     virtual size_t artboardCount() = 0;
     virtual ArtboardInstance* artboardInstance(int index = 0) = 0;
-    virtual std::vector<uint32_t> dataBindPathIds() { return {}; }
     virtual void internalDataContext(DataContext* dataContext) = 0;
     virtual void bindViewModelInstance(rcp<ViewModelInstance> viewModelInstance,
                                        DataContext* parent) = 0;

include/rive/assets/manifest_asset.hpp

@@ -1,17 +1,21 @@
 #ifndef _RIVE_MANIFEST_ASSET_HPP_
 #define _RIVE_MANIFEST_ASSET_HPP_
 #include "rive/generated/assets/manifest_asset_base.hpp"
-#include "rive/name_resolver.hpp"
+#include "rive/data_resolver.hpp"
 #include <stdio.h>
 #include <unordered_map>
 #include <string>
 namespace rive
 {
-class ManifestAsset : public ManifestAssetBase, public NameResolver
+class ManifestAsset : public ManifestAssetBase, public DataResolver
 {
 private:
     std::unordered_map<int, std::string> m_names;
+    std::unordered_map<int, std::vector<uint32_t>> m_paths;
     static const std::string empty;
+    static const std::vector<uint32_t> emptyIntVector;
+    bool decodeNames(BinaryReader& reader);
+    bool decodePaths(BinaryReader& reader);
 
 protected:
     bool addsToBackboard() override { return false; }
@@ -20,6 +24,7 @@ class ManifestAsset : public ManifestAssetBase, public NameResolver
     bool decode(SimpleArray<uint8_t>&, Factory*) override;
     std::string fileExtension() const override;
     const std::string& resolveName(int id) override;
+    const std::vector<uint32_t>& resolvePath(int id) override;
 };
 } // namespace rive
 

include/rive/data_bind/data_bind_context.hpp

@@ -17,6 +17,10 @@ class DataBindContext : public DataBindContextBase
     void decodeSourcePathIds(Span<const uint8_t> value) override;
     void copySourcePathIds(const DataBindContextBase& object) override;
     void bindFromContext(DataContext* dataContext);
+
+private:
+    void resolvePath();
+    bool m_isPathResolved = false;
 };
 } // namespace rive
 

include/rive/data_bind/data_bind_path.hpp

@@ -0,0 +1,29 @@
+#ifndef _RIVE_DATA_BIND_PATH_HPP_
+#define _RIVE_DATA_BIND_PATH_HPP_
+#include "rive/generated/data_bind/data_bind_path_base.hpp"
+#include <stdio.h>
+namespace rive
+{
+class File;
+class DataBindPath : public DataBindPathBase
+{
+public:
+    void decodePath(Span<const uint8_t> value) override;
+    void copyPath(const DataBindPathBase& object) override;
+    StatusCode import(ImportStack& importStack) override;
+    std::vector<uint32_t>& path() { return m_pathBuffer; }
+    const std::vector<uint32_t>& resolvedPath();
+    void file(File* value);
+    File* file() { return m_file; };
+    void resolved(bool value) { m_resolved = value; }
+
+protected:
+    std::vector<uint32_t> m_pathBuffer;
+
+private:
+    File* m_file = nullptr;
+    bool m_resolved = false;
+};
+} // namespace rive
+
+#endif

include/rive/data_bind/data_context.hpp

@@ -2,11 +2,12 @@
 #define _RIVE_DATA_CONTEXT_HPP_
 #include "rive/viewmodel/viewmodel_instance_value.hpp"
 #include "rive/viewmodel/viewmodel_instance.hpp"
-#include "rive/name_resolver.hpp"
+#include "rive/data_resolver.hpp"
 #include "rive/refcnt.hpp"
 
 namespace rive
 {
+class DataBindPath;
 class DataContext
 {
 private:
@@ -22,9 +23,13 @@ class DataContext
         const std::vector<uint32_t> path) const;
     ViewModelInstanceValue* getRelativeViewModelProperty(
         const std::vector<uint32_t> path,
-        NameResolver* resolver) const;
+        DataResolver* resolver) const;
     rcp<ViewModelInstance> getViewModelInstance(
         const std::vector<uint32_t> path) const;
+    rcp<ViewModelInstance> getViewModelInstance(DataBindPath*) const;
+    rcp<ViewModelInstance> getRelativeViewModelInstance(
+        const std::vector<uint32_t> path,
+        DataResolver* resolver) const;
     void viewModelInstance(rcp<ViewModelInstance> value);
     void advanced();
     rcp<ViewModelInstance> viewModelInstance() { return m_ViewModelInstance; };

include/rive/data_bind_path_referencer.hpp

@@ -0,0 +1,23 @@
+#ifndef _RIVE_DATA_BIND_PATH_REFERENCER_HPP_
+#define _RIVE_DATA_BIND_PATH_REFERENCER_HPP_
+#include <stdio.h>
+#include "rive/data_bind/data_bind_path.hpp"
+namespace rive
+{
+class File;
+class DataBindPathReferencer
+{
+public:
+    ~DataBindPathReferencer();
+    DataBindPath* dataBindPath() const { return m_dataBindPath; }
+
+    void copyDataBindPath(DataBindPath* dataBindPath);
+    void importDataBindPath(ImportStack& importStack);
+    void decodeDataBindPath(Span<const uint8_t>& value);
+
+protected:
+    DataBindPath* m_dataBindPath = nullptr;
+};
+} // namespace rive
+
+#endif

include/rive/data_resolver.hpp

@@ -0,0 +1,15 @@
+#ifndef _RIVE_DATA_RESOLVER_HPP_
+#define _RIVE_DATA_RESOLVER_HPP_
+#include <stdio.h>
+#include <string>
+namespace rive
+{
+class DataResolver
+{
+public:
+    virtual const std::string& resolveName(int id) = 0;
+    virtual const std::vector<uint32_t>& resolvePath(int id) = 0;
+};
+} // namespace rive
+
+#endif