[Bf-blender-cvs] [a35f5ff3c85] functions-experimental-refactor: improve add/mul/min/max math nodes

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


Commit: a35f5ff3c85631a5145429499dcee3bf6de0200a
Author: Jacques Lucke
Date:   Tue Nov 5 13:47:57 2019 +0100
Branches: functions-experimental-refactor
https://developer.blender.org/rBa35f5ff3c85631a5145429499dcee3bf6de0200a

improve add/mul/min/max math nodes

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

M	release/scripts/startup/nodes/function_nodes/float_math.py
M	release/scripts/startup/nodes/function_nodes/list.py
M	release/scripts/startup/nodes/node_builder.py
M	source/blender/functions2/intern/multi_functions/mixed.cc
M	source/blender/functions2/intern/multi_functions/mixed.h
M	source/blender/functions2/intern/vtree_multi_function_network/builder.cc
M	source/blender/functions2/intern/vtree_multi_function_network/builder.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 89f4454288e..a7d03a42fc8 100644
--- a/release/scripts/startup/nodes/function_nodes/float_math.py
+++ b/release/scripts/startup/nodes/function_nodes/float_math.py
@@ -3,6 +3,33 @@ from bpy.props import *
 from .. base import FunctionNode
 from .. node_builder import NodeBuilder
 
+def create_variadic_math_node(data_type, idname, label):
+    '''
+    Should only be used for operations with associative property.
+    '''
+
+    class MathNode(bpy.types.Node, FunctionNode):
+        bl_idname = idname
+        bl_label = label
+
+        variadic: NodeBuilder.BaseListVariadicProperty()
+
+        def declaration(self, builder: NodeBuilder):
+            builder.base_list_variadic_input("inputs", "variadic", data_type)
+
+            if NodeBuilder.BaseListVariadicPropertyHasList(self.variadic):
+                builder.fixed_output("result", "Result", data_type + " List")
+            else:
+                builder.fixed_output("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")
+
+
 operation_items = [
     ("ADD",     "Add",          "", "", 1),
     ("SUB",     "Subtract",     "", "", 2),
@@ -53,9 +80,7 @@ class FloatMathNode(bpy.types.Node, FunctionNode):
     bl_label = "Float Math"
 
     search_terms = (
-        ("Add Floats", {"operation" : "ADD"}),
         ("Subtract Floats", {"operation" : "SUB"}),
-        ("Multiply Floats", {"operation" : "MULTIPLY"}),
         ("Divide Floats", {"operation" : "DIVIDE"}),
     )
 
diff --git a/release/scripts/startup/nodes/function_nodes/list.py b/release/scripts/startup/nodes/function_nodes/list.py
index 70c7617dba4..f7d5315d093 100644
--- a/release/scripts/startup/nodes/function_nodes/list.py
+++ b/release/scripts/startup/nodes/function_nodes/list.py
@@ -40,7 +40,7 @@ class PackListNode(bpy.types.Node, FunctionNode):
     variadic: NodeBuilder.BaseListVariadicProperty()
 
     def declaration(self, builder):
-        builder.pack_list_input("inputs", "variadic", self.active_type)
+        builder.base_list_variadic_input("inputs", "variadic", self.active_type)
         builder.fixed_output("output", "List", type_infos.to_list(self.active_type))
 
     def draw_advanced(self, layout):
diff --git a/release/scripts/startup/nodes/node_builder.py b/release/scripts/startup/nodes/node_builder.py
index fe7522ca104..d81cbddeea8 100644
--- a/release/scripts/startup/nodes/node_builder.py
+++ b/release/scripts/startup/nodes/node_builder.py
@@ -111,7 +111,12 @@ class NodeBuilder:
     def BaseListVariadicProperty():
         return BaseListVariadic.Property()
 
-    def pack_list_input(self, identifier, prop_name, base_type, default_amount=2):
+    @staticmethod
+    def BaseListVariadicPropertyHasList(prop):
+        return any(v.state == "LIST" for v in prop)
+
+
+    def base_list_variadic_input(self, identifier, prop_name, base_type, default_amount=2):
         decl = BaseListVariadic(self.node, identifier, prop_name, base_type, default_amount)
         self._add_input(decl)
 
diff --git a/source/blender/functions2/intern/multi_functions/mixed.cc b/source/blender/functions2/intern/multi_functions/mixed.cc
index 75e149a9b62..d4607b8888d 100644
--- a/source/blender/functions2/intern/multi_functions/mixed.cc
+++ b/source/blender/functions2/intern/multi_functions/mixed.cc
@@ -232,6 +232,7 @@ MF_SimpleVectorize::MF_SimpleVectorize(const MultiFunction &function,
   UNUSED_VARS_NDEBUG(found_output_param);
   for (uint param_index : function.param_indices()) {
     MFParamType param_type = function.param_type(param_index);
+    StringRef param_name = function.param_name(param_index);
     switch (param_type.category()) {
       case MFParamType::None:
       case MFParamType::ReadonlyVectorInput:
@@ -243,16 +244,16 @@ MF_SimpleVectorize::MF_SimpleVectorize(const MultiFunction &function,
       case MFParamType::ReadonlySingleInput: {
         BLI_assert(!found_output_param);
         if (input_is_vectorized[param_index]) {
-          signature.readonly_vector_input("Input", param_type.type());
+          signature.readonly_vector_input(param_name + " (List)", param_type.type());
           m_vectorized_inputs.append(param_index);
         }
         else {
-          signature.readonly_single_input("Input", param_type.type());
+          signature.readonly_single_input(param_name, param_type.type());
         }
         break;
       }
       case MFParamType::SingleOutput: {
-        signature.vector_output("Output", param_type.type());
+        signature.vector_output(param_name + " (List)", param_type.type());
         m_output_indices.append(param_index);
         found_output_param = true;
         break;
@@ -273,7 +274,8 @@ void MF_SimpleVectorize::call(const MFMask &mask, MFParams &params, MFContext &c
   vectorization_lengths.fill_indices(mask.indices(), -1);
 
   for (uint param_index : m_vectorized_inputs) {
-    GenericVirtualListListRef values = params.readonly_vector_input(param_index, "Input");
+    GenericVirtualListListRef values = params.readonly_vector_input(param_index,
+                                                                    this->param_name(param_index));
     for (uint i : mask.indices()) {
       if (vectorization_lengths[i] != 0) {
         vectorization_lengths[i] = std::max<int>(vectorization_lengths[i], values[i].size());
@@ -283,7 +285,8 @@ void MF_SimpleVectorize::call(const MFMask &mask, MFParams &params, MFContext &c
 
   Vector<GenericVectorArray *> output_vector_arrays;
   for (uint param_index : m_output_indices) {
-    GenericVectorArray *vector_array = &params.vector_output(param_index, "Output");
+    GenericVectorArray *vector_array = &params.vector_output(param_index,
+                                                             this->param_name(param_index));
     output_vector_arrays.append(vector_array);
   }
 
@@ -303,20 +306,22 @@ void MF_SimpleVectorize::call(const MFMask &mask, MFParams &params, MFContext &c
         }
         case MFParamType::ReadonlySingleInput: {
           if (m_input_is_vectorized[param_index]) {
-            GenericVirtualListListRef input_list_list = params.readonly_vector_input(param_index,
-                                                                                     "Input");
+            GenericVirtualListListRef input_list_list = params.readonly_vector_input(
+                param_index, this->param_name(param_index));
             GenericVirtualListRef repeated_input = input_list_list.repeated_sublist(index, length);
             params_builder.add_readonly_single_input(repeated_input);
           }
           else {
-            GenericVirtualListRef input_list = params.readonly_single_input(param_index, "Input");
+            GenericVirtualListRef input_list = params.readonly_single_input(
+                param_index, this->param_name(param_index));
             GenericVirtualListRef repeated_input = input_list.repeated_element(index, length);
             params_builder.add_readonly_single_input(repeated_input);
           }
           break;
         }
         case MFParamType::SingleOutput: {
-          GenericVectorArray &output_array_list = params.vector_output(param_index, "Output");
+          GenericVectorArray &output_array_list = params.vector_output(
+              param_index, this->param_name(param_index));
           GenericMutableArrayRef output_array = output_array_list.allocate_single(index, length);
           params_builder.add_single_output(output_array);
           break;
diff --git a/source/blender/functions2/intern/multi_functions/mixed.h b/source/blender/functions2/intern/multi_functions/mixed.h
index d618ef3b34c..57d24eedce5 100644
--- a/source/blender/functions2/intern/multi_functions/mixed.h
+++ b/source/blender/functions2/intern/multi_functions/mixed.h
@@ -124,4 +124,49 @@ class MF_ContextCurrentFrame final : public MultiFunction {
   void call(const MFMask &mask, MFParams &params, MFContext &context) const override;
 };
 
+template<typename T, T (*Compute)(T, T)> class MF_SimpleMath final : public MultiFunction {
+ private:
+  uint m_input_amount;
+
+ public:
+  MF_SimpleMath(StringRef name, uint input_amount) : m_input_amount(input_amount)
+  {
+    BLI_assert(input_amount >= 1);
+    MFSignatureBuilder signature(name);
+    for (uint i = 0; i < m_input_amount; i++) {
+      signature.readonly_single_input<T>("Input");
+    }
+    signature.single_output<T>("Output");
+    this->set_signature(signature);
+  }
+
+  void call(const MFMask &mask, MFParams &params, MFContext &UNUSED(context)) const override
+  {
+    MutableArrayRef<T> outputs = params.single_output<T>(m_input_amount, "Output");
+
+    if (m_input_amount == 1) {
+      VirtualListRef<T> inputs = params.readonly_single_input<T>(0, "Input");
+      for (uint i : mask.indices()) {
+        outputs[i] = inputs[i];
+      }
+    }
+    else {
+      BLI_assert(m_input_amount >= 2);
+      VirtualListRef<T> inputs0 = params.readonly_single_input<T>(0, "Input");
+      VirtualListRef<T> inputs1 = params.readonly_single_input<T>(1, "Input");
+
+      for (uint i : mask.indices()) {
+        outputs[i] = Compute(inputs0[i], inputs1[i]);
+      }
+
+      for (uint param_index = 2; param_index < m_input_amount; param_index++) {
+        VirtualListRef<T> inputs = params.readonly_single_input<T>(param_index, "Input");
+        for (uint i : mask.indices()) {
+          outputs[i] = Compute(outputs[i], inputs[i]);
+        }
+      }
+    }
+  }
+};
+
 }  // namespace FN
diff --git a/source/blender/functions2/intern/vtree_multi_function_network/builder.cc b/source/blender/functions2/intern/vtree_multi_function_network/builder.cc
index 35729429b5a..4d503d187ff 100644
--- a/source/blender/functions2/intern/vtree_multi_f

@@ Diff output truncated at 10240 characters. @@



More information about the Bf-blender-cvs mailing list