Cleanup: inline signatures into multi-function constructors

This reduces the amount of code. Also the signature should be thought
of as being setup in the constructor, so it's good if the code is there as well.

source/blender/functions/tests/FN_multi_function_test.cc

@@ -13,20 +13,17 @@ class AddFunction : public MultiFunction {
  public:
   AddFunction()
   {
-    static Signature signature = create_signature();
+    static Signature signature = []() {
+      Signature signature;
+      SignatureBuilder builder("Add", signature);
+      builder.single_input<int>("A");
+      builder.single_input<int>("B");
+      builder.single_output<int>("Result");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static Signature create_signature()
-  {
-    Signature signature;
-    SignatureBuilder builder("Add", signature);
-    builder.single_input<int>("A");
-    builder.single_input<int>("B");
-    builder.single_output<int>("Result");
-    return signature;
-  }
-
   void call(IndexMask mask, MFParams params, Context /*context*/) const override
   {
     const VArray<int> &a = params.readonly_single_input<int>(0, "A");

source/blender/functions/tests/FN_multi_function_test_common.hh

@@ -8,19 +8,16 @@ class AddPrefixFunction : public MultiFunction {
  public:
   AddPrefixFunction()
   {
-    static Signature signature = create_signature();
+    static const Signature signature = []() {
+      Signature signature;
+      SignatureBuilder builder{"Add Prefix", signature};
+      builder.single_input<std::string>("Prefix");
+      builder.single_mutable<std::string>("Strings");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static Signature create_signature()
-  {
-    Signature signature;
-    SignatureBuilder builder{"Add Prefix", signature};
-    builder.single_input<std::string>("Prefix");
-    builder.single_mutable<std::string>("Strings");
-    return signature;
-  }
-
   void call(IndexMask mask, MFParams params, Context /*context*/) const override
   {
     const VArray<std::string> &prefixes = params.readonly_single_input<std::string>(0, "Prefix");
@@ -36,19 +33,16 @@ class CreateRangeFunction : public MultiFunction {
  public:
   CreateRangeFunction()
   {
-    static Signature signature = create_signature();
+    static const Signature signature = []() {
+      Signature signature;
+      SignatureBuilder builder{"Create Range", signature};
+      builder.single_input<int>("Size");
+      builder.vector_output<int>("Range");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static Signature create_signature()
-  {
-    Signature signature;
-    SignatureBuilder builder{"Create Range", signature};
-    builder.single_input<int>("Size");
-    builder.vector_output<int>("Range");
-    return signature;
-  }
-
   void call(IndexMask mask, MFParams params, Context /*context*/) const override
   {
     const VArray<int> &sizes = params.readonly_single_input<int>(0, "Size");
@@ -94,19 +88,16 @@ class ConcatVectorsFunction : public MultiFunction {
  public:
   ConcatVectorsFunction()
   {
-    static Signature signature = create_signature();
+    static const Signature signature = []() {
+      Signature signature;
+      SignatureBuilder builder{"Concat Vectors", signature};
+      builder.vector_mutable<int>("A");
+      builder.vector_input<int>("B");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static Signature create_signature()
-  {
-    Signature signature;
-    SignatureBuilder builder{"Concat Vectors", signature};
-    builder.vector_mutable<int>("A");
-    builder.vector_input<int>("B");
-    return signature;
-  }
-
   void call(IndexMask mask, MFParams params, Context /*context*/) const override
   {
     GVectorArray &a = params.vector_mutable(0);
@@ -119,19 +110,16 @@ class AppendFunction : public MultiFunction {
  public:
   AppendFunction()
   {
-    static Signature signature = create_signature();
+    static const Signature signature = []() {
+      Signature signature;
+      SignatureBuilder builder{"Append", signature};
+      builder.vector_mutable<int>("Vector");
+      builder.single_input<int>("Value");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static Signature create_signature()
-  {
-    Signature signature;
-    SignatureBuilder builder{"Append", signature};
-    builder.vector_mutable<int>("Vector");
-    builder.single_input<int>("Value");
-    return signature;
-  }
-
   void call(IndexMask mask, MFParams params, Context /*context*/) const override
   {
     GVectorArray_TypedMutableRef<int> vectors = params.vector_mutable<int>(0);
@@ -147,19 +135,16 @@ class SumVectorFunction : public MultiFunction {
  public:
   SumVectorFunction()
   {
-    static Signature signature = create_signature();
+    static const Signature signature = []() {
+      Signature signature;
+      SignatureBuilder builder{"Sum Vectors", signature};
+      builder.vector_input<int>("Vector");
+      builder.single_output<int>("Sum");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static Signature create_signature()
-  {
-    Signature signature;
-    SignatureBuilder builder{"Sum Vectors", signature};
-    builder.vector_input<int>("Vector");
-    builder.single_output<int>("Sum");
-    return signature;
-  }
-
   void call(IndexMask mask, MFParams params, Context /*context*/) const override
   {
     const VVectorArray<int> &vectors = params.readonly_vector_input<int>(0);
@@ -179,19 +164,16 @@ class OptionalOutputsFunction : public MultiFunction {
  public:
   OptionalOutputsFunction()
   {
-    static Signature signature = create_signature();
+    static const Signature signature = []() {
+      Signature signature;
+      SignatureBuilder builder{"Optional Outputs", signature};
+      builder.single_output<int>("Out 1");
+      builder.single_output<std::string>("Out 2");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static Signature create_signature()
-  {
-    Signature signature;
-    SignatureBuilder builder{"Optional Outputs", signature};
-    builder.single_output<int>("Out 1");
-    builder.single_output<std::string>("Out 2");
-    return signature;
-  }
-
   void call(IndexMask mask, MFParams params, Context /*context*/) const override
   {
     if (params.single_output_is_required(0, "Out 1")) {

source/blender/nodes/function/nodes/node_fn_align_euler_to_vector.cc

@@ -142,22 +142,18 @@ class MF_AlignEulerToVector : public mf::MultiFunction {
   MF_AlignEulerToVector(int main_axis_mode, int pivot_axis_mode)
       : main_axis_mode_(main_axis_mode), pivot_axis_mode_(pivot_axis_mode)
   {
-    static mf::Signature signature = create_signature();
+    static const mf::Signature signature = []() {
+      mf::Signature signature;
+      mf::SignatureBuilder builder{"Align Euler to Vector", signature};
+      builder.single_input<float3>("Rotation");
+      builder.single_input<float>("Factor");
+      builder.single_input<float3>("Vector");
+      builder.single_output<float3>("Rotation");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"Align Euler to Vector", signature};
-    builder.single_input<float3>("Rotation");
-    builder.single_input<float>("Factor");
-    builder.single_input<float3>("Vector");
-
-    builder.single_output<float3>("Rotation");
-    return signature;
-  }
-
   void call(IndexMask mask, mf::MFParams params, mf::Context /*context*/) const override
   {
     const VArray<float3> &input_rotations = params.readonly_single_input<float3>(0, "Rotation");

source/blender/nodes/function/nodes/node_fn_input_special_characters.cc

@@ -14,19 +14,16 @@ class MF_SpecialCharacters : public mf::MultiFunction {
  public:
   MF_SpecialCharacters()
   {
-    static mf::Signature signature = create_signature();
+    static const mf::Signature signature = []() {
+      mf::Signature signature;
+      mf::SignatureBuilder builder{"Special Characters", signature};
+      builder.single_output<std::string>("Line Break");
+      builder.single_output<std::string>("Tab");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"Special Characters", signature};
-    builder.single_output<std::string>("Line Break");
-    builder.single_output<std::string>("Tab");
-    return signature;
-  }
-
   void call(IndexMask mask, mf::MFParams params, mf::Context /*context*/) const override
   {
     MutableSpan<std::string> lb = params.uninitialized_single_output<std::string>(0, "Line Break");

source/blender/nodes/function/nodes/node_fn_separate_color.cc

@@ -41,22 +41,19 @@ class SeparateRGBAFunction : public mf::MultiFunction {
  public:
   SeparateRGBAFunction()
   {
-    static mf::Signature signature = create_signature();
+    static const mf::Signature signature = []() {
+      mf::Signature signature;
+      mf::SignatureBuilder builder{"Separate Color", signature};
+      builder.single_input<ColorGeometry4f>("Color");
+      builder.single_output<float>("Red");
+      builder.single_output<float>("Green");
+      builder.single_output<float>("Blue");
+      builder.single_output<float>("Alpha");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"Separate Color", signature};
-    builder.single_input<ColorGeometry4f>("Color");
-    builder.single_output<float>("Red");
-    builder.single_output<float>("Green");
-    builder.single_output<float>("Blue");
-    builder.single_output<float>("Alpha");
-    return signature;
-  }
-
   void call(IndexMask mask, mf::MFParams params, mf::Context /*context*/) const override
   {
     const VArray<ColorGeometry4f> &colors = params.readonly_single_input<ColorGeometry4f>(0,
@@ -103,22 +100,19 @@ class SeparateHSVAFunction : public mf::MultiFunction {
  public:
   SeparateHSVAFunction()
   {
-    static mf::Signature signature = create_signature();
+    static const mf::Signature signature = []() {
+      mf::Signature signature;
+      mf::SignatureBuilder builder{"Separate Color", signature};
+      builder.single_input<ColorGeometry4f>("Color");
+      builder.single_output<float>("Hue");
+      builder.single_output<float>("Saturation");
+      builder.single_output<float>("Value");
+      builder.single_output<float>("Alpha");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"Separate Color", signature};
-    builder.single_input<ColorGeometry4f>("Color");
-    builder.single_output<float>("Hue");
-    builder.single_output<float>("Saturation");
-    builder.single_output<float>("Value");
-    builder.single_output<float>("Alpha");
-    return signature;
-  }
-
   void call(IndexMask mask, mf::MFParams params, mf::Context /*context*/) const override
   {
     const VArray<ColorGeometry4f> &colors = params.readonly_single_input<ColorGeometry4f>(0,
@@ -144,22 +138,19 @@ class SeparateHSLAFunction : public mf::MultiFunction {
  public:
   SeparateHSLAFunction()
   {
-    static mf::Signature signature = create_signature();
+    static const mf::Signature signature = []() {
+      mf::Signature signature;
+      mf::SignatureBuilder builder{"Separate Color", signature};
+      builder.single_input<ColorGeometry4f>("Color");
+      builder.single_output<float>("Hue");
+      builder.single_output<float>("Saturation");
+      builder.single_output<float>("Lightness");
+      builder.single_output<float>("Alpha");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"Separate Color", signature};
-    builder.single_input<ColorGeometry4f>("Color");
-    builder.single_output<float>("Hue");
-    builder.single_output<float>("Saturation");
-    builder.single_output<float>("Lightness");
-    builder.single_output<float>("Alpha");
-    return signature;
-  }
-
   void call(IndexMask mask, mf::MFParams params, mf::Context /*context*/) const override
   {
     const VArray<ColorGeometry4f> &colors = params.readonly_single_input<ColorGeometry4f>(0,

source/blender/nodes/geometry/nodes/node_geo_curve_sample.cc

@@ -211,21 +211,18 @@ class SampleFloatSegmentsFunction : public mf::MultiFunction {
                               const GeometryNodeCurveSampleMode length_mode)
       : accumulated_lengths_(std::move(accumulated_lengths)), length_mode_(length_mode)
   {
-    static mf::Signature signature = create_signature();
+    static const mf::Signature signature = []() {
+      mf::Signature signature;
+      mf::SignatureBuilder builder{"Sample Curve Index", signature};
+      builder.single_input<float>("Length");
+
+      builder.single_output<int>("Curve Index");
+      builder.single_output<float>("Length in Curve");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"Sample Curve Index", signature};
-    builder.single_input<float>("Length");
-
-    builder.single_output<int>("Curve Index");
-    builder.single_output<float>("Length in Curve");
-    return signature;
-  }
-
   void call(IndexMask mask, mf::MFParams params, mf::Context /*context*/) const override
   {
     const VArraySpan<float> lengths = params.readonly_single_input<float>(0, "Length");
@@ -261,22 +258,16 @@ class SampleCurveFunction : public mf::MultiFunction {
                       const GField &src_field)
       : geometry_set_(std::move(geometry_set)), src_field_(src_field), length_mode_(length_mode)
   {
-    signature_ = create_signature();
-    this->set_signature(&signature_);
-    this->evaluate_source();
-  }
-
-  mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"Sample Curve", signature};
+    mf::SignatureBuilder builder{"Sample Curve", signature_};
     builder.single_input<int>("Curve Index");
     builder.single_input<float>("Length");
     builder.single_output<float3>("Position");
     builder.single_output<float3>("Tangent");
     builder.single_output<float3>("Normal");
     builder.single_output("Value", src_field_.cpp_type());
-    return signature;
+    this->set_signature(&signature_);
+
+    this->evaluate_source();
   }
 
   void call(IndexMask mask, mf::MFParams params, mf::Context /*context*/) const override

source/blender/nodes/geometry/nodes/node_geo_image_texture.cc

@@ -64,7 +64,14 @@ class ImageFieldsFunction : public mf::MultiFunction {
         image_(image),
         image_user_(image_user)
   {
-    static mf::Signature signature = create_signature();
+    static const mf::Signature signature = []() {
+      mf::Signature signature;
+      mf::SignatureBuilder builder{"ImageFunction", signature};
+      builder.single_input<float3>("Vector");
+      builder.single_output<ColorGeometry4f>("Color");
+      builder.single_output<float>("Alpha");
+      return signature;
+    }();
     this->set_signature(&signature);
 
     image_buffer_ = BKE_image_acquire_ibuf(&image_, &image_user_, &image_lock_);
@@ -91,16 +98,6 @@ class ImageFieldsFunction : public mf::MultiFunction {
     BKE_image_release_ibuf(&image_, image_buffer_, image_lock_);
   }
 
-  static mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"ImageFunction", signature};
-    builder.single_input<float3>("Vector");
-    builder.single_output<ColorGeometry4f>("Color");
-    builder.single_output<float>("Alpha");
-    return signature;
-  }
-
   static int wrap_periodic(int x, const int width)
   {
     x %= width;

source/blender/nodes/geometry/nodes/node_geo_proximity.cc

@@ -138,20 +138,17 @@ class ProximityFunction : public mf::MultiFunction {
   ProximityFunction(GeometrySet target, GeometryNodeProximityTargetType type)
       : target_(std::move(target)), type_(type)
   {
-    static mf::Signature signature = create_signature();
+    static const mf::Signature signature = []() {
+      mf::Signature signature;
+      mf::SignatureBuilder builder{"Geometry Proximity", signature};
+      builder.single_input<float3>("Source Position");
+      builder.single_output<float3>("Position");
+      builder.single_output<float>("Distance");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"Geometry Proximity", signature};
-    builder.single_input<float3>("Source Position");
-    builder.single_output<float3>("Position");
-    builder.single_output<float>("Distance");
-    return signature;
-  }
-
   void call(IndexMask mask, mf::MFParams params, mf::Context /*context*/) const override
   {
     const VArray<float3> &src_positions = params.readonly_single_input<float3>(0,

source/blender/nodes/geometry/nodes/node_geo_raycast.cc

@@ -225,14 +225,8 @@ class RaycastFunction : public mf::MultiFunction {
   {
     target_.ensure_owns_direct_data();
     this->evaluate_target_field(std::move(src_field));
-    signature_ = create_signature();
-    this->set_signature(&signature_);
-  }
 
-  mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"Geometry Proximity", signature};
+    mf::SignatureBuilder builder{"Geometry Proximity", signature_};
     builder.single_input<float3>("Source Position");
     builder.single_input<float3>("Ray Direction");
     builder.single_input<float>("Ray Length");
@@ -243,7 +237,7 @@ class RaycastFunction : public mf::MultiFunction {
     if (target_data_) {
       builder.single_output("Attribute", target_data_->type());
     }
-    return signature;
+    this->set_signature(&signature_);
   }
 
   void call(IndexMask mask, mf::MFParams params, mf::Context /*context*/) const override

source/blender/nodes/geometry/nodes/node_geo_sample_index.cc

@@ -200,21 +200,14 @@ class SampleIndexFunction : public mf::MultiFunction {
   {
     src_geometry_.ensure_owns_direct_data();
 
-    signature_ = this->create_signature();
+    mf::SignatureBuilder builder{"Sample Index", signature_};
+    builder.single_input<int>("Index");
+    builder.single_output("Value", src_field_.cpp_type());
     this->set_signature(&signature_);
 
     this->evaluate_field();
   }
 
-  mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"Sample Index", signature};
-    builder.single_input<int>("Index");
-    builder.single_output("Value", src_field_.cpp_type());
-    return signature;
-  }
-
   void evaluate_field()
   {
     const GeometryComponent *component = find_source_component(src_geometry_, domain_);

source/blender/nodes/geometry/nodes/node_geo_sample_nearest.cc

@@ -245,19 +245,12 @@ class SampleNearestFunction : public mf::MultiFunction {
       : source_(std::move(geometry)), domain_(domain)
   {
     source_.ensure_owns_direct_data();
-    signature_ = this->create_signature();
-    this->set_signature(&signature_);
-
     this->src_component_ = find_source_component(source_, domain_);
-  }
 
-  mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"Sample Nearest", signature};
+    mf::SignatureBuilder builder{"Sample Nearest", signature_};
     builder.single_input<float3>("Position");
     builder.single_output<int>("Index");
-    return signature;
+    this->set_signature(&signature_);
   }
 
   void call(IndexMask mask, mf::MFParams params, mf::Context /*context*/) const override

source/blender/nodes/geometry/nodes/node_geo_sample_nearest_surface.cc

@@ -139,18 +139,12 @@ class SampleNearestSurfaceFunction : public mf::MultiFunction {
       : source_(std::move(geometry)), src_field_(std::move(src_field))
   {
     source_.ensure_owns_direct_data();
-    signature_ = this->create_signature();
-    this->set_signature(&signature_);
     this->evaluate_source_field();
-  }
 
-  mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"Sample Nearest Surface", signature};
+    mf::SignatureBuilder builder{"Sample Nearest Surface", signature_};
     builder.single_input<float3>("Position");
     builder.single_output("Value", src_field_.cpp_type());
-    return signature;
+    this->set_signature(&signature_);
   }
 
   void call(IndexMask mask, mf::MFParams params, mf::Context /*context*/) const override

source/blender/nodes/geometry/nodes/node_geo_sample_uv_surface.cc

@@ -129,19 +129,13 @@ class SampleMeshBarycentricFunction : public mf::MultiFunction {
       : source_(std::move(geometry)), src_field_(std::move(src_field))
   {
     source_.ensure_owns_direct_data();
-    this->set_signature(&signature_);
-    signature_ = this->create_signature();
     this->evaluate_source();
-  }
 
-  mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"Sample Barycentric Triangles", signature};
+    mf::SignatureBuilder builder{"Sample Barycentric Triangles", signature_};
     builder.single_input<int>("Triangle Index");
     builder.single_input<float3>("Barycentric Weight");
     builder.single_output("Value", src_field_.cpp_type());
-    return signature;
+    this->set_signature(&signature_);
   }
 
   void call(IndexMask mask, mf::MFParams params, mf::Context /*context*/) const override
@@ -200,20 +194,18 @@ class ReverseUVSampleFunction : public mf::MultiFunction {
       : source_(std::move(geometry)), src_uv_map_field_(std::move(src_uv_map_field))
   {
     source_.ensure_owns_direct_data();
-    static mf::Signature signature = create_signature();
-    this->set_signature(&signature);
     this->evaluate_source();
-  }
 
-  static mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"Sample UV Surface", signature};
-    builder.single_input<float2>("Sample UV");
-    builder.single_output<bool>("Is Valid");
-    builder.single_output<int>("Triangle Index");
-    builder.single_output<float3>("Barycentric Weights");
-    return signature;
+    static const mf::Signature signature = []() {
+      mf::Signature signature;
+      mf::SignatureBuilder builder{"Sample UV Surface", signature};
+      builder.single_input<float2>("Sample UV");
+      builder.single_output<bool>("Is Valid");
+      builder.single_output<int>("Triangle Index");
+      builder.single_output<float3>("Barycentric Weights");
+      return signature;
+    }();
+    this->set_signature(&signature);
   }
 
   void call(IndexMask mask, mf::MFParams params, mf::Context /*context*/) const override

source/blender/nodes/shader/nodes/node_shader_color_ramp.cc

@@ -94,20 +94,17 @@ class ColorBandFunction : public mf::MultiFunction {
  public:
   ColorBandFunction(const ColorBand &color_band) : color_band_(color_band)
   {
-    static mf::Signature signature = create_signature();
+    static const mf::Signature signature = []() {
+      mf::Signature signature;
+      mf::SignatureBuilder builder{"Color Band", signature};
+      builder.single_input<float>("Value");
+      builder.single_output<ColorGeometry4f>("Color");
+      builder.single_output<float>("Alpha");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"Color Band", signature};
-    builder.single_input<float>("Value");
-    builder.single_output<ColorGeometry4f>("Color");
-    builder.single_output<float>("Alpha");
-    return signature;
-  }
-
   void call(IndexMask mask, mf::MFParams params, mf::Context /*context*/) const override
   {
     const VArray<float> &values = params.readonly_single_input<float>(0, "Value");

source/blender/nodes/shader/nodes/node_shader_curves.cc

@@ -70,20 +70,17 @@ class CurveVecFunction : public mf::MultiFunction {
  public:
   CurveVecFunction(const CurveMapping &cumap) : cumap_(cumap)
   {
-    static mf::Signature signature = create_signature();
+    static const mf::Signature signature = []() {
+      mf::Signature signature;
+      mf::SignatureBuilder builder{"Curve Vec", signature};
+      builder.single_input<float>("Fac");
+      builder.single_input<float3>("Vector");
+      builder.single_output<float3>("Vector");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"Curve Vec", signature};
-    builder.single_input<float>("Fac");
-    builder.single_input<float3>("Vector");
-    builder.single_output<float3>("Vector");
-    return signature;
-  }
-
   void call(IndexMask mask, mf::MFParams params, mf::Context /*context*/) const override
   {
     const VArray<float> &fac = params.readonly_single_input<float>(0, "Fac");
@@ -216,20 +213,17 @@ class CurveRGBFunction : public mf::MultiFunction {
  public:
   CurveRGBFunction(const CurveMapping &cumap) : cumap_(cumap)
   {
-    static mf::Signature signature = create_signature();
+    static const mf::Signature signature = []() {
+      mf::Signature signature;
+      mf::SignatureBuilder builder{"Curve RGB", signature};
+      builder.single_input<float>("Fac");
+      builder.single_input<ColorGeometry4f>("Color");
+      builder.single_output<ColorGeometry4f>("Color");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"Curve RGB", signature};
-    builder.single_input<float>("Fac");
-    builder.single_input<ColorGeometry4f>("Color");
-    builder.single_output<ColorGeometry4f>("Color");
-    return signature;
-  }
-
   void call(IndexMask mask, mf::MFParams params, mf::Context /*context*/) const override
   {
     const VArray<float> &fac = params.readonly_single_input<float>(0, "Fac");
@@ -339,20 +333,17 @@ class CurveFloatFunction : public mf::MultiFunction {
  public:
   CurveFloatFunction(const CurveMapping &cumap) : cumap_(cumap)
   {
-    static mf::Signature signature = create_signature();
+    static const mf::Signature signature = []() {
+      mf::Signature signature;
+      mf::SignatureBuilder builder{"Curve Float", signature};
+      builder.single_input<float>("Factor");
+      builder.single_input<float>("Value");
+      builder.single_output<float>("Value");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"Curve Float", signature};
-    builder.single_input<float>("Factor");
-    builder.single_input<float>("Value");
-    builder.single_output<float>("Value");
-    return signature;
-  }
-
   void call(IndexMask mask, mf::MFParams params, mf::Context /*context*/) const override
   {
     const VArray<float> &fac = params.readonly_single_input<float>(0, "Factor");

source/blender/nodes/shader/nodes/node_shader_mix.cc

@@ -361,21 +361,18 @@ class MixColorFunction : public mf::MultiFunction {
   MixColorFunction(const bool clamp_factor, const bool clamp_result, const int blend_type)
       : clamp_factor_(clamp_factor), clamp_result_(clamp_result), blend_type_(blend_type)
   {
-    static mf::Signature signature = create_signature();
+    static const mf::Signature signature = []() {
+      mf::Signature signature;
+      mf::SignatureBuilder builder{"MixColor", signature};
+      builder.single_input<float>("Factor");
+      builder.single_input<ColorGeometry4f>("A");
+      builder.single_input<ColorGeometry4f>("B");
+      builder.single_output<ColorGeometry4f>("Result");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"MixColor", signature};
-    builder.single_input<float>("Factor");
-    builder.single_input<ColorGeometry4f>("A");
-    builder.single_input<ColorGeometry4f>("B");
-    builder.single_output<ColorGeometry4f>("Result");
-    return signature;
-  }
-
   void call(IndexMask mask, mf::MFParams params, mf::Context /*context*/) const override
   {
     const VArray<float> &fac = params.readonly_single_input<float>(0, "Factor");

source/blender/nodes/shader/nodes/node_shader_mix_rgb.cc

@@ -99,21 +99,18 @@ class MixRGBFunction : public mf::MultiFunction {
  public:
   MixRGBFunction(bool clamp, int type) : clamp_(clamp), type_(type)
   {
-    static mf::Signature signature = create_signature();
+    static const mf::Signature signature = []() {
+      mf::Signature signature;
+      mf::SignatureBuilder builder{"MixRGB", signature};
+      builder.single_input<float>("Fac");
+      builder.single_input<ColorGeometry4f>("Color1");
+      builder.single_input<ColorGeometry4f>("Color2");
+      builder.single_output<ColorGeometry4f>("Color");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"MixRGB", signature};
-    builder.single_input<float>("Fac");
-    builder.single_input<ColorGeometry4f>("Color1");
-    builder.single_input<ColorGeometry4f>("Color2");
-    builder.single_output<ColorGeometry4f>("Color");
-    return signature;
-  }
-
   void call(IndexMask mask, mf::MFParams params, mf::Context /*context*/) const override
   {
     const VArray<float> &fac = params.readonly_single_input<float>(0, "Fac");

source/blender/nodes/shader/nodes/node_shader_sepcomb_rgb.cc

@@ -31,21 +31,18 @@ class SeparateRGBFunction : public mf::MultiFunction {
  public:
   SeparateRGBFunction()
   {
-    static mf::Signature signature = create_signature();
+    static const mf::Signature signature = []() {
+      mf::Signature signature;
+      mf::SignatureBuilder builder{"Separate RGB", signature};
+      builder.single_input<ColorGeometry4f>("Color");
+      builder.single_output<float>("R");
+      builder.single_output<float>("G");
+      builder.single_output<float>("B");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"Separate RGB", signature};
-    builder.single_input<ColorGeometry4f>("Color");
-    builder.single_output<float>("R");
-    builder.single_output<float>("G");
-    builder.single_output<float>("B");
-    return signature;
-  }
-
   void call(IndexMask mask, mf::MFParams params, mf::Context /*context*/) const override
   {
     const VArray<ColorGeometry4f> &colors = params.readonly_single_input<ColorGeometry4f>(0,

source/blender/nodes/shader/nodes/node_shader_sepcomb_xyz.cc

@@ -31,21 +31,18 @@ class MF_SeparateXYZ : public mf::MultiFunction {
  public:
   MF_SeparateXYZ()
   {
-    static mf::Signature signature = create_signature();
+    static const mf::Signature signature = []() {
+      mf::Signature signature;
+      mf::SignatureBuilder builder{"Separate XYZ", signature};
+      builder.single_input<float3>("XYZ");
+      builder.single_output<float>("X");
+      builder.single_output<float>("Y");
+      builder.single_output<float>("Z");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"Separate XYZ", signature};
-    builder.single_input<float3>("XYZ");
-    builder.single_output<float>("X");
-    builder.single_output<float>("Y");
-    builder.single_output<float>("Z");
-    return signature;
-  }
-
   void call(IndexMask mask, mf::MFParams params, mf::Context /*context*/) const override
   {
     const VArray<float3> &vectors = params.readonly_single_input<float3>(0, "XYZ");

source/blender/nodes/shader/nodes/node_shader_tex_brick.cc

@@ -122,29 +122,26 @@ class BrickFunction : public mf::MultiFunction {
                 const int squash_freq)
       : offset_(offset), offset_freq_(offset_freq), squash_(squash), squash_freq_(squash_freq)
   {
-    static mf::Signature signature = create_signature();
+    static const mf::Signature signature = []() {
+      mf::Signature signature;
+      mf::SignatureBuilder builder{"BrickTexture", signature};
+      builder.single_input<float3>("Vector");
+      builder.single_input<ColorGeometry4f>("Color1");
+      builder.single_input<ColorGeometry4f>("Color2");
+      builder.single_input<ColorGeometry4f>("Mortar");
+      builder.single_input<float>("Scale");
+      builder.single_input<float>("Mortar Size");
+      builder.single_input<float>("Mortar Smooth");
+      builder.single_input<float>("Bias");
+      builder.single_input<float>("Brick Width");
+      builder.single_input<float>("Row Height");
+      builder.single_output<ColorGeometry4f>("Color");
+      builder.single_output<float>("Fac");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"BrickTexture", signature};
-    builder.single_input<float3>("Vector");
-    builder.single_input<ColorGeometry4f>("Color1");
-    builder.single_input<ColorGeometry4f>("Color2");
-    builder.single_input<ColorGeometry4f>("Mortar");
-    builder.single_input<float>("Scale");
-    builder.single_input<float>("Mortar Size");
-    builder.single_input<float>("Mortar Smooth");
-    builder.single_input<float>("Bias");
-    builder.single_input<float>("Brick Width");
-    builder.single_input<float>("Row Height");
-    builder.single_output<ColorGeometry4f>("Color");
-    builder.single_output<float>("Fac");
-    return signature;
-  }
-
   /* Fast integer noise. */
   static float brick_noise(uint n)
   {

source/blender/nodes/shader/nodes/node_shader_tex_checker.cc

@@ -48,23 +48,20 @@ class NodeTexChecker : public mf::MultiFunction {
  public:
   NodeTexChecker()
   {
-    static mf::Signature signature = create_signature();
+    static const mf::Signature signature = []() {
+      mf::Signature signature;
+      mf::SignatureBuilder builder{"Checker", signature};
+      builder.single_input<float3>("Vector");
+      builder.single_input<ColorGeometry4f>("Color1");
+      builder.single_input<ColorGeometry4f>("Color2");
+      builder.single_input<float>("Scale");
+      builder.single_output<ColorGeometry4f>("Color");
+      builder.single_output<float>("Fac");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"Checker", signature};
-    builder.single_input<float3>("Vector");
-    builder.single_input<ColorGeometry4f>("Color1");
-    builder.single_input<ColorGeometry4f>("Color2");
-    builder.single_input<float>("Scale");
-    builder.single_output<ColorGeometry4f>("Color");
-    builder.single_output<float>("Fac");
-    return signature;
-  }
-
   void call(IndexMask mask, mf::MFParams params, mf::Context /*context*/) const override
   {
     const VArray<float3> &vector = params.readonly_single_input<float3>(0, "Vector");

source/blender/nodes/shader/nodes/node_shader_tex_gradient.cc

@@ -54,20 +54,17 @@ class GradientFunction : public mf::MultiFunction {
  public:
   GradientFunction(int gradient_type) : gradient_type_(gradient_type)
   {
-    static mf::Signature signature = create_signature();
+    static const mf::Signature signature = []() {
+      mf::Signature signature;
+      mf::SignatureBuilder builder{"GradientFunction", signature};
+      builder.single_input<float3>("Vector");
+      builder.single_output<ColorGeometry4f>("Color");
+      builder.single_output<float>("Fac");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"GradientFunction", signature};
-    builder.single_input<float3>("Vector");
-    builder.single_output<ColorGeometry4f>("Color");
-    builder.single_output<float>("Fac");
-    return signature;
-  }
-
   void call(IndexMask mask, mf::MFParams params, mf::Context /*context*/) const override
   {
     const VArray<float3> &vector = params.readonly_single_input<float3>(0, "Vector");

source/blender/nodes/shader/nodes/node_shader_tex_magic.cc

@@ -55,22 +55,19 @@ class MagicFunction : public mf::MultiFunction {
  public:
   MagicFunction(int depth) : depth_(depth)
   {
-    static mf::Signature signature = create_signature();
+    static const mf::Signature signature = []() {
+      mf::Signature signature;
+      mf::SignatureBuilder builder{"MagicFunction", signature};
+      builder.single_input<float3>("Vector");
+      builder.single_input<float>("Scale");
+      builder.single_input<float>("Distortion");
+      builder.single_output<ColorGeometry4f>("Color");
+      builder.single_output<float>("Fac");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"MagicFunction", signature};
-    builder.single_input<float3>("Vector");
-    builder.single_input<float>("Scale");
-    builder.single_input<float>("Distortion");
-    builder.single_output<ColorGeometry4f>("Color");
-    builder.single_output<float>("Fac");
-    return signature;
-  }
-
   void call(IndexMask mask, mf::MFParams params, mf::Context /*context*/) const override
   {
     const VArray<float3> &vector = params.readonly_single_input<float3>(0, "Vector");

source/blender/nodes/shader/nodes/node_shader_tex_wave.cc

@@ -94,26 +94,23 @@ class WaveFunction : public mf::MultiFunction {
         rings_direction_(rings_direction),
         wave_profile_(wave_profile)
   {
-    static mf::Signature signature = create_signature();
+    static const mf::Signature signature = []() {
+      mf::Signature signature;
+      mf::SignatureBuilder builder{"MagicFunction", signature};
+      builder.single_input<float3>("Vector");
+      builder.single_input<float>("Scale");
+      builder.single_input<float>("Distortion");
+      builder.single_input<float>("Detail");
+      builder.single_input<float>("Detail Scale");
+      builder.single_input<float>("Detail Roughness");
+      builder.single_input<float>("Phase Offset");
+      builder.single_output<ColorGeometry4f>("Color");
+      builder.single_output<float>("Fac");
+      return signature;
+    }();
     this->set_signature(&signature);
   }
 
-  static mf::Signature create_signature()
-  {
-    mf::Signature signature;
-    mf::SignatureBuilder builder{"MagicFunction", signature};
-    builder.single_input<float3>("Vector");
-    builder.single_input<float>("Scale");
-    builder.single_input<float>("Distortion");
-    builder.single_input<float>("Detail");
-    builder.single_input<float>("Detail Scale");
-    builder.single_input<float>("Detail Roughness");
-    builder.single_input<float>("Phase Offset");
-    builder.single_output<ColorGeometry4f>("Color");
-    builder.single_output<float>("Fac");
-    return signature;
-  }
-
   void call(IndexMask mask, mf::MFParams params, mf::Context /*context*/) const override
   {
     const VArray<float3> &vector = params.readonly_single_input<float3>(0, "Vector");