diff options
Diffstat (limited to 'source/blender/nodes/intern/type_conversions.cc')
| -rw-r--r-- | source/blender/nodes/intern/type_conversions.cc | 263 |
1 files changed, 184 insertions, 79 deletions
diff --git a/source/blender/nodes/intern/type_conversions.cc b/source/blender/nodes/intern/type_conversions.cc index 0f6bfa1d6d1..1c1b7c7feb5 100644 --- a/source/blender/nodes/intern/type_conversions.cc +++ b/source/blender/nodes/intern/type_conversions.cc @@ -26,83 +26,192 @@ namespace blender::nodes { using fn::MFDataType; -template<typename From, typename To> +template<typename From, typename To, To (*ConversionF)(const From &)> static void add_implicit_conversion(DataTypeConversions &conversions) { - static fn::CustomMF_Convert<From, To> function; - conversions.add(fn::MFDataType::ForSingle<From>(), fn::MFDataType::ForSingle<To>(), function); + const CPPType &from_type = CPPType::get<From>(); + const CPPType &to_type = CPPType::get<To>(); + const std::string conversion_name = from_type.name() + " to " + to_type.name(); + + static fn::CustomMF_SI_SO<From, To> multi_function{conversion_name, ConversionF}; + static auto convert_single_to_initialized = [](const void *src, void *dst) { + *(To *)dst = ConversionF(*(const From *)src); + }; + static auto convert_single_to_uninitialized = [](const void *src, void *dst) { + new (dst) To(ConversionF(*(const From *)src)); + }; + conversions.add(fn::MFDataType::ForSingle<From>(), + fn::MFDataType::ForSingle<To>(), + multi_function, + convert_single_to_initialized, + convert_single_to_uninitialized); } -template<typename From, typename To, typename ConversionF> -static void add_implicit_conversion(DataTypeConversions &conversions, - StringRef name, - ConversionF conversion) +static float2 float_to_float2(const float &a) { - static fn::CustomMF_SI_SO<From, To> function{name, conversion}; - conversions.add(fn::MFDataType::ForSingle<From>(), fn::MFDataType::ForSingle<To>(), function); + return float2(a); +} +static float3 float_to_float3(const float &a) +{ + return float3(a); +} +static int32_t float_to_int(const float &a) +{ + return (int32_t)a; +} +static bool float_to_bool(const float &a) +{ + return a > 0.0f; +} +static Color4f float_to_color(const float &a) +{ + return Color4f(a, a, a, 1.0f); +} + +static float3 float2_to_float3(const float2 &a) +{ + return float3(a.x, a.y, 0.0f); +} +static float float2_to_float(const float2 &a) +{ + return (a.x + a.y) / 2.0f; +} +static int float2_to_int(const float2 &a) +{ + return (int32_t)((a.x + a.y) / 2.0f); +} +static bool float2_to_bool(const float2 &a) +{ + return !is_zero_v2(a); +} +static Color4f float2_to_color(const float2 &a) +{ + return Color4f(a.x, a.y, 0.0f, 1.0f); +} + +static bool float3_to_bool(const float3 &a) +{ + return !is_zero_v3(a); +} +static float float3_to_float(const float3 &a) +{ + return (a.x + a.y + a.z) / 3.0f; +} +static int float3_to_int(const float3 &a) +{ + return (int)((a.x + a.y + a.z) / 3.0f); +} +static float2 float3_to_float2(const float3 &a) +{ + return float2(a); +} +static Color4f float3_to_color(const float3 &a) +{ + return Color4f(a.x, a.y, a.z, 1.0f); +} + +static bool int_to_bool(const int32_t &a) +{ + return a > 0; +} +static float int_to_float(const int32_t &a) +{ + return (float)a; +} +static float2 int_to_float2(const int32_t &a) +{ + return float2((float)a); +} +static float3 int_to_float3(const int32_t &a) +{ + return float3((float)a); +} +static Color4f int_to_color(const int32_t &a) +{ + return Color4f((float)a, (float)a, (float)a, 1.0f); +} + +static float bool_to_float(const bool &a) +{ + return (bool)a; +} +static int32_t bool_to_int(const bool &a) +{ + return (int32_t)a; +} +static float2 bool_to_float2(const bool &a) +{ + return (a) ? float2(1.0f) : float2(0.0f); +} +static float3 bool_to_float3(const bool &a) +{ + return (a) ? float3(1.0f) : float3(0.0f); +} +static Color4f bool_to_color(const bool &a) +{ + return (a) ? Color4f(1.0f, 1.0f, 1.0f, 1.0f) : Color4f(0.0f, 0.0f, 0.0f, 1.0f); +} + +static bool color_to_bool(const Color4f &a) +{ + return rgb_to_grayscale(a) > 0.0f; +} +static float color_to_float(const Color4f &a) +{ + return rgb_to_grayscale(a); +} +static int32_t color_to_int(const Color4f &a) +{ + return (int)rgb_to_grayscale(a); +} +static float2 color_to_float2(const Color4f &a) +{ + return float2(a.r, a.g); +} +static float3 color_to_float3(const Color4f &a) +{ + return float3(a.r, a.g, a.b); } static DataTypeConversions create_implicit_conversions() { DataTypeConversions conversions; - add_implicit_conversion<float, float2>(conversions); - add_implicit_conversion<float, float3>(conversions); - add_implicit_conversion<float, int32_t>(conversions); - add_implicit_conversion<float, bool>( - conversions, "float to boolean", [](float a) { return a > 0.0f; }); - add_implicit_conversion<float, Color4f>( - conversions, "float to Color4f", [](float a) { return Color4f(a, a, a, 1.0f); }); - - add_implicit_conversion<float2, float3>( - conversions, "float2 to float3", [](float2 a) { return float3(a.x, a.y, 0.0f); }); - add_implicit_conversion<float2, float>( - conversions, "float2 to float", [](float2 a) { return (a.x + a.y) / 2.0f; }); - add_implicit_conversion<float2, int32_t>( - conversions, "float2 to int32_t", [](float2 a) { return (int32_t)((a.x + a.y) / 2.0f); }); - add_implicit_conversion<float2, bool>( - conversions, "float2 to bool", [](float2 a) { return !is_zero_v2(a); }); - add_implicit_conversion<float2, Color4f>( - conversions, "float2 to Color4f", [](float2 a) { return Color4f(a.x, a.y, 0.0f, 1.0f); }); - - add_implicit_conversion<float3, bool>( - conversions, "float3 to boolean", [](float3 a) { return !is_zero_v3(a); }); - add_implicit_conversion<float3, float>( - conversions, "float3 to float", [](float3 a) { return (a.x + a.y + a.z) / 3.0f; }); - add_implicit_conversion<float3, int32_t>( - conversions, "float3 to int32_t", [](float3 a) { return (int)((a.x + a.y + a.z) / 3.0f); }); - add_implicit_conversion<float3, float2>(conversions); - add_implicit_conversion<float3, Color4f>( - conversions, "float3 to Color4f", [](float3 a) { return Color4f(a.x, a.y, a.z, 1.0f); }); - - add_implicit_conversion<int32_t, bool>( - conversions, "int32 to boolean", [](int32_t a) { return a > 0; }); - add_implicit_conversion<int32_t, float>(conversions); - add_implicit_conversion<int32_t, float2>( - conversions, "int32 to float2", [](int32_t a) { return float2((float)a); }); - add_implicit_conversion<int32_t, float3>( - conversions, "int32 to float3", [](int32_t a) { return float3((float)a); }); - add_implicit_conversion<int32_t, Color4f>(conversions, "int32 to Color4f", [](int32_t a) { - return Color4f((float)a, (float)a, (float)a, 1.0f); - }); - - add_implicit_conversion<bool, float>(conversions); - add_implicit_conversion<bool, int32_t>(conversions); - add_implicit_conversion<bool, float2>( - conversions, "boolean to float2", [](bool a) { return (a) ? float2(1.0f) : float2(0.0f); }); - add_implicit_conversion<bool, float3>( - conversions, "boolean to float3", [](bool a) { return (a) ? float3(1.0f) : float3(0.0f); }); - add_implicit_conversion<bool, Color4f>(conversions, "boolean to Color4f", [](bool a) { - return (a) ? Color4f(1.0f, 1.0f, 1.0f, 1.0f) : Color4f(0.0f, 0.0f, 0.0f, 1.0f); - }); - - add_implicit_conversion<Color4f, bool>( - conversions, "Color4f to boolean", [](Color4f a) { return rgb_to_grayscale(a) > 0.0f; }); - add_implicit_conversion<Color4f, float>( - conversions, "Color4f to float", [](Color4f a) { return rgb_to_grayscale(a); }); - add_implicit_conversion<Color4f, float2>( - conversions, "Color4f to float2", [](Color4f a) { return float2(a.r, a.g); }); - add_implicit_conversion<Color4f, float3>( - conversions, "Color4f to float3", [](Color4f a) { return float3(a.r, a.g, a.b); }); + + add_implicit_conversion<float, float2, float_to_float2>(conversions); + add_implicit_conversion<float, float3, float_to_float3>(conversions); + add_implicit_conversion<float, int32_t, float_to_int>(conversions); + add_implicit_conversion<float, bool, float_to_bool>(conversions); + add_implicit_conversion<float, Color4f, float_to_color>(conversions); + + add_implicit_conversion<float2, float3, float2_to_float3>(conversions); + add_implicit_conversion<float2, float, float2_to_float>(conversions); + add_implicit_conversion<float2, int32_t, float2_to_int>(conversions); + add_implicit_conversion<float2, bool, float2_to_bool>(conversions); + add_implicit_conversion<float2, Color4f, float2_to_color>(conversions); + + add_implicit_conversion<float3, bool, float3_to_bool>(conversions); + add_implicit_conversion<float3, float, float3_to_float>(conversions); + add_implicit_conversion<float3, int32_t, float3_to_int>(conversions); + add_implicit_conversion<float3, float2, float3_to_float2>(conversions); + add_implicit_conversion<float3, Color4f, float3_to_color>(conversions); + + add_implicit_conversion<int32_t, bool, int_to_bool>(conversions); + add_implicit_conversion<int32_t, float, int_to_float>(conversions); + add_implicit_conversion<int32_t, float2, int_to_float2>(conversions); + add_implicit_conversion<int32_t, float3, int_to_float3>(conversions); + add_implicit_conversion<int32_t, Color4f, int_to_color>(conversions); + + add_implicit_conversion<bool, float, bool_to_float>(conversions); + add_implicit_conversion<bool, int32_t, bool_to_int>(conversions); + add_implicit_conversion<bool, float2, bool_to_float2>(conversions); + add_implicit_conversion<bool, float3, bool_to_float3>(conversions); + add_implicit_conversion<bool, Color4f, bool_to_color>(conversions); + + add_implicit_conversion<Color4f, bool, color_to_bool>(conversions); + add_implicit_conversion<Color4f, float, color_to_float>(conversions); + add_implicit_conversion<Color4f, int32_t, color_to_int>(conversions); + add_implicit_conversion<Color4f, float2, color_to_float2>(conversions); + add_implicit_conversion<Color4f, float3, color_to_float3>(conversions); return conversions; } @@ -113,20 +222,16 @@ const DataTypeConversions &get_implicit_type_conversions() return conversions; } -void DataTypeConversions::convert(const CPPType &from_type, - const CPPType &to_type, - const void *from_value, - void *to_value) const +void DataTypeConversions::convert_to_uninitialized(const CPPType &from_type, + const CPPType &to_type, + const void *from_value, + void *to_value) const { - const fn::MultiFunction *fn = this->get_conversion(MFDataType::ForSingle(from_type), - MFDataType::ForSingle(to_type)); - BLI_assert(fn != nullptr); + const ConversionFunctions *functions = this->get_conversion_functions( + MFDataType::ForSingle(from_type), MFDataType::ForSingle(to_type)); + BLI_assert(functions != nullptr); - fn::MFContextBuilder context; - fn::MFParamsBuilder params{*fn, 1}; - params.add_readonly_single_input(fn::GSpan(from_type, from_value, 1)); - params.add_uninitialized_single_output(fn::GMutableSpan(to_type, to_value, 1)); - fn->call({0}, params, context); + functions->convert_single_to_uninitialized(from_value, to_value); } } // namespace blender::nodes |