Blender V5.3
NOD_geometry_exec.hh
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#pragma once
10
11#include "BLI_color_types.hh"
13
14#include "FN_field.hh"
15#include "FN_lazy_function.hh"
17
21#include "BKE_geometry_set.hh"
22#include "BKE_node_runtime.hh"
28
29#include "DNA_node_types.h"
30
33#include "NOD_menu_value.hh"
34
35namespace blender::nodes {
36
37using bke::AttrDomain;
38using bke::AttributeAccessor;
39using bke::AttributeDomainAndType;
40using bke::AttributeFieldInput;
41using bke::AttributeFilter;
42using bke::AttributeIter;
43using bke::AttributeMetaData;
44using bke::AttributeReader;
45using bke::AttributeWriter;
46using bke::CurveComponent;
47using bke::GAttributeReader;
48using bke::GAttributeWriter;
49using bke::GeometryComponent;
50using bke::GeometryComponentEditData;
51using bke::GeometryNodesReferenceSet;
52using bke::GeometrySet;
53using bke::GreasePencilComponent;
54using bke::GSpanAttributeWriter;
55using bke::InstancesComponent;
56using bke::MeshComponent;
57using bke::MutableAttributeAccessor;
58using bke::PointCloudComponent;
59using bke::SocketValueVariant;
60using bke::SpanAttributeWriter;
61using bke::VolumeComponent;
63using fn::Field;
64using fn::FieldContext;
65using fn::FieldEvaluator;
66using fn::FieldInput;
67using fn::FieldOperation;
68using fn::GField;
69
71 private:
72 const GeometryNodesReferenceSet &set_;
73
74 public:
76
77 Result filter(StringRef attribute_name) const override;
78};
79
81 private:
82 const bNode &node_;
83 lf::Params &params_;
84 const lf::Context &lf_context_;
85 const Span<int> lf_input_for_output_bsocket_usage_;
86 const Span<int> lf_input_for_attribute_propagation_to_output_;
87 const FunctionRef<std::string(int)> get_output_attribute_id_;
88
89 public:
91 lf::Params &params,
92 const lf::Context &lf_context,
93 const Span<int> lf_input_for_output_bsocket_usage,
94 const Span<int> lf_input_for_attribute_propagation_to_output,
95 const FunctionRef<std::string(int)> get_output_attribute_id)
96 : node_(node),
97 params_(params),
98 lf_context_(lf_context),
99 lf_input_for_output_bsocket_usage_(lf_input_for_output_bsocket_usage),
100 lf_input_for_attribute_propagation_to_output_(
101 lf_input_for_attribute_propagation_to_output),
102 get_output_attribute_id_(get_output_attribute_id)
103 {
104 }
105
111 template<typename T> T extract_input(const UString identifier)
112 {
113#ifndef NDEBUG
114 this->check_input_access(identifier);
115#endif
116 const int index = this->get_input_index(identifier);
117 if constexpr (is_GeoNodesMultiInput_v<T>) {
118 using ValueT = typename T::value_type;
119 BLI_assert(node_.input_by_identifier(identifier)->is_multi_input());
120 if constexpr (std::is_same_v<ValueT, SocketValueVariant>) {
121 return params_.extract_input<T>(index);
122 }
123 else {
124 auto values_variants = params_.extract_input<GeoNodesMultiInput<SocketValueVariant>>(
125 index);
127 values.values.reserve(values_variants.values.size());
128 for (const int i : values_variants.values.index_range()) {
129 values.values.append(std::move(values_variants.values[i].ensure_type<ValueT>()));
130 }
131 return values;
132 }
133 }
134 else {
135 SocketValueVariant value_variant = params_.extract_input<SocketValueVariant>(index);
136 if constexpr (std::is_same_v<T, SocketValueVariant>) {
137 return value_variant;
138 }
139 else if constexpr (std::is_enum_v<T>) {
140 return T(value_variant.ensure_type<MenuValue>().value);
141 }
142 else {
143 T value = std::move(value_variant.ensure_type<T>());
144 if constexpr (std::is_same_v<T, GeometrySet>) {
145 this->check_input_geometry_set(identifier, value);
146 }
147 return value;
148 }
149 }
150 }
151
152 void check_input_geometry_set(UString identifier, const GeometrySet &geometry_set) const;
153 void check_output_geometry_set(const GeometrySet &geometry_set) const;
154
158 template<typename T> T get_input(const UString identifier) const
159 {
160#ifndef NDEBUG
161 this->check_input_access(identifier);
162#endif
163 const int index = this->get_input_index(identifier);
164 if constexpr (is_GeoNodesMultiInput_v<T>) {
165 using ValueT = typename T::value_type;
166 BLI_assert(node_.input_by_identifier(identifier)->is_multi_input());
167 if constexpr (std::is_same_v<ValueT, SocketValueVariant>) {
168 return params_.get_input<T>(index);
169 }
170 else {
171 auto values_variants = params_.get_input<GeoNodesMultiInput<SocketValueVariant>>(index);
172 Vector<ValueT> values(values_variants.values.size());
173 for (const int i : values_variants.values.index_range()) {
174 values[i] = values_variants.values[i].ensure_type<ValueT>();
175 }
176 return values;
177 }
178 }
179 else {
180 SocketValueVariant value_variant = params_.get_input<SocketValueVariant>(index);
181 if constexpr (std::is_same_v<T, SocketValueVariant>) {
182 return value_variant;
183 }
184 else if constexpr (std::is_enum_v<T>) {
185 return T(value_variant.ensure_type<MenuValue>().value);
186 }
187 else {
188 T value = value_variant.ensure_type<T>();
189 if constexpr (std::is_same_v<T, GeometrySet>) {
190 this->check_input_geometry_set(identifier, value);
191 }
192 return value;
193 }
194 }
195 }
196
203 {
204 return params_;
205 }
206
210 template<typename T> void set_output(const UString identifier, T &&value)
211 {
212 using StoredT = std::decay_t<T>;
213#ifndef NDEBUG
214 this->check_output_access(identifier);
215#endif
216 if constexpr (std::is_same_v<StoredT, GeometrySet>) {
217 this->check_output_geometry_set(value);
218 }
219 const int index = this->get_output_index(identifier);
220 if constexpr (std::is_same_v<StoredT, SocketValueVariant>) {
221 params_.set_output(index, std::forward<T>(value));
222 }
223 else {
224 params_.set_output(index, SocketValueVariant::from(std::forward<T>(value)));
225 }
226 }
227
232
236 void set_input_unused(const UString identifier)
237 {
238 const int index = this->get_input_index(identifier);
239 params_.set_input_unused(index);
240 }
241
245 bool output_is_required(const UString identifier) const
246 {
247 const int index = this->get_output_index(identifier);
248 return params_.get_output_usage(index) != lf::ValueUsage::Unused;
249 }
250
254 const bNode &node() const
255 {
256 return node_;
257 }
258
259 const Object *self_object() const
260 {
261 if (const auto *data = this->user_data()) {
262 return data->call_data->self_object();
263 }
264 return nullptr;
265 }
266
267 const Depsgraph *depsgraph() const
268 {
269 if (const auto *data = this->user_data()) {
270 if (data->call_data->modifier_data) {
271 return data->call_data->modifier_data->depsgraph;
272 }
273 if (data->call_data->operator_data) {
274 return data->call_data->operator_data->depsgraphs->active;
275 }
276 }
277 return nullptr;
278 }
279
280 Main *bmain() const;
281
283 {
284 return static_cast<GeoNodesUserData *>(lf_context_.user_data);
285 }
286
288 {
289 return static_cast<GeoNodesLocalUserData *>(lf_context_.local_user_data);
290 }
291
296 void error_message_add(const NodeWarningType type, StringRef message) const;
297
299
300 void used_named_attribute(StringRef attribute_name, NamedAttributeUsage usage);
301
306 {
307 const int lf_index =
308 lf_input_for_output_bsocket_usage_[node_.output_by_identifier(UString(output_identifier))
309 ->index_in_all_outputs()];
310 return params_.get_input<bool>(lf_index);
311 }
312
318 const UString output_identifier, const bool force_create = false)
319 {
320 if (!this->anonymous_attribute_output_is_required(output_identifier) && !force_create) {
321 return std::nullopt;
322 }
323 const bNodeSocket &output_socket = *node_.output_by_identifier(UString(output_identifier));
324 return get_output_attribute_id_(output_socket.index());
325 }
326
330 NodeAttributeFilter get_attribute_filter(const UString output_identifier) const
331 {
332 const int lf_index = lf_input_for_attribute_propagation_to_output_
333 [node_.output_by_identifier(UString(output_identifier))->index_in_all_outputs()];
334 const GeometryNodesReferenceSet &set = params_.get_input<GeometryNodesReferenceSet>(lf_index);
335 return NodeAttributeFilter(set);
336 }
337
342 std::optional<std::string> ensure_absolute_path(StringRefNull path) const;
343
344 private:
345 /* Utilities for detecting common errors at when using this class. */
346 void check_input_access(UString identifier) const;
347 void check_output_access(UString identifier) const;
348
349 int get_input_index(const UString identifier) const
350 {
351 int counter = 0;
352 for (const bNodeSocket *socket : node_.input_sockets()) {
353 if (!socket->is_available()) {
354 continue;
355 }
356 if (socket->identifier_ustr() == identifier) {
357 return counter;
358 }
359 counter++;
360 }
362 return -1;
363 }
364
365 int get_output_index(const UString identifier) const
366 {
367 int counter = 0;
368 for (const bNodeSocket *socket : node_.output_sockets()) {
369 if (!socket->is_available()) {
370 continue;
371 }
372 if (socket->identifier == identifier) {
373 return counter;
374 }
375 counter++;
376 }
378 return -1;
379 }
380};
381
382} // namespace blender::nodes
#define BLI_assert_unreachable()
UString()=default
GeoNodesLocalUserData * local_user_data() const
void error_message_add(const NodeWarningType type, StringRef message) const
eval_log::NodeTreeLogger * get_local_tree_logger() const
NodeAttributeFilter get_attribute_filter(const UString output_identifier) const
void check_output_geometry_set(const GeometrySet &geometry_set) const
std::optional< std::string > get_output_anonymous_attribute_id_if_needed(const UString output_identifier, const bool force_create=false)
T extract_input(const UString identifier)
void check_input_geometry_set(UString identifier, const GeometrySet &geometry_set) const
GeoNodeExecParams(const bNode &node, lf::Params &params, const lf::Context &lf_context, const Span< int > lf_input_for_output_bsocket_usage, const Span< int > lf_input_for_attribute_propagation_to_output, const FunctionRef< std::string(int)> get_output_attribute_id)
T get_input(const UString identifier) const
GeoNodesUserData * user_data() const
bool output_is_required(const UString identifier) const
std::optional< std::string > ensure_absolute_path(StringRefNull path) const
void used_named_attribute(StringRef attribute_name, NamedAttributeUsage usage)
const Depsgraph * depsgraph() const
bool anonymous_attribute_output_is_required(const UString output_identifier)
void set_output(const UString identifier, T &&value)
void set_input_unused(const UString identifier)
NodeAttributeFilter(const GeometryNodesReferenceSet &set)
static SocketValueVariant from(T &&value)
#define T
constexpr bool is_GeoNodesMultiInput_v
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
BMesh const char void * data
eval_log::NodeTreeLogger * try_get_tree_logger(const GeoNodesUserData &user_data) const