dillongoostudios/goo-engine
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleanup: store less data per node that is already stored together

Browse Source
This commit is contained in:
Jacques Lucke
2023-04-26 10:42:23 +02:00
parent c1d4b6f339
commit 8ebabac003
1 changed files with 53 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/blender/nodes/intern/geometry_nodes_lazy_function.cc
+53 -77
View File
@@ -146,19 +146,7 @@ class NodeAnonymousAttributeID : public AnonymousAttributeID {
class LazyFunctionForGeometryNode : public LazyFunction {
private:
const bNode &node_;
/**
* Index of a boolean input that indicates whether the output socket is used.
*/
const Span<int> lf_input_for_output_bsocket_usage_;
/**
* Index of an attribute set input that indicates which anonymous attributes should be
* propagated to the output.
*/
const Span<int> lf_input_for_attribute_propagation_to_output_;
/**
* Maps #bNodeSocket::index_in_tree to input/output indices of the current lazy-function.
*/
const Span<int> lf_index_by_bsocket_;
const GeometryNodesLazyFunctionGraphInfo &own_lf_graph_info_;
/**
* A bool for every output bsocket. If true, the socket just outputs a field containing an
* anonymous attribute id. If only such outputs are requested by other nodes, the node itself
@@ -177,19 +165,15 @@ class LazyFunctionForGeometryNode : public LazyFunction {
public:
LazyFunctionForGeometryNode(const bNode &node,
MutableSpan<int> r_lf_input_for_output_bsocket_usage,
MutableSpan<int> r_lf_input_for_attribute_propagation_to_output,
MutableSpan<int> r_lf_index_by_bsocket)
GeometryNodesLazyFunctionGraphInfo &own_lf_graph_info)
: node_(node),
lf_input_for_output_bsocket_usage_(r_lf_input_for_output_bsocket_usage),
lf_input_for_attribute_propagation_to_output_(
r_lf_input_for_attribute_propagation_to_output),
lf_index_by_bsocket_(r_lf_index_by_bsocket),
own_lf_graph_info_(own_lf_graph_info),
is_attribute_output_bsocket_(node.output_sockets().size(), false)
{
BLI_assert(node.typeinfo->geometry_node_execute != nullptr);
debug_name_ = node.name;
lazy_function_interface_from_node(node, inputs_, outputs_, r_lf_index_by_bsocket);
lazy_function_interface_from_node(
node, inputs_, outputs_, own_lf_graph_info.mapping.lf_index_by_bsocket);
const NodeDeclaration &node_decl = *node.declaration();
const aal::RelationsInNode *relations = node_decl.anonymous_attribute_relations();
@@ -212,7 +196,9 @@ class LazyFunctionForGeometryNode : public LazyFunction {
if (output_bsocket.is_available() && !handled_field_outputs.contains(&output_bsocket)) {
handled_field_outputs.append(&output_bsocket);
const int lf_index = inputs_.append_and_get_index_as("Output Used", CPPType::get<bool>());
r_lf_input_for_output_bsocket_usage[output_bsocket.index_in_all_outputs()] = lf_index;
own_lf_graph_info.mapping
.lf_input_index_for_output_bsocket_usage[output_bsocket.index_in_all_outputs()] =
lf_index;
}
}
@@ -223,8 +209,8 @@ class LazyFunctionForGeometryNode : public LazyFunction {
handled_geometry_outputs.append(&output_bsocket);
const int lf_index = inputs_.append_and_get_index_as(
"Propagate to Output", CPPType::get<bke::AnonymousAttributeSet>());
r_lf_input_for_attribute_propagation_to_output[output_bsocket.index_in_all_outputs()] =
lf_index;
own_lf_graph_info.mapping.lf_input_index_for_attribute_propagation_to_output
[output_bsocket.index_in_all_outputs()] = lf_index;
}
}
}
@@ -268,7 +254,8 @@ class LazyFunctionForGeometryNode : public LazyFunction {
bool used_non_attribute_output_exists = false;
for (const int output_bsocket_index : node_.output_sockets().index_range()) {
const bNodeSocket &output_bsocket = node_.output_socket(output_bsocket_index);
const int lf_index = lf_index_by_bsocket_[output_bsocket.index_in_tree()];
const int lf_index =
own_lf_graph_info_.mapping.lf_index_by_bsocket[output_bsocket.index_in_tree()];
if (lf_index == -1) {
continue;
}
@@ -307,12 +294,13 @@ class LazyFunctionForGeometryNode : public LazyFunction {
return;
}
GeoNodeExecParams geo_params{node_,
params,
context,
lf_input_for_output_bsocket_usage_,
lf_input_for_attribute_propagation_to_output_,
get_output_attribute_id};
GeoNodeExecParams geo_params{
node_,
params,
context,
own_lf_graph_info_.mapping.lf_input_index_for_output_bsocket_usage,
own_lf_graph_info_.mapping.lf_input_index_for_attribute_propagation_to_output,
get_output_attribute_id};
geo_eval_log::TimePoint start_time = geo_eval_log::Clock::now();
node_.typeinfo->geometry_node_execute(geo_params);
@@ -347,14 +335,17 @@ class LazyFunctionForGeometryNode : public LazyFunction {
{
for (const bNodeSocket *bsocket : node_.output_sockets()) {
{
const int lf_index = lf_input_for_output_bsocket_usage_[bsocket->index_in_all_outputs()];
const int lf_index =
own_lf_graph_info_.mapping
.lf_input_index_for_output_bsocket_usage[bsocket->index_in_all_outputs()];
if (index == lf_index) {
return StringRef("Use Output '") + bsocket->identifier + "'";
}
}
{
const int lf_index =
lf_input_for_attribute_propagation_to_output_[bsocket->index_in_all_outputs()];
own_lf_graph_info_.mapping.lf_input_index_for_attribute_propagation_to_output
[bsocket->index_in_all_outputs()];
if (index == lf_index) {
return StringRef("Propagate to '") + bsocket->identifier + "'";
}
@@ -858,6 +849,7 @@ class LazyFunctionForViewerInputUsage : public LazyFunction {
class LazyFunctionForGroupNode : public LazyFunction {
private:
const bNode &group_node_;
const GeometryNodesLazyFunctionGraphInfo &own_lf_graph_info_;
bool has_many_nodes_ = false;
std::optional<GeometryNodesLazyFunctionLogger> lf_logger_;
std::optional<GeometryNodesLazyFunctionSideEffectProvider> lf_side_effect_provider_;
@@ -875,77 +867,66 @@ class LazyFunctionForGroupNode : public LazyFunction {
* input is used.
*/
Map<int, int> lf_output_for_input_bsocket_usage_;
/**
* For every output bsocket there is a corresponding boolean input that indicates whether the
* output is used.
*/
const Span<int> lf_input_for_output_bsocket_usage_;
/**
* For every geometry output that can propagate attributes from an input, there is an attribute
* set input. It indicates which attributes should be propagated to the output.
*/
const Span<int> lf_input_for_attribute_propagation_to_output_;
LazyFunctionForGroupNode(const bNode &group_node,
const GeometryNodesLazyFunctionGraphInfo &lf_graph_info,
MutableSpan<int> r_lf_input_for_output_bsocket_usage,
MutableSpan<int> r_lf_input_for_attribute_propagation_to_output,
MutableSpan<int> r_lf_index_by_bsocket)
: group_node_(group_node),
lf_input_for_output_bsocket_usage_(r_lf_input_for_output_bsocket_usage),
lf_input_for_attribute_propagation_to_output_(
r_lf_input_for_attribute_propagation_to_output)
const GeometryNodesLazyFunctionGraphInfo &group_lf_graph_info,
GeometryNodesLazyFunctionGraphInfo &own_lf_graph_info)
: group_node_(group_node), own_lf_graph_info_(own_lf_graph_info)
{
debug_name_ = group_node.name;
allow_missing_requested_inputs_ = true;
lazy_function_interface_from_node(group_node, inputs_, outputs_, r_lf_index_by_bsocket);
lazy_function_interface_from_node(
group_node, inputs_, outputs_, own_lf_graph_info.mapping.lf_index_by_bsocket);
for (lf::Input &input : inputs_) {
input.usage = lf::ValueUsage::Maybe;
}
has_many_nodes_ = lf_graph_info.num_inline_nodes_approximate > 1000;
has_many_nodes_ = group_lf_graph_info.num_inline_nodes_approximate > 1000;
Vector<const lf::OutputSocket *> graph_inputs;
/* Add inputs that also exist on the bnode. */
graph_inputs.extend(lf_graph_info.mapping.group_input_sockets);
graph_inputs.extend(group_lf_graph_info.mapping.group_input_sockets);
/* Add a boolean input for every output bsocket that indicates whether that socket is used. */
for (const int i : group_node.output_sockets().index_range()) {
r_lf_input_for_output_bsocket_usage[group_node.output_socket(i).index_in_all_outputs()] =
graph_inputs.append_and_get_index(lf_graph_info.mapping.group_output_used_sockets[i]);
own_lf_graph_info.mapping.lf_input_index_for_output_bsocket_usage
[group_node.output_socket(i).index_in_all_outputs()] = graph_inputs.append_and_get_index(
group_lf_graph_info.mapping.group_output_used_sockets[i]);
inputs_.append_as("Output is Used", CPPType::get<bool>(), lf::ValueUsage::Maybe);
}
graph_inputs.extend(lf_graph_info.mapping.group_output_used_sockets);
graph_inputs.extend(group_lf_graph_info.mapping.group_output_used_sockets);
/* Add an attribute set input for every output geometry socket that can propagate attributes
* from inputs. */
for (auto [output_index, lf_socket] :
lf_graph_info.mapping.attribute_set_by_geometry_output.items()) {
group_lf_graph_info.mapping.attribute_set_by_geometry_output.items()) {
const int lf_index = inputs_.append_and_get_index_as(
"Attribute Set", CPPType::get<bke::AnonymousAttributeSet>(), lf::ValueUsage::Maybe);
graph_inputs.append(lf_socket);
r_lf_input_for_attribute_propagation_to_output[group_node_.output_socket(output_index)
.index_in_all_outputs()] = lf_index;
own_lf_graph_info.mapping.lf_input_index_for_attribute_propagation_to_output
[group_node_.output_socket(output_index).index_in_all_outputs()] = lf_index;
}
Vector<const lf::InputSocket *> graph_outputs;
/* Add outputs that also exist on the bnode. */
graph_outputs.extend(lf_graph_info.mapping.standard_group_output_sockets);
graph_outputs.extend(group_lf_graph_info.mapping.standard_group_output_sockets);
/* Add a boolean output for every input bsocket that indicates whether that socket is used. */
for (const int i : group_node.input_sockets().index_range()) {
const InputUsageHint &input_usage_hint = lf_graph_info.mapping.group_input_usage_hints[i];
const InputUsageHint &input_usage_hint =
group_lf_graph_info.mapping.group_input_usage_hints[i];
if (input_usage_hint.type == InputUsageHintType::DynamicSocket) {
const lf::InputSocket *lf_socket = lf_graph_info.mapping.group_input_usage_sockets[i];
const lf::InputSocket *lf_socket =
group_lf_graph_info.mapping.group_input_usage_sockets[i];
lf_output_for_input_bsocket_usage_.add_new(i,
graph_outputs.append_and_get_index(lf_socket));
outputs_.append_as("Input is Used", CPPType::get<bool>());
}
}
lf_logger_.emplace(lf_graph_info);
lf_logger_.emplace(group_lf_graph_info);
lf_side_effect_provider_.emplace();
graph_executor_.emplace(lf_graph_info.graph,
graph_executor_.emplace(group_lf_graph_info.graph,
std::move(graph_inputs),
std::move(graph_outputs),
&*lf_logger_,
@@ -1012,14 +993,17 @@ class LazyFunctionForGroupNode : public LazyFunction {
}
for (const bNodeSocket *bsocket : group_node_.output_sockets()) {
{
const int lf_index = lf_input_for_output_bsocket_usage_[bsocket->index_in_all_outputs()];
const int lf_index =
own_lf_graph_info_.mapping
.lf_input_index_for_output_bsocket_usage[bsocket->index_in_all_outputs()];
if (i == lf_index) {
return StringRef("Use Output '") + bsocket->identifier + "'";
}
}
{
const int lf_index =
lf_input_for_attribute_propagation_to_output_[bsocket->index_in_all_outputs()];
own_lf_graph_info_.mapping.lf_input_index_for_attribute_propagation_to_output
[bsocket->index_in_all_outputs()];
if (i == lf_index) {
return StringRef("Propagate to '") + bsocket->identifier + "'";
}
@@ -1641,11 +1625,7 @@ struct GeometryNodesLazyFunctionGraphBuilder {
}
auto lazy_function = std::make_unique<LazyFunctionForGroupNode>(
bnode,
*group_lf_graph_info,
mapping_->lf_input_index_for_output_bsocket_usage,
mapping_->lf_input_index_for_attribute_propagation_to_output,
mapping_->lf_index_by_bsocket);
bnode, *group_lf_graph_info, *lf_graph_info_);
lf::FunctionNode &lf_node = lf_graph_->add_function(*lazy_function);
for (const int i : bnode.input_sockets().index_range()) {
@@ -1690,11 +1670,7 @@ struct GeometryNodesLazyFunctionGraphBuilder {
void handle_geometry_node(const bNode &bnode)
{
auto lazy_function = std::make_unique<LazyFunctionForGeometryNode>(
bnode,
mapping_->lf_input_index_for_output_bsocket_usage,
mapping_->lf_input_index_for_attribute_propagation_to_output,
mapping_->lf_index_by_bsocket);
auto lazy_function = std::make_unique<LazyFunctionForGeometryNode>(bnode, *lf_graph_info_);
lf::Node &lf_node = lf_graph_->add_function(*lazy_function);
for (const bNodeSocket *bsocket : bnode.input_sockets()) {