Geometry Nodes: reduce overhead when processing single values

Currently the geometry nodes evaluator always stores a field for every
type that supports it, even if it is just a single value. This results in a lot
of overhead when there are many sockets that just contain a single
value, which is often the case.

This introduces a new `ValueOrField<T>` type that is used by the geometry
nodes evaluator. Now a field will only be created when it is actually
necessary. See D13307 for more details. In extrem cases this can speed
up the evaluation 2-3x (those cases are probably never hit in practice
though, but it's good to get rid of unnecessary overhead nevertheless).

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

1 files changed, 24 insertions, 24 deletions

diff --git a/source/blender/editors/space_node/node_draw.cc b/source/blender/editors/space_node/node_draw.cc
index 867544d0805..f9a9e491403 100644
--- a/source/blender/editors/space_node/node_draw.cc
+++ b/source/blender/editors/space_node/node_draw.cc
@@ -843,29 +843,43 @@ struct SocketTooltipData {
   bNodeSocket *socket;
 };
 
-static void create_inspection_string_for_generic_value(const geo_log::GenericValueLog &value_log,
-                                                       std::stringstream &ss)
+static void create_inspection_string_for_generic_value(const GPointer value, std::stringstream &ss)
 {
   auto id_to_inspection_string = [&](ID *id, short idcode) {
     ss << (id ? id->name + 2 : TIP_("None")) << " (" << BKE_idtype_idcode_to_name(idcode) << ")";
   };
 
-  const GPointer value = value_log.value();
   const CPPType &type = *value.type();
+  const void *buffer = value.get();
   if (type.is<Object *>()) {
-    id_to_inspection_string((ID *)*value.get<Object *>(), ID_OB);
+    id_to_inspection_string((ID *)buffer, ID_OB);
   }
   else if (type.is<Material *>()) {
-    id_to_inspection_string((ID *)*value.get<Material *>(), ID_MA);
+    id_to_inspection_string((ID *)buffer, ID_MA);
   }
   else if (type.is<Tex *>()) {
-    id_to_inspection_string((ID *)*value.get<Tex *>(), ID_TE);
+    id_to_inspection_string((ID *)buffer, ID_TE);
   }
   else if (type.is<Image *>()) {
-    id_to_inspection_string((ID *)*value.get<Image *>(), ID_IM);
+    id_to_inspection_string((ID *)buffer, ID_IM);
   }
   else if (type.is<Collection *>()) {
-    id_to_inspection_string((ID *)*value.get<Collection *>(), ID_GR);
+    id_to_inspection_string((ID *)buffer, ID_GR);
+  }
+  else if (type.is<int>()) {
+    ss << *(int *)buffer << TIP_(" (Integer)");
+  }
+  else if (type.is<float>()) {
+    ss << *(float *)buffer << TIP_(" (Float)");
+  }
+  else if (type.is<blender::float3>()) {
+    ss << *(blender::float3 *)buffer << TIP_(" (Vector)");
+  }
+  else if (type.is<bool>()) {
+    ss << ((*(bool *)buffer) ? TIP_("True") : TIP_("False")) << TIP_(" (Boolean)");
+  }
+  else if (type.is<std::string>()) {
+    ss << *(std::string *)buffer << TIP_(" (String)");
   }
 }
 
@@ -880,21 +894,7 @@ static void create_inspection_string_for_gfield(const geo_log::GFieldValueLog &v
     if (field) {
       BUFFER_FOR_CPP_TYPE_VALUE(type, buffer);
       blender::fn::evaluate_constant_field(field, buffer);
-      if (type.is<int>()) {
-        ss << *(int *)buffer << TIP_(" (Integer)");
-      }
-      else if (type.is<float>()) {
-        ss << *(float *)buffer << TIP_(" (Float)");
-      }
-      else if (type.is<blender::float3>()) {
-        ss << *(blender::float3 *)buffer << TIP_(" (Vector)");
-      }
-      else if (type.is<bool>()) {
-        ss << ((*(bool *)buffer) ? TIP_("True") : TIP_("False")) << TIP_(" (Boolean)");
-      }
-      else if (type.is<std::string>()) {
-        ss << *(std::string *)buffer << TIP_(" (String)");
-      }
+      create_inspection_string_for_generic_value({type, buffer}, ss);
       type.destruct(buffer);
     }
     else {
@@ -1023,7 +1023,7 @@ static std::optional<std::string> create_socket_inspection_string(bContext *C,
   std::stringstream ss;
   if (const geo_log::GenericValueLog *generic_value_log =
           dynamic_cast<const geo_log::GenericValueLog *>(value_log)) {
-    create_inspection_string_for_generic_value(*generic_value_log, ss);
+    create_inspection_string_for_generic_value(generic_value_log->value(), ss);
   }
   if (const geo_log::GFieldValueLog *gfield_value_log =
           dynamic_cast<const geo_log::GFieldValueLog *>(value_log)) {