32using bke::AttributeAccessor;
33using bke::GeometryComponent;
34using bke::GeometrySet;
35using bke::MutableAttributeAccessor;
36using bke::SocketValueVariant;
74 if (this->
id.component_type == GeometryComponent::Type::GreasePencil &&
75 ELEM(this->
id.domain, AttrDomain::Point, AttrDomain::Curve))
77 this->field_context.emplace(
78 *
geometry.get_grease_pencil(), this->id.domain, *this->id.layer_index);
81 this->field_context.emplace(*
geometry.get_component(this->id.component_type),
88 return *this->field_context->attributes();
93 if (this->
id.component_type == GeometryComponent::Type::GreasePencil &&
94 ELEM(this->
id.domain, AttrDomain::Point, AttrDomain::Curve))
121 void execute_impl(lf::Params ¶ms,
const lf::Context &context)
const override;
127 const lf::Context &context,
128 int first_valid_item_i)
const;
130 const lf::Context &context,
134 const lf::Context &context,
150 const lf::Context &context)
const override
154 const LazyFunction &
fn =
node.function();
157 fn.execute(params, context);
167 body_compute_context.
hash());
170 lf::Context body_context{context.storage, &body_user_data, &body_local_user_data};
171 fn.execute(params, body_context);
185 const lf::Context &context)
const override
193 const Span<int> iterations_with_side_effects =
198 for (
const int i : iterations_with_side_effects) {
243 const bNode &output_bnode_;
261 ItemIndices generation;
264 friend LazyFunctionForReduceForeachGeometryElement;
273 output_bnode_(*zone.output_node()),
274 zone_info_(zone_info),
277 debug_name_ =
"Foreach Geometry Element";
282 inputs_[i].usage = lf::ValueUsage::Used;
286 output_bnode_.storage);
288 BLI_assert(zone_.input_node()->output_socket(1).is_available() ==
289 (iteration_domain != AttrDomain::Corner));
291 const int input_items_num = node_storage.input_items.items_num;
292 const int main_items_num = node_storage.main_items.items_num;
293 const int generation_items_num = node_storage.generation_items.items_num;
297 iteration_domain == AttrDomain::Corner ? 1 : 2, input_items_num);
298 indices_.inputs.bsocket_outer = indices_.inputs.lf_outer;
299 indices_.inputs.bsocket_inner = indices_.inputs.lf_inner;
303 indices_.main.bsocket_outer = indices_.main.lf_outer;
304 indices_.main.bsocket_inner = indices_.main.lf_inner;
307 generation_items_num);
309 generation_items_num);
311 generation_items_num);
313 generation_items_num);
324 if (s->graph_executor_storage) {
325 s->graph_executor->destruct_storage(s->graph_executor_storage);
330 void execute_impl(lf::Params ¶ms,
const lf::Context &context)
const override
338 output_bnode_.storage);
342 if (!eval_storage.graph_executor) {
347 if (eval_storage.total_iterations_num == 0) {
348 if (!eval_storage.main_geometry.is_empty()) {
351 {zone_.input_node()->identifier,
352 {NodeWarningType::Info,
353 N_(
"Input geometry has no elements in the iteration domain.")}});
359 lf::Context eval_graph_context{
360 eval_storage.graph_executor_storage, context.user_data, context.local_user_data};
362 eval_storage.graph_executor->execute(params, eval_graph_context);
372 zone_info_.indices.inputs.main[0])
381 lf::Graph &lf_graph = eval_storage.
graph;
384 for (
const int i : inputs_.index_range()) {
385 const lf::Input &input = inputs_[i];
386 graph_inputs.
append(&lf_graph.add_input(*input.type, this->input_name(i)));
388 for (
const int i : outputs_.index_range()) {
389 const lf::Output &
output = outputs_[i];
390 graph_outputs.
append(&lf_graph.add_output(*
output.type, this->output_name(i)));
404 lf_graph.update_node_indices();
419 output_bnode_.identifier, [&]() { return lf_graph.to_dot(); });
432 const bNodeSocket &element_geometry_bsocket = zone_.input_node()->output_socket(1);
433 const bool create_element_geometries = element_geometry_bsocket.is_available() &&
434 element_geometry_bsocket.is_directly_linked();
440 if (src_component->type() == GeometryComponent::Type::GreasePencil &&
441 ELEM(iteration_domain, AttrDomain::Point, AttrDomain::Curve))
444 for (
const int layer_i :
grease_pencil.layers().index_range()) {
447 if (drawing ==
nullptr) {
454 component_ids.
append({component_type, iteration_domain, layer_i});
458 const int domain_size = src_component->attribute_domain_size(iteration_domain);
459 if (domain_size > 0) {
460 component_ids.
append({component_type, iteration_domain});
467 zone_info_.indices.inputs.main[1])
471 int body_nodes_offset = 0;
473 for (
const int component_i : component_ids.
index_range()) {
476 component_info.
id =
id;
489 zone_info_.indices.inputs.main[indices_.inputs.lf_outer[item_i]])
490 .ensure_type<GField>();
501 body_nodes_offset +=
mask.size();
505 mask.foreach_index_optimized<
int>(
506 [&](
const int i,
const int pos) { component_info.
index_values[pos].emplace<
int>(i); });
508 if (create_element_geometries) {
515 element_geometries->index_range(), 256, [&](
const IndexRange range) {
516 for (const int i : range) {
517 (*component_info.element_geometries)[i] = SocketValueVariant::from(
518 (*element_geometries)[i]);
530 component_info.item_input_values[item_i].reinitialize(
mask.size());
531 const GVArray &values = component_info.field_evaluator->get_evaluated(item_i);
533 [&](
const int i,
const int pos) {
542 eval_storage.total_iterations_num = body_nodes_offset;
551 switch (
id.component_type) {
552 case GeometryComponent::Type::Mesh: {
556 case AttrDomain::Point: {
560 case AttrDomain::Edge: {
564 case AttrDomain::Face: {
574 element_geometries[i].replace_mesh(meshes[i]);
576 return element_geometries;
578 case GeometryComponent::Type::PointCloud: {
579 if (
id.domain != AttrDomain::Point) {
584 main_pointcloud,
mask, attribute_filter);
587 element_geometries[i].replace_pointcloud(pointclouds[i]);
589 return element_geometries;
591 case GeometryComponent::Type::Curve: {
595 case AttrDomain::Point: {
599 case AttrDomain::Curve: {
608 element_geometries[i].replace_curves(element_curves[i]);
610 return element_geometries;
612 case GeometryComponent::Type::Instance: {
613 if (
id.domain != AttrDomain::Instance) {
618 main_instances,
mask, attribute_filter);
620 for (
const int i : element_instances.
index_range()) {
621 element_geometries[i].replace_instances(element_instances[i]);
623 return element_geometries;
625 case GeometryComponent::Type::GreasePencil: {
629 case AttrDomain::Layer: {
631 main_grease_pencil,
mask, attribute_filter);
634 case AttrDomain::Point: {
636 main_grease_pencil, *
id.layer_index,
mask, attribute_filter);
639 case AttrDomain::Curve: {
641 main_grease_pencil, *
id.layer_index,
mask, attribute_filter);
648 for (
const int i : element_geometries.
index_range()) {
649 element_geometries[i].replace_grease_pencil(element_grease_pencils[i]);
651 return element_geometries;
664 lf::Graph &lf_graph = eval_storage.
graph;
669 lf::FunctionNode &lf_node = lf_graph.add_function(*body_fn_.function);
670 lf_body_nodes.
add_new(&lf_node);
674 for (
const int zone_output_i : body_fn_.indices.inputs.output_usages.index_range()) {
676 lf::GraphInputSocket &lf_graph_input =
677 *graph_inputs[zone_info_.indices.inputs.output_usages[1 + zone_output_i]];
679 lf::FunctionNode &lf_node = *lf_body_nodes[i];
680 lf_graph.add_link(lf_graph_input,
681 lf_node.input(body_fn_.indices.inputs.output_usages[zone_output_i]));
685 const bNodeSocket &element_geometry_bsocket = zone_.input_node()->output_socket(1);
691 lf::FunctionNode &lf_body_node = *lf_body_nodes[body_i];
693 lf_body_node.input(body_fn_.indices.inputs.main[0])
696 if (element_geometry_bsocket.is_available()) {
700 &empty_geometry_value;
701 lf_body_node.input(body_fn_.indices.inputs.main[1]).set_default_value(element_geometry);
705 lf_body_node.input(body_fn_.indices.inputs.main[indices_.inputs.lf_inner[item_i]])
709 for (
const int border_link_i : zone_info_.indices.inputs.border_links.index_range()) {
711 *graph_inputs[zone_info_.indices.inputs.border_links[border_link_i]],
712 lf_body_node.input(body_fn_.indices.inputs.border_links[border_link_i]));
715 for (
const auto &item : body_fn_.indices.inputs.reference_sets.items()) {
717 *graph_inputs[zone_info_.indices.inputs.reference_sets.lookup(item.key)],
718 lf_body_node.input(item.value));
725 lf::FunctionNode &lf_reduce = lf_graph.add_function(*eval_storage.
reduce_function);
730 BLI_assert(body_main_outputs_num == body_fn_.indices.outputs.main.size());
732 lf::FunctionNode &lf_body_node = *lf_body_nodes[i];
734 lf_graph.add_link(lf_body_node.output(body_fn_.indices.outputs.main[item_i]),
735 lf_reduce.input(i * body_main_outputs_num + item_i));
739 lf_graph.add_link(lf_body_node.output(body_fn_.indices.outputs.main[body_output_i]),
740 lf_reduce.input(i * body_main_outputs_num + body_output_i));
745 lf_graph.add_link(lf_reduce.output(0), *graph_outputs[zone_info_.indices.outputs.main[0]]);
747 const int output_i = indices_.main.lf_outer[item_i];
748 lf_graph.add_link(lf_reduce.output(output_i),
749 *graph_outputs[zone_info_.indices.outputs.main[output_i]]);
752 const int output_i = indices_.generation.lf_outer[item_i];
753 lf_graph.add_link(lf_reduce.output(output_i),
754 *graph_outputs[zone_info_.indices.outputs.main[output_i]]);
758 static bool static_true{
true};
759 for (
const int i : zone_info_.indices.outputs.input_usages) {
760 graph_outputs[i]->set_default_value(&static_true);
766 for (
const int border_link_i : zone_.border_links.index_range()) {
767 lf::FunctionNode &lf_or = lf_graph.add_function(*eval_storage.
or_function);
769 lf::FunctionNode &lf_body_node = *lf_body_nodes[i];
771 lf_body_node.output(body_fn_.indices.outputs.border_link_usages[border_link_i]),
776 *graph_outputs[zone_info_.indices.outputs.border_link_usages[border_link_i]]);
796 debug_name_ =
"Reduce";
802 (node_storage.main_items.items_num + node_storage.generation_items.items_num));
806 for (const int item_i : IndexRange(node_storage.main_items.items_num)) {
807 const NodeForeachGeometryElementMainItem &item = node_storage.main_items.items[item_i];
808 inputs_.append_as(item.name, CPPType::get<SocketValueVariant>(), lf::ValueUsage::Used);
811 for (
const int item_i :
IndexRange(node_storage.generation_items.items_num)) {
812 const NodeForeachGeometryElementGenerationItem &item =
813 node_storage.generation_items.items[item_i];
814 inputs_.append_as(item.name, CPPType::get<SocketValueVariant>(), lf::ValueUsage::Maybe);
821 for (
const int item_i :
IndexRange(node_storage.main_items.items_num)) {
822 const NodeForeachGeometryElementMainItem &item = node_storage.main_items.items[item_i];
823 outputs_.append_as(item.name, CPPType::get<SocketValueVariant>());
826 for (
const int item_i :
IndexRange(node_storage.generation_items.items_num)) {
827 const NodeForeachGeometryElementGenerationItem &item =
828 node_storage.generation_items.items[item_i];
829 outputs_.append_as(item.name, CPPType::get<SocketValueVariant>());
837 switch (component_type) {
838 case GeometryComponent::Type::Mesh:
839 case GeometryComponent::Type::PointCloud:
840 return AttrDomain::Point;
841 case GeometryComponent::Type::Curve:
842 return AttrDomain::Curve;
843 case GeometryComponent::Type::Instance:
844 return AttrDomain::Instance;
845 case GeometryComponent::Type::GreasePencil:
846 return AttrDomain::Layer;
854 const lf::Context &context)
const
860 if (node_storage.generation_items.items_num == 0) {
867 lf::Params ¶ms,
const lf::Context &context)
const
873 node_storage.generation_items.items_num;
875 const int main_geometry_output = 0;
876 if (params.output_was_set(main_geometry_output)) {
883 for (
const int item_i :
IndexRange(node_storage.main_items.items_num)) {
887 if (!base_cpp_type) {
894 user_data.call_data->self_object()->id.name,
895 user_data.compute_context->hash(),
907 attribute_name, component_info.
id.
domain, cd_type);
916 mask.foreach_index([&](
const int i,
const int pos) {
917 const int lf_param_index = pos * body_main_outputs_num + item_i;
919 const void *value = value_variant.
ensure_type(*base_cpp_type);
931 parent_.output_bnode_.output_socket(
parent_.indices_.main.bsocket_outer[item_i])));
940 lf::Params ¶ms,
const lf::Context &context)
const
946 if (first_valid_item_i == node_storage.generation_items.items_num) {
953 lf::Params ¶ms)
const
960 for (; item_i < node_storage.generation_items.items_num; item_i++) {
962 node_storage.generation_items.items[item_i];
967 const int lf_socket_i =
parent_.indices_.generation.lf_outer[item_i];
968 if (!params.output_was_set(lf_socket_i)) {
969 const int bsocket_i =
parent_.indices_.generation.bsocket_outer[item_i];
978 lf::Params ¶ms,
const lf::Context &context,
const int first_valid_item_i)
const
982 int previous_geometry_item_i = first_valid_item_i;
985 for (
const int item_i :
989 node_storage.generation_items.items[item_i];
995 previous_geometry_item_i,
997 previous_geometry_item_i = item_i;
1003 previous_geometry_item_i,
1005 node_storage.generation_items.items_num));
1010 const lf::Context &context,
1011 const int geometry_item_i,
1012 const IndexRange generation_items_range)
const
1018 node_storage.generation_items.items_num;
1022 params, context, geometry_item_i, generation_items_range))
1035 for (
const int i : generation_items_range.
index_range()) {
1036 const int item_i = generation_items_range[i];
1038 node_storage.generation_items.items[item_i];
1040 user_data.call_data->self_object()->id.name,
1041 user_data.compute_context->hash(),
1050 struct NameWithType {
1069 mask.foreach_index([&](
const int element_i,
const int local_body_i) {
1071 const int geometry_param_i = body_i * body_main_outputs_num +
1072 parent_.indices_.generation.lf_inner[geometry_item_i];
1077 {GeometryComponent::Type::Mesh,
1078 GeometryComponent::Type::PointCloud,
1079 GeometryComponent::Type::Curve,
1080 GeometryComponent::Type::GreasePencil,
1081 GeometryComponent::Type::Instance})
1083 if (!
geometry.has(dst_component_type)) {
1091 const std::optional<AttrDomain> propagation_domain =
1093 if (!propagation_domain) {
1098 for (
const NameWithType &name_with_type : attributes_to_propagate) {
1099 const StringRef name = name_with_type.name;
1104 if (dst_attributes.
contains(name)) {
1115 if (!src_attribute) {
1125 name, *propagation_domain, data_type);
1134 for (
const int local_item_i : generation_items_range.
index_range()) {
1135 const int item_i = generation_items_range[local_item_i];
1137 node_storage.generation_items.items[item_i];
1139 const int field_param_i = body_i * body_main_outputs_num +
1140 parent_.indices_.generation.lf_inner[item_i];
1143 if (capture_domain == AttrDomain::Instance) {
1146 geometry.get_component_for_write(GeometryComponent::Type::Instance),
1147 attribute_names[local_item_i],
1155 {GeometryComponent::Type::Mesh,
1156 GeometryComponent::Type::PointCloud,
1157 GeometryComponent::Type::Curve,
1158 GeometryComponent::Type::GreasePencil})
1160 if (sub_geometry.
has(component_type)) {
1163 attribute_names[local_item_i],
1177 edit_data_geometry.
keep_only({GeometryComponent::Type::Edit});
1183 params.set_output(
parent_.indices_.generation.lf_outer[geometry_item_i],
1187 for (
const int local_item_i : generation_items_range.
index_range()) {
1188 const int item_i = generation_items_range[local_item_i];
1190 node_storage.generation_items.items[item_i];
1193 const StringRef attribute_name = attribute_names[local_item_i];
1198 parent_.output_bnode_.output_socket(2 + node_storage.main_items.items_num + item_i)));
1199 params.set_output(
parent_.indices_.generation.lf_outer[item_i],
1206 const lf::Context & ,
1207 const int geometry_item_i,
1208 const IndexRange generation_items_range)
const
1213 node_storage.generation_items.items_num;
1215 const int geometry_output_param =
parent_.indices_.generation.lf_outer[geometry_item_i];
1217 if (params.output_was_set(geometry_output_param)) {
1221 const lf::ValueUsage geometry_output_usage = params.get_output_usage(geometry_output_param);
1222 if (geometry_output_usage == lf::ValueUsage::Unused) {
1224 const int start_bsocket_i =
parent_.indices_.generation.bsocket_outer[geometry_item_i];
1225 for (
const int i :
IndexRange(1 + generation_items_range.
size())) {
1226 const bNodeSocket &bsocket =
parent_.output_bnode_.output_socket(start_bsocket_i + i);
1231 bool any_output_used =
false;
1232 for (
const int i :
IndexRange(1 + generation_items_range.
size())) {
1233 const lf::ValueUsage usage = params.get_output_usage(geometry_output_param + i);
1234 if (usage == lf::ValueUsage::Used) {
1235 any_output_used =
true;
1239 if (!any_output_used) {
1246 bool has_missing_input =
false;
1247 for (
const int body_i :
IndexRange(bodies_num)) {
1248 const int offset = body_i * body_main_outputs_num +
1249 parent_.indices_.generation.lf_inner[geometry_item_i];
1250 for (
const int i :
IndexRange(1 + generation_items_range.
size())) {
1251 const bool is_available = params.try_get_input_data_ptr_or_request(offset + i) !=
nullptr;
1252 if (!is_available) {
1253 has_missing_input =
true;
1257 if (has_missing_input) {
1271 btree, zone, zone_info, body_fn);
Low-level operations for curves.
Low-level operations for grease pencil.
#define BUFFER_FOR_CPP_TYPE_VALUE(type, variable_name)
__forceinline float extract(const int4 &b)
const T & last(const int64_t n=0) const
IndexRange index_range() const
static const CPPType & get()
void value_initialize_indices(void *ptr, const IndexMask &mask) const
void fill_assign_n(const void *value, void *dst, int64_t n) const
void copy_construct(const void *src, void *dst) const
void destruct(void *ptr) const
const ComputeContextHash & hash() const
const CPPType & type() const
void get_to_uninitialized(int64_t index, void *r_value) const
constexpr int64_t size() const
static constexpr IndexRange from_begin_end(const int64_t begin, const int64_t end)
constexpr IndexRange()=default
static constexpr IndexRange from_begin_size(const int64_t begin, const int64_t size)
constexpr IndexRange index_range() const
destruct_ptr< T > construct(Args &&...args)
Value & lookup_or_add_cb(const Key &key, const CreateValueF &create_value)
T & construct(Args &&...args)
constexpr int64_t size() const
int64_t index_of_try(const Key &key) const
IndexRange index_range() const
void add_new(const Key &key)
void append(const T &value)
IndexRange index_range() const
Span< T > as_span() const
void foreach_attribute(const FunctionRef< void(const AttributeIter &)> fn) const
bool contains(StringRef name) const
GVArray adapt_domain(const GVArray &varray, const AttrDomain from_domain, const AttrDomain to_domain) const
GAttributeReader lookup(const StringRef name) const
int domain_size(const AttrDomain domain) const
bool is_builtin(const StringRef name) const
MutableAttributeAccessor attributes_for_write()
virtual std::optional< MutableAttributeAccessor > attributes_for_write()
GSpanAttributeWriter lookup_or_add_for_write_only_span(StringRef name, AttrDomain domain, AttrType data_type)
void * allocate_single(const CPPType &type)
std::unique_ptr< LoggedZoneGraphs > logged_zone_graphs
const bNode * output_node() const
bke::CurvesGeometry & strokes_for_write()
const bke::CurvesGeometry & strokes() const
const bNode * output_bnode_
VectorSet< lf::FunctionNode * > * lf_body_nodes_
void execute_node(const lf::FunctionNode &node, lf::Params ¶ms, const lf::Context &context) const override
Vector< const lf::FunctionNode * > get_nodes_with_side_effects(const lf::Context &context) const override
const bNode * output_bnode_
Span< lf::FunctionNode * > lf_body_nodes_
void execute_impl(lf::Params ¶ms, const lf::Context &context) const override
std::optional< Array< GeometrySet > > try_extract_element_geometries(const GeometrySet &main_geometry, const ForeachElementComponentID &id, const IndexMask &mask, const bke::AttributeFilter &attribute_filter) const
void initialize_execution_graph(lf::Params ¶ms, ForeachGeometryElementEvalStorage &eval_storage, const NodeGeometryForeachGeometryElementOutput &node_storage) const
void prepare_components(lf::Params ¶ms, ForeachGeometryElementEvalStorage &eval_storage, const NodeGeometryForeachGeometryElementOutput &node_storage) const
std::string input_name(const int i) const override
LazyFunctionForForeachGeometryElementZone(const bNodeTree &btree, const bke::bNodeTreeZone &zone, ZoneBuildInfo &zone_info, const ZoneBodyFunction &body_fn)
std::string output_name(const int i) const override
void * init_storage(LinearAllocator<> &allocator) const override
void build_graph_contents(ForeachGeometryElementEvalStorage &eval_storage, const NodeGeometryForeachGeometryElementOutput &node_storage, Span< lf::GraphInputSocket * > graph_inputs, Span< lf::GraphOutputSocket * > graph_outputs) const
void destruct_storage(void *storage) const override
static SocketValueVariant from(T &&value)
LinearAllocator * allocator
linear_allocator::ChunkedList< WarningWithNode > node_warnings
#define storage(slot, qualifiers)
bool try_capture_field_on_geometry(MutableAttributeAccessor attributes, const fn::FieldContext &field_context, const StringRef name, AttrDomain domain, const fn::Field< bool > &selection, const fn::GField &field)
const CPPType * socket_type_to_geo_nodes_base_cpp_type(eNodeSocketDatatype type)
AttrType cpp_type_to_attribute_type(const CPPType &type)
std::string hash_to_anonymous_attribute_name(Args &&...args)
constexpr ParallelGrainSize grain_size(int grain_size)
Array< bke::Instances * > extract_instances(const bke::Instances &instances, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
Array< GreasePencil * > extract_greasepencil_layer_points(const GreasePencil &grease_pencil, int layer_i, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
bke::GeometrySet join_geometries(Span< bke::GeometrySet > geometries, const bke::AttributeFilter &attribute_filter, const std::optional< Span< bke::GeometryComponent::Type > > &component_types_to_join=std::nullopt, bool allow_merging_instance_references=true)
void foreach_real_geometry(bke::GeometrySet &geometry, FunctionRef< void(bke::GeometrySet &geometry_set)> fn)
Array< Mesh * > extract_mesh_faces(const Mesh &mesh, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
Array< Mesh * > extract_mesh_vertices(const Mesh &mesh, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
Array< Curves * > extract_curves(const Curves &curves, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
Array< Curves * > extract_curves_points(const Curves &curves, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
Array< GreasePencil * > extract_greasepencil_layers(const GreasePencil &grease_pencil, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
Array< GreasePencil * > extract_greasepencil_layer_curves(const GreasePencil &grease_pencil, int layer_i, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
Array< PointCloud * > extract_pointcloud_points(const PointCloud &pointcloud, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
Array< Mesh * > extract_mesh_edges(const Mesh &mesh, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
static std::optional< AttrDomain > get_foreach_attribute_propagation_target_domain(const GeometryComponent::Type component_type)
void initialize_zone_wrapper(const bNodeTreeZone &zone, ZoneBuildInfo &zone_info, const ZoneBodyFunction &body_fn, const bool expose_all_reference_sets, Vector< lf::Input > &r_inputs, Vector< lf::Output > &r_outputs)
bool should_log_verbose_in_context(const GeoNodesUserData &user_data, const ComputeContextHash hash)
std::string make_anonymous_attribute_socket_inspection_string(const bNodeSocket &socket)
void set_default_value_for_output_socket(lf::Params ¶ms, const int lf_index, const bNodeSocket &bsocket)
std::string zone_wrapper_output_name(const ZoneBuildInfo &zone_info, const bNodeTreeZone &zone, const Span< lf::Output > outputs, const int lf_socket_i)
LazyFunction & build_foreach_geometry_element_zone_lazy_function(ResourceScope &scope, const bNodeTree &btree, const bke::bNodeTreeZone &zone, ZoneBuildInfo &zone_info, const ZoneBodyFunction &body_fn)
std::string zone_wrapper_input_name(const ZoneBuildInfo &zone_info, const bNodeTreeZone &zone, const Span< lf::Input > inputs, const int lf_socket_i)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
T * DEG_get_original(T *id)
eNodeSocketDatatype socket_type
eNodeSocketDatatype socket_type
NodeForeachGeometryElementInputItems input_items
NodeForeachGeometryElementGenerationItems generation_items
NodeForeachGeometryElementMainItems main_items
bke::bNodeTreeRuntime * runtime
bool allow_skip(const StringRef name) const
void keep_only(Span< GeometryComponent::Type > component_types)
GeometryComponent & get_component_for_write(GeometryComponent::Type component_type)
const GreasePencil * get_grease_pencil() const
Vector< const GeometryComponent * > get_components() const
bool has(const GeometryComponent::Type component_type) const
const Curves * get_curves() const
const Instances * get_instances() const
const PointCloud * get_pointcloud() const
const Mesh * get_mesh() const
GeometryComponent::Type component_type
std::optional< int > layer_index
Array< SocketValueVariant > index_values
std::optional< Array< SocketValueVariant > > element_geometries
AttributeAccessor input_attributes() const
void emplace_field_context(const GeometrySet &geometry)
MutableAttributeAccessor attributes_for_write(GeometrySet &geometry) const
ForeachElementComponentID id
std::optional< fn::FieldEvaluator > field_evaluator
std::optional< bke::GeometryFieldContext > field_context
Array< Array< SocketValueVariant > > item_input_values
IndexRange body_nodes_range
GeometrySet main_geometry
std::optional< LazyFunctionForReduceForeachGeometryElement > reduce_function
VectorSet< lf::FunctionNode * > lf_body_nodes
std::optional< lf::GraphExecutor > graph_executor
LinearAllocator allocator
std::optional< LazyFunctionForLogicalOr > or_function
std::optional< ForeachGeometryElementZoneSideEffectProvider > side_effect_provider
Array< ForeachElementComponent > components
void * graph_executor_storage
std::optional< ForeachGeometryElementNodeExecuteWrapper > body_execute_wrapper
const GeoNodesSideEffectNodes * side_effect_nodes
MultiValueMap< std::pair< ComputeContextHash, int32_t >, int > iterations_by_iteration_zone
const ComputeContext * compute_context
const GeoNodesCallData * call_data
LazyFunctionForReduceForeachGeometryElement(const LazyFunctionForForeachGeometryElementZone &parent, ForeachGeometryElementEvalStorage &eval_storage)
void handle_main_items_and_geometry(lf::Params ¶ms, const lf::Context &context) const
void handle_generation_items_group(lf::Params ¶ms, const lf::Context &context, int geometry_item_i, IndexRange generation_items_range) const
void handle_generation_item_groups(lf::Params ¶ms, const lf::Context &context, int first_valid_item_i) const
ForeachGeometryElementEvalStorage & eval_storage_
const LazyFunctionForForeachGeometryElementZone & parent_
void execute_impl(lf::Params ¶ms, const lf::Context &context) const override
bool handle_generation_items_group_lazyness(lf::Params ¶ms, const lf::Context &context, int geometry_item_i, IndexRange generation_items_range) const
void handle_generation_items(lf::Params ¶ms, const lf::Context &context) const
int handle_invalid_generation_items(lf::Params ¶ms) const
ZoneFunctionIndices indices
struct blender::nodes::ZoneFunctionIndices::@342054057300321050315260123310012173322070035365 inputs