[Bf-blender-cvs] [2929bc8d7e6] functions: cleanup

[Jacques Lucke]

Commit: 2929bc8d7e627968093d88bfa138898d1bee02fd
Author: Jacques Lucke
Date:   Wed Jan 29 18:56:49 2020 +0100
Branches: functions
https://developer.blender.org/rB2929bc8d7e627968093d88bfa138898d1bee02fd

cleanup

===================================================================

M	source/blender/functions/intern/multi_functions/customizable.h
M	source/blender/functions/intern/node_tree_multi_function_network/mappings_nodes.cc

===================================================================

diff --git a/source/blender/functions/intern/multi_functions/customizable.h b/source/blender/functions/intern/multi_functions/customizable.h
index d0d9d0d09dd..cef8164cd68 100644
--- a/source/blender/functions/intern/multi_functions/customizable.h
+++ b/source/blender/functions/intern/multi_functions/customizable.h
@@ -99,6 +99,51 @@ class MF_Custom_In2_Out1 final : public MultiFunction {
     signature.operation_hash(operation_hash);
   }
 
+  template<typename ElementFuncT>
+  MF_Custom_In2_Out1(StringRef name,
+                     ElementFuncT element_fn,
+                     Optional<uint32_t> operation_hash = {})
+      : MF_Custom_In2_Out1(name, MF_Custom_In2_Out1::create_function(element_fn), operation_hash)
+  {
+  }
+
+  template<typename ElementFuncT> static FunctionT create_function(ElementFuncT element_fn)
+  {
+    return [=](IndexMask mask,
+               VirtualListRef<InT1> inputs1,
+               VirtualListRef<InT2> inputs2,
+               MutableArrayRef<OutT> outputs) -> void {
+      if (inputs1.is_non_single_full_array() && inputs2.is_non_single_full_array()) {
+        ArrayRef<InT1> in1_array = inputs1.as_full_array();
+        ArrayRef<InT2> in2_array = inputs2.as_full_array();
+        mask.foreach_index(
+            [=](uint i) { new (&outputs[i]) OutT(element_fn(in1_array[i], in2_array[i])); });
+      }
+      else if (inputs1.is_non_single_full_array() && inputs2.is_single_element()) {
+        ArrayRef<InT1> in1_array = inputs1.as_full_array();
+        InT2 in2_single = inputs2.as_single_element();
+        mask.foreach_index(
+            [=](uint i) { new (&outputs[i]) OutT(element_fn(in1_array[i], in2_single)); });
+      }
+      else if (inputs1.is_single_element() && inputs2.is_non_single_full_array()) {
+        InT1 in1_single = inputs1.as_single_element();
+        ArrayRef<InT2> in2_array = inputs2.as_full_array();
+        mask.foreach_index(
+            [=](uint i) { new (&outputs[i]) OutT(element_fn(in1_single, in2_array[i])); });
+      }
+      else if (inputs1.is_single_element() && inputs2.is_single_element()) {
+        InT1 in1_single = inputs1.as_single_element();
+        InT2 in2_single = inputs2.as_single_element();
+        OutT out_single = element_fn(in1_single, in2_single);
+        outputs.fill_indices(mask.indices(), out_single);
+      }
+      else {
+        mask.foreach_index(
+            [=](uint i) { new (&outputs[i]) OutT(element_fn(inputs1[i], inputs2[i])); });
+      }
+    };
+  }
+
   void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override
   {
     VirtualListRef<InT1> inputs1 = params.readonly_single_input<InT1>(0);
@@ -133,6 +178,18 @@ template<typename T> class MF_VariadicMath final : public MultiFunction {
     signature.operation_hash(operation_hash);
   }
 
+  template<typename ElementFuncT>
+  MF_VariadicMath(StringRef name,
+                  uint input_amount,
+                  ElementFuncT element_func,
+                  Optional<uint32_t> operation_hash = {})
+      : MF_VariadicMath(name,
+                        input_amount,
+                        MF_Custom_In2_Out1<T, T, T>::create_function(element_func),
+                        operation_hash)
+  {
+  }
+
   void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override
   {
     MutableArrayRef<T> outputs = params.uninitialized_single_output<T>(m_input_amount, "Output");
diff --git a/source/blender/functions/intern/node_tree_multi_function_network/mappings_nodes.cc b/source/blender/functions/intern/node_tree_multi_function_network/mappings_nodes.cc
index 327da6a2175..ddc5a257495 100644
--- a/source/blender/functions/intern/node_tree_multi_function_network/mappings_nodes.cc
+++ b/source/blender/functions/intern/node_tree_multi_function_network/mappings_nodes.cc
@@ -171,68 +171,28 @@ static void build_math_fn_1in_1out(FNodeMFBuilder &builder,
       {"use_list"}, builder.fnode().name(), func, operation_hash);
 }
 
-template<typename InT1, typename InT2, typename OutT, typename FuncT>
-static std::function<
-    void(IndexMask, VirtualListRef<InT1>, VirtualListRef<InT2>, MutableArrayRef<OutT>)>
-vectorize_function_2in_1out(FuncT func)
-{
-  return [=](IndexMask mask,
-             VirtualListRef<InT1> inputs1,
-             VirtualListRef<InT2> inputs2,
-             MutableArrayRef<OutT> outputs) -> void {
-    if (inputs1.is_non_single_full_array() && inputs2.is_non_single_full_array()) {
-      ArrayRef<InT1> in1_array = inputs1.as_full_array();
-      ArrayRef<InT2> in2_array = inputs2.as_full_array();
-      mask.foreach_index(
-          [=](uint i) { new (&outputs[i]) OutT(func(in1_array[i], in2_array[i])); });
-    }
-    else if (inputs1.is_non_single_full_array() && inputs2.is_single_element()) {
-      ArrayRef<InT1> in1_array = inputs1.as_full_array();
-      InT2 in2_single = inputs2.as_single_element();
-      mask.foreach_index([=](uint i) { new (&outputs[i]) OutT(func(in1_array[i], in2_single)); });
-    }
-    else if (inputs1.is_single_element() && inputs2.is_non_single_full_array()) {
-      InT1 in1_single = inputs1.as_single_element();
-      ArrayRef<InT2> in2_array = inputs2.as_full_array();
-      mask.foreach_index([=](uint i) { new (&outputs[i]) OutT(func(in1_single, in2_array[i])); });
-    }
-    else if (inputs1.is_single_element() && inputs2.is_single_element()) {
-      InT1 in1_single = inputs1.as_single_element();
-      InT2 in2_single = inputs2.as_single_element();
-      OutT out_single = func(in1_single, in2_single);
-      outputs.fill_indices(mask.indices(), out_single);
-    }
-    else {
-      mask.foreach_index([=](uint i) { new (&outputs[i]) OutT(func(inputs1[i], inputs2[i])); });
-    }
-  };
-}
-
 template<typename InT1, typename InT2, typename OutT, typename FuncT>
 static void build_math_fn_in2_out1(FNodeMFBuilder &builder,
-                                   FuncT func,
+                                   FuncT element_func,
                                    Optional<uint32_t> operation_hash = {})
 {
-  auto fn = vectorize_function_2in_1out<InT1, InT2, OutT>(func);
   builder.set_vectorized_constructed_matching_fn<MF_Custom_In2_Out1<InT1, InT2, OutT>>(
-      {"use_list__a", "use_list__b"}, builder.fnode().name(), fn, operation_hash);
+      {"use_list__a", "use_list__b"}, builder.fnode().name(), element_func, operation_hash);
 }
 
 template<typename T, typename FuncT>
 static void build_variadic_math_fn(FNodeMFBuilder &builder,
-                                   FuncT func,
+                                   FuncT element_func,
                                    T default_value,
                                    Optional<uint32_t> operation_hash = {})
 {
-  auto fn = vectorize_function_2in_1out<T, T, T>(func);
-
   Vector<bool> list_states = builder.get_list_base_variadic_states("variadic");
   if (list_states.size() == 0) {
     builder.set_constructed_matching_fn<MF_ConstantValue<T>>(default_value);
   }
   else {
     const MultiFunction &base_fn = builder.construct_fn<MF_VariadicMath<T>>(
-        builder.fnode().name(), list_states.size(), fn, operation_hash);
+        builder.fnode().name(), list_states.size(), element_func, operation_hash);
     if (list_states.contains(true)) {
       builder.set_constructed_matching_fn<MF_SimpleVectorize>(base_fn, list_states);
     }