1 files changed, 79 insertions, 3 deletions

diff --git a/source/blender/blenkernel/BKE_attribute_math.hh b/source/blender/blenkernel/BKE_attribute_math.hh
index 16fc0db60fb..0afdc436415 100644
--- a/source/blender/blenkernel/BKE_attribute_math.hh
+++ b/source/blender/blenkernel/BKE_attribute_math.hh
@@ -14,6 +14,8 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
+#pragma once
+
 #include "BLI_array.hh"
 #include "BLI_color.hh"
 #include "BLI_float2.hh"
@@ -21,13 +23,17 @@
 
 #include "DNA_customdata_types.h"
 
+#include "FN_cpp_type.hh"
+
 namespace blender::attribute_math {
 
+using fn::CPPType;
+
 /**
  * Utility function that simplifies calling a templated function based on a custom data type.
  */
 template<typename Func>
-void convert_to_static_type(const CustomDataType data_type, const Func &func)
+inline void convert_to_static_type(const CustomDataType data_type, const Func &func)
 {
   switch (data_type) {
     case CD_PROP_FLOAT:
@@ -54,6 +60,32 @@ void convert_to_static_type(const CustomDataType data_type, const Func &func)
   }
 }
 
+template<typename Func>
+inline void convert_to_static_type(const fn::CPPType &cpp_type, const Func &func)
+{
+  if (cpp_type.is<float>()) {
+    func(float());
+  }
+  else if (cpp_type.is<float2>()) {
+    func(float2());
+  }
+  else if (cpp_type.is<float3>()) {
+    func(float3());
+  }
+  else if (cpp_type.is<int>()) {
+    func(int());
+  }
+  else if (cpp_type.is<bool>()) {
+    func(bool());
+  }
+  else if (cpp_type.is<Color4f>()) {
+    func(Color4f());
+  }
+  else {
+    BLI_assert_unreachable();
+  }
+}
+
 /* -------------------------------------------------------------------- */
 /** \name Mix three values of the same type.
  *
@@ -101,6 +133,48 @@ inline Color4f mix3(const float3 &weights, const Color4f &v0, const Color4f &v1,
 /** \} */
 
 /* -------------------------------------------------------------------- */
+/** \name Mix two values of the same type.
+ *
+ * This is just basic linear interpolation.
+ * \{ */
+
+template<typename T> T mix2(const float factor, const T &a, const T &b);
+
+template<> inline bool mix2(const float factor, const bool &a, const bool &b)
+{
+  return ((1.0f - factor) * a + factor * b) >= 0.5f;
+}
+
+template<> inline int mix2(const float factor, const int &a, const int &b)
+{
+  return static_cast<int>((1.0f - factor) * a + factor * b);
+}
+
+template<> inline float mix2(const float factor, const float &a, const float &b)
+{
+  return (1.0f - factor) * a + factor * b;
+}
+
+template<> inline float2 mix2(const float factor, const float2 &a, const float2 &b)
+{
+  return float2::interpolate(a, b, factor);
+}
+
+template<> inline float3 mix2(const float factor, const float3 &a, const float3 &b)
+{
+  return float3::interpolate(a, b, factor);
+}
+
+template<> inline Color4f mix2(const float factor, const Color4f &a, const Color4f &b)
+{
+  Color4f result;
+  interp_v4_v4v4(result, a, b, factor);
+  return result;
+}
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
 /** \name Mix a dynamic amount of values with weights for many elements.
  *
  * This section provides an abstraction for "mixers". The abstraction encapsulates details about
@@ -153,8 +227,10 @@ template<typename T> class SimpleMixer {
   }
 };
 
-/** This mixer accumulates values in a type that is different from the one that is mixed. Some
- * types cannot encode the floating point weights in their values (e.g. int and bool). */
+/**
+ * This mixer accumulates values in a type that is different from the one that is mixed.
+ * Some types cannot encode the floating point weights in their values (e.g. int and bool).
+ */
 template<typename T, typename AccumulationT, T (*ConvertToT)(const AccumulationT &value)>
 class SimpleMixerWithAccumulationType {
  private: