Attributes: Infrastructure for generic 8-bit integer data type

This commit adds infrastructure for 8 bit signed integer attributes.
This can be useful given the discussion in T94193, where we want to
store spline type, Bezier handle type, and other small enums as
attributes.

This is only exposed in the interface in the attribute lists, so it
shouldn't be an option in geometry nodes, at least for now.
I expect that this type won't be used directly very often, it
should mostly be cast to an enum type. However, with support
for 8 bit integers, it also makes sense to add things like mixing
implementations for consistency.

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

1 files changed, 64 insertions, 0 deletions

diff --git a/source/blender/blenkernel/intern/type_conversions.cc b/source/blender/blenkernel/intern/type_conversions.cc
index cb05337ef2a..b2011d2baf7 100644
--- a/source/blender/blenkernel/intern/type_conversions.cc
+++ b/source/blender/blenkernel/intern/type_conversions.cc
@@ -62,6 +62,11 @@ static bool float_to_bool(const float &a)
 {
   return a > 0.0f;
 }
+static int8_t float_to_int8(const float &a)
+{
+  return std::clamp(
+      a, float(std::numeric_limits<int8_t>::min()), float(std::numeric_limits<int8_t>::max()));
+}
 static ColorGeometry4f float_to_color(const float &a)
 {
   return ColorGeometry4f(a, a, a, 1.0f);
@@ -83,6 +88,10 @@ static bool float2_to_bool(const float2 &a)
 {
   return !is_zero_v2(a);
 }
+static int8_t float2_to_int8(const float2 &a)
+{
+  return float_to_int8((a.x + a.y) / 2.0f);
+}
 static ColorGeometry4f float2_to_color(const float2 &a)
 {
   return ColorGeometry4f(a.x, a.y, 0.0f, 1.0f);
@@ -92,6 +101,10 @@ static bool float3_to_bool(const float3 &a)
 {
   return !is_zero_v3(a);
 }
+static int8_t float3_to_int8(const float3 &a)
+{
+  return float_to_int8((a.x + a.y + a.z) / 3.0f);
+}
 static float float3_to_float(const float3 &a)
 {
   return (a.x + a.y + a.z) / 3.0f;
@@ -113,6 +126,11 @@ static bool int_to_bool(const int32_t &a)
 {
   return a > 0;
 }
+static int8_t int_to_int8(const int32_t &a)
+{
+  return std::clamp(
+      a, int(std::numeric_limits<int8_t>::min()), int(std::numeric_limits<int8_t>::max()));
+}
 static float int_to_float(const int32_t &a)
 {
   return (float)a;
@@ -130,10 +148,39 @@ static ColorGeometry4f int_to_color(const int32_t &a)
   return ColorGeometry4f((float)a, (float)a, (float)a, 1.0f);
 }
 
+static bool int8_to_bool(const int8_t &a)
+{
+  return a > 0;
+}
+static int int8_to_int(const int8_t &a)
+{
+  return static_cast<int>(a);
+}
+static float int8_to_float(const int8_t &a)
+{
+  return (float)a;
+}
+static float2 int8_to_float2(const int8_t &a)
+{
+  return float2((float)a);
+}
+static float3 int8_to_float3(const int8_t &a)
+{
+  return float3((float)a);
+}
+static ColorGeometry4f int8_to_color(const int8_t &a)
+{
+  return ColorGeometry4f((float)a, (float)a, (float)a, 1.0f);
+}
+
 static float bool_to_float(const bool &a)
 {
   return (bool)a;
 }
+static int8_t bool_to_int8(const bool &a)
+{
+  return static_cast<int8_t>(a);
+}
 static int32_t bool_to_int(const bool &a)
 {
   return (int32_t)a;
@@ -163,6 +210,10 @@ static int32_t color_to_int(const ColorGeometry4f &a)
 {
   return (int)rgb_to_grayscale(a);
 }
+static int8_t color_to_int8(const ColorGeometry4f &a)
+{
+  return int_to_int8(color_to_int(a));
+}
 static float2 color_to_float2(const ColorGeometry4f &a)
 {
   return float2(a.r, a.g);
@@ -180,33 +231,46 @@ static DataTypeConversions create_implicit_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, int8_t, float_to_int8>(conversions);
   add_implicit_conversion<float, ColorGeometry4f, 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, int8_t, float2_to_int8>(conversions);
   add_implicit_conversion<float2, ColorGeometry4f, float2_to_color>(conversions);
 
   add_implicit_conversion<float3, bool, float3_to_bool>(conversions);
+  add_implicit_conversion<float3, int8_t, float3_to_int8>(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, ColorGeometry4f, float3_to_color>(conversions);
 
   add_implicit_conversion<int32_t, bool, int_to_bool>(conversions);
+  add_implicit_conversion<int32_t, int8_t, int_to_int8>(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, ColorGeometry4f, int_to_color>(conversions);
 
+  add_implicit_conversion<int8_t, bool, int8_to_bool>(conversions);
+  add_implicit_conversion<int8_t, int32_t, int8_to_int>(conversions);
+  add_implicit_conversion<int8_t, float, int8_to_float>(conversions);
+  add_implicit_conversion<int8_t, float2, int8_to_float2>(conversions);
+  add_implicit_conversion<int8_t, float3, int8_to_float3>(conversions);
+  add_implicit_conversion<int8_t, ColorGeometry4f, int8_to_color>(conversions);
+
   add_implicit_conversion<bool, float, bool_to_float>(conversions);
+  add_implicit_conversion<bool, int8_t, bool_to_int8>(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, ColorGeometry4f, bool_to_color>(conversions);
 
   add_implicit_conversion<ColorGeometry4f, bool, color_to_bool>(conversions);
+  add_implicit_conversion<ColorGeometry4f, int8_t, color_to_int8>(conversions);
   add_implicit_conversion<ColorGeometry4f, float, color_to_float>(conversions);
   add_implicit_conversion<ColorGeometry4f, int32_t, color_to_int>(conversions);
   add_implicit_conversion<ColorGeometry4f, float2, color_to_float2>(conversions);