[Bf-blender-cvs] [30d71a74058] temp-derived-node-tree-refactor: initial somewhat working function
Jacques Lucke
noreply at git.blender.org
Wed Mar 3 11:44:03 CET 2021
Commit: 30d71a740584cfbcc55273f6cb0d2ec0fa35ea85
Author: Jacques Lucke
Date: Wed Mar 3 11:40:52 2021 +0100
Branches: temp-derived-node-tree-refactor
https://developer.blender.org/rB30d71a740584cfbcc55273f6cb0d2ec0fa35ea85
initial somewhat working function
Still does not work correctly with the pebbles demo file, because
the math nodes don't work yet.
===================================================================
M source/blender/modifiers/intern/MOD_nodes.cc
M source/blender/nodes/NOD_XXX_node_tree.hh
M source/blender/nodes/NOD_geometry_exec.hh
M source/blender/nodes/NOD_node_tree_ref.hh
M source/blender/nodes/intern/node_geometry_exec.cc
M source/blender/nodes/intern/xxx_node_tree.cc
===================================================================
diff --git a/source/blender/modifiers/intern/MOD_nodes.cc b/source/blender/modifiers/intern/MOD_nodes.cc
index 8ac2607f17c..45fbf8dea7f 100644
--- a/source/blender/modifiers/intern/MOD_nodes.cc
+++ b/source/blender/modifiers/intern/MOD_nodes.cc
@@ -28,6 +28,7 @@
#include "MEM_guardedalloc.h"
#include "BLI_float3.hh"
+#include "BLI_function_ref.hh"
#include "BLI_listbase.h"
#include "BLI_set.hh"
#include "BLI_string.h"
@@ -78,6 +79,7 @@
#include "NOD_type_callbacks.hh"
using blender::float3;
+using blender::FunctionRef;
using blender::IndexRange;
using blender::Map;
using blender::Set;
@@ -256,8 +258,8 @@ static bool isDisabled(const struct Scene *UNUSED(scene),
class GeometryNodesEvaluator {
private:
blender::LinearAllocator<> allocator_;
- Map<std::pair<const DInputSocket *, const DOutputSocket *>, GMutablePointer> value_by_input_;
- Vector<const DInputSocket *> group_outputs_;
+ Map<std::pair<XXXInputSocket, XXXOutputSocket>, GMutablePointer> value_by_input_;
+ Vector<XXXInputSocket> group_outputs_;
blender::nodes::MultiFunctionByNode &mf_by_node_;
const blender::nodes::DataTypeConversions &conversions_;
const PersistentDataHandleMap &handle_map_;
@@ -266,8 +268,8 @@ class GeometryNodesEvaluator {
Depsgraph *depsgraph_;
public:
- GeometryNodesEvaluator(const Map<const DOutputSocket *, GMutablePointer> &group_input_data,
- Vector<const DInputSocket *> group_outputs,
+ GeometryNodesEvaluator(const Map<XXXOutputSocket, GMutablePointer> &group_input_data,
+ Vector<XXXInputSocket> group_outputs,
blender::nodes::MultiFunctionByNode &mf_by_node,
const PersistentDataHandleMap &handle_map,
const Object *self_object,
@@ -282,15 +284,15 @@ class GeometryNodesEvaluator {
depsgraph_(depsgraph)
{
for (auto item : group_input_data.items()) {
- this->forward_to_inputs(*item.key, item.value);
+ this->forward_to_inputs(item.key, item.value);
}
}
Vector<GMutablePointer> execute()
{
Vector<GMutablePointer> results;
- for (const DInputSocket *group_output : group_outputs_) {
- Vector<GMutablePointer> result = this->get_input_values(*group_output);
+ for (const XXXInputSocket &group_output : group_outputs_) {
+ Vector<GMutablePointer> result = this->get_input_values(group_output);
results.append(result[0]);
}
for (GMutablePointer value : value_by_input_.values()) {
@@ -300,62 +302,109 @@ class GeometryNodesEvaluator {
}
private:
- Vector<GMutablePointer> get_input_values(const DInputSocket &socket_to_compute)
+ Vector<GMutablePointer> get_input_values(const XXXInputSocket socket_to_compute)
{
+ Vector<XXXSocket> from_sockets;
+ this->foreach_origin_socket(socket_to_compute,
+ [&](XXXSocket socket) { from_sockets.append(socket); });
- Span<const DOutputSocket *> from_sockets = socket_to_compute.linked_sockets();
- Span<const DGroupInput *> from_group_inputs = socket_to_compute.linked_group_inputs();
- const int total_inputs = from_sockets.size() + from_group_inputs.size();
-
- if (total_inputs == 0) {
+ if (from_sockets.is_empty()) {
/* The input is not connected, use the value from the socket itself. */
return {get_unlinked_input_value(socket_to_compute)};
}
- if (from_group_inputs.size() == 1) {
- return {get_unlinked_input_value(socket_to_compute)};
- }
-
/* Multi-input sockets contain a vector of inputs. */
- if (socket_to_compute.is_multi_input_socket()) {
+ if (socket_to_compute.socket->is_multi_input_socket()) {
Vector<GMutablePointer> values;
- for (const DOutputSocket *from_socket : from_sockets) {
- const std::pair<const DInputSocket *, const DOutputSocket *> key = std::make_pair(
- &socket_to_compute, from_socket);
- std::optional<GMutablePointer> value = value_by_input_.pop_try(key);
- if (value.has_value()) {
- values.append(*value);
+ for (const XXXSocket from_socket : from_sockets) {
+ if (from_socket.socket->is_output()) {
+ XXXOutputSocket from_output_socket{from_socket};
+ const std::pair<XXXInputSocket, XXXOutputSocket> key = std::make_pair(
+ socket_to_compute, from_output_socket);
+ std::optional<GMutablePointer> value = value_by_input_.pop_try(key);
+ if (value.has_value()) {
+ values.append(*value);
+ }
+ else {
+ this->compute_output_and_forward(from_output_socket);
+ GMutablePointer value = value_by_input_.pop(key);
+ values.append(value);
+ }
}
else {
- this->compute_output_and_forward(*from_socket);
- GMutablePointer value = value_by_input_.pop(key);
+ /* This is an unlinked group input. */
+ XXXInputSocket from_input_socket{from_socket};
+ GMutablePointer value = get_unlinked_input_value(from_input_socket);
values.append(value);
}
}
return values;
}
- const DOutputSocket &from_socket = *from_sockets[0];
- const std::pair<const DInputSocket *, const DOutputSocket *> key = std::make_pair(
- &socket_to_compute, &from_socket);
- std::optional<GMutablePointer> value = value_by_input_.pop_try(key);
- if (value.has_value()) {
- /* This input has been computed before, return it directly. */
- return {*value};
+ const XXXSocket from_socket = from_sockets[0];
+ if (from_socket.socket->is_output()) {
+ const XXXOutputSocket from_output_socket{from_socket};
+ const std::pair<XXXInputSocket, XXXOutputSocket> key = std::make_pair(socket_to_compute,
+ from_output_socket);
+ std::optional<GMutablePointer> value = value_by_input_.pop_try(key);
+ if (value.has_value()) {
+ /* This input has been computed before, return it directly. */
+ return {*value};
+ }
+
+ /* Compute the socket now. */
+ this->compute_output_and_forward(from_output_socket);
+ return {value_by_input_.pop(key)};
}
- /* Compute the socket now. */
- this->compute_output_and_forward(from_socket);
- return {value_by_input_.pop(key)};
+ /* This is an unlinked group input. */
+ const XXXInputSocket from_input_socket{from_socket};
+ return {get_unlinked_input_value(from_input_socket)};
+ }
+
+ void foreach_origin_socket(XXXInputSocket to_socket, FunctionRef<void(XXXSocket)> callback) const
+ {
+ for (const OutputSocketRef *linked_socket : to_socket.socket->linked_sockets()) {
+ const NodeRef &linked_node = linked_socket->node();
+ XXXOutputSocket linked_xxx_socket{to_socket.context, linked_socket};
+ if (linked_node.is_group_input_node()) {
+ if (to_socket.context.info().is_root()) {
+ callback(linked_xxx_socket);
+ }
+ else {
+ XXXInputSocket socket_in_parent_group =
+ linked_xxx_socket.get_corresponding_group_node_input();
+ if (socket_in_parent_group.socket->is_linked()) {
+ this->foreach_origin_socket(socket_in_parent_group, callback);
+ }
+ else {
+ callback(socket_in_parent_group);
+ }
+ }
+ }
+ else if (linked_node.is_group_node()) {
+ XXXInputSocket socket_in_group = linked_xxx_socket.get_corresponding_group_output_socket();
+ if (socket_in_group.socket->is_linked()) {
+ this->foreach_origin_socket(socket_in_group, callback);
+ }
+ else {
+ callback(socket_in_group);
+ }
+ }
+ else {
+ callback(linked_xxx_socket);
+ }
+ }
}
- void compute_output_and_forward(const DOutputSocket &socket_to_compute)
+ void compute_output_and_forward(const XXXOutputSocket socket_to_compute)
{
- const DNode &node = socket_to_compute.node();
+ const XXXNode node{socket_to_compute.context, &socket_to_compute.socket->node()};
- if (!socket_to_compute.is_available()) {
+ if (!socket_to_compute.socket->is_available()) {
/* If the output is not available, use a default value. */
- const CPPType &type = *blender::nodes::socket_cpp_type_get(*socket_to_compute.typeinfo());
+ const CPPType &type = *blender::nodes::socket_cpp_type_get(
+ *socket_to_compute.socket->typeinfo());
void *buffer = allocator_.allocate(type.size(), type.alignment());
type.copy_to_uninitialized(type.default_value(), buffer);
this->forward_to_inputs(socket_to_compute, {type, buffer});
@@ -364,9 +413,9 @@ class GeometryNodesEvaluator {
/* Prepare inputs required to execute the node. */
GValueMap<StringRef> node_inputs_map{allocator_};
- for (const DInputSocket *input_socket : node.inputs()) {
+ for (const InputSocketRef *input_socket : node.node->inputs()) {
if (input_socket->is_available()) {
- Vector<GMutablePointer> values = this->get_input_values(*input_socket);
+ Vector<GMutablePointer> values = this->get_input_values({node.context, input_socket});
for (int i = 0; i < values.size(); ++i) {
/* Values from Multi Input Sockets are stored in input map with the format
* <identifier>[<index>]. */
@@ -384,15 +433,15 @@ class GeometryNodesEvaluator {
this->execute_node(node, params);
/* Forward computed outputs to linked input sockets. */
- for (const DOutputSocket *output_socket : node.outputs()) {
+ for (const OutputSocketRef *output_socket : node.node->outputs()) {
if (output_socket->is_available()) {
GMutablePointer value = node_outputs_map.extract(output_socket->identifier());
- this->forward_to_inputs(*output_socket, value);
+ this->forward_to_inputs({node.context, output_socket}, value);
}
}
}
- void execute_node(const DNode &node, GeoNodeExecParams params)
+ void execute_node(const XXXNode node, GeoNodeExecParams params)
{
const bNode &bnode = params.node();
@@ -405,7 +454,7 @@ class
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list