[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 ¶ms, 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 ¶ms, MFContext &c
Vector<GenericVectorArray *> output_vector_arrays;
for (uint param_index : m_output_indices) {
- GenericVectorArray *vector_array = ¶ms.vector_output(param_index, "Output");
+ GenericVectorArray *vector_array = ¶ms.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 ¶ms, 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 ¶ms, 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 ¶ms, 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