Geometry nodes support

Plugins~/CMakeLists.txt

@@ -53,7 +53,7 @@ include(UnityPackage)
 setup_unity_package_version()
 add_definitions(-DMESHSYNC_DCC_PLUGIN_VER="${UNITY_PACKAGE_VERSION}")
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
 
 # Force Unicode character set
 add_definitions(-DUNICODE -D_UNICODE)

Plugins~/Src/MeshSyncClientBlender/BlenderPyObjects/BlenderPyContext.cpp

@@ -11,6 +11,13 @@ PropertyRNA* BlenderPyContext_blend_data = nullptr;
 PropertyRNA* BlenderPyContext_scene = nullptr;
 FunctionRNA* BlenderPyContext_evaluated_depsgraph_get = nullptr;
 FunctionRNA* BlenderPyContext_depsgraph_update = nullptr;
+PropertyRNA* BlenderPyContext_depsgraph_object_instances = nullptr;
+PropertyRNA* BlenderPyContext_depsgraph_instance_object = nullptr;
+PropertyRNA* BlenderPyContext_depsgraph_is_instance = nullptr;
+PropertyRNA* BlenderPyContext_depsgraph_world_matrix = nullptr;
+PropertyRNA* BlenderPyContext_depsgraph_parent = nullptr;
+PropertyRNA* BlenderPyContext_depsgraph_object = nullptr;
+
 
 
 BlenderPyContext BlenderPyContext::get()
@@ -36,5 +43,74 @@ void BlenderPyContext::UpdateDepsgraph(Depsgraph* depsgraph) {
     call<Depsgraph, void>(g_context, depsgraph, BlenderPyContext_depsgraph_update);
 }
 
+void BlenderPyContext::object_instances_begin(CollectionPropertyIterator* it, Depsgraph* depsgraph) {
+
+    PointerRNA rna;
+    rna.data = depsgraph;
+
+    CollectionPropertyRNA* cprop = (CollectionPropertyRNA*)BlenderPyContext_depsgraph_object_instances;
+
+    cprop->begin(it, &rna);
+}
+
+void BlenderPyContext::object_instances_end(CollectionPropertyIterator* it) {
+
+    CollectionPropertyRNA* cprop = (CollectionPropertyRNA*)BlenderPyContext_depsgraph_object_instances;
+    cprop->end(it);
+}
+
+void BlenderPyContext::object_instances_next(CollectionPropertyIterator * it){
+    CollectionPropertyRNA* cprop = (CollectionPropertyRNA*)BlenderPyContext_depsgraph_object_instances;
+    cprop->next(it);
+}
+
+PointerRNA BlenderPyContext::object_instances_get(CollectionPropertyIterator* it) {
+
+    auto collectionProp = (CollectionPropertyRNA*)BlenderPyContext_depsgraph_object_instances;
+    return collectionProp->get(it);
+
+}
+
+Object* BlenderPyContext::instance_object_get(PointerRNA instance) {
+    auto objectInstanceProp = (PointerPropertyRNA*)BlenderPyContext_depsgraph_instance_object;
+    auto object = objectInstanceProp->get(&instance);
+
+    if (object.type == nullptr || object.data == nullptr) {
+        return nullptr;
+    }
+
+    return (Object*)object.data;
+}
+
+
+
+bool BlenderPyContext::object_instances_is_instance(PointerRNA object) {
+    auto booleanProp = (BoolPropertyRNA*)BlenderPyContext_depsgraph_is_instance;
+    return booleanProp->get(&object);
+}
+
+void BlenderPyContext::world_matrix_get(PointerRNA* instance, mu::float4x4* result)
+{
+    auto floatProp = (FloatPropertyRNA*)BlenderPyContext_depsgraph_world_matrix;
+    floatProp->getarray(instance, &(result->m[0][0])); // Sean Dillon - TODO: is the matrix object memory guaranteed to be aligned?
+}
+
+Object* BlenderPyContext::instance_parent_get(PointerRNA* instance) {
+    auto pointerProp = (PointerPropertyRNA*)BlenderPyContext_depsgraph_parent;
+    auto parent = pointerProp->get(instance);
+
+    return (Object*)parent.data;
+}
+
+Object* BlenderPyContext::object_get(PointerRNA instance) {
+    auto objectInstanceProp = (PointerPropertyRNA*)BlenderPyContext_depsgraph_object;
+    auto object = objectInstanceProp->get(&instance);
+
+    if (object.type == nullptr || object.data == nullptr) {
+        return nullptr;
+    }
+
+    return (Object*)object.data;
+}
 
 } // namespace blender

Plugins~/Src/MeshSyncClientBlender/BlenderPyObjects/BlenderPyContext.h

@@ -2,6 +2,7 @@
 
 #include <BKE_context.h> //bContext
 #include "msblenMacros.h" //MSBLEN_BOILERPLATE2
+#include "MeshUtils/muMath.h"
 
 namespace blender
 {
@@ -18,6 +19,17 @@ namespace blender
 
         static void UpdateDepsgraph(Depsgraph* depsgraph);
 
+        void object_instances_begin(CollectionPropertyIterator* it, Depsgraph* depsgrah);
+        void object_instances_end(CollectionPropertyIterator* it);
+        void object_instances_next(CollectionPropertyIterator* it);
+        PointerRNA object_instances_get(CollectionPropertyIterator* it);
+
+
+        Object* instance_object_get(PointerRNA instance);
+        bool object_instances_is_instance(PointerRNA instance);
+        void world_matrix_get(PointerRNA* instance, mu::float4x4* world_matrix);
+        Object* instance_parent_get(PointerRNA* instance);
+        Object* object_get(PointerRNA instance);
     };
 
 } // namespace blender

Plugins~/Src/MeshSyncClientBlender/BlenderPyObjects/BlenderPyDepsgraphUpdate.cpp

@@ -0,0 +1,41 @@
+#include "BlenderPyDepsgraphUpdate.h"
+#include "BlenderPyCommon.h"
+
+namespace blender {
+
+	PropertyRNA* BlenderPyDepsgraphUpdate_updates = nullptr;
+	FunctionRNA* BlenderPyDepsgraphUpdate_id_type_updated = nullptr;
+	extern bContext* g_context;
+
+
+	CollectionPropertyRNA* get_property() {
+		return (CollectionPropertyRNA*)BlenderPyDepsgraphUpdate_updates;
+	}
+
+	void blender::BlenderPyDepgraphUpdate::updates_begin(CollectionPropertyIterator* it, Depsgraph* graph)
+	{
+		PointerRNA rna;
+		rna.data = graph;
+		get_property()->begin(it, &rna);
+	}
+
+	void blender::BlenderPyDepgraphUpdate::updates_next(CollectionPropertyIterator* it)
+	{
+		get_property()->next(it);
+	}
+
+	void blender::BlenderPyDepgraphUpdate::updates_end(CollectionPropertyIterator* it)
+	{
+		get_property()->end(it);
+	}
+
+	PointerRNA blender::BlenderPyDepgraphUpdate::updates_get(CollectionPropertyIterator* it)
+	{
+		return get_property()->get(it);
+	}
+
+	bool blender::BlenderPyDepgraphUpdate::id_type_updated(int type, Depsgraph* graph) {
+
+		return call<Depsgraph, bool, int>(g_context, graph, BlenderPyDepsgraphUpdate_id_type_updated, type);
+	}
+}

Plugins~/Src/MeshSyncClientBlender/BlenderPyObjects/BlenderPyDepsgraphUpdate.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <BKE_context.h> //bContext
+#include "MeshUtils/muMath.h"
+#include <DNA_modifier_types.h>
+#include <RNA_define.h> 
+
+namespace blender
+{
+    class BlenderPyDepgraphUpdate
+    {
+    public:
+
+        void updates_begin(CollectionPropertyIterator* it, Depsgraph* graph);
+        void updates_next(CollectionPropertyIterator* it);
+        void updates_end(CollectionPropertyIterator* it);
+        PointerRNA updates_get(CollectionPropertyIterator* it);
+
+        bool id_type_updated(int type, Depsgraph* graph);
+    };
+
+} // namespace blender

Plugins~/Src/MeshSyncClientBlender/BlenderPyObjects/BlenderPyNodeTree.cpp

@@ -0,0 +1,91 @@
+#include "pch.h"
+#include "BlenderPyNodeTree.h"
+
+namespace blender {
+
+	PropertyRNA* BlenderPyNodeTree_inputs = nullptr;
+	PropertyRNA* BlenderPyNodeTree_nodes = nullptr;
+	PropertyRNA* BlenderPyNodeTree_outputs = nullptr;
+	StructRNA* BlenderPyNodeTree_Tree = nullptr;
+
+	void begin(CollectionPropertyIterator* it, const bNodeTree* nodeTree, PropertyRNA* prop) {
+		auto cprop = (CollectionPropertyRNA*)prop;
+		PointerRNA rna;
+		rna.data = &nodeTree;
+		cprop->begin(it, &rna);
+	}
+
+	void next(CollectionPropertyIterator* it, PropertyRNA* prop) {
+		auto cprop = (CollectionPropertyRNA*)prop;
+		cprop->next(it);
+	}
+
+	void end(CollectionPropertyIterator* it, PropertyRNA* prop) {
+		auto cprop = (CollectionPropertyRNA*)prop;
+		cprop->end(it);
+	}
+
+	PointerRNA get(CollectionPropertyIterator* it, PropertyRNA* prop) {
+		auto cprop = (CollectionPropertyRNA*)prop;
+		return cprop->get(it);
+	}
+
+	/**Inputs**/
+	void BlenderPyNodeTree::inputs_begin(CollectionPropertyIterator* it, bNodeTree* nodeTree)
+	{
+		begin(it , nodeTree, BlenderPyNodeTree_inputs);
+	}
+	void BlenderPyNodeTree::inputs_next(CollectionPropertyIterator* it)
+	{
+		next(it, BlenderPyNodeTree_inputs);
+	}
+	void BlenderPyNodeTree::inputs_end(CollectionPropertyIterator* it)
+	{
+		end(it, BlenderPyNodeTree_inputs);
+	}
+
+	PointerRNA BlenderPyNodeTree::inputs_get(CollectionPropertyIterator* it)
+	{
+		return get(it, BlenderPyNodeTree_inputs);
+	}
+
+	void BlenderPyNodeTree::outputs_begin(CollectionPropertyIterator* it, bNodeTree* nodeTree)
+	{
+		begin(it, nodeTree, BlenderPyNodeTree_outputs);
+	}
+
+	void BlenderPyNodeTree::outputs_next(CollectionPropertyIterator* it)
+	{
+		next(it, BlenderPyNodeTree_outputs);
+	}
+
+	void BlenderPyNodeTree::outputs_end(CollectionPropertyIterator* it)
+	{
+		end(it, BlenderPyNodeTree_outputs);
+	}
+
+	PointerRNA BlenderPyNodeTree::outputs_get(CollectionPropertyIterator* it)
+	{
+		return get(it, BlenderPyNodeTree_outputs);
+	}
+
+	/*Outputs*/
+
+
+	/*Nodes*/
+	void BlenderPyNodeTree::nodes_begin(CollectionPropertyIterator* it, const bNodeTree* nodeTree) {
+		begin(it, nodeTree, BlenderPyNodeTree_nodes);
+	}
+
+	void BlenderPyNodeTree::nodes_next(CollectionPropertyIterator* it) {
+		next(it, BlenderPyNodeTree_nodes);
+	}
+
+	void BlenderPyNodeTree::nodes_end(CollectionPropertyIterator* it) {
+		end(it, BlenderPyNodeTree_nodes);
+	}
+
+	PointerRNA BlenderPyNodeTree::nodes_get(CollectionPropertyIterator* it) {
+		return get(it, BlenderPyNodeTree_nodes);
+	}
+}

Plugins~/Src/MeshSyncClientBlender/BlenderPyObjects/BlenderPyNodeTree.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <BKE_context.h> //bContext
+#include "MeshUtils/muMath.h"
+#include <DNA_modifier_types.h>
+#include <RNA_define.h> 
+
+namespace blender
+{
+    class BlenderPyNodeTree
+    {
+    public:
+
+        /*Inputs*/
+        void inputs_begin(CollectionPropertyIterator* it, bNodeTree* nodeTree);
+        void inputs_next(CollectionPropertyIterator* it);
+        void inputs_end(CollectionPropertyIterator* it);
+        PointerRNA inputs_get(CollectionPropertyIterator* it);
+
+        /*Outputs*/
+        void outputs_begin(CollectionPropertyIterator* it, bNodeTree* nodeTree);
+        void outputs_next(CollectionPropertyIterator* it);
+        void outputs_end(CollectionPropertyIterator* it);
+        PointerRNA outputs_get(CollectionPropertyIterator* it);
+
+        /*Nodes*/
+        void nodes_begin(CollectionPropertyIterator* it, const bNodeTree* nodeTree);
+        void nodes_next(CollectionPropertyIterator* it);
+        void nodes_end(CollectionPropertyIterator* it);
+        PointerRNA nodes_get(CollectionPropertyIterator* it);
+    };
+
+} // namespace blender

Plugins~/Src/MeshSyncClientBlender/MeshSyncClientBlender.cpp

@@ -1,11 +1,27 @@
 #include "pch.h"
 #include "msblenBinder.h"
 #include "msblenContext.h"
+#include "BlenderPyObjects/BlenderPyDepsgraphUpdate.h"
+#include "BlenderPyObjects/BlenderPyContext.h"
 
 #include "MeshSyncClient/ExportTarget.h"
 
 namespace bl = blender;
 
+static Depsgraph* DepsgraphFromPyObject(py::object graphObj) {
+    Depsgraph* graph;
+    BPy_StructRNA* rna = (BPy_StructRNA*)graphObj.ptr();
+    auto typeName = rna->ob_base.ob_type->tp_name;
+
+    if (strcmp(typeName, "Depsgraph") != 0) {
+        return nullptr;
+    }
+
+    blender::rna_sdata(graphObj, graph);
+
+    return graph;
+}
+
 static bool msblenSend(msblenContext& self, MeshSyncClient::ExportTarget target, MeshSyncClient::ObjectScope scope)
 {
     if (!self.isServerAvailable()) {
@@ -122,7 +138,7 @@ PYBIND11_MODULE(MeshSyncClientBlender, m)
                 [](self_t& self, bool v) { self->getSettings().make_double_sided = v; })
             BindProperty(bake_modifiers,
                 [](const self_t& self) { return self->getSettings().BakeModifiers; },
-                [](self_t& self, bool v) { self->getSettings().BakeModifiers= v; })
+                [](self_t& self, bool v) { self->getSettings().BakeModifiers = v; })
             BindProperty(bake_transform,
                 [](const self_t& self) { return self->getSettings().BakeTransform; },
                 [](self_t& self, bool v) { self->getSettings().BakeTransform = v; })
@@ -157,7 +173,11 @@ PYBIND11_MODULE(MeshSyncClientBlender, m)
             BindMethod(clear, [](self_t& self) { self->clear(); })
             BindMethod(exportUpdatedObjects, [](self_t& self) { self->sendObjects(MeshSyncClient::ObjectScope::Updated, false); })
             BindMethod(export, [](self_t& self, int _target) { msblenSend(*self, (MeshSyncClient::ExportTarget)_target, MeshSyncClient::ObjectScope::All); })
-            ;
+            BindMethod(OnDepsgraphUpdatePost,
+                [](self_t& self, py::object depsgraph) {
+                    auto graph = DepsgraphFromPyObject(depsgraph);
+                    self->onDepsgraphUpdatedPost(graph);
+                });
     }
     {
         using self_t = CacheProxy;