[Bf-blender-cvs] [280c0399082] temp-geometry-nodes-evaluator-refactor: Merge branch 'master' into temp-geometry-nodes-evaluator-refactor
Jacques Lucke
noreply at git.blender.org
Wed Aug 31 16:08:07 CEST 2022
Commit: 280c0399082b1ee7411c0ea2826fc360e82e0a7f
Author: Jacques Lucke
Date: Wed Aug 31 12:34:03 2022 +0200
Branches: temp-geometry-nodes-evaluator-refactor
https://developer.blender.org/rB280c0399082b1ee7411c0ea2826fc360e82e0a7f
Merge branch 'master' into temp-geometry-nodes-evaluator-refactor
===================================================================
===================================================================
diff --cc source/blender/modifiers/intern/MOD_nodes.cc
index c06ec7b9717,2908fbf5597..ef5808c2477
--- a/source/blender/modifiers/intern/MOD_nodes.cc
+++ b/source/blender/modifiers/intern/MOD_nodes.cc
@@@ -763,14 -756,14 +764,13 @@@ void MOD_nodes_update_interface(Object
}
static void initialize_group_input(NodesModifierData &nmd,
- const bNodeSocket &bsocket,
- const int input_index,
+ const bNodeSocket &socket,
void *r_value)
{
- const bNodeSocketType &socket_type = *bsocket.typeinfo;
- const eNodeSocketDatatype &socket_data_type = static_cast<eNodeSocketDatatype>(bsocket.type);
- const bNodeSocketType &socket_type = *socket.typeinfo;
- const bNodeSocket &bsocket = socket;
- const eNodeSocketDatatype socket_data_type = static_cast<eNodeSocketDatatype>(bsocket.type);
++ const bNodeSocketType &socket_type = *socket.typeinfo();
++ const eNodeSocketDatatype socket_data_type = static_cast<eNodeSocketDatatype>(socket.type);
if (nmd.settings.properties == nullptr) {
-- socket_type.get_geometry_nodes_cpp_value(bsocket, r_value);
++ socket_type.get_geometry_nodes_cpp_value(socket, r_value);
return;
}
const IDProperty *property = IDP_GetPropertyFromGroup(nmd.settings.properties,
@@@ -784,7 -777,7 +784,7 @@@
return;
}
- if (!input_has_attribute_toggle(*nmd.node_group, input_index)) {
- if (!input_has_attribute_toggle(*nmd.node_group, socket.runtime->index_in_node)) {
++ if (!input_has_attribute_toggle(*nmd.node_group, socket.index())) {
init_socket_cpp_value_from_property(*property, socket_data_type, r_value);
return;
}
@@@ -1086,107 -1079,92 +1086,106 @@@ static void store_output_attributes(Geo
/**
* Evaluate a node group to compute the output geometry.
*/
- static GeometrySet compute_geometry(const NodeTreeRef &tree_ref,
- const NodeRef &output_node,
-static GeometrySet compute_geometry(const DerivedNodeTree &tree,
- Span<const bNode *> group_input_nodes,
++static GeometrySet compute_geometry(const bNodeTree &tree_ref,
+ const bNode &output_node,
GeometrySet input_geometry_set,
NodesModifierData *nmd,
const ModifierEvalContext *ctx)
{
- blender::ResourceScope scope;
- blender::LinearAllocator<> &allocator = scope.linear_allocator();
- blender::nodes::NodeMultiFunctions mf_by_node{tree};
+ UNUSED_VARS(find_sockets_to_preview, logging_enabled);
- Map<DOutputSocket, GMutablePointer> group_inputs;
+ lf::LazyFunctionGraph graph;
+ blender::nodes::GeometryNodeLazyFunctionMapping mapping;
+ blender::nodes::GeometryNodesLazyFunctionResources graph_resources;
+ blender::nodes::geometry_nodes_to_lazy_function_graph(tree_ref, graph, graph_resources, mapping);
+ graph.update_node_indices();
+ // std::cout << graph.to_dot() << "\n";
- const DTreeContext *root_context = &tree.root_context();
- for (const bNode *group_input_node : group_input_nodes) {
- Span<const bNodeSocket *> group_input_sockets = group_input_node->output_sockets().drop_back(
- 1);
- if (group_input_sockets.is_empty()) {
- continue;
- }
+ Vector<const lf::OutputSocket *> graph_inputs;
+ Vector<const lf::InputSocket *> graph_outputs;
+ for (const lf::OutputSocket *socket : mapping.group_input_sockets) {
+ graph_inputs.append(socket);
+ }
- for (const InputSocketRef *socket_ref : output_node.inputs().drop_back(1)) {
++ for (const bNodeSocket *socket_ref : output_node.input_sockets().drop_back(1)) {
+ const lf::InputSocket &socket = mapping.dummy_socket_map.lookup(socket_ref)->as_input();
+ graph_outputs.append(&socket);
+ }
- Span<const bNodeSocket *> remaining_input_sockets = group_input_sockets;
+ Array<GMutablePointer> param_inputs(graph_inputs.size());
+ Array<GMutablePointer> param_outputs(graph_outputs.size());
+ Array<std::optional<lf::ValueUsage>> param_input_usages(graph_inputs.size());
+ Array<lf::ValueUsage> param_output_usages(graph_outputs.size(), lf::ValueUsage::Used);
+ Array<bool> param_set_outputs(graph_outputs.size(), false);
- /* If the group expects a geometry as first input, use the geometry that has been passed to
- * modifier. */
- const bNodeSocket *first_input_socket = group_input_sockets[0];
- if (first_input_socket->type == SOCK_GEOMETRY) {
- GeometrySet *geometry_set_in =
- allocator.construct<GeometrySet>(input_geometry_set).release();
- group_inputs.add_new({root_context, first_input_socket}, geometry_set_in);
- remaining_input_sockets = remaining_input_sockets.drop_front(1);
- }
+ lf::LazyFunctionGraphExecutor graph_executor{graph, graph_inputs, graph_outputs};
- /* Initialize remaining group inputs. */
- for (const bNodeSocket *socket : remaining_input_sockets) {
- const CPPType &cpp_type = *socket->typeinfo->geometry_nodes_cpp_type;
- void *value_in = allocator.allocate(cpp_type.size(), cpp_type.alignment());
- initialize_group_input(*nmd, *socket, value_in);
- group_inputs.add_new({root_context, socket}, {cpp_type, value_in});
- }
- }
+ blender::nodes::GeoNodesModifierData geo_nodes_modifier_data;
+ geo_nodes_modifier_data.depsgraph = ctx->depsgraph;
+ geo_nodes_modifier_data.self_object = ctx->object;
+ /* TODO: Only use logging when enabled. */
+ auto eval_log = std::make_unique<GeoModifierLog>();
+ geo_nodes_modifier_data.eval_log = eval_log.get();
+ blender::nodes::GeoNodesLFUserData user_data;
+ user_data.modifier_data = &geo_nodes_modifier_data;
+ blender::nodes::ModifierContextStack modifier_context_stack{nullptr, nmd->modifier.name};
+ user_data.context_stack = &modifier_context_stack;
- Vector<DInputSocket> group_outputs;
- for (const bNodeSocket *socket_ref : output_node.input_sockets().drop_back(1)) {
- group_outputs.append({root_context, socket_ref});
- }
+ blender::LinearAllocator<> allocator;
- std::optional<geo_log::GeoLogger> geo_logger;
+ Vector<GMutablePointer> inputs_to_destruct;
- blender::modifiers::geometry_nodes::GeometryNodesEvaluationParams eval_params;
+ int input_index;
- LISTBASE_FOREACH_INDEX (
- bNodeSocket *, interface_socket, &tree_ref.btree()->inputs, input_index) {
++ LISTBASE_FOREACH_INDEX (bNodeSocket *, interface_socket, &tree_ref.inputs, input_index) {
+ if (interface_socket->type == SOCK_GEOMETRY && input_index == 0) {
+ param_inputs[input_index] = &input_geometry_set;
+ continue;
+ }
- if (logging_enabled(ctx)) {
- Set<DSocket> preview_sockets;
- find_sockets_to_preview(nmd, ctx, tree, preview_sockets);
- eval_params.force_compute_sockets.extend(preview_sockets.begin(), preview_sockets.end());
- geo_logger.emplace(std::move(preview_sockets));
+ const CPPType *type = interface_socket->typeinfo->geometry_nodes_cpp_type;
+ BLI_assert(type != nullptr); /* Todo */
+ void *value = allocator.allocate(type->size(), type->alignment());
+ initialize_group_input(*nmd, *interface_socket, input_index, value);
+ param_inputs[input_index] = {type, value};
+ inputs_to_destruct.append({type, value});
+ }
- geo_logger->log_input_geometry(input_geometry_set);
+ for (const int i : graph_outputs.index_range()) {
+ const lf::InputSocket &socket = *graph_outputs[i];
+ const CPPType &type = socket.type();
+ void *buffer = allocator.allocate(type.size(), type.alignment());
+ param_outputs[i] = {type, buffer};
}
- /* Don't keep a reference to the input geometry components to avoid copies during evaluation. */
- input_geometry_set.clear();
+ lf::Context lf_context;
+ lf_context.storage = graph_executor.init_storage(allocator);
+ lf_context.user_data = &user_data;
- eval_params.input_values = group_inputs;
- eval_params.output_sockets = group_outputs;
- eval_params.mf_by_node = &mf_by_node;
- eval_params.modifier_ = nmd;
- eval_params.depsgraph = ctx->depsgraph;
- eval_params.self_object = ctx->object;
- eval_params.geo_logger = geo_logger.has_value() ? &*geo_logger : nullptr;
- blender::modifiers::geometry_nodes::evaluate_geometry_nodes(eval_params);
+ lf::BasicParams params{graph_executor,
+ param_inputs,
+ param_outputs,
+ param_input_usages,
+ param_output_usages,
+ param_set_outputs};
+ graph_executor.execute(params, lf_context);
- GeometrySet output_geometry_set = std::move(*eval_params.r_output_values[0].get<GeometrySet>());
+ graph_executor.destruct_storage(lf_context.storage);
- if (geo_logger.has_value()) {
- geo_logger->log_output_geometry(output_geometry_set);
- NodesModifierData *nmd_orig = (NodesModifierData *)BKE_modifier_get_original(ctx->object,
- &nmd->modifier);
- clear_runtime_data(nmd_orig);
- nmd_orig->runtime_eval_log = new geo_log::ModifierLog(*geo_logger);
+ for (GMutablePointer &ptr : inputs_to_destruct) {
+ ptr.destruct();
}
- store_output_attributes(output_geometry_set, *nmd, output_node, eval_params.r_output_values);
+ GeometrySet output_geometry_set = std::move(*static_cast<GeometrySet *>(param_outputs[0].get()));
+ store_output_attributes(output_geometry_set, *nmd, output_node, param_outputs);
- for (GMutablePointer value : eval_params.r_output_values) {
- value.destruct();
+ for (GMutablePointer &ptr : param_outputs) {
+ ptr.destruct();
+ }
+
+ if (logging_enabled(ctx)) {
+ NodesModifierData *nmd_orig = reinterpret_cast<NodesModifierData *>(
+ BKE_modifier_get_original(ctx->object, &nmd->modifier));
+ delete static_cast<GeoModifierLog *>(nmd_orig->runtime_eval_log);
+ nmd_orig->runtime_eval_log = eval_log.releas
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list