[Bf-blender-cvs] [ab2625529c4] functions-experimental-refactor: bring back more math nodes

Jacques Lucke noreply at git.blender.org
Tue Nov 5 15:55:07 CET 2019 

Commit: ab2625529c4d30842e7fbec711fb40e87dacb9d5
Author: Jacques Lucke
Date:   Tue Nov 5 14:17:35 2019 +0100
Branches: functions-experimental-refactor
https://developer.blender.org/rBab2625529c4d30842e7fbec711fb40e87dacb9d5

bring back more math nodes

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

M	release/scripts/startup/nodes/function_nodes/float_math.py
M	source/blender/functions2/intern/multi_functions/mixed.h
M	source/blender/functions2/intern/vtree_multi_function_network/mappings_nodes.cc

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

diff --git a/release/scripts/startup/nodes/function_nodes/float_math.py b/release/scripts/startup/nodes/function_nodes/float_math.py
index a7d03a42fc8..d0aeb716957 100644
--- a/release/scripts/startup/nodes/function_nodes/float_math.py
+++ b/release/scripts/startup/nodes/function_nodes/float_math.py
@@ -24,11 +24,30 @@ def create_variadic_math_node(data_type, idname, label):
 
     return MathNode
 
+def create_single_input_math_node(data_type, idname, label):
+
+    class MathNode(bpy.types.Node, FunctionNode):
+        bl_idname = idname
+        bl_label = label
+
+        use_list: NodeBuilder.VectorizedProperty()
+
+        def declaration(self, builder: NodeBuilder):
+            builder.vectorized_input("input", "use_list", "Value", "Values", data_type)
+            builder.vectorized_output("output", ["use_list"], "Result", "Result", data_type)
+
+    return MathNode
+
 AddFloatsNode = create_variadic_math_node("Float", "fn_AddFloatsNode", "Add Floats")
 MultiplyFloatsNode = create_variadic_math_node("Float", "fn_MultiplyFloatsNode", "Multiply Floats")
 MinimumFloatsNode = create_variadic_math_node("Float", "fn_MinimumFloatsNode", "Minimum Floats")
 MaximumFloatsNode = create_variadic_math_node("Float", "fn_MaximumFloatsNode", "Maximum Floats")
 
+SqrtFloatNode = create_single_input_math_node("Float", "fn_SqrtFloatNode", "Sqrt Float")
+AbsFloatNode = create_single_input_math_node("Float", "fn_AbsoluteFloatNode", "Absolute Float")
+SineNode = create_single_input_math_node("Float", "fn_SineNode", "Sine")
+CosineNode = create_single_input_math_node("Float", "fn_CosineNode", "Cosine")
+
 
 operation_items = [
     ("ADD",     "Add",          "", "", 1),
diff --git a/source/blender/functions2/intern/multi_functions/mixed.h b/source/blender/functions2/intern/multi_functions/mixed.h
index 57d24eedce5..610ba378d71 100644
--- a/source/blender/functions2/intern/multi_functions/mixed.h
+++ b/source/blender/functions2/intern/multi_functions/mixed.h
@@ -124,6 +124,30 @@ class MF_ContextCurrentFrame final : public MultiFunction {
   void call(const MFMask &mask, MFParams &params, MFContext &context) const override;
 };
 
+template<typename FromT, typename ToT, ToT (*Compute)(const FromT &)>
+class MF_Mappping final : public MultiFunction {
+ public:
+  MF_Mappping(StringRef name)
+  {
+    MFSignatureBuilder signature(name);
+    signature.readonly_single_input<FromT>("Input");
+    signature.single_output<ToT>("Output");
+    this->set_signature(signature);
+  }
+
+  void call(const MFMask &mask, MFParams &params, MFContext &UNUSED(context)) const override
+  {
+    VirtualListRef<FromT> inputs = params.readonly_single_input<FromT>(0, "Input");
+    MutableArrayRef<ToT> outputs = params.single_output<ToT>(1, "Output");
+
+    for (uint i : mask.indices()) {
+      const FromT &from_value = inputs[i];
+      ToT to_value = Compute(from_value);
+      new (&outputs[i]) ToT(std::move(to_value));
+    }
+  }
+};
+
 template<typename T, T (*Compute)(T, T)> class MF_SimpleMath final : public MultiFunction {
  private:
   uint m_input_amount;
diff --git a/source/blender/functions2/intern/vtree_multi_function_network/mappings_nodes.cc b/source/blender/functions2/intern/vtree_multi_function_network/mappings_nodes.cc
index 61c09a91b3b..ea352610365 100644
--- a/source/blender/functions2/intern/vtree_multi_function_network/mappings_nodes.cc
+++ b/source/blender/functions2/intern/vtree_multi_function_network/mappings_nodes.cc
@@ -155,26 +155,6 @@ static void INSERT_time_info(VTreeMFNetworkBuilder &builder, const VNode &vnode)
   builder.add_function(fn, {}, {0}, vnode);
 }
 
-template<typename T> T add_func_cb(T a, T b)
-{
-  return a + b;
-}
-
-template<typename T> T mul_func_cb(T a, T b)
-{
-  return a * b;
-}
-
-template<typename T> T min_func_cb(T a, T b)
-{
-  return std::min(a, b);
-}
-
-template<typename T> T max_func_cb(T a, T b)
-{
-  return std::max(a, b);
-}
-
 template<typename T, T (*Compute)(T, T)>
 static const MultiFunction &get_simple_math_function(VTreeMFNetworkBuilder &builder,
                                                      StringRef name,
@@ -198,9 +178,9 @@ static const MultiFunction &get_simple_math_function(VTreeMFNetworkBuilder &buil
 }
 
 template<typename T, T (*Compute)(T, T)>
-void insert_simple_math_function(VTreeMFNetworkBuilder &builder,
-                                 const VNode &vnode,
-                                 T default_value)
+static void insert_simple_math_function(VTreeMFNetworkBuilder &builder,
+                                        const VNode &vnode,
+                                        T default_value)
 {
   Vector<bool> list_states = get_list_base_variadic_states(vnode, "variadic");
   const MultiFunction &fn = get_simple_math_function<T, Compute>(
@@ -209,6 +189,26 @@ void insert_simple_math_function(VTreeMFNetworkBuilder &builder,
       fn, IndexRange(list_states.size()).as_array_ref(), {list_states.size()}, vnode);
 }
 
+template<typename T> T add_func_cb(T a, T b)
+{
+  return a + b;
+}
+
+template<typename T> T mul_func_cb(T a, T b)
+{
+  return a * b;
+}
+
+template<typename T> T min_func_cb(T a, T b)
+{
+  return std::min(a, b);
+}
+
+template<typename T> T max_func_cb(T a, T b)
+{
+  return std::max(a, b);
+}
+
 static void INSERT_add_floats(VTreeMFNetworkBuilder &builder, const VNode &vnode)
 {
   insert_simple_math_function<float, add_func_cb<float>>(builder, vnode, 0.0f);
@@ -229,6 +229,55 @@ static void INSERT_maximum_floats(VTreeMFNetworkBuilder &builder, const VNode &v
   insert_simple_math_function<float, max_func_cb<float>>(builder, vnode, 0.0f);
 }
 
+template<typename T, T (*Compute)(const T &)>
+static void insert_single_input_math_function(VTreeMFNetworkBuilder &builder, const VNode &vnode)
+{
+  const MultiFunction &base_fn = builder.allocate_function<FN::MF_Mappping<T, T, Compute>>(
+      vnode.name());
+  const MultiFunction &fn = get_vectorized_function(builder, base_fn, vnode.rna(), {"use_list"});
+  builder.add_function(fn, {0}, {1}, vnode);
+}
+
+template<typename T> T safe_sqrt_func_cb(const T &a)
+{
+  return (a >= 0.0) ? (T)std::sqrt(a) : 0.0f;
+}
+
+template<typename T> T abs_func_cb(const T &a)
+{
+  return (T)std::abs(a);
+}
+
+template<typename T> T sine_func_cb(const T &a)
+{
+  return (T)std::sin(a);
+}
+
+template<typename T> T cosine_func_cb(const T &a)
+{
+  return (T)std::cos(a);
+}
+
+static void INSERT_sqrt_float(VTreeMFNetworkBuilder &builder, const VNode &vnode)
+{
+  insert_single_input_math_function<float, safe_sqrt_func_cb<float>>(builder, vnode);
+}
+
+static void INSERT_abs_float(VTreeMFNetworkBuilder &builder, const VNode &vnode)
+{
+  insert_single_input_math_function<float, abs_func_cb<float>>(builder, vnode);
+}
+
+static void INSERT_sine(VTreeMFNetworkBuilder &builder, const VNode &vnode)
+{
+  insert_single_input_math_function<float, sine_func_cb<float>>(builder, vnode);
+}
+
+static void INSERT_cosine(VTreeMFNetworkBuilder &builder, const VNode &vnode)
+{
+  insert_single_input_math_function<float, cosine_func_cb<float>>(builder, vnode);
+}
+
 void add_vtree_node_mapping_info(VTreeMultiFunctionMappings &mappings)
 {
   mappings.vnode_inserters.add_new("fn_FloatMathNode", INSERT_float_math);
@@ -248,6 +297,11 @@ void add_vtree_node_mapping_info(VTreeMultiFunctionMappings &mappings)
   mappings.vnode_inserters.add_new("fn_MultiplyFloatsNode", INSERT_multiply_floats);
   mappings.vnode_inserters.add_new("fn_MinimumFloatsNode", INSERT_minimum_floats);
   mappings.vnode_inserters.add_new("fn_MaximumFloatsNode", INSERT_maximum_floats);
+
+  mappings.vnode_inserters.add_new("fn_SqrtFloatNode", INSERT_sqrt_float);
+  mappings.vnode_inserters.add_new("fn_AbsoluteFloatNode", INSERT_abs_float);
+  mappings.vnode_inserters.add_new("fn_SineNode", INSERT_sine);
+  mappings.vnode_inserters.add_new("fn_CosineNode", INSERT_cosine);
 }
 
 };  // namespace FN

More information about the Bf-blender-cvs mailing list