diff options
16 files changed, 224 insertions, 67 deletions
diff --git a/source/blender/functions/FN_multi_function.hh b/source/blender/functions/FN_multi_function.hh index d8924b3cf23..2ce65426245 100644 --- a/source/blender/functions/FN_multi_function.hh +++ b/source/blender/functions/FN_multi_function.hh @@ -53,7 +53,7 @@ namespace blender::fn { class MultiFunction { private: - MFSignature signature_; + const MFSignature *signature_ref_ = nullptr; public: virtual ~MultiFunction() @@ -74,44 +74,50 @@ class MultiFunction { int param_amount() const { - return signature_.param_types.size(); + return signature_ref_->param_types.size(); } IndexRange param_indices() const { - return signature_.param_types.index_range(); + return signature_ref_->param_types.index_range(); } MFParamType param_type(int param_index) const { - return signature_.param_types[param_index]; + return signature_ref_->param_types[param_index]; } StringRefNull param_name(int param_index) const { - return signature_.param_names[param_index]; + return signature_ref_->param_names[param_index]; } StringRefNull name() const { - return signature_.function_name; + return signature_ref_->function_name; } bool depends_on_context() const { - return signature_.depends_on_context; + return signature_ref_->depends_on_context; } const MFSignature &signature() const { - return signature_; + BLI_assert(signature_ref_ != nullptr); + return *signature_ref_; } protected: - MFSignatureBuilder get_builder(std::string function_name) + /* Make the function use the given signature. This should be called once in the constructor of + * child classes. No copy of the signature is made, so the caller has to make sure that the + * signature lives as long as the multi function. It is ok to embed the signature into the child + * class. */ + void set_signature(const MFSignature *signature) { - signature_.function_name = std::move(function_name); - return MFSignatureBuilder(signature_); + /* Take a pointer as argument, so that it is more obvious that no copy is created. */ + BLI_assert(signature != nullptr); + signature_ref_ = signature; } }; diff --git a/source/blender/functions/FN_multi_function_builder.hh b/source/blender/functions/FN_multi_function_builder.hh index b73c41d3f59..389d0b14bb5 100644 --- a/source/blender/functions/FN_multi_function_builder.hh +++ b/source/blender/functions/FN_multi_function_builder.hh @@ -40,13 +40,16 @@ template<typename In1, typename Out1> class CustomMF_SI_SO : public MultiFunctio private: using FunctionT = std::function<void(IndexMask, const VArray<In1> &, MutableSpan<Out1>)>; FunctionT function_; + MFSignature signature_; public: CustomMF_SI_SO(StringRef name, FunctionT function) : function_(std::move(function)) { - MFSignatureBuilder signature = this->get_builder(name); + MFSignatureBuilder signature{name}; signature.single_input<In1>("In1"); signature.single_output<Out1>("Out1"); + signature_ = signature.build(); + this->set_signature(&signature_); } template<typename ElementFuncT> @@ -83,14 +86,17 @@ class CustomMF_SI_SI_SO : public MultiFunction { using FunctionT = std::function<void(IndexMask, const VArray<In1> &, const VArray<In2> &, MutableSpan<Out1>)>; FunctionT function_; + MFSignature signature_; public: CustomMF_SI_SI_SO(StringRef name, FunctionT function) : function_(std::move(function)) { - MFSignatureBuilder signature = this->get_builder(name); + MFSignatureBuilder signature{name}; signature.single_input<In1>("In1"); signature.single_input<In2>("In2"); signature.single_output<Out1>("Out1"); + signature_ = signature.build(); + this->set_signature(&signature_); } template<typename ElementFuncT> @@ -135,15 +141,18 @@ class CustomMF_SI_SI_SI_SO : public MultiFunction { const VArray<In3> &, MutableSpan<Out1>)>; FunctionT function_; + MFSignature signature_; public: CustomMF_SI_SI_SI_SO(StringRef name, FunctionT function) : function_(std::move(function)) { - MFSignatureBuilder signature = this->get_builder(name); + MFSignatureBuilder signature{name}; signature.single_input<In1>("In1"); signature.single_input<In2>("In2"); signature.single_input<In3>("In3"); signature.single_output<Out1>("Out1"); + signature_ = signature.build(); + this->set_signature(&signature_); } template<typename ElementFuncT> @@ -193,16 +202,19 @@ class CustomMF_SI_SI_SI_SI_SO : public MultiFunction { const VArray<In4> &, MutableSpan<Out1>)>; FunctionT function_; + MFSignature signature_; public: CustomMF_SI_SI_SI_SI_SO(StringRef name, FunctionT function) : function_(std::move(function)) { - MFSignatureBuilder signature = this->get_builder(name); + MFSignatureBuilder signature{name}; signature.single_input<In1>("In1"); signature.single_input<In2>("In2"); signature.single_input<In3>("In3"); signature.single_input<In4>("In4"); signature.single_output<Out1>("Out1"); + signature_ = signature.build(); + this->set_signature(&signature_); } template<typename ElementFuncT> @@ -244,12 +256,15 @@ template<typename Mut1> class CustomMF_SM : public MultiFunction { private: using FunctionT = std::function<void(IndexMask, MutableSpan<Mut1>)>; FunctionT function_; + MFSignature signature_; public: CustomMF_SM(StringRef name, FunctionT function) : function_(std::move(function)) { - MFSignatureBuilder signature = this->get_builder(name); + MFSignatureBuilder signature{name}; signature.single_mutable<Mut1>("Mut1"); + signature_ = signature.build(); + this->set_signature(&signature_); } template<typename ElementFuncT> @@ -279,10 +294,17 @@ template<typename From, typename To> class CustomMF_Convert : public MultiFuncti public: CustomMF_Convert() { + static MFSignature signature = create_signature(); + this->set_signature(&signature); + } + + static MFSignature create_signature() + { std::string name = CPPType::get<From>().name() + " to " + CPPType::get<To>().name(); - MFSignatureBuilder signature = this->get_builder(std::move(name)); + MFSignatureBuilder signature{std::move(name)}; signature.single_input<From>("Input"); signature.single_output<To>("Output"); + return signature.build(); } void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override @@ -304,6 +326,7 @@ class CustomMF_GenericConstant : public MultiFunction { private: const CPPType &type_; const void *value_; + MFSignature signature_; template<typename T> friend class CustomMF_Constant; @@ -321,6 +344,7 @@ class CustomMF_GenericConstant : public MultiFunction { class CustomMF_GenericConstantArray : public MultiFunction { private: GSpan array_; + MFSignature signature_; public: CustomMF_GenericConstantArray(GSpan array); @@ -333,14 +357,17 @@ class CustomMF_GenericConstantArray : public MultiFunction { template<typename T> class CustomMF_Constant : public MultiFunction { private: T value_; + MFSignature signature_; public: template<typename U> CustomMF_Constant(U &&value) : value_(std::forward<U>(value)) { - MFSignatureBuilder signature = this->get_builder("Constant"); + MFSignatureBuilder signature{"Constant"}; std::stringstream ss; ss << value_; signature.single_output<T>(ss.str()); + signature_ = signature.build(); + this->set_signature(&signature_); } void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override @@ -375,6 +402,7 @@ template<typename T> class CustomMF_Constant : public MultiFunction { class CustomMF_DefaultOutput : public MultiFunction { private: int output_amount_; + MFSignature signature_; public: CustomMF_DefaultOutput(StringRef name, diff --git a/source/blender/functions/FN_multi_function_network_evaluation.hh b/source/blender/functions/FN_multi_function_network_evaluation.hh index 2c0d94615b0..17cffa406f7 100644 --- a/source/blender/functions/FN_multi_function_network_evaluation.hh +++ b/source/blender/functions/FN_multi_function_network_evaluation.hh @@ -28,6 +28,7 @@ class MFNetworkEvaluationStorage; class MFNetworkEvaluator : public MultiFunction { private: + MFSignature signature_; Vector<const MFOutputSocket *> inputs_; Vector<const MFInputSocket *> outputs_; diff --git a/source/blender/functions/FN_multi_function_signature.hh b/source/blender/functions/FN_multi_function_signature.hh index e05ea1c2578..23309c9a5e6 100644 --- a/source/blender/functions/FN_multi_function_signature.hh +++ b/source/blender/functions/FN_multi_function_signature.hh @@ -44,18 +44,21 @@ struct MFSignature { class MFSignatureBuilder { private: - MFSignature &data_; + MFSignature signature_; int span_count_ = 0; int virtual_array_count_ = 0; int virtual_vector_array_count_ = 0; int vector_array_count_ = 0; public: - MFSignatureBuilder(MFSignature &data) : data_(data) + MFSignatureBuilder(std::string function_name) { - BLI_assert(data.param_names.is_empty()); - BLI_assert(data.param_types.is_empty()); - BLI_assert(data.param_data_indices.is_empty()); + signature_.function_name = std::move(function_name); + } + + MFSignature build() const + { + return std::move(signature_); } /* Input Parameter Types */ @@ -78,15 +81,15 @@ class MFSignatureBuilder { } void input(StringRef name, MFDataType data_type) { - data_.param_names.append(name); - data_.param_types.append(MFParamType(MFParamType::Input, data_type)); + signature_.param_names.append(name); + signature_.param_types.append(MFParamType(MFParamType::Input, data_type)); switch (data_type.category()) { case MFDataType::Single: - data_.param_data_indices.append(virtual_array_count_++); + signature_.param_data_indices.append(virtual_array_count_++); break; case MFDataType::Vector: - data_.param_data_indices.append(virtual_vector_array_count_++); + signature_.param_data_indices.append(virtual_vector_array_count_++); break; } } @@ -111,15 +114,15 @@ class MFSignatureBuilder { } void output(StringRef name, MFDataType data_type) { - data_.param_names.append(name); - data_.param_types.append(MFParamType(MFParamType::Output, data_type)); + signature_.param_names.append(name); + signature_.param_types.append(MFParamType(MFParamType::Output, data_type)); switch (data_type.category()) { case MFDataType::Single: - data_.param_data_indices.append(span_count_++); + signature_.param_data_indices.append(span_count_++); break; case MFDataType::Vector: - data_.param_data_indices.append(vector_array_count_++); + signature_.param_data_indices.append(vector_array_count_++); break; } } @@ -144,15 +147,15 @@ class MFSignatureBuilder { } void mutable_(StringRef name, MFDataType data_type) { - data_.param_names.append(name); - data_.param_types.append(MFParamType(MFParamType::Mutable, data_type)); + signature_.param_names.append(name); + signature_.param_types.append(MFParamType(MFParamType::Mutable, data_type)); switch (data_type.category()) { case MFDataType::Single: - data_.param_data_indices.append(span_count_++); + signature_.param_data_indices.append(span_count_++); break; case MFDataType::Vector: - data_.param_data_indices.append(vector_array_count_++); + signature_.param_data_indices.append(vector_array_count_++); break; } } @@ -163,7 +166,7 @@ class MFSignatureBuilder { * depend on the fact that the function always performers the same operation. */ void depends_on_context() { - data_.depends_on_context = true; + signature_.depends_on_context = true; } }; diff --git a/source/blender/functions/intern/multi_function.cc b/source/blender/functions/intern/multi_function.cc index a41c6bdf3cd..bb657f321ec 100644 --- a/source/blender/functions/intern/multi_function.cc +++ b/source/blender/functions/intern/multi_function.cc @@ -22,7 +22,14 @@ class DummyMultiFunction : public MultiFunction { public: DummyMultiFunction() { - this->get_builder("Dummy"); + static MFSignature signature = create_signature(); + this->set_signature(&signature); + } + + static MFSignature create_signature() + { + MFSignatureBuilder signature{"Dummy"}; + return signature.build(); } void call(IndexMask UNUSED(mask), diff --git a/source/blender/functions/intern/multi_function_builder.cc b/source/blender/functions/intern/multi_function_builder.cc index c9e8b88ba03..3567f4f9167 100644 --- a/source/blender/functions/intern/multi_function_builder.cc +++ b/source/blender/functions/intern/multi_function_builder.cc @@ -23,10 +23,12 @@ namespace blender::fn { CustomMF_GenericConstant::CustomMF_GenericConstant(const CPPType &type, const void *value) : type_(type), value_(value) { - MFSignatureBuilder signature = this->get_builder("Constant " + type.name()); + MFSignatureBuilder signature{"Constant " + type.name()}; std::stringstream ss; type.debug_print(value, ss); signature.single_output(ss.str(), type); + signature_ = signature.build(); + this->set_signature(&signature_); } void CustomMF_GenericConstant::call(IndexMask mask, @@ -73,8 +75,10 @@ static std::string gspan_to_string(GSpan array) CustomMF_GenericConstantArray::CustomMF_GenericConstantArray(GSpan array) : array_(array) { const CPPType &type = array.type(); - MFSignatureBuilder signature = this->get_builder("Constant " + type.name() + " Vector"); + MFSignatureBuilder signature{"Constant " + type.name() + " Vector"}; signature.vector_output(gspan_to_string(array), type); + signature_ = signature.build(); + this->set_signature(&signature_); } void CustomMF_GenericConstantArray::call(IndexMask mask, @@ -92,13 +96,15 @@ CustomMF_DefaultOutput::CustomMF_DefaultOutput(StringRef name, Span<MFDataType> output_types) : output_amount_(output_types.size()) { - MFSignatureBuilder signature = this->get_builder(name); + MFSignatureBuilder signature{name}; for (MFDataType data_type : input_types) { signature.input("Input", data_type); } for (MFDataType data_type : output_types) { signature.output("Output", data_type); } + signature_ = signature.build(); + this->set_signature(&signature_); } void CustomMF_DefaultOutput::call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const { diff --git a/source/blender/functions/intern/multi_function_network_evaluation.cc b/source/blender/functions/intern/multi_function_network_evaluation.cc index 98500a350ae..daa0a42963a 100644 --- a/source/blender/functions/intern/multi_function_network_evaluation.cc +++ b/source/blender/functions/intern/multi_function_network_evaluation.cc @@ -115,7 +115,7 @@ MFNetworkEvaluator::MFNetworkEvaluator(Vector<const MFOutputSocket *> inputs, : inputs_(std::move(inputs)), outputs_(std::move(outputs)) { BLI_assert(outputs_.size() > 0); - MFSignatureBuilder signature = this->get_builder("Function Tree"); + MFSignatureBuilder signature{"Function Tree"}; for (const MFOutputSocket *socket : inputs_) { BLI_assert(socket->node().is_dummy()); @@ -144,6 +144,9 @@ MFNetworkEvaluator::MFNetworkEvaluator(Vector<const MFOutputSocket *> inputs, break; } } + + signature_ = signature.build(); + this->set_signature(&signature_); } void MFNetworkEvaluator::call(IndexMask mask, MFParams params, MFContext context) const diff --git a/source/blender/functions/tests/FN_multi_function_network_test.cc b/source/blender/functions/tests/FN_multi_function_network_test.cc index 70da0315b93..51e116b5983 100644 --- a/source/blender/functions/tests/FN_multi_function_network_test.cc +++ b/source/blender/functions/tests/FN_multi_function_network_test.cc @@ -69,9 +69,16 @@ class ConcatVectorsFunction : public MultiFunction { public: ConcatVectorsFunction() { - MFSignatureBuilder signature = this->get_builder("Concat Vectors"); + static MFSignature signature = create_signature(); + this->set_signature(&signature); + } + + static MFSignature create_signature() + { + MFSignatureBuilder signature{"Concat Vectors"}; signature.vector_mutable<int>("A"); signature.vector_input<int>("B"); + return signature.build(); } void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override @@ -86,9 +93,16 @@ class AppendFunction : public MultiFunction { public: AppendFunction() { - MFSignatureBuilder signature = this->get_builder("Append"); + static MFSignature signature = create_signature(); + this->set_signature(&signature); + } + + static MFSignature create_signature() + { + MFSignatureBuilder signature{"Append"}; signature.vector_mutable<int>("Vector"); signature.single_input<int>("Value"); + return signature.build(); } void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override @@ -106,9 +120,16 @@ class SumVectorFunction : public MultiFunction { public: SumVectorFunction() { - MFSignatureBuilder signature = this->get_builder("Sum Vector"); + static MFSignature signature = create_signature(); + this->set_signature(&signature); + } + + static MFSignature create_signature() + { + MFSignatureBuilder signature{"Sum Vectors"}; signature.vector_input<int>("Vector"); signature.single_output<int>("Sum"); + return signature.build(); } void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override @@ -130,9 +151,16 @@ class CreateRangeFunction : public MultiFunction { public: CreateRangeFunction() { - MFSignatureBuilder builder = this->get_builder("Create Range"); - builder.single_input<int>("Size"); - builder.vector_output<int>("Range"); + static MFSignature signature = create_signature(); + this->set_signature(&signature); + } + + static MFSignature create_signature() + { + MFSignatureBuilder signature{"Create Range"}; + signature.single_input<int>("Size"); + signature.vector_output<int>("Range"); + return signature.build(); } void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override diff --git a/source/blender/functions/tests/FN_multi_function_test.cc b/source/blender/functions/tests/FN_multi_function_test.cc index 3ed60665149..3d73e020eb2 100644 --- a/source/blender/functions/tests/FN_multi_function_test.cc +++ b/source/blender/functions/tests/FN_multi_function_test.cc @@ -12,10 +12,17 @@ class AddFunction : public MultiFunction { public: AddFunction() { - MFSignatureBuilder builder = this->get_builder("Add"); - builder.single_input<int>("A"); - builder.single_input<int>("B"); - builder.single_output<int>("Result"); + static MFSignature signature = create_signature(); + this->set_signature(&signature); + } + + static MFSignature create_signature() + { + MFSignatureBuilder signature("Add"); + signature.single_input<int>("A"); + signature.single_input<int>("B"); + signature.single_output<int>("Result"); + return signature.build(); } void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override @@ -56,9 +63,16 @@ class AddPrefixFunction : public MultiFunction { public: AddPrefixFunction() { - MFSignatureBuilder builder = this->get_builder("Add Prefix"); - builder.single_input<std::string>("Prefix"); - builder.single_mutable<std::string>("Strings"); + static MFSignature signature = create_signature(); + this->set_signature(&signature); + } + + static MFSignature create_signature() + { + MFSignatureBuilder signature{"Add Prefix"}; + signature.single_input<std::string>("Prefix"); + signature.single_mutable<std::string>("Strings"); + return signature.build(); } void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override @@ -103,9 +117,16 @@ class CreateRangeFunction : public MultiFunction { public: CreateRangeFunction() { - MFSignatureBuilder builder = this->get_builder("Create Range"); - builder.single_input<uint>("Size"); - builder.vector_output<uint>("Range"); + static MFSignature signature = create_signature(); + this->set_signature(&signature); + } + + static MFSignature create_signature() + { + MFSignatureBuilder signature{"Create Range"}; + signature.single_input<uint>("Size"); + signature.vector_output<uint>("Range"); + return signature.build(); } void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override @@ -152,12 +173,17 @@ TEST(multi_function, CreateRangeFunction) } class GenericAppendFunction : public MultiFunction { + private: + MFSignature signature_; + public: GenericAppendFunction(const CPPType &type) { - MFSignatureBuilder builder = this->get_builder("Append"); - builder.vector_mutable("Vector", type); - builder.single_input("Value", type); + MFSignatureBuilder signature{"Append"}; + signature.vector_mutable("Vector", type); + signature.single_input("Value", type); + signature_ = signature.build(); + this->set_signature(&signature_); } void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override diff --git a/source/blender/nodes/function/nodes/node_fn_object_transforms.cc b/source/blender/nodes/function/nodes/node_fn_object_transforms.cc index 55f592d7879..a73049776e5 100644 --- a/source/blender/nodes/function/nodes/node_fn_object_transforms.cc +++ b/source/blender/nodes/function/nodes/node_fn_object_transforms.cc @@ -32,10 +32,17 @@ class ObjectTransformsFunction : public blender::fn::MultiFunction { public: ObjectTransformsFunction() { - blender::fn::MFSignatureBuilder signature = this->get_builder("Object Transforms"); + static blender::fn::MFSignature signature = create_signature(); + this->set_signature(&signature); + } + + static blender::fn::MFSignature create_signature() + { + blender::fn::MFSignatureBuilder signature{"Object Transforms"}; signature.depends_on_context(); signature.single_input<blender::bke::PersistentObjectHandle>("Object"); signature.single_output<blender::float3>("Location"); + return signature.build(); } void call(blender::IndexMask mask, diff --git a/source/blender/nodes/function/nodes/node_fn_random_float.cc b/source/blender/nodes/function/nodes/node_fn_random_float.cc index 84ded73c601..d156cd431e0 100644 --- a/source/blender/nodes/function/nodes/node_fn_random_float.cc +++ b/source/blender/nodes/function/nodes/node_fn_random_float.cc @@ -37,11 +37,18 @@ class RandomFloatFunction : public blender::fn::MultiFunction { public: RandomFloatFunction(uint32_t function_seed) : function_seed_(function_seed) { - blender::fn::MFSignatureBuilder signature = this->get_builder("Random float"); + static blender::fn::MFSignature signature = create_signature(); + this->set_signature(&signature); + } + + static blender::fn::MFSignature create_signature() + { + blender::fn::MFSignatureBuilder signature{"Random float"}; signature.single_input<float>("Min"); signature.single_input<float>("Max"); signature.single_input<int>("Seed"); signature.single_output<float>("Value"); + return signature.build(); } void call(blender::IndexMask mask, diff --git a/source/blender/nodes/intern/node_socket.cc b/source/blender/nodes/intern/node_socket.cc index 0ddea0051bc..26df3f77738 100644 --- a/source/blender/nodes/intern/node_socket.cc +++ b/source/blender/nodes/intern/node_socket.cc @@ -637,9 +637,16 @@ class ObjectSocketMultiFunction : public blender::fn::MultiFunction { public: ObjectSocketMultiFunction(Object *object) : object_(object) { - blender::fn::MFSignatureBuilder signature = this->get_builder("Object Socket"); + static blender::fn::MFSignature signature = create_signature(); + this->set_signature(&signature); + } + + static blender::fn::MFSignature create_signature() + { + blender::fn::MFSignatureBuilder signature{"Object Socket"}; signature.depends_on_context(); signature.single_output<blender::bke::PersistentObjectHandle>("Object"); + return signature.build(); } void call(blender::IndexMask mask, diff --git a/source/blender/nodes/shader/nodes/node_shader_map_range.cc b/source/blender/nodes/shader/nodes/node_shader_map_range.cc index 3aa533599cf..3b4ea3d1bdf 100644 --- a/source/blender/nodes/shader/nodes/node_shader_map_range.cc +++ b/source/blender/nodes/shader/nodes/node_shader_map_range.cc @@ -95,13 +95,20 @@ class MapRangeFunction : public blender::fn::MultiFunction { public: MapRangeFunction(bool clamp) : clamp_(clamp) { - blender::fn::MFSignatureBuilder signature = this->get_builder("Map Range"); + static blender::fn::MFSignature signature = create_signature(); + this->set_signature(&signature); + } + + static blender::fn::MFSignature create_signature() + { + blender::fn::MFSignatureBuilder signature{"Map Range"}; signature.single_input<float>("Value"); signature.single_input<float>("From Min"); signature.single_input<float>("From Max"); signature.single_input<float>("To Min"); signature.single_input<float>("To Max"); signature.single_output<float>("Result"); + return signature.build(); } void call(blender::IndexMask mask, diff --git a/source/blender/nodes/shader/nodes/node_shader_sepcombRGB.cc b/source/blender/nodes/shader/nodes/node_shader_sepcombRGB.cc index a9057428981..8ca4a6bab5f 100644 --- a/source/blender/nodes/shader/nodes/node_shader_sepcombRGB.cc +++ b/source/blender/nodes/shader/nodes/node_shader_sepcombRGB.cc @@ -63,11 +63,18 @@ class SeparateRGBFunction : public blender::fn::MultiFunction { public: SeparateRGBFunction() { - blender::fn::MFSignatureBuilder signature = this->get_builder("Separate RGB"); + static blender::fn::MFSignature signature = create_signature(); + this->set_signature(&signature); + } + + static blender::fn::MFSignature create_signature() + { + blender::fn::MFSignatureBuilder signature{"Separate RGB"}; signature.single_input<blender::Color4f>("Color"); signature.single_output<float>("R"); signature.single_output<float>("G"); signature.single_output<float>("B"); + return signature.build(); } void call(blender::IndexMask mask, diff --git a/source/blender/nodes/shader/nodes/node_shader_sepcombXYZ.cc b/source/blender/nodes/shader/nodes/node_shader_sepcombXYZ.cc index c0dc66b3342..efa9581c414 100644 --- a/source/blender/nodes/shader/nodes/node_shader_sepcombXYZ.cc +++ b/source/blender/nodes/shader/nodes/node_shader_sepcombXYZ.cc @@ -48,11 +48,18 @@ class MF_SeparateXYZ : public blender::fn::MultiFunction { public: MF_SeparateXYZ() { - blender::fn::MFSignatureBuilder signature = this->get_builder("Separate XYZ"); + static blender::fn::MFSignature signature = create_signature(); + this->set_signature(&signature); + } + + static blender::fn::MFSignature create_signature() + { + blender::fn::MFSignatureBuilder signature{"Separate XYZ"}; signature.single_input<blender::float3>("XYZ"); signature.single_output<float>("X"); signature.single_output<float>("Y"); signature.single_output<float>("Z"); + return signature.build(); } void call(blender::IndexMask mask, diff --git a/source/blender/nodes/shader/nodes/node_shader_valToRgb.cc b/source/blender/nodes/shader/nodes/node_shader_valToRgb.cc index 0d50582e23a..90e8161c09f 100644 --- a/source/blender/nodes/shader/nodes/node_shader_valToRgb.cc +++ b/source/blender/nodes/shader/nodes/node_shader_valToRgb.cc @@ -132,10 +132,17 @@ class ColorBandFunction : public blender::fn::MultiFunction { public: ColorBandFunction(const ColorBand &color_band) : color_band_(color_band) { - blender::fn::MFSignatureBuilder signature = this->get_builder("Color Band"); + static blender::fn::MFSignature signature = create_signature(); + this->set_signature(&signature); + } + + static blender::fn::MFSignature create_signature() + { + blender::fn::MFSignatureBuilder signature{"Color Band"}; signature.single_input<float>("Value"); signature.single_output<blender::Color4f>("Color"); signature.single_output<float>("Alpha"); + return signature.build(); } void call(blender::IndexMask mask, |