Spreadsheet: support showing data of specific node

Previously, the spreadsheet editor could only show data of the original
and of the final evaluated object. Now it is possible to show the data
at some intermediate stages too.

For that the mode has to be set to "Node" in the spreadsheet editor.
Furthermore, the preview of a specific node has to be activated by
clicking the new icon in the header of geometry nodes.

The exact ui of this feature might be refined in upcoming commits.
It is already very useful for debugging node groups in it's current
state though.

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

1 files changed, 118 insertions, 1 deletions

diff --git a/source/blender/modifiers/intern/MOD_nodes.cc b/source/blender/modifiers/intern/MOD_nodes.cc
index 843797e0f72..c7d822e5418 100644
--- a/source/blender/modifiers/intern/MOD_nodes.cc
+++ b/source/blender/modifiers/intern/MOD_nodes.cc
@@ -43,17 +43,22 @@
 #include "DNA_pointcloud_types.h"
 #include "DNA_scene_types.h"
 #include "DNA_screen_types.h"
+#include "DNA_space_types.h"
+#include "DNA_windowmanager_types.h"
 
 #include "BKE_customdata.h"
 #include "BKE_global.h"
 #include "BKE_idprop.h"
 #include "BKE_lib_query.h"
+#include "BKE_main.h"
 #include "BKE_mesh.h"
 #include "BKE_modifier.h"
 #include "BKE_node_ui_storage.hh"
+#include "BKE_object.h"
 #include "BKE_pointcloud.h"
 #include "BKE_screen.h"
 #include "BKE_simulation.h"
+#include "BKE_workspace.h"
 
 #include "BLO_read_write.h"
 
@@ -1088,6 +1093,110 @@ static void reset_tree_ui_storage(Span<const blender::nodes::NodeTreeRef *> tree
   }
 }
 
+static const DTreeContext *find_derived_tree_context_that_matches_tree_path(
+    const SpaceNode &snode, const DerivedNodeTree &tree)
+{
+  const DTreeContext &root_context = tree.root_context();
+  bNodeTree *root_tree_eval = root_context.tree().btree();
+  bNodeTree *root_tree_orig = (bNodeTree *)DEG_get_original_id(&root_tree_eval->id);
+  if (snode.nodetree != root_tree_orig) {
+    return nullptr;
+  }
+
+  const DTreeContext *current_context = &root_context;
+  bool is_first = true;
+  LISTBASE_FOREACH (const bNodeTreePath *, path, &snode.treepath) {
+    if (is_first) {
+      is_first = false;
+      continue;
+    }
+    StringRef parent_node_name = path->node_name;
+    const NodeTreeRef &tree_ref = current_context->tree();
+    const NodeRef *parent_node_ref = nullptr;
+    for (const NodeRef *node_ref : tree_ref.nodes()) {
+      if (node_ref->name() == parent_node_name) {
+        parent_node_ref = node_ref;
+        break;
+      }
+    }
+    if (parent_node_ref == nullptr) {
+      return nullptr;
+    }
+    current_context = current_context->child_context(*parent_node_ref);
+    if (current_context == nullptr) {
+      return nullptr;
+    }
+  }
+  return current_context;
+}
+
+static DNode find_active_preview_node_in_node_editor(const SpaceNode &snode,
+                                                     const DerivedNodeTree &tree)
+{
+  const DTreeContext *context = find_derived_tree_context_that_matches_tree_path(snode, tree);
+  if (context == nullptr) {
+    return {};
+  }
+  const NodeTreeRef &tree_ref = context->tree();
+  for (const NodeRef *node_ref : tree_ref.nodes()) {
+    if (node_ref->bnode()->flag & NODE_ACTIVE_PREVIEW) {
+      return {context, node_ref};
+    }
+  }
+  return {};
+}
+
+static DNode find_active_preview_node_in_all_node_editors(Depsgraph *depsgraph,
+                                                          const DerivedNodeTree &tree)
+{
+  Main *bmain = DEG_get_bmain(depsgraph);
+  wmWindowManager *wm = (wmWindowManager *)bmain->wm.first;
+  LISTBASE_FOREACH (wmWindow *, window, &wm->windows) {
+    bScreen *screen = BKE_workspace_active_screen_get(window->workspace_hook);
+    LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
+      SpaceLink *sl = (SpaceLink *)area->spacedata.first;
+      if (sl->spacetype != SPACE_NODE) {
+        continue;
+      }
+      SpaceNode *snode = (SpaceNode *)sl;
+      DNode preview_node = find_active_preview_node_in_node_editor(*snode, tree);
+      if (!preview_node) {
+        continue;
+      }
+      return preview_node;
+    }
+  }
+  return {};
+}
+
+static DSocket find_preview_socket_in_all_node_editors(Depsgraph *depsgraph,
+                                                       const DerivedNodeTree &tree)
+{
+  DNode preview_node = find_active_preview_node_in_all_node_editors(depsgraph, tree);
+  if (!preview_node) {
+    return {};
+  }
+  for (const SocketRef *socket : preview_node->outputs()) {
+    if (socket->bsocket()->type == SOCK_GEOMETRY) {
+      return {preview_node.context(), socket};
+    }
+  }
+  for (const SocketRef *socket : preview_node->inputs()) {
+    if (socket->bsocket()->type == SOCK_GEOMETRY &&
+        (socket->bsocket()->flag & SOCK_MULTI_INPUT) == 0) {
+      return {preview_node.context(), socket};
+    }
+  }
+  return {};
+}
+
+static void log_preview_socket_value(const Span<GPointer> values, Object *object)
+{
+  GeometrySet geometry_set = *(const GeometrySet *)values[0].get();
+  geometry_set.ensure_owns_direct_data();
+  BKE_object_set_preview_geometry_set(object, new GeometrySet(std::move(geometry_set)));
+}
+
 /**
  * Evaluate a node group to compute the output geometry.
  * Currently, this uses a fairly basic and inefficient algorithm that might compute things more
@@ -1143,6 +1252,14 @@ static GeometrySet compute_geometry(const DerivedNodeTree &tree,
   Vector<DInputSocket> group_outputs;
   group_outputs.append({root_context, &socket_to_compute});
 
+  const DSocket preview_socket = find_preview_socket_in_all_node_editors(ctx->depsgraph, tree);
+
+  auto log_socket_value = [&](const DSocket socket, const Span<GPointer> values) {
+    if (socket == preview_socket && nmd->modifier.flag & eModifierFlag_Active) {
+      log_preview_socket_value(values, ctx->object);
+    }
+  };
+
   GeometryNodesEvaluator evaluator{group_inputs,
                                    group_outputs,
                                    mf_by_node,
@@ -1150,7 +1267,7 @@ static GeometrySet compute_geometry(const DerivedNodeTree &tree,
                                    ctx->object,
                                    (ModifierData *)nmd,
                                    ctx->depsgraph,
-                                   {}};
+                                   log_socket_value};
 
   Vector<GMutablePointer> results = evaluator.execute();
   BLI_assert(results.size() == 1);