[Bf-blender-cvs] [01321c78254] temp-attribute-processor: support other component types

[Jacques Lucke]

Commit: 01321c78254ac6dbe969fc8554913e96286fb6ac
Author: Jacques Lucke
Date:   Thu May 27 13:30:13 2021 +0200
Branches: temp-attribute-processor
https://developer.blender.org/rB01321c78254ac6dbe969fc8554913e96286fb6ac

support other component types

===================================================================

M	source/blender/nodes/geometry/nodes/node_geo_attribute_processor.cc

===================================================================

diff --git a/source/blender/nodes/geometry/nodes/node_geo_attribute_processor.cc b/source/blender/nodes/geometry/nodes/node_geo_attribute_processor.cc
index c249af0d6be..5319394a551 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_attribute_processor.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_attribute_processor.cc
@@ -344,71 +344,23 @@ static CustomDataType get_custom_data_type(bNodeSocketType *typeinfo)
   return CD_PROP_FLOAT;
 }
 
-static void process_attributes(GeoNodeExecParams &geo_params, GeometrySet &geometry_set)
+static void process_attributes_on_component(GeoNodeExecParams &geo_params,
+                                            GeometryComponent &component,
+                                            const fn::MultiFunction &network_fn,
+                                            const DerivedNodeTree &tree,
+                                            const DNode output_node,
+                                            const Span<DOutputSocket> used_group_inputs)
 {
   const bNode &node = geo_params.node();
-  const NodeGeometryAttributeProcessor &storage = *(NodeGeometryAttributeProcessor *)node.storage;
   bNodeTree *group = (bNodeTree *)node.id;
+  const NodeGeometryAttributeProcessor &storage = *(NodeGeometryAttributeProcessor *)node.storage;
   const AttributeDomain domain = (AttributeDomain)storage.domain;
 
-  if (group == nullptr) {
-    return;
-  }
-
-  geometry_set = geometry_set_realize_instances(geometry_set);
-
-  if (!geometry_set.has_mesh()) {
-    return;
-  }
-  GeometryComponent &component = geometry_set.get_component_for_write<MeshComponent>();
   const int domain_size = component.attribute_domain_size(domain);
   if (domain_size == 0) {
     return;
   }
 
-  NodeTreeRefMap tree_refs;
-  DerivedNodeTree tree{*group, tree_refs};
-  fn::MFNetwork network;
-  ResourceScope scope;
-  MFNetworkTreeMap network_map = insert_node_tree_into_mf_network(network, tree, scope);
-
-  Vector<const fn::MFOutputSocket *> fn_input_sockets;
-  Vector<const fn::MFInputSocket *> fn_output_sockets;
-
-  const DTreeContext &root_context = tree.root_context();
-  const NodeTreeRef &root_tree_ref = root_context.tree();
-
-  Span<const NodeRef *> output_nodes = root_tree_ref.nodes_by_type("NodeGroupOutput");
-
-  if (output_nodes.size() != 1) {
-    return;
-  }
-  const DNode output_node{&root_context, output_nodes[0]};
-  if (output_node->inputs().size() <= 1) {
-    return;
-  }
-
-  Vector<fn::MFInputSocket *> network_outputs;
-  for (const InputSocketRef *socket_ref : output_node->inputs().drop_back(1)) {
-    const DInputSocket socket{&root_context, socket_ref};
-    network_outputs.append(network_map.lookup(socket).first());
-  }
-
-  VectorSet<const fn::MFOutputSocket *> network_inputs;
-  VectorSet<const fn::MFInputSocket *> unlinked_inputs;
-  network.find_dependencies(network_outputs, network_inputs, unlinked_inputs);
-  BLI_assert(unlinked_inputs.is_empty());
-
-  Vector<DOutputSocket> used_group_inputs;
-  for (const fn::MFOutputSocket *dummy_socket : network_inputs) {
-    const DOutputSocket dsocket = network_map.try_lookup(*dummy_socket);
-    BLI_assert(dsocket);
-    used_group_inputs.append(dsocket);
-  }
-
-  fn::MFNetworkEvaluator network_fn{Vector<const fn::MFOutputSocket *>(network_inputs.as_span()),
-                                    Vector<const fn::MFInputSocket *>(network_outputs.as_span())};
-
   fn::MFParamsBuilder fn_params{network_fn, domain_size};
   fn::MFContextBuilder context;
 
@@ -451,7 +403,7 @@ static void process_attributes(GeoNodeExecParams &geo_params, GeometrySet &geome
 
   Vector<std::unique_ptr<OutputAttribute>> output_attributes;
   for (const InputSocketRef *socket_ref : output_node->inputs().drop_back(1)) {
-    const DInputSocket socket{&root_context, socket_ref};
+    const DInputSocket socket{&tree.root_context(), socket_ref};
     const int index = socket->index();
     const AttributeProcessorOutputSettings *output_settings = (AttributeProcessorOutputSettings *)
         BLI_findlink(&storage.outputs_settings, index);
@@ -490,6 +442,86 @@ static void process_attributes(GeoNodeExecParams &geo_params, GeometrySet &geome
   }
 }
 
+static void process_attributes(GeoNodeExecParams &geo_params, GeometrySet &geometry_set)
+{
+  const bNode &node = geo_params.node();
+  bNodeTree *group = (bNodeTree *)node.id;
+
+  if (group == nullptr) {
+    return;
+  }
+
+  geometry_set = geometry_set_realize_instances(geometry_set);
+
+  NodeTreeRefMap tree_refs;
+  DerivedNodeTree tree{*group, tree_refs};
+  fn::MFNetwork network;
+  ResourceScope scope;
+  MFNetworkTreeMap network_map = insert_node_tree_into_mf_network(network, tree, scope);
+
+  Vector<const fn::MFOutputSocket *> fn_input_sockets;
+  Vector<const fn::MFInputSocket *> fn_output_sockets;
+
+  const DTreeContext &root_context = tree.root_context();
+  const NodeTreeRef &root_tree_ref = root_context.tree();
+
+  Span<const NodeRef *> output_nodes = root_tree_ref.nodes_by_type("NodeGroupOutput");
+
+  if (output_nodes.size() != 1) {
+    return;
+  }
+  const DNode output_node{&root_context, output_nodes[0]};
+  if (output_node->inputs().size() <= 1) {
+    return;
+  }
+
+  Vector<fn::MFInputSocket *> network_outputs;
+  for (const InputSocketRef *socket_ref : output_node->inputs().drop_back(1)) {
+    const DInputSocket socket{&root_context, socket_ref};
+    network_outputs.append(network_map.lookup(socket).first());
+  }
+
+  VectorSet<const fn::MFOutputSocket *> network_inputs;
+  VectorSet<const fn::MFInputSocket *> unlinked_inputs;
+  network.find_dependencies(network_outputs, network_inputs, unlinked_inputs);
+  BLI_assert(unlinked_inputs.is_empty());
+
+  Vector<DOutputSocket> used_group_inputs;
+  for (const fn::MFOutputSocket *dummy_socket : network_inputs) {
+    const DOutputSocket dsocket = network_map.try_lookup(*dummy_socket);
+    BLI_assert(dsocket);
+    used_group_inputs.append(dsocket);
+  }
+
+  fn::MFNetworkEvaluator network_fn{Vector<const fn::MFOutputSocket *>(network_inputs.as_span()),
+                                    Vector<const fn::MFInputSocket *>(network_outputs.as_span())};
+
+  if (geometry_set.has_mesh()) {
+    process_attributes_on_component(geo_params,
+                                    geometry_set.get_component_for_write<MeshComponent>(),
+                                    network_fn,
+                                    tree,
+                                    output_node,
+                                    used_group_inputs);
+  }
+  if (geometry_set.has_pointcloud()) {
+    process_attributes_on_component(geo_params,
+                                    geometry_set.get_component_for_write<PointCloudComponent>(),
+                                    network_fn,
+                                    tree,
+                                    output_node,
+                                    used_group_inputs);
+  }
+  if (geometry_set.has_curve()) {
+    process_attributes_on_component(geo_params,
+                                    geometry_set.get_component_for_write<CurveComponent>(),
+                                    network_fn,
+                                    tree,
+                                    output_node,
+                                    used_group_inputs);
+  }
+}
+
 static void geo_node_attribute_processor_exec(GeoNodeExecParams params)
 {
   GeometrySet geometry_set = params.extract_input<GeometrySet>("Geometry");