1 files changed, 163 insertions, 1 deletions
diff --git a/source/blender/blenkernel/BKE_attribute_math.hh b/source/blender/blenkernel/BKE_attribute_math.hh
index b8bb2048d9d..606811ca12d 100644
--- a/source/blender/blenkernel/BKE_attribute_math.hh
+++ b/source/blender/blenkernel/BKE_attribute_math.hh
@@ -14,9 +14,11 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
+#include "BLI_array.hh"
 #include "BLI_color.hh"
 #include "BLI_float2.hh"
 #include "BLI_float3.hh"
+
 #include "DNA_customdata_types.h"
 
 namespace blender::attribute_math {
@@ -52,7 +54,12 @@ void convert_to_static_type(const CustomDataType data_type, const Func &func)
   }
 }
 
-/* Interpolate between three values. */
+/* -------------------------------------------------------------------- */
+/** \name Mix three values of the same type.
+ *
+ * This is typically used to interpolate values within a triangle.
+ * \{ */
+
 template<typename T> T mix3(const float3 &weights, const T &v0, const T &v1, const T &v2);
 
 template<> inline bool mix3(const float3 &weights, const bool &v0, const bool &v1, const bool &v2)
@@ -91,4 +98,159 @@ inline Color4f mix3(const float3 &weights, const Color4f &v0, const Color4f &v1,
   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
+ * how different types should be mixed. Usually #DefaultMixer<T> should be used to get a mixer for
+ * a specific type.
+ * \{ */
+
+template<typename T> class SimpleMixer {
+ private:
+  MutableSpan<T> buffer_;
+  T default_value_;
+  Array<float> total_weights_;
+
+ public:
+  /**
+   * \param buffer: Span where the interpolated values should be stored.
+   * \param default_value: Output value for an element that has not been affected by a #mix_in.
+   */
+  SimpleMixer(MutableSpan<T> buffer, T default_value = {})
+      : buffer_(buffer), default_value_(default_value), total_weights_(buffer.size(), 0.0f)
+  {
+    BLI_STATIC_ASSERT(std::is_trivial_v<T>, "");
+    memset(buffer_.data(), 0, sizeof(T) * buffer_.size());
+  }
+
+  /**
+   * Mix a #value into the element with the given #index.
+   */
+  void mix_in(const int64_t index, const T &value, const float weight = 1.0f)
+  {
+    BLI_assert(weight >= 0.0f);
+    buffer_[index] += value * weight;
+    total_weights_[index] += weight;
+  }
+
+  /**
+   * Has to be called before the buffer provided in the constructor is used.
+   */
+  void finalize()
+  {
+    for (const int64_t i : buffer_.index_range()) {
+      const float weight = total_weights_[i];
+      if (weight > 0.0f) {
+        buffer_[i] *= 1.0f / weight;
+      }
+      else {
+        buffer_[i] = default_value_;
+      }
+    }
+  }
+};
+
+/** 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:
+  struct Item {
+    /* Store both values together, because they are accessed together. */
+    AccumulationT value = {0};
+    float weight = 0.0f;
+  };
+
+  MutableSpan<T> buffer_;
+  T default_value_;
+  Array<Item> accumulation_buffer_;
+
+ public:
+  SimpleMixerWithAccumulationType(MutableSpan<T> buffer, T default_value = {})
+      : buffer_(buffer), default_value_(default_value), accumulation_buffer_(buffer.size())
+  {
+  }
+
+  void mix_in(const int64_t index, const T &value, const float weight = 1.0f)
+  {
+    const AccumulationT converted_value = static_cast<AccumulationT>(value);
+    Item &item = accumulation_buffer_[index];
+    item.value += converted_value * weight;
+    item.weight += weight;
+  }
+
+  void finalize()
+  {
+    for (const int64_t i : buffer_.index_range()) {
+      const Item &item = accumulation_buffer_[i];
+      if (item.weight > 0.0f) {
+        const float weight_inv = 1.0f / item.weight;
+        const T converted_value = ConvertToT(item.value * weight_inv);
+        buffer_[i] = converted_value;
+      }
+      else {
+        buffer_[i] = default_value_;
+      }
+    }
+  }
+};
+
+class Color4fMixer {
+ private:
+  MutableSpan<Color4f> buffer_;
+  Color4f default_color_;
+  Array<float> total_weights_;
+
+ public:
+  Color4fMixer(MutableSpan<Color4f> buffer, Color4f default_color = {0, 0, 0, 1});
+  void mix_in(const int64_t index, const Color4f &color, const float weight = 1.0f);
+  void finalize();
+};
+
+template<typename T> struct DefaultMixerStruct {
+  /* Use void by default. This can be check for in `if constexpr` statements. */
+  using type = void;
+};
+template<> struct DefaultMixerStruct<float> {
+  using type = SimpleMixer<float>;
+};
+template<> struct DefaultMixerStruct<float2> {
+  using type = SimpleMixer<float2>;
+};
+template<> struct DefaultMixerStruct<float3> {
+  using type = SimpleMixer<float3>;
+};
+template<> struct DefaultMixerStruct<Color4f> {
+  /* Use a special mixer for colors. Color4f can't be added/multiplied, because this is not
+   * something one should usually do with colors.  */
+  using type = Color4fMixer;
+};
+template<> struct DefaultMixerStruct<int> {
+  static int double_to_int(const double &value)
+  {
+    return static_cast<int>(value);
+  }
+  /* Store interpolated ints in a double temporarily, so that weights are handled correctly. It
+   * uses double instead of float so that it is accurate for all 32 bit integers. */
+  using type = SimpleMixerWithAccumulationType<int, double, double_to_int>;
+};
+template<> struct DefaultMixerStruct<bool> {
+  static bool float_to_bool(const float &value)
+  {
+    return value >= 0.5f;
+  }
+  /* Store interpolated bools in a float temporary. Otherwise information provided by weights is
+   * easily rounded away. */
+  using type = SimpleMixerWithAccumulationType<bool, float, float_to_bool>;
+};
+
+/* Utility to get a good default mixer for a given type. This is `void` when there is no default
+ * mixer for the given type. */
+template<typename T> using DefaultMixer = typename DefaultMixerStruct<T>::type;
+
+/** \} */
+
 }  // namespace blender::attribute_math