Geometry Nodes: better support for byte color attributes

Since {rBeae36be372a6b16ee3e76eff0485a47da4f3c230} the distinction
between float and byte colors is more explicit in the ui. So far, geometry
nodes couldn't really deal with byte colors in general. This patch fixes that.
There is still only one color socket, which contains float colors. Conversion
to and from byte colors is done when read from or writing to attributes.

* Support writing to byte color attributes in Store Named Attribute node.
* Support converting to/from byte color in attribute conversion operator.
* Support propagating byte color attributes.
* Add all the implicit conversions from byte colors to the other types.
* Display byte colors as integers in spreadsheet.

Differential Revision: https://developer.blender.org/D14705

1 files changed, 45 insertions, 6 deletions

diff --git a/source/blender/blenkernel/intern/attribute_math.cc b/source/blender/blenkernel/intern/attribute_math.cc
index df3cab474cd..c38df2a2969 100644
--- a/source/blender/blenkernel/intern/attribute_math.cc
+++ b/source/blender/blenkernel/intern/attribute_math.cc
@@ -4,8 +4,8 @@
 
 namespace blender::attribute_math {
 
-ColorGeometryMixer::ColorGeometryMixer(MutableSpan<ColorGeometry4f> output_buffer,
-                                       ColorGeometry4f default_color)
+ColorGeometry4fMixer::ColorGeometry4fMixer(MutableSpan<ColorGeometry4f> output_buffer,
+                                           ColorGeometry4f default_color)
     : buffer_(output_buffer),
       default_color_(default_color),
       total_weights_(output_buffer.size(), 0.0f)
@@ -13,9 +13,9 @@ ColorGeometryMixer::ColorGeometryMixer(MutableSpan<ColorGeometry4f> output_buffe
   buffer_.fill(ColorGeometry4f(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
-void ColorGeometryMixer::mix_in(const int64_t index,
-                                const ColorGeometry4f &color,
-                                const float weight)
+void ColorGeometry4fMixer::mix_in(const int64_t index,
+                                  const ColorGeometry4f &color,
+                                  const float weight)
 {
   BLI_assert(weight >= 0.0f);
   ColorGeometry4f &output_color = buffer_[index];
@@ -26,7 +26,7 @@ void ColorGeometryMixer::mix_in(const int64_t index,
   total_weights_[index] += weight;
 }
 
-void ColorGeometryMixer::finalize()
+void ColorGeometry4fMixer::finalize()
 {
   for (const int64_t i : buffer_.index_range()) {
     const float weight = total_weights_[i];
@@ -44,4 +44,43 @@ void ColorGeometryMixer::finalize()
   }
 }
 
+ColorGeometry4bMixer::ColorGeometry4bMixer(MutableSpan<ColorGeometry4b> buffer,
+                                           ColorGeometry4b default_color)
+    : buffer_(buffer),
+      default_color_(default_color),
+      total_weights_(buffer.size(), 0.0f),
+      accumulation_buffer_(buffer.size(), float4(0, 0, 0, 0))
+{
+}
+
+void ColorGeometry4bMixer::mix_in(int64_t index, const ColorGeometry4b &color, float weight)
+{
+  BLI_assert(weight >= 0.0f);
+  float4 &accum_value = accumulation_buffer_[index];
+  accum_value[0] += color.r * weight;
+  accum_value[1] += color.g * weight;
+  accum_value[2] += color.b * weight;
+  accum_value[3] += color.a * weight;
+  total_weights_[index] += weight;
+}
+
+void ColorGeometry4bMixer::finalize()
+{
+  for (const int64_t i : buffer_.index_range()) {
+    const float weight = total_weights_[i];
+    const float4 &accum_value = accumulation_buffer_[i];
+    ColorGeometry4b &output_color = buffer_[i];
+    if (weight > 0.0f) {
+      const float weight_inv = 1.0f / weight;
+      output_color.r = accum_value[0] * weight_inv;
+      output_color.g = accum_value[1] * weight_inv;
+      output_color.b = accum_value[2] * weight_inv;
+      output_color.a = accum_value[3] * weight_inv;
+    }
+    else {
+      output_color = default_color_;
+    }
+  }
+}
+
 }  // namespace blender::attribute_math