blender
/
blender
136
406
Fork 589
Code Issues 6.2k Pull Requests 750 Projects 19 Wiki Activity

Functions: build multi-function signature in-place 

This avoids a move of the signature after building it. Tthe value had
to be moved out of `MFSignatureBuilder` in the `build` method.

This also makes the naming a bit less confusing where sometimes
both the `MFSignature` and `MFSignatureBuilder` were referred
to as "signature".
This commit is contained in:
Jacques Lucke 2023-01-07 16:30:56 +01:00
parent b3146200a8
commit 577442a26f
33 changed files with 331 additions and 303 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
source/blender/functions/FN_multi_function_builder.hh
View File

@ -445,10 +445,9 @@ template<typename CallFn, typename... ParamTags> class CustomMF : public MultiFu
CustomMF(const char *name, CallFn call_fn, TypeSequence<ParamTags...> /*param_tags*/)
: call_fn_(std::move(call_fn))
{
MFSignatureBuilder signature{name};
MFSignatureBuilder builder{name, signature_};
/* Loop over all parameter types and add an entry for each in the signature. */
([&] { signature.add(ParamTags(), ""); }(), ...);
signature_ = signature.build();
([&] { builder.add(ParamTags(), ""); }(), ...);
this->set_signature(&signature_);
}
@ -631,9 +630,8 @@ template<typename T> class CustomMF_Constant : public MultiFunction {
public:
template<typename U> CustomMF_Constant(U &&value) : value_(std::forward<U>(value))
{
MFSignatureBuilder signature{"Constant"};
signature.single_output<T>("Value");
signature_ = signature.build();
MFSignatureBuilder builder{"Constant", signature_};
builder.single_output<T>("Value");
this->set_signature(&signature_);
}

10
source/blender/functions/FN_multi_function_signature.hh
View File

@ -32,19 +32,15 @@ struct MFSignature {
class MFSignatureBuilder {
private:
MFSignature signature_;
MFSignature &signature_;
public:
MFSignatureBuilder(const char *function_name)
MFSignatureBuilder(const char *function_name, MFSignature &signature_to_build)
: signature_(signature_to_build)
{
signature_.function_name = function_name;
}
MFSignature build() const
{
return std::move(signature_);
}
/* Input Parameter Types */
template<typename T> void single_input(const char *name)

24
source/blender/functions/intern/multi_function_builder.cc
View File

@ -18,9 +18,8 @@ CustomMF_GenericConstant::CustomMF_GenericConstant(const CPPType &type,
}
value_ = value;
MFSignatureBuilder signature{"Constant"};
signature.single_output("Value", type);
signature_ = signature.build();
MFSignatureBuilder builder{"Constant", signature_};
builder.single_output("Value", type);
this->set_signature(&signature_);
}
@ -58,9 +57,8 @@ bool CustomMF_GenericConstant::equals(const MultiFunction &other) const
CustomMF_GenericConstantArray::CustomMF_GenericConstantArray(GSpan array) : array_(array)
{
const CPPType &type = array.type();
MFSignatureBuilder signature{"Constant Vector"};
signature.vector_output("Value", type);
signature_ = signature.build();
MFSignatureBuilder builder{"Constant Vector", signature_};
builder.vector_output("Value", type);
this->set_signature(&signature_);
}
@ -78,14 +76,13 @@ CustomMF_DefaultOutput::CustomMF_DefaultOutput(Span<MFDataType> input_types,
Span<MFDataType> output_types)
: output_amount_(output_types.size())
{
MFSignatureBuilder signature{"Default Output"};
MFSignatureBuilder builder{"Default Output", signature_};
for (MFDataType data_type : input_types) {
signature.input("Input", data_type);
builder.input("Input", data_type);
}
for (MFDataType data_type : output_types) {
signature.output("Output", data_type);
builder.output("Output", data_type);
}
signature_ = signature.build();
this->set_signature(&signature_);
}
void CustomMF_DefaultOutput::call(IndexMask mask, MFParams params, MFContext /*context*/) const
@ -106,10 +103,9 @@ void CustomMF_DefaultOutput::call(IndexMask mask, MFParams params, MFContext /*c
CustomMF_GenericCopy::CustomMF_GenericCopy(MFDataType data_type)
{
MFSignatureBuilder signature{"Copy"};
signature.input("Input", data_type);
signature.output("Output", data_type);
signature_ = signature.build();
MFSignatureBuilder builder{"Copy", signature_};
builder.input("Input", data_type);
builder.output("Output", data_type);
this->set_signature(&signature_);
}

5
source/blender/functions/intern/multi_function_procedure_executor.cc
View File

@ -8,13 +8,12 @@ namespace blender::fn {
MFProcedureExecutor::MFProcedureExecutor(const MFProcedure &procedure) : procedure_(procedure)
{
MFSignatureBuilder signature("Procedure Executor");
MFSignatureBuilder builder("Procedure Executor", signature_);
for (const ConstMFParameter &param : procedure.params()) {
signature.add("Parameter", MFParamType(param.type, param.variable->data_type()));
builder.add("Parameter", MFParamType(param.type, param.variable->data_type()));
}
signature_ = signature.build();
this->set_signature(&signature_);
}

11
source/blender/functions/tests/FN_field_test.cc
View File

@ -156,12 +156,11 @@ class TwoOutputFunction : public MultiFunction {
public:
TwoOutputFunction()
{
MFSignatureBuilder signature{"Two Outputs"};
signature.single_input<int>("In1");
signature.single_input<int>("In2");
signature.single_output<int>("Add");
signature.single_output<int>("Add10");
signature_ = signature.build();
MFSignatureBuilder builder{"Two Outputs", signature_};
builder.single_input<int>("In1");
builder.single_input<int>("In2");
builder.single_output<int>("Add");
builder.single_output<int>("Add10");
this->set_signature(&signature_);
}

11
source/blender/functions/tests/FN_multi_function_test.cc
View File

@ -19,11 +19,12 @@ class AddFunction : public MultiFunction {
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();
MFSignature signature;
MFSignatureBuilder 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, MFContext /*context*/) const override

61
source/blender/functions/tests/FN_multi_function_test_common.hh
View File

@ -14,10 +14,11 @@ class AddPrefixFunction : public MultiFunction {
static MFSignature create_signature()
{
MFSignatureBuilder signature{"Add Prefix"};
signature.single_input<std::string>("Prefix");
signature.single_mutable<std::string>("Strings");
return signature.build();
MFSignature signature;
MFSignatureBuilder builder{"Add Prefix", signature};
builder.single_input<std::string>("Prefix");
builder.single_mutable<std::string>("Strings");
return signature;
}
void call(IndexMask mask, MFParams params, MFContext /*context*/) const override
@ -41,10 +42,11 @@ class CreateRangeFunction : public MultiFunction {
static MFSignature create_signature()
{
MFSignatureBuilder signature{"Create Range"};
signature.single_input<int>("Size");
signature.vector_output<int>("Range");
return signature.build();
MFSignature signature;
MFSignatureBuilder builder{"Create Range", signature};
builder.single_input<int>("Size");
builder.vector_output<int>("Range");
return signature;
}
void call(IndexMask mask, MFParams params, MFContext /*context*/) const override
@ -68,10 +70,9 @@ class GenericAppendFunction : public MultiFunction {
public:
GenericAppendFunction(const CPPType &type)
{
MFSignatureBuilder signature{"Append"};
signature.vector_mutable("Vector", type);
signature.single_input("Value", type);
signature_ = signature.build();
MFSignatureBuilder builder{"Append", signature_};
builder.vector_mutable("Vector", type);
builder.single_input("Value", type);
this->set_signature(&signature_);
}
@ -99,10 +100,11 @@ class ConcatVectorsFunction : public MultiFunction {
static MFSignature create_signature()
{
MFSignatureBuilder signature{"Concat Vectors"};
signature.vector_mutable<int>("A");
signature.vector_input<int>("B");
return signature.build();
MFSignature signature;
MFSignatureBuilder builder{"Concat Vectors", signature};
builder.vector_mutable<int>("A");
builder.vector_input<int>("B");
return signature;
}
void call(IndexMask mask, MFParams params, MFContext /*context*/) const override
@ -123,10 +125,11 @@ class AppendFunction : public MultiFunction {
static MFSignature create_signature()
{
MFSignatureBuilder signature{"Append"};
signature.vector_mutable<int>("Vector");
signature.single_input<int>("Value");
return signature.build();
MFSignature signature;
MFSignatureBuilder builder{"Append", signature};
builder.vector_mutable<int>("Vector");
builder.single_input<int>("Value");
return signature;
}
void call(IndexMask mask, MFParams params, MFContext /*context*/) const override
@ -150,10 +153,11 @@ class SumVectorFunction : public MultiFunction {
static MFSignature create_signature()
{
MFSignatureBuilder signature{"Sum Vectors"};
signature.vector_input<int>("Vector");
signature.single_output<int>("Sum");
return signature.build();
MFSignature signature;
MFSignatureBuilder builder{"Sum Vectors", signature};
builder.vector_input<int>("Vector");
builder.single_output<int>("Sum");
return signature;
}
void call(IndexMask mask, MFParams params, MFContext /*context*/) const override
@ -181,10 +185,11 @@ class OptionalOutputsFunction : public MultiFunction {
static MFSignature create_signature()
{
MFSignatureBuilder signature{"Optional Outputs"};
signature.single_output<int>("Out 1");
signature.single_output<std::string>("Out 2");
return signature.build();
MFSignature signature;
MFSignatureBuilder 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, MFContext /*context*/) const override

13
source/blender/nodes/function/nodes/node_fn_align_euler_to_vector.cc
View File

@ -148,13 +148,14 @@ class MF_AlignEulerToVector : public fn::MultiFunction {
static fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"Align Euler to Vector"};
signature.single_input<float3>("Rotation");
signature.single_input<float>("Factor");
signature.single_input<float3>("Vector");
fn::MFSignature signature;
fn::MFSignatureBuilder builder{"Align Euler to Vector", signature};
builder.single_input<float3>("Rotation");
builder.single_input<float>("Factor");
builder.single_input<float3>("Vector");
signature.single_output<float3>("Rotation");
return signature.build();
builder.single_output<float3>("Rotation");
return signature;
}
void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override

9
source/blender/nodes/function/nodes/node_fn_input_special_characters.cc
View File

@ -20,10 +20,11 @@ class MF_SpecialCharacters : public fn::MultiFunction {
static fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"Special Characters"};
signature.single_output<std::string>("Line Break");
signature.single_output<std::string>("Tab");
return signature.build();
fn::MFSignature signature;
fn::MFSignatureBuilder builder{"Special Characters", signature};
builder.single_output<std::string>("Line Break");
builder.single_output<std::string>("Tab");
return signature;
}
void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override

45
source/blender/nodes/function/nodes/node_fn_separate_color.cc
View File

@ -47,13 +47,14 @@ class SeparateRGBAFunction : public fn::MultiFunction {
static fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"Separate Color"};
signature.single_input<ColorGeometry4f>("Color");
signature.single_output<float>("Red");
signature.single_output<float>("Green");
signature.single_output<float>("Blue");
signature.single_output<float>("Alpha");
return signature.build();
fn::MFSignature signature;
fn::MFSignatureBuilder 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, fn::MFParams params, fn::MFContext /*context*/) const override
@ -108,13 +109,14 @@ class SeparateHSVAFunction : public fn::MultiFunction {
static fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"Separate Color"};
signature.single_input<ColorGeometry4f>("Color");
signature.single_output<float>("Hue");
signature.single_output<float>("Saturation");
signature.single_output<float>("Value");
signature.single_output<float>("Alpha");
return signature.build();
fn::MFSignature signature;
fn::MFSignatureBuilder 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, fn::MFParams params, fn::MFContext /*context*/) const override
@ -148,13 +150,14 @@ class SeparateHSLAFunction : public fn::MultiFunction {
static fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"Separate Color"};
signature.single_input<ColorGeometry4f>("Color");
signature.single_output<float>("Hue");
signature.single_output<float>("Saturation");
signature.single_output<float>("Lightness");
signature.single_output<float>("Alpha");
return signature.build();
fn::MFSignature signature;
fn::MFSignatureBuilder 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, fn::MFParams params, fn::MFContext /*context*/) const override

28
source/blender/nodes/geometry/nodes/node_geo_curve_sample.cc
View File

@ -217,12 +217,13 @@ class SampleFloatSegmentsFunction : public fn::MultiFunction {
static fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"Sample Curve Index"};
signature.single_input<float>("Length");
fn::MFSignature signature;
fn::MFSignatureBuilder builder{"Sample Curve Index", signature};
builder.single_input<float>("Length");
signature.single_output<int>("Curve Index");
signature.single_output<float>("Length in Curve");
return signature.build();
builder.single_output<int>("Curve Index");
builder.single_output<float>("Length in Curve");
return signature;
}
void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
@ -267,14 +268,15 @@ class SampleCurveFunction : public fn::MultiFunction {
fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"Sample Curve"};
signature.single_input<int>("Curve Index");
signature.single_input<float>("Length");
signature.single_output<float3>("Position");
signature.single_output<float3>("Tangent");
signature.single_output<float3>("Normal");
signature.single_output("Value", src_field_.cpp_type());
return signature.build();
fn::MFSignature signature;
fn::MFSignatureBuilder 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;
}
void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override

11
source/blender/nodes/geometry/nodes/node_geo_image_texture.cc
View File

@ -93,11 +93,12 @@ class ImageFieldsFunction : public fn::MultiFunction {
static fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"ImageFunction"};
signature.single_input<float3>("Vector");
signature.single_output<ColorGeometry4f>("Color");
signature.single_output<float>("Alpha");
return signature.build();
fn::MFSignature signature;
fn::MFSignatureBuilder 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)

11
source/blender/nodes/geometry/nodes/node_geo_proximity.cc
View File

@ -144,11 +144,12 @@ class ProximityFunction : public fn::MultiFunction {
static fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"Geometry Proximity"};
signature.single_input<float3>("Source Position");
signature.single_output<float3>("Position");
signature.single_output<float>("Distance");
return signature.build();
fn::MFSignature signature;
fn::MFSignatureBuilder 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, fn::MFParams params, fn::MFContext /*context*/) const override

21
source/blender/nodes/geometry/nodes/node_geo_raycast.cc
View File

@ -231,18 +231,19 @@ class RaycastFunction : public fn::MultiFunction {
fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"Geometry Proximity"};
signature.single_input<float3>("Source Position");
signature.single_input<float3>("Ray Direction");
signature.single_input<float>("Ray Length");
signature.single_output<bool>("Is Hit");
signature.single_output<float3>("Hit Position");
signature.single_output<float3>("Hit Normal");
signature.single_output<float>("Distance");
fn::MFSignature signature;
fn::MFSignatureBuilder builder{"Geometry Proximity", signature};
builder.single_input<float3>("Source Position");
builder.single_input<float3>("Ray Direction");
builder.single_input<float>("Ray Length");
builder.single_output<bool>("Is Hit");
builder.single_output<float3>("Hit Position");
builder.single_output<float3>("Hit Normal");
builder.single_output<float>("Distance");
if (target_data_) {
signature.single_output("Attribute", target_data_->type());
builder.single_output("Attribute", target_data_->type());
}
return signature.build();
return signature;
}
void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override

9
source/blender/nodes/geometry/nodes/node_geo_sample_index.cc
View File

@ -208,10 +208,11 @@ class SampleIndexFunction : public fn::MultiFunction {
fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"Sample Index"};
signature.single_input<int>("Index");
signature.single_output("Value", src_field_.cpp_type());
return signature.build();
fn::MFSignature signature;
fn::MFSignatureBuilder builder{"Sample Index", signature};
builder.single_input<int>("Index");
builder.single_output("Value", src_field_.cpp_type());
return signature;
}
void evaluate_field()

9
source/blender/nodes/geometry/nodes/node_geo_sample_nearest.cc
View File

@ -253,10 +253,11 @@ class SampleNearestFunction : public fn::MultiFunction {
fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"Sample Nearest"};
signature.single_input<float3>("Position");
signature.single_output<int>("Index");
return signature.build();
fn::MFSignature signature;
fn::MFSignatureBuilder builder{"Sample Nearest", signature};
builder.single_input<float3>("Position");
builder.single_output<int>("Index");
return signature;
}
void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override

9
source/blender/nodes/geometry/nodes/node_geo_sample_nearest_surface.cc
View File

@ -146,10 +146,11 @@ class SampleNearestSurfaceFunction : public fn::MultiFunction {
fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"Sample Nearest Surface"};
signature.single_input<float3>("Position");
signature.single_output("Value", src_field_.cpp_type());
return signature.build();
fn::MFSignature signature;
fn::MFSignatureBuilder builder{"Sample Nearest Surface", signature};
builder.single_input<float3>("Position");
builder.single_output("Value", src_field_.cpp_type());
return signature;
}
void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override

24
source/blender/nodes/geometry/nodes/node_geo_sample_uv_surface.cc
View File

@ -136,11 +136,12 @@ class SampleMeshBarycentricFunction : public fn::MultiFunction {
fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"Sample Barycentric Triangles"};
signature.single_input<int>("Triangle Index");
signature.single_input<float3>("Barycentric Weight");
signature.single_output("Value", src_field_.cpp_type());
return signature.build();
fn::MFSignature signature;
fn::MFSignatureBuilder 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;
}
void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
@ -206,12 +207,13 @@ class ReverseUVSampleFunction : public fn::MultiFunction {
static fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"Sample UV Surface"};
signature.single_input<float2>("Sample UV");
signature.single_output<bool>("Is Valid");
signature.single_output<int>("Triangle Index");
signature.single_output<float3>("Barycentric Weights");
return signature.build();
fn::MFSignature signature;
fn::MFSignatureBuilder 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;
}
void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override

11
source/blender/nodes/shader/nodes/node_shader_color_ramp.cc
View File

@ -100,11 +100,12 @@ class ColorBandFunction : public fn::MultiFunction {
static fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"Color Band"};
signature.single_input<float>("Value");
signature.single_output<ColorGeometry4f>("Color");
signature.single_output<float>("Alpha");
return signature.build();
fn::MFSignature signature;
fn::MFSignatureBuilder 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, fn::MFParams params, fn::MFContext /*context*/) const override

33
source/blender/nodes/shader/nodes/node_shader_curves.cc
View File

@ -76,11 +76,12 @@ class CurveVecFunction : public fn::MultiFunction {
static fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"Curve Vec"};
signature.single_input<float>("Fac");
signature.single_input<float3>("Vector");
signature.single_output<float3>("Vector");
return signature.build();
fn::MFSignature signature;
fn::MFSignatureBuilder 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, fn::MFParams params, fn::MFContext /*context*/) const override
@ -221,11 +222,12 @@ class CurveRGBFunction : public fn::MultiFunction {
static fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"Curve RGB"};
signature.single_input<float>("Fac");
signature.single_input<ColorGeometry4f>("Color");
signature.single_output<ColorGeometry4f>("Color");
return signature.build();
fn::MFSignature signature;
fn::MFSignatureBuilder 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, fn::MFParams params, fn::MFContext /*context*/) const override
@ -343,11 +345,12 @@ class CurveFloatFunction : public fn::MultiFunction {
static fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"Curve Float"};
signature.single_input<float>("Factor");
signature.single_input<float>("Value");
signature.single_output<float>("Value");
return signature.build();
fn::MFSignature signature;
fn::MFSignatureBuilder 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, fn::MFParams params, fn::MFContext /*context*/) const override

13
source/blender/nodes/shader/nodes/node_shader_mix.cc
View File

@ -367,12 +367,13 @@ class MixColorFunction : public fn::MultiFunction {
static fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"MixColor"};
signature.single_input<float>("Factor");
signature.single_input<ColorGeometry4f>("A");
signature.single_input<ColorGeometry4f>("B");
signature.single_output<ColorGeometry4f>("Result");
return signature.build();
fn::MFSignature signature;
fn::MFSignatureBuilder 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, fn::MFParams params, fn::MFContext /*context*/) const override

13
source/blender/nodes/shader/nodes/node_shader_mix_rgb.cc
View File

@ -105,12 +105,13 @@ class MixRGBFunction : public fn::MultiFunction {
static fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"MixRGB"};
signature.single_input<float>("Fac");
signature.single_input<ColorGeometry4f>("Color1");
signature.single_input<ColorGeometry4f>("Color2");
signature.single_output<ColorGeometry4f>("Color");
return signature.build();
fn::MFSignature signature;
fn::MFSignatureBuilder 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, fn::MFParams params, fn::MFContext /*context*/) const override

13
source/blender/nodes/shader/nodes/node_shader_sepcomb_rgb.cc
View File

@ -37,12 +37,13 @@ class SeparateRGBFunction : public fn::MultiFunction {
static fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"Separate RGB"};
signature.single_input<ColorGeometry4f>("Color");
signature.single_output<float>("R");
signature.single_output<float>("G");
signature.single_output<float>("B");
return signature.build();
fn::MFSignature signature;
fn::MFSignatureBuilder 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, fn::MFParams params, fn::MFContext /*context*/) const override

13
source/blender/nodes/shader/nodes/node_shader_sepcomb_xyz.cc
View File

@ -37,12 +37,13 @@ class MF_SeparateXYZ : public fn::MultiFunction {
static fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"Separate XYZ"};
signature.single_input<float3>("XYZ");
signature.single_output<float>("X");
signature.single_output<float>("Y");
signature.single_output<float>("Z");
return signature.build();
fn::MFSignature signature;
fn::MFSignatureBuilder 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, fn::MFParams params, fn::MFContext /*context*/) const override

29
source/blender/nodes/shader/nodes/node_shader_tex_brick.cc
View File

@ -128,20 +128,21 @@ class BrickFunction : public fn::MultiFunction {
static fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"BrickTexture"};
signature.single_input<float3>("Vector");
signature.single_input<ColorGeometry4f>("Color1");
signature.single_input<ColorGeometry4f>("Color2");
signature.single_input<ColorGeometry4f>("Mortar");
signature.single_input<float>("Scale");
signature.single_input<float>("Mortar Size");
signature.single_input<float>("Mortar Smooth");
signature.single_input<float>("Bias");
signature.single_input<float>("Brick Width");
signature.single_input<float>("Row Height");
signature.single_output<ColorGeometry4f>("Color");
signature.single_output<float>("Fac");
return signature.build();
fn::MFSignature signature;
fn::MFSignatureBuilder 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. */

17
source/blender/nodes/shader/nodes/node_shader_tex_checker.cc
View File

@ -54,14 +54,15 @@ class NodeTexChecker : public fn::MultiFunction {
static fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"Checker"};
signature.single_input<float3>("Vector");
signature.single_input<ColorGeometry4f>("Color1");
signature.single_input<ColorGeometry4f>("Color2");
signature.single_input<float>("Scale");
signature.single_output<ColorGeometry4f>("Color");
signature.single_output<float>("Fac");
return signature.build();
fn::MFSignature signature;
fn::MFSignatureBuilder 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, fn::MFParams params, fn::MFContext /*context*/) const override

11
source/blender/nodes/shader/nodes/node_shader_tex_gradient.cc
View File

@ -60,11 +60,12 @@ class GradientFunction : public fn::MultiFunction {
static fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"GradientFunction"};
signature.single_input<float3>("Vector");
signature.single_output<ColorGeometry4f>("Color");
signature.single_output<float>("Fac");
return signature.build();
fn::MFSignature signature;
fn::MFSignatureBuilder builder{"GradientFunction", signature};
builder.single_input<float3>("Vector");
builder.single_output<ColorGeometry4f>("Color");
builder.single_output<float>("Fac");
return signature;
}
void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override

15
source/blender/nodes/shader/nodes/node_shader_tex_magic.cc
View File

@ -61,13 +61,14 @@ class MagicFunction : public fn::MultiFunction {
static fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"MagicFunction"};
signature.single_input<float3>("Vector");
signature.single_input<float>("Scale");
signature.single_input<float>("Distortion");
signature.single_output<ColorGeometry4f>("Color");
signature.single_output<float>("Fac");
return signature.build();
fn::MFSignature signature;
fn::MFSignatureBuilder 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, fn::MFParams params, fn::MFContext /*context*/) const override

23
source/blender/nodes/shader/nodes/node_shader_tex_musgrave.cc
View File

@ -167,31 +167,32 @@ class MusgraveFunction : public fn::MultiFunction {
static fn::MFSignature create_signature(const int dimensions, const int musgrave_type)
{
fn::MFSignatureBuilder signature{"Musgrave"};
fn::MFSignature signature;
fn::MFSignatureBuilder builder{"Musgrave", signature};
if (ELEM(dimensions, 2, 3, 4)) {
signature.single_input<float3>("Vector");
builder.single_input<float3>("Vector");
}
if (ELEM(dimensions, 1, 4)) {
signature.single_input<float>("W");
builder.single_input<float>("W");
}
signature.single_input<float>("Scale");
signature.single_input<float>("Detail");
signature.single_input<float>("Dimension");
signature.single_input<float>("Lacunarity");
builder.single_input<float>("Scale");
builder.single_input<float>("Detail");
builder.single_input<float>("Dimension");
builder.single_input<float>("Lacunarity");
if (ELEM(musgrave_type,
SHD_MUSGRAVE_RIDGED_MULTIFRACTAL,
SHD_MUSGRAVE_HYBRID_MULTIFRACTAL,
SHD_MUSGRAVE_HETERO_TERRAIN)) {
signature.single_input<float>("Offset");
builder.single_input<float>("Offset");
}
if (ELEM(musgrave_type, SHD_MUSGRAVE_RIDGED_MULTIFRACTAL, SHD_MUSGRAVE_HYBRID_MULTIFRACTAL)) {
signature.single_input<float>("Gain");
builder.single_input<float>("Gain");
}
signature.single_output<float>("Fac");
builder.single_output<float>("Fac");
return signature.build();
return signature;
}
void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override

21
source/blender/nodes/shader/nodes/node_shader_tex_noise.cc
View File

@ -100,24 +100,25 @@ class NoiseFunction : public fn::MultiFunction {
static fn::MFSignature create_signature(int dimensions)
{
fn::MFSignatureBuilder signature{"Noise"};
fn::MFSignature signature;
fn::MFSignatureBuilder builder{"Noise", signature};
if (ELEM(dimensions, 2, 3, 4)) {
signature.single_input<float3>("Vector");
builder.single_input<float3>("Vector");
}
if (ELEM(dimensions, 1, 4)) {
signature.single_input<float>("W");
builder.single_input<float>("W");
}
signature.single_input<float>("Scale");
signature.single_input<float>("Detail");
signature.single_input<float>("Roughness");
signature.single_input<float>("Distortion");
builder.single_input<float>("Scale");
builder.single_input<float>("Detail");
builder.single_input<float>("Roughness");
builder.single_input<float>("Distortion");
signature.single_output<float>("Fac");
signature.single_output<ColorGeometry4f>("Color");
builder.single_output<float>("Fac");
builder.single_output<ColorGeometry4f>("Color");
return signature.build();
return signature;
}
void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override

65
source/blender/nodes/shader/nodes/node_shader_tex_voronoi.cc
View File

@ -209,31 +209,32 @@ class VoronoiMinowskiFunction : public fn::MultiFunction {
static fn::MFSignature create_signature(int dimensions, int feature)
{
fn::MFSignatureBuilder signature{"voronoi_minowski"};
fn::MFSignature signature;
fn::MFSignatureBuilder builder{"voronoi_minowski", signature};
if (ELEM(dimensions, 2, 3, 4)) {
signature.single_input<float3>("Vector");
builder.single_input<float3>("Vector");
}
if (ELEM(dimensions, 1, 4)) {
signature.single_input<float>("W");
builder.single_input<float>("W");
}
signature.single_input<float>("Scale");
builder.single_input<float>("Scale");
if (feature == SHD_VORONOI_SMOOTH_F1) {
signature.single_input<float>("Smoothness");
builder.single_input<float>("Smoothness");
}
signature.single_input<float>("Exponent");
signature.single_input<float>("Randomness");
signature.single_output<float>("Distance");
signature.single_output<ColorGeometry4f>("Color");
builder.single_input<float>("Exponent");
builder.single_input<float>("Randomness");
builder.single_output<float>("Distance");
builder.single_output<ColorGeometry4f>("Color");
if (dimensions != 1) {
signature.single_output<float3>("Position");
builder.single_output<float3>("Position");
}
if (ELEM(dimensions, 1, 4)) {
signature.single_output<float>("W");
builder.single_output<float>("W");
}
return signature.build();
return signature;
}
void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
@ -646,30 +647,31 @@ class VoronoiMetricFunction : public fn::MultiFunction {
static fn::MFSignature create_signature(int dimensions, int feature)
{
fn::MFSignatureBuilder signature{"voronoi_metric"};
fn::MFSignature signature;
fn::MFSignatureBuilder builder{"voronoi_metric", signature};
if (ELEM(dimensions, 2, 3, 4)) {
signature.single_input<float3>("Vector");
builder.single_input<float3>("Vector");
}
if (ELEM(dimensions, 1, 4)) {
signature.single_input<float>("W");
builder.single_input<float>("W");
}
signature.single_input<float>("Scale");
builder.single_input<float>("Scale");
if (feature == SHD_VORONOI_SMOOTH_F1) {
signature.single_input<float>("Smoothness");
builder.single_input<float>("Smoothness");
}
signature.single_input<float>("Randomness");
signature.single_output<float>("Distance");
signature.single_output<ColorGeometry4f>("Color");
builder.single_input<float>("Randomness");
builder.single_output<float>("Distance");
builder.single_output<ColorGeometry4f>("Color");
if (dimensions != 1) {
signature.single_output<float3>("Position");
builder.single_output<float3>("Position");
}
if (ELEM(dimensions, 1, 4)) {
signature.single_output<float>("W");
builder.single_output<float>("W");
}
return signature.build();
return signature;
}
void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
@ -1158,25 +1160,26 @@ class VoronoiEdgeFunction : public fn::MultiFunction {
static fn::MFSignature create_signature(int dimensions, int feature)
{
fn::MFSignatureBuilder signature{"voronoi_edge"};
fn::MFSignature signature;
fn::MFSignatureBuilder builder{"voronoi_edge", signature};
if (ELEM(dimensions, 2, 3, 4)) {
signature.single_input<float3>("Vector");
builder.single_input<float3>("Vector");
}
if (ELEM(dimensions, 1, 4)) {
signature.single_input<float>("W");
builder.single_input<float>("W");
}
signature.single_input<float>("Scale");
signature.single_input<float>("Randomness");
builder.single_input<float>("Scale");
builder.single_input<float>("Randomness");
if (feature == SHD_VORONOI_DISTANCE_TO_EDGE) {
signature.single_output<float>("Distance");
builder.single_output<float>("Distance");
}
if (feature == SHD_VORONOI_N_SPHERE_RADIUS) {
signature.single_output<float>("Radius");
builder.single_output<float>("Radius");
}
return signature.build();
return signature;
}
void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override

23
source/blender/nodes/shader/nodes/node_shader_tex_wave.cc
View File

@ -100,17 +100,18 @@ class WaveFunction : public fn::MultiFunction {
static fn::MFSignature create_signature()
{
fn::MFSignatureBuilder signature{"MagicFunction"};
signature.single_input<float3>("Vector");
signature.single_input<float>("Scale");
signature.single_input<float>("Distortion");
signature.single_input<float>("Detail");
signature.single_input<float>("Detail Scale");
signature.single_input<float>("Detail Roughness");
signature.single_input<float>("Phase Offset");
signature.single_output<ColorGeometry4f>("Color");
signature.single_output<float>("Fac");
return signature.build();
fn::MFSignature signature;
fn::MFSignatureBuilder 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, fn::MFParams params, fn::MFContext /*context*/) const override

13
source/blender/nodes/shader/nodes/node_shader_tex_white_noise.cc
View File

@ -82,19 +82,20 @@ class WhiteNoiseFunction : public fn::MultiFunction {
static fn::MFSignature create_signature(int dimensions)
{
fn::MFSignatureBuilder signature{"WhiteNoise"};
fn::MFSignature signature;
fn::MFSignatureBuilder builder{"WhiteNoise", signature};
if (ELEM(dimensions, 2, 3, 4)) {
signature.single_input<float3>("Vector");
builder.single_input<float3>("Vector");
}
if (ELEM(dimensions, 1, 4)) {
signature.single_input<float>("W");
builder.single_input<float>("W");
}
signature.single_output<float>("Value");
signature.single_output<ColorGeometry4f>("Color");
builder.single_output<float>("Value");
builder.single_output<ColorGeometry4f>("Color");
return signature.build();
return signature;
}
void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override