update functiondeform modifier to using functions2

4 files changed, 117 insertions, 134 deletions

diff --git a/source/blender/functions2/intern/multi_functions/mixed.cc b/source/blender/functions2/intern/multi_functions/mixed.cc
index 7aa387793f7..15f6ff3b7de 100644
--- a/source/blender/functions2/intern/multi_functions/mixed.cc
+++ b/source/blender/functions2/intern/multi_functions/mixed.cc
@@ -13,7 +13,7 @@ namespace FN {
 
 using BLI::float3;
 
-MultiFunction_AddFloats::MultiFunction_AddFloats()
+MF_AddFloats::MF_AddFloats()
 {
   MFSignatureBuilder signature("Add Floats");
   signature.readonly_single_input<float>("A");
@@ -22,9 +22,7 @@ MultiFunction_AddFloats::MultiFunction_AddFloats()
   this->set_signature(signature);
 }
 
-void MultiFunction_AddFloats::call(const MFMask &mask,
-                                   MFParams &params,
-                                   MFContext &UNUSED(context)) const
+void MF_AddFloats::call(const MFMask &mask, MFParams &params, MFContext &UNUSED(context)) const
 {
   auto a = params.readonly_single_input<float>(0, "A");
   auto b = params.readonly_single_input<float>(1, "B");
@@ -35,7 +33,7 @@ void MultiFunction_AddFloats::call(const MFMask &mask,
   }
 }
 
-MultiFunction_AddFloat3s::MultiFunction_AddFloat3s()
+MF_AddFloat3s::MF_AddFloat3s()
 {
   MFSignatureBuilder signature("Add Float3s");
   signature.readonly_single_input<float3>("A");
@@ -44,9 +42,7 @@ MultiFunction_AddFloat3s::MultiFunction_AddFloat3s()
   this->set_signature(signature);
 }
 
-void MultiFunction_AddFloat3s::call(const MFMask &mask,
-                                    MFParams &params,
-                                    MFContext &UNUSED(context)) const
+void MF_AddFloat3s::call(const MFMask &mask, MFParams &params, MFContext &UNUSED(context)) const
 {
   auto a = params.readonly_single_input<float3>(0, "A");
   auto b = params.readonly_single_input<float3>(1, "B");
@@ -57,7 +53,7 @@ void MultiFunction_AddFloat3s::call(const MFMask &mask,
   }
 }
 
-MultiFunction_CombineVector::MultiFunction_CombineVector()
+MF_CombineVector::MF_CombineVector()
 {
   MFSignatureBuilder signature("Combine Vector");
   signature.readonly_single_input<float>("X");
@@ -67,9 +63,7 @@ MultiFunction_CombineVector::MultiFunction_CombineVector()
   this->set_signature(signature);
 }
 
-void MultiFunction_CombineVector::call(const MFMask &mask,
-                                       MFParams &params,
-                                       MFContext &UNUSED(context)) const
+void MF_CombineVector::call(const MFMask &mask, MFParams &params, MFContext &UNUSED(context)) const
 {
   auto x = params.readonly_single_input<float>(0, "X");
   auto y = params.readonly_single_input<float>(1, "Y");
@@ -81,7 +75,7 @@ void MultiFunction_CombineVector::call(const MFMask &mask,
   }
 }
 
-MultiFunction_SeparateVector::MultiFunction_SeparateVector()
+MF_SeparateVector::MF_SeparateVector()
 {
   MFSignatureBuilder signature("Separate Vector");
   signature.readonly_single_input<float3>("Vector");
@@ -91,9 +85,9 @@ MultiFunction_SeparateVector::MultiFunction_SeparateVector()
   this->set_signature(signature);
 }
 
-void MultiFunction_SeparateVector::call(const MFMask &mask,
-                                        MFParams &params,
-                                        MFContext &UNUSED(context)) const
+void MF_SeparateVector::call(const MFMask &mask,
+                             MFParams &params,
+                             MFContext &UNUSED(context)) const
 {
   auto vector = params.readonly_single_input<float3>(0, "Vector");
   auto x = params.single_output<float>(1, "X");
@@ -108,7 +102,7 @@ void MultiFunction_SeparateVector::call(const MFMask &mask,
   }
 }
 
-MultiFunction_VectorDistance::MultiFunction_VectorDistance()
+MF_VectorDistance::MF_VectorDistance()
 {
   MFSignatureBuilder signature("Vector Distance");
   signature.readonly_single_input<float3>("A");
@@ -117,9 +111,9 @@ MultiFunction_VectorDistance::MultiFunction_VectorDistance()
   this->set_signature(signature);
 }
 
-void MultiFunction_VectorDistance::call(const MFMask &mask,
-                                        MFParams &params,
-                                        MFContext &UNUSED(context)) const
+void MF_VectorDistance::call(const MFMask &mask,
+                             MFParams &params,
+                             MFContext &UNUSED(context)) const
 {
   auto a = params.readonly_single_input<float3>(0, "A");
   auto b = params.readonly_single_input<float3>(1, "B");
@@ -130,7 +124,7 @@ void MultiFunction_VectorDistance::call(const MFMask &mask,
   }
 }
 
-MultiFunction_FloatArraySum::MultiFunction_FloatArraySum()
+MF_FloatArraySum::MF_FloatArraySum()
 {
   MFSignatureBuilder signature("Float Array Sum");
   signature.readonly_vector_input<float>("Array");
@@ -138,9 +132,7 @@ MultiFunction_FloatArraySum::MultiFunction_FloatArraySum()
   this->set_signature(signature);
 }
 
-void MultiFunction_FloatArraySum::call(const MFMask &mask,
-                                       MFParams &params,
-                                       MFContext &UNUSED(context)) const
+void MF_FloatArraySum::call(const MFMask &mask, MFParams &params, MFContext &UNUSED(context)) const
 {
   auto arrays = params.readonly_vector_input<float>(0, "Array");
   MutableArrayRef<float> sums = params.single_output<float>(1, "Sum");
@@ -155,7 +147,7 @@ void MultiFunction_FloatArraySum::call(const MFMask &mask,
   }
 }
 
-MultiFunction_FloatRange::MultiFunction_FloatRange()
+MF_FloatRange::MF_FloatRange()
 {
   MFSignatureBuilder signature("Float Range");
   signature.readonly_single_input<float>("Start");
@@ -165,9 +157,7 @@ MultiFunction_FloatRange::MultiFunction_FloatRange()
   this->set_signature(signature);
 }
 
-void MultiFunction_FloatRange::call(const MFMask &mask,
-                                    MFParams &params,
-                                    MFContext &UNUSED(context)) const
+void MF_FloatRange::call(const MFMask &mask, MFParams &params, MFContext &UNUSED(context)) const
 {
   auto starts = params.readonly_single_input<float>(0, "Start");
   auto steps = params.readonly_single_input<float>(1, "Step");
@@ -182,7 +172,7 @@ void MultiFunction_FloatRange::call(const MFMask &mask,
   }
 }
 
-MultiFunction_ObjectWorldLocation::MultiFunction_ObjectWorldLocation()
+MF_ObjectWorldLocation::MF_ObjectWorldLocation()
 {
   MFSignatureBuilder signature("Object Location");
   signature.readonly_single_input<Object *>("Object");
@@ -190,9 +180,9 @@ MultiFunction_ObjectWorldLocation::MultiFunction_ObjectWorldLocation()
   this->set_signature(signature);
 }
 
-void MultiFunction_ObjectWorldLocation::call(const MFMask &mask,
-                                             MFParams &params,
-                                             MFContext &UNUSED(context)) const
+void MF_ObjectWorldLocation::call(const MFMask &mask,
+                                  MFParams &params,
+                                  MFContext &UNUSED(context)) const
 {
   auto objects = params.readonly_single_input<Object *>(0, "Object");
   auto locations = params.single_output<float3>(1, "Location");
@@ -207,7 +197,7 @@ void MultiFunction_ObjectWorldLocation::call(const MFMask &mask,
   }
 }
 
-MultiFunction_TextLength::MultiFunction_TextLength()
+MF_TextLength::MF_TextLength()
 {
   MFSignatureBuilder signature("Text Length");
   signature.readonly_single_input<std::string>("Text");
@@ -215,9 +205,7 @@ MultiFunction_TextLength::MultiFunction_TextLength()
   this->set_signature(signature);
 }
 
-void MultiFunction_TextLength::call(const MFMask &mask,
-                                    MFParams &params,
-                                    MFContext &UNUSED(context)) const
+void MF_TextLength::call(const MFMask &mask, MFParams &params, MFContext &UNUSED(context)) const
 {
   auto texts = params.readonly_single_input<std::string>(0, "Text");
   auto lengths = params.single_output<int>(1, "Length");
@@ -227,8 +215,8 @@ void MultiFunction_TextLength::call(const MFMask &mask,
   }
 }
 
-MultiFunction_SimpleVectorize::MultiFunction_SimpleVectorize(const MultiFunction &function,
-                                                             ArrayRef<bool> input_is_vectorized)
+MF_SimpleVectorize::MF_SimpleVectorize(const MultiFunction &function,
+                                       ArrayRef<bool> input_is_vectorized)
     : m_function(function), m_input_is_vectorized(input_is_vectorized)
 {
   BLI_assert(input_is_vectorized.contains(true));
@@ -269,9 +257,7 @@ MultiFunction_SimpleVectorize::MultiFunction_SimpleVectorize(const MultiFunction
   this->set_signature(signature);
 }
 
-void MultiFunction_SimpleVectorize::call(const MFMask &mask,
-                                         MFParams &params,
-                                         MFContext &context) const
+void MF_SimpleVectorize::call(const MFMask &mask, MFParams &params, MFContext &context) const
 {
   if (mask.indices_amount() == 0) {
     return;
diff --git a/source/blender/functions2/intern/multi_functions/mixed.h b/source/blender/functions2/intern/multi_functions/mixed.h
index 0e470114ba3..4aaed4689d6 100644
--- a/source/blender/functions2/intern/multi_functions/mixed.h
+++ b/source/blender/functions2/intern/multi_functions/mixed.h
@@ -4,66 +4,66 @@
 
 namespace FN {
 
-class MultiFunction_AddFloats final : public MultiFunction {
+class MF_AddFloats final : public MultiFunction {
  public:
-  MultiFunction_AddFloats();
+  MF_AddFloats();
   void call(const MFMask &mask, MFParams &params, MFContext &context) const override;
 };
 
-class MultiFunction_AddFloat3s final : public MultiFunction {
+class MF_AddFloat3s final : public MultiFunction {
  public:
-  MultiFunction_AddFloat3s();
+  MF_AddFloat3s();
   void call(const MFMask &mask, MFParams &params, MFContext &context) const override;
 };
 
-class MultiFunction_CombineVector final : public MultiFunction {
+class MF_CombineVector final : public MultiFunction {
  public:
-  MultiFunction_CombineVector();
+  MF_CombineVector();
   void call(const MFMask &mask, MFParams &params, MFContext &context) const override;
 };
 
-class MultiFunction_SeparateVector final : public MultiFunction {
+class MF_SeparateVector final : public MultiFunction {
  public:
-  MultiFunction_SeparateVector();
+  MF_SeparateVector();
   void call(const MFMask &mask, MFParams &params, MFContext &context) const override;
 };
 
-class MultiFunction_VectorDistance final : public MultiFunction {
+class MF_VectorDistance final : public MultiFunction {
  public:
-  MultiFunction_VectorDistance();
+  MF_VectorDistance();
   void call(const MFMask &mask, MFParams &params, MFContext &context) const override;
 };
 
-class MultiFunction_FloatArraySum final : public MultiFunction {
+class MF_FloatArraySum final : public MultiFunction {
  public:
-  MultiFunction_FloatArraySum();
+  MF_FloatArraySum();
   void call(const MFMask &mask, MFParams &params, MFContext &context) const override;
 };
 
-class MultiFunction_FloatRange final : public MultiFunction {
+class MF_FloatRange final : public MultiFunction {
  public:
-  MultiFunction_FloatRange();
+  MF_FloatRange();
   void call(const MFMask &mask, MFParams &params, MFContext &context) const override;
 };
 
-class MultiFunction_ObjectWorldLocation final : public MultiFunction {
+class MF_ObjectWorldLocation final : public MultiFunction {
  public:
-  MultiFunction_ObjectWorldLocation();
+  MF_ObjectWorldLocation();
   void call(const MFMask &mask, MFParams &params, MFContext &context) const override;
 };
 
-class MultiFunction_TextLength final : public MultiFunction {
+class MF_TextLength final : public MultiFunction {
  public:
-  MultiFunction_TextLength();
+  MF_TextLength();
   void call(const MFMask &mask, MFParams &params, MFContext &context) const override;
 };
 
-template<typename T> class MultiFunction_ConstantValue : public MultiFunction {
+template<typename T> class MF_ConstantValue : public MultiFunction {
  private:
   T m_value;
 
  public:
-  MultiFunction_ConstantValue(T value) : m_value(std::move(value))
+  MF_ConstantValue(T value) : m_value(std::move(value))
   {
     MFSignatureBuilder signature("Constant " + GET_TYPE<T>().name());
     signature.single_output<T>("Output");
@@ -78,9 +78,9 @@ template<typename T> class MultiFunction_ConstantValue : public MultiFunction {
   }
 };
 
-template<typename FromT, typename ToT> class MultiFunction_Convert : public MultiFunction {
+template<typename FromT, typename ToT> class MF_Convert : public MultiFunction {
  public:
-  MultiFunction_Convert()
+  MF_Convert()
   {
     MFSignatureBuilder signature(GET_TYPE<FromT>().name() + " to " + GET_TYPE<ToT>().name());
     signature.readonly_single_input<FromT>("Input");
@@ -100,7 +100,7 @@ template<typename FromT, typename ToT> class MultiFunction_Convert : public Mult
   }
 };
 
-class MultiFunction_SimpleVectorize final : public MultiFunction {
+class MF_SimpleVectorize final : public MultiFunction {
  private:
   const MultiFunction &m_function;
   Vector<bool> m_input_is_vectorized;
@@ -108,7 +108,7 @@ class MultiFunction_SimpleVectorize final : public MultiFunction {
   Vector<uint> m_output_indices;
 
  public:
-  MultiFunction_SimpleVectorize(const MultiFunction &function, ArrayRef<bool> input_is_vectorized);
+  MF_SimpleVectorize(const MultiFunction &function, ArrayRef<bool> input_is_vectorized);
   void call(const MFMask &mask, MFParams &params, MFContext &context) const override;
 };
 
diff --git a/source/blender/modifiers/CMakeLists.txt b/source/blender/modifiers/CMakeLists.txt
index 3cfbac5ad9f..7ef0c4f18fa 100644
--- a/source/blender/modifiers/CMakeLists.txt
+++ b/source/blender/modifiers/CMakeLists.txt
@@ -27,6 +27,7 @@ set(INC
   ../bmesh
   ../depsgraph
   ../functions
+  ../functions2
   ../simulations
   ../makesdna
   ../makesrna
diff --git a/source/blender/modifiers/intern/MOD_functiondeform_cxx.cc b/source/blender/modifiers/intern/MOD_functiondeform_cxx.cc
index 3d406be86dd..a16e1de36bf 100644
--- a/source/blender/modifiers/intern/MOD_functiondeform_cxx.cc
+++ b/source/blender/modifiers/intern/MOD_functiondeform_cxx.cc
@@ -1,9 +1,8 @@
 #include "DNA_modifier_types.h"
 
 #include "BKE_virtual_node_tree_cxx.h"
-#include "BKE_multi_functions.h"
-#include "BKE_tuple.h"
-#include "BKE_multi_function_network.h"
+#include "FN_multi_functions.h"
+#include "FN_multi_function_network.h"
 
 #include "BLI_math_cxx.h"
 #include "BLI_string_map.h"
@@ -13,36 +12,6 @@
 
 #include "DEG_depsgraph_query.h"
 
-using BKE::CPPType;
-using BKE::GenericArrayRef;
-using BKE::GenericMutableArrayRef;
-using BKE::GenericVectorArray;
-using BKE::GenericVirtualListListRef;
-using BKE::GenericVirtualListRef;
-using BKE::MFBuilderDummyNode;
-using BKE::MFBuilderFunctionNode;
-using BKE::MFBuilderInputSocket;
-using BKE::MFBuilderNode;
-using BKE::MFBuilderOutputSocket;
-using BKE::MFBuilderSocket;
-using BKE::MFContext;
-using BKE::MFDataType;
-using BKE::MFDummyNode;
-using BKE::MFFunctionNode;
-using BKE::MFInputSocket;
-using BKE::MFMask;
-using BKE::MFNetwork;
-using BKE::MFNetworkBuilder;
-using BKE::MFNode;
-using BKE::MFOutputSocket;
-using BKE::MFParams;
-using BKE::MFParamsBuilder;
-using BKE::MFParamType;
-using BKE::MFSignature;
-using BKE::MFSignatureBuilder;
-using BKE::MFSocket;
-using BKE::MultiFunction;
-using BKE::TupleRef;
 using BKE::VirtualLink;
 using BKE::VirtualNode;
 using BKE::VirtualNodeTree;
@@ -58,6 +27,35 @@ using BLI::StringMap;
 using BLI::StringRef;
 using BLI::TemporaryVector;
 using BLI::Vector;
+using FN::CPPType;
+using FN::GenericArrayRef;
+using FN::GenericMutableArrayRef;
+using FN::GenericVectorArray;
+using FN::GenericVirtualListListRef;
+using FN::GenericVirtualListRef;
+using FN::MFBuilderDummyNode;
+using FN::MFBuilderFunctionNode;
+using FN::MFBuilderInputSocket;
+using FN::MFBuilderNode;
+using FN::MFBuilderOutputSocket;
+using FN::MFBuilderSocket;
+using FN::MFContext;
+using FN::MFDataType;
+using FN::MFDummyNode;
+using FN::MFFunctionNode;
+using FN::MFInputSocket;
+using FN::MFMask;
+using FN::MFNetwork;
+using FN::MFNetworkBuilder;
+using FN::MFNode;
+using FN::MFOutputSocket;
+using FN::MFParams;
+using FN::MFParamsBuilder;
+using FN::MFParamType;
+using FN::MFSignature;
+using FN::MFSignatureBuilder;
+using FN::MFSocket;
+using FN::MultiFunction;
 
 extern "C" {
 void MOD_functiondeform_do(FunctionDeformModifierData *fdmd, float (*vertexCos)[3], int numVerts);
@@ -110,26 +108,26 @@ static MFDataType get_type_by_socket(const VirtualSocket &vsocket)
 static const CPPType &get_cpp_type_by_name(StringRef name)
 {
   if (name == "Float") {
-    return BKE::GET_TYPE<float>();
+    return FN::GET_TYPE<float>();
   }
   else if (name == "Vector") {
-    return BKE::GET_TYPE<float3>();
+    return FN::GET_TYPE<float3>();
   }
   else if (name == "Integer") {
-    return BKE::GET_TYPE<int32_t>();
+    return FN::GET_TYPE<int32_t>();
   }
   else if (name == "Boolean") {
-    return BKE::GET_TYPE<bool>();
+    return FN::GET_TYPE<bool>();
   }
   else if (name == "Object") {
-    return BKE::GET_TYPE<Object *>();
+    return FN::GET_TYPE<Object *>();
   }
   else if (name == "Text") {
-    return BKE::GET_TYPE<std::string>();
+    return FN::GET_TYPE<std::string>();
   }
 
   BLI_assert(false);
-  return BKE::GET_TYPE<float>();
+  return FN::GET_TYPE<float>();
 }
 
 class VTreeMFNetwork {
@@ -405,8 +403,8 @@ static void INSERT_vector_math(VTreeMFNetworkBuilder &builder,
                                OwnedResources &resources,
                                const VirtualNode &vnode)
 {
-  const MultiFunction &fn = allocate_resource<BKE::MultiFunction_AddFloat3s>(
-      "vector math function", resources);
+  const MultiFunction &fn = allocate_resource<FN::MF_AddFloat3s>("vector math function",
+                                                                 resources);
   builder.add_function(fn, {0, 1}, {2}, vnode);
 }
 
@@ -427,7 +425,7 @@ static const MultiFunction &get_vectorized_function(
   }
 
   if (input_is_vectorized.contains(true)) {
-    return allocate_resource<BKE::MultiFunction_SimpleVectorize>(
+    return allocate_resource<FN::MF_SimpleVectorize>(
         "vectorized function", resources, base_function, input_is_vectorized);
   }
   else {
@@ -439,8 +437,8 @@ static void INSERT_float_math(VTreeMFNetworkBuilder &builder,
                               OwnedResources &resources,
                               const VirtualNode &vnode)
 {
-  const MultiFunction &base_fn = allocate_resource<BKE::MultiFunction_AddFloats>(
-      "float math function", resources);
+  const MultiFunction &base_fn = allocate_resource<FN::MF_AddFloats>("float math function",
+                                                                     resources);
   const MultiFunction &fn = get_vectorized_function(
       base_fn, resources, vnode.rna(), {"use_list__a", "use_list__b"});
 
@@ -451,8 +449,8 @@ static void INSERT_combine_vector(VTreeMFNetworkBuilder &builder,
                                   OwnedResources &resources,
                                   const VirtualNode &vnode)
 {
-  const MultiFunction &base_fn = allocate_resource<BKE::MultiFunction_CombineVector>(
-      "combine vector function", resources);
+  const MultiFunction &base_fn = allocate_resource<FN::MF_CombineVector>("combine vector function",
+                                                                         resources);
   const MultiFunction &fn = get_vectorized_function(
       base_fn, resources, vnode.rna(), {"use_list__x", "use_list__y", "use_list__z"});
   builder.add_function(fn, {0, 1, 2}, {3}, vnode);
@@ -462,7 +460,7 @@ static void INSERT_separate_vector(VTreeMFNetworkBuilder &builder,
                                    OwnedResources &resources,
                                    const VirtualNode &vnode)
 {
-  const MultiFunction &base_fn = allocate_resource<BKE::MultiFunction_SeparateVector>(
+  const MultiFunction &base_fn = allocate_resource<FN::MF_SeparateVector>(
       "separate vector function", resources);
   const MultiFunction &fn = get_vectorized_function(
       base_fn, resources, vnode.rna(), {"use_list__vector"});
@@ -478,7 +476,7 @@ static void INSERT_list_length(VTreeMFNetworkBuilder &builder,
   const CPPType &type = get_cpp_type_by_name(type_name);
   MEM_freeN(type_name);
 
-  const MultiFunction &fn = allocate_resource<BKE::MultiFunction_ListLength>(
+  const MultiFunction &fn = allocate_resource<FN::MF_ListLength>(
       "list length function", resources, type);
   builder.add_function(fn, {0}, {1}, vnode);
 }
@@ -492,7 +490,7 @@ static void INSERT_get_list_element(VTreeMFNetworkBuilder &builder,
   const CPPType &type = get_cpp_type_by_name(type_name);
   MEM_freeN(type_name);
 
-  const MultiFunction &fn = allocate_resource<BKE::MultiFunction_GetListElement>(
+  const MultiFunction &fn = allocate_resource<FN::MF_GetListElement>(
       "get list element function", resources, type);
   builder.add_function(fn, {0, 1, 2}, {3}, vnode);
 }
@@ -526,7 +524,7 @@ static MFBuilderOutputSocket &build_pack_list_node(VTreeMFNetworkBuilder &builde
   uint input_amount = input_is_list.size();
   uint output_param_index = (input_amount > 0 && input_is_list[0]) ? 0 : input_amount;
 
-  const MultiFunction &fn = allocate_resource<BKE::MultiFunction_PackList>(
+  const MultiFunction &fn = allocate_resource<FN::MF_PackList>(
       "pack list function", resources, base_type, input_is_list);
   MFBuilderFunctionNode &node = builder.add_function(
       fn, IndexRange(input_amount).as_array_ref(), {output_param_index});
@@ -556,7 +554,7 @@ static void INSERT_object_location(VTreeMFNetworkBuilder &builder,
                                    OwnedResources &resources,
                                    const VirtualNode &vnode)
 {
-  const MultiFunction &fn = allocate_resource<BKE::MultiFunction_ObjectWorldLocation>(
+  const MultiFunction &fn = allocate_resource<FN::MF_ObjectWorldLocation>(
       "object location function", resources);
   builder.add_function(fn, {0}, {1}, vnode);
 }
@@ -565,8 +563,8 @@ static void INSERT_text_length(VTreeMFNetworkBuilder &builder,
                                OwnedResources &resources,
                                const VirtualNode &vnode)
 {
-  const MultiFunction &fn = allocate_resource<BKE::MultiFunction_TextLength>(
-      "text length function", resources);
+  const MultiFunction &fn = allocate_resource<FN::MF_TextLength>("text length function",
+                                                                 resources);
   builder.add_function(fn, {0}, {1}, vnode);
 }
 
@@ -593,7 +591,7 @@ static MFBuilderOutputSocket &INSERT_vector_socket(VTreeMFNetworkBuilder &builde
   float3 value;
   RNA_float_get_array(&rna, "value", value);
 
-  const MultiFunction &fn = allocate_resource<BKE::MultiFunction_ConstantValue<float3>>(
+  const MultiFunction &fn = allocate_resource<FN::MF_ConstantValue<float3>>(
       "vector socket", resources, value);
   MFBuilderFunctionNode &node = builder.add_function(fn, {}, {0});
   return *node.outputs()[0];
@@ -606,7 +604,7 @@ static MFBuilderOutputSocket &INSERT_float_socket(VTreeMFNetworkBuilder &builder
   PointerRNA rna = vsocket.rna();
   float value = RNA_float_get(&rna, "value");
 
-  const MultiFunction &fn = allocate_resource<BKE::MultiFunction_ConstantValue<float>>(
+  const MultiFunction &fn = allocate_resource<FN::MF_ConstantValue<float>>(
       "float socket", resources, value);
   MFBuilderFunctionNode &node = builder.add_function(fn, {}, {0});
   return *node.outputs()[0];
@@ -619,7 +617,7 @@ static MFBuilderOutputSocket &INSERT_int_socket(VTreeMFNetworkBuilder &builder,
   PointerRNA rna = vsocket.rna();
   int value = RNA_int_get(&rna, "value");
 
-  const MultiFunction &fn = allocate_resource<BKE::MultiFunction_ConstantValue<int>>(
+  const MultiFunction &fn = allocate_resource<FN::MF_ConstantValue<int>>(
       "int socket", resources, value);
   MFBuilderFunctionNode &node = builder.add_function(fn, {}, {0});
   return *node.outputs()[0];
@@ -632,7 +630,7 @@ static MFBuilderOutputSocket &INSERT_object_socket(VTreeMFNetworkBuilder &builde
   PointerRNA rna = vsocket.rna();
   Object *value = (Object *)RNA_pointer_get(&rna, "value").data;
 
-  const MultiFunction &fn = allocate_resource<BKE::MultiFunction_ConstantValue<Object *>>(
+  const MultiFunction &fn = allocate_resource<FN::MF_ConstantValue<Object *>>(
       "object socket", resources, value);
   MFBuilderFunctionNode &node = builder.add_function(fn, {}, {0});
   return *node.outputs()[0];
@@ -647,7 +645,7 @@ static MFBuilderOutputSocket &INSERT_text_socket(VTreeMFNetworkBuilder &builder,
   std::string text = value;
   MEM_freeN(value);
 
-  const MultiFunction &fn = allocate_resource<BKE::MultiFunction_ConstantValue<std::string>>(
+  const MultiFunction &fn = allocate_resource<FN::MF_ConstantValue<std::string>>(
       "text socket", resources, text);
   MFBuilderFunctionNode &node = builder.add_function(fn, {}, {0});
   return *node.outputs()[0];
@@ -658,8 +656,7 @@ static MFBuilderOutputSocket &INSERT_empty_list_socket(VTreeMFNetworkBuilder &bu
                                                        OwnedResources &resources,
                                                        const VirtualSocket &UNUSED(vsocket))
 {
-  const MultiFunction &fn = allocate_resource<BKE::MultiFunction_EmptyList<T>>("empty list socket",
-                                                                               resources);
+  const MultiFunction &fn = allocate_resource<FN::MF_EmptyList<T>>("empty list socket", resources);
   MFBuilderFunctionNode &node = builder.add_function(fn, {}, {0});
   return *node.outputs()[0];
 }
@@ -684,8 +681,8 @@ template<typename FromT, typename ToT>
 static std::pair<MFBuilderInputSocket *, MFBuilderOutputSocket *> INSERT_convert(
     VTreeMFNetworkBuilder &builder, OwnedResources &resources)
 {
-  const MultiFunction &fn = allocate_resource<BKE::MultiFunction_Convert<FromT, ToT>>(
-      "converter function", resources);
+  const MultiFunction &fn = allocate_resource<FN::MF_Convert<FromT, ToT>>("converter function",
+                                                                          resources);
   MFBuilderFunctionNode &node = builder.add_function(fn, {0}, {1});
   return {node.inputs()[0], node.outputs()[0]};
 }
@@ -694,7 +691,7 @@ template<typename FromT, typename ToT>
 static std::pair<MFBuilderInputSocket *, MFBuilderOutputSocket *> INSERT_convert_list(
     VTreeMFNetworkBuilder &builder, OwnedResources &resources)
 {
-  const MultiFunction &fn = allocate_resource<BKE::MultiFunction_ConvertList<FromT, ToT>>(
+  const MultiFunction &fn = allocate_resource<FN::MF_ConvertList<FromT, ToT>>(
       "convert list function", resources);
   MFBuilderFunctionNode &node = builder.add_function(fn, {0}, {1});
   return {node.inputs()[0], node.outputs()[0]};
@@ -704,7 +701,7 @@ template<typename T>
 static std::pair<MFBuilderInputSocket *, MFBuilderOutputSocket *> INSERT_element_to_list(
     VTreeMFNetworkBuilder &builder, OwnedResources &resources)
 {
-  const MultiFunction &fn = allocate_resource<BKE::MultiFunction_SingleElementList<T>>(
+  const MultiFunction &fn = allocate_resource<FN::MF_SingleElementList<T>>(
       "single element list function", resources);
   MFBuilderFunctionNode &node = builder.add_function(fn, {0}, {1});
   return {node.inputs()[0], node.outputs()[0]};
@@ -836,14 +833,13 @@ static bool insert_unlinked_inputs(VTreeMFNetworkBuilder &builder, OwnedResource
   return true;
 }
 
-class MultiFunction_FunctionTree : public BKE::MultiFunction {
+class MF_FunctionTree : public FN::MultiFunction {
  private:
   Vector<const MFOutputSocket *> m_inputs;
   Vector<const MFInputSocket *> m_outputs;
 
  public:
-  MultiFunction_FunctionTree(Vector<const MFOutputSocket *> inputs,
-                             Vector<const MFInputSocket *> outputs)
+  MF_FunctionTree(Vector<const MFOutputSocket *> inputs, Vector<const MFInputSocket *> outputs)
       : m_inputs(std::move(inputs)), m_outputs(std::move(outputs))
   {
     MFSignatureBuilder signature("Function Tree");
@@ -1272,7 +1268,7 @@ void MOD_functiondeform_do(FunctionDeformModifierData *fdmd, float (*vertexCos)[
   Vector<const MFInputSocket *> function_outputs = {
       &vtree_network->lookup_socket(output_vnode.input(0)).as_input()};
 
-  MultiFunction_FunctionTree function{function_inputs, function_outputs};
+  MF_FunctionTree function{function_inputs, function_outputs};
 
   MFParamsBuilder params(function, numVerts);
   params.add_readonly_single_input(ArrayRef<float3>((float3 *)vertexCos, numVerts));