Blender V5.3
node_geo_scale_elements.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#include "BLI_array.hh"
6#include "BLI_array_utils.hh"
8#include "BLI_math_matrix.hh"
9#include "BLI_task.hh"
10#include "BLI_virtual_array.hh"
11
12#include "DNA_mesh_types.h"
13
15#include "UI_resources.hh"
16
18#include "GEO_mesh_selection.hh"
19
20#include "NOD_rna_define.hh"
21
22#include "node_geometry_util.hh"
23
25
28 "UNIFORM",
29 ICON_NONE,
30 N_("Uniform"),
31 N_("Scale elements by the same factor in every direction")},
33 "SINGLE_AXIS",
34 ICON_NONE,
35 N_("Single Axis"),
36 N_("Scale elements in a single direction")},
37 {0, nullptr, 0, nullptr, nullptr},
38};
39
41{
42 b.use_custom_socket_order();
43 b.allow_any_socket_order();
44 b.add_default_layout();
45 b.add_input<decl::Geometry>("Geometry"_ustr)
46 .supported_type(GeometryComponent::Type::Mesh)
47 .description("Geometry to scale elements of");
48 b.add_output<decl::Geometry>("Geometry"_ustr).propagate_all_geometry().align_with_previous();
49 b.add_input<decl::Bool>("Selection"_ustr)
50 .default_value(true)
51 .hide_value()
52 .evaluated_geometry_field();
53
54 b.add_input<decl::Float>("Scale"_ustr, "Scale"_ustr)
55 .default_value(1.0f)
56 .min(0.0f)
57 .evaluated_geometry_field();
58 b.add_input<decl::Vector>("Center"_ustr)
59 .subtype(PROP_TRANSLATION)
60 .evaluated_geometry_field()
62 .description(
63 "Origin of the scaling for each element. If multiple elements are connected, their "
64 "center is averaged");
65 b.add_input<decl::Menu>("Scale Mode"_ustr)
66 .static_items(scale_mode_items)
68 .optional_label();
69 b.add_input<decl::Vector>("Axis"_ustr)
70 .default_value({1.0f, 0.0f, 0.0f})
71 .evaluated_geometry_field()
72 .description("Direction in which to scale the element")
73 .usage_by_single_menu(GEO_NODE_SCALE_ELEMENTS_SINGLE_AXIS);
74};
75
76static void node_layout(ui::Layout &layout, bContext * /*C*/, PointerRNA *ptr)
77{
78 layout.prop(ptr, "domain", UI_ITEM_NONE, "", ICON_NONE);
79}
80
81static void node_init(bNodeTree * /*tree*/, bNode *node)
82{
83 node->custom1 = int16_t(AttrDomain::Face);
84}
85
86template<typename T> static T gather_mean(const VArray<T> &values, const Span<int> indices)
87{
88 BLI_assert(!indices.is_empty());
89 using MeanAccumulator = std::pair<T, int>;
90 const auto join_accumulators = [](const MeanAccumulator a,
91 const MeanAccumulator b) -> MeanAccumulator {
92 return {(a.first + b.first) / (a.second + b.second), 1};
93 };
94
95 T value;
96 devirtualize_varray(values, [&](const auto values) {
98 indices.index_range(),
99 2048,
100 MeanAccumulator(T(), 0),
101 [&](const IndexRange range, MeanAccumulator other) -> MeanAccumulator {
102 T value(0);
103 for (const int i : indices.slice(range)) {
104 value += values[i];
105 }
106 return join_accumulators({value, int(range.size())}, other);
107 },
108 join_accumulators);
109 value = accumulator.first / accumulator.second;
110 });
111 return value;
112}
113
114template<typename T>
115static void gather_means(const VArray<T> &values, GroupedSpan<int> groups, MutableSpan<T> means)
116{
117 threading::parallel_for(groups.index_range(), 512, [&](const IndexRange range) {
118 for (const int group : range) {
119 means[group] = gather_mean<T>(values, groups[group]);
120 }
121 });
122}
123
124template<typename T> static Array<T> gather_means(const VArray<T> &values, GroupedSpan<int> groups)
125{
126 if (const std::optional<T> value = values.get_if_single()) {
127 return Array<T>(groups.size(), *value);
128 }
129 Array<T> means(groups.size());
130 /* NOTE: This could also be implemented with #attribute_math::mix_groups if #values is a span and
131 * all the group sizes are below the grain size. */
132 gather_means<T>(values, groups, means);
133 return means;
134}
135
137 const float3 &center,
138 const float scale)
139{
140 const float3 diff = position - center;
141 const float3 scaled_diff = scale * diff;
142 const float3 new_position = center + scaled_diff;
143 return new_position;
144}
145
146static void scale_uniformly(const GroupedSpan<int> elem_islands,
147 const GroupedSpan<int> vert_islands,
148 const VArray<float> &scale_varray,
149 const VArray<float3> &center_varray,
150 Mesh &mesh)
151{
152 const Array<float> scales = gather_means(scale_varray, elem_islands);
153 const Array<float3> centers = gather_means(center_varray, elem_islands);
154 MutableSpan<float3> positions = mesh.vert_positions_for_write();
156 elem_islands.index_range(),
157 512,
158 [&](const IndexRange range) {
159 for (const int island_index : range) {
160 const Span<int> vert_island = vert_islands[island_index];
161 const float scale = scales[island_index];
162 const float3 center = centers[island_index];
163 threading::parallel_for(vert_island.index_range(), 2048, [&](const IndexRange range) {
164 for (const int vert_i : vert_island.slice(range)) {
165 positions[vert_i] = transform_with_uniform_scale(positions[vert_i], center, scale);
166 }
167 });
168 }
169 },
171 return elem_islands.offsets[range].size() + vert_islands.offsets[range].size();
172 }));
173}
174
176 const float3 &axis,
177 const float scale)
178{
179 /* Scale along x axis. The other axis need to be orthogonal, but their specific value does not
180 * matter. */
181 const float3 x_axis = math::normalize(axis);
182 float3 y_axis = math::cross(x_axis, float3(0.0f, 0.0f, 1.0f));
183 if (math::is_zero(y_axis)) {
184 y_axis = math::cross(x_axis, float3(0.0f, 1.0f, 0.0f));
185 }
186 y_axis = math::normalize(y_axis);
187 const float3 z_axis = math::cross(x_axis, y_axis);
188
190
191 /* Move scaling center to the origin. */
192 transform.location() -= center;
193
194 /* `base_change` and `base_change_inv` are used to rotate space so that scaling along the
195 * provided axis is the same as scaling along the x axis. */
196 float4x4 base_change = float4x4::identity();
197 base_change.x_axis() = x_axis;
198 base_change.y_axis() = y_axis;
199 base_change.z_axis() = z_axis;
200
201 /* Can invert by transposing, because the matrix is orthonormal. */
202 float4x4 base_change_inv = math::transpose(base_change);
203
204 float4x4 scale_transform = float4x4::identity();
205 scale_transform[0][0] = scale;
206
207 transform = base_change * scale_transform * base_change_inv * transform;
208
209 /* Move scaling center back to where it was. */
210 transform.location() += center;
211
212 return transform;
213}
214
215static void scale_on_axis(const GroupedSpan<int> elem_islands,
216 const GroupedSpan<int> vert_islands,
217 const VArray<float> &scale_varray,
218 const VArray<float3> &center_varray,
219 const VArray<float3> &axis_varray,
220 Mesh &mesh)
221{
222 const Array<float> scales = gather_means(scale_varray, elem_islands);
223 const Array<float3> centers = gather_means(center_varray, elem_islands);
224 const Array<float3> axes = gather_means(axis_varray, elem_islands);
225 MutableSpan<float3> positions = mesh.vert_positions_for_write();
227 elem_islands.index_range(),
228 512,
229 [&](const IndexRange range) {
230 for (const int island_index : range) {
231 const Span<int> vert_island = vert_islands[island_index];
232 const float scale = scales[island_index];
233 const float3 center = centers[island_index];
234 const float3 axis = axes[island_index];
235 const float3 fixed_axis = math::is_zero(axis) ? float3(1.0f, 0.0f, 0.0f) : axis;
236 const float4x4 transform = create_single_axis_transform(center, fixed_axis, scale);
237 threading::parallel_for(vert_island.index_range(), 2048, [&](const IndexRange range) {
238 for (const int vert_i : vert_island.slice(range)) {
239 positions[vert_i] = math::transform_point(transform, positions[vert_i]);
240 }
241 });
242 }
243 },
245 return vert_islands.offsets[range].size() + elem_islands.offsets[range].size();
246 }));
247}
248
250 const IndexMask &face_mask,
251 const IndexMask &vert_mask,
252 MutableSpan<int> face_island_indices,
253 MutableSpan<int> vert_island_indices)
254{
255 Array<int> verts_pos(vert_mask.min_array_size());
256 index_mask::build_reverse_map<int>(vert_mask, verts_pos);
257
258 AtomicDisjointSet disjoint_set(vert_mask.size());
259 const GroupedSpan<int> face_verts(mesh.faces(), mesh.corner_verts());
260
261 face_mask.foreach_index_optimized<int>(
262 [&](const int face_i) {
263 const Span<int> verts = face_verts[face_i];
264 const int v1 = verts_pos[verts.first()];
265 for (const int vert_i : verts.drop_front(1)) {
266 const int v2 = verts_pos[vert_i];
267 disjoint_set.join(v1, v2);
268 }
269 },
271
272 disjoint_set.calc_reduced_ids(vert_island_indices);
273
274 face_mask.foreach_index(
275 [&](const int face_i, const int face_pos) {
276 const int face_vert_i = face_verts[face_i].first();
277 const int vert_pos = verts_pos[face_vert_i];
278 const int vert_island = vert_island_indices[vert_pos];
279 face_island_indices[face_pos] = vert_island;
280 },
282
283 return disjoint_set.count_sets();
284}
285
286static void gather_face_islands(const Mesh &mesh,
287 const IndexMask &face_mask,
288 Array<int> &r_item_offsets,
289 Array<int> &r_item_indices,
290 Array<int> &r_vert_offsets,
291 Array<int> &r_vert_indices)
292{
293 IndexMaskMemory memory;
295 mesh.face_offsets(), face_mask, mesh.corner_verts(), mesh.verts_num, memory);
296
297 Array<int> face_island_indices(face_mask.size());
298 Array<int> vert_island_indices(vert_mask.size());
299 const int total_islands = face_to_vert_islands(
300 mesh, face_mask, vert_mask, face_island_indices, vert_island_indices);
301
302 /* Group gathered vertices and faces. */
304 vert_island_indices, total_islands, r_vert_offsets, r_vert_indices);
306 face_island_indices, total_islands, r_item_offsets, r_item_indices);
307
308 /* If result indices is for gathered array, map than back into global indices. */
309 if (face_mask.size() != mesh.faces_num) {
310 Array<int> face_mask_map(face_mask.size());
311 face_mask.to_indices<int>(face_mask_map);
313 face_mask_map.as_span(), r_item_indices.as_span(), r_item_indices.as_mutable_span());
314 }
315 if (vert_mask.size() != mesh.verts_num) {
316 Array<int> vert_mask_map(vert_mask.size());
317 vert_mask.to_indices<int>(vert_mask_map);
319 vert_mask_map.as_span(), r_vert_indices.as_span(), r_vert_indices.as_mutable_span());
320 }
321}
322
324 const IndexMask &edge_mask,
325 const IndexMask &vert_mask,
326 MutableSpan<int> edge_island_indices,
327 MutableSpan<int> vert_island_indices)
328{
329 Array<int> verts_pos(vert_mask.min_array_size());
330 index_mask::build_reverse_map<int>(vert_mask, verts_pos);
331
332 AtomicDisjointSet disjoint_set(vert_mask.size());
333 const Span<int2> edges = mesh.edges();
334
335 edge_mask.foreach_index_optimized<int>(
336 [&](const int edge_i) {
337 const int2 edge = edges[edge_i];
338 const int v1 = verts_pos[edge[0]];
339 const int v2 = verts_pos[edge[1]];
340 disjoint_set.join(v1, v2);
341 },
343
344 disjoint_set.calc_reduced_ids(vert_island_indices);
345
346 edge_mask.foreach_index(
347 [&](const int edge_i, const int edge_pos) {
348 const int2 edge = edges[edge_i];
349 const int edge_vert_i = edge[0];
350 const int vert_pos = verts_pos[edge_vert_i];
351 const int vert_island = vert_island_indices[vert_pos];
352 edge_island_indices[edge_pos] = vert_island;
353 },
355
356 return disjoint_set.count_sets();
357}
358
359static void gather_edge_islands(const Mesh &mesh,
360 const IndexMask &edge_mask,
361 Array<int> &r_item_offsets,
362 Array<int> &r_item_indices,
363 Array<int> &r_vert_offsets,
364 Array<int> &r_vert_indices)
365{
366 IndexMaskMemory memory;
368 mesh.edges(), edge_mask, mesh.verts_num, memory);
369
370 Array<int> edge_island_indices(edge_mask.size());
371 Array<int> vert_island_indices(vert_mask.size());
372 const int total_islands = edge_to_vert_islands(
373 mesh, edge_mask, vert_mask, edge_island_indices, vert_island_indices);
374
375 /* Group gathered vertices and edges. */
377 vert_island_indices, total_islands, r_vert_offsets, r_vert_indices);
379 edge_island_indices, total_islands, r_item_offsets, r_item_indices);
380
381 /* If result indices is for gathered array, map than back into global indices. */
382 if (edge_mask.size() != mesh.edges_num) {
383 Array<int> edge_mask_map(edge_mask.size());
384 edge_mask.to_indices<int>(edge_mask_map);
386 edge_mask_map.as_span(), r_item_indices.as_span(), r_item_indices.as_mutable_span());
387 }
388 if (vert_mask.size() != mesh.verts_num) {
389 Array<int> vert_mask_map(vert_mask.size());
390 vert_mask.to_indices<int>(vert_mask_map);
392 vert_mask_map.as_span(), r_vert_indices.as_span(), r_vert_indices.as_mutable_span());
393 }
394}
395
397{
398 const bNode &node = params.node();
399 const AttrDomain domain = AttrDomain(node.custom1);
400 const auto scale_mode = params.get_input<GeometryNodeScaleElementsMode>("Scale Mode"_ustr);
401
402 GeometrySet geometry = params.extract_input<GeometrySet>("Geometry"_ustr);
403
404 const Field<bool> selection_field = params.extract_input<Field<bool>>("Selection"_ustr);
405 const Field<float> scale_field = params.extract_input<Field<float>>("Scale"_ustr);
406 const Field<float3> center_field = params.extract_input<Field<float3>>("Center"_ustr);
407
409 if (Mesh *mesh = geometry.get_mesh_for_write()) {
410 const bke::MeshFieldContext context{*mesh, domain};
411 FieldEvaluator evaluator{context, mesh->attributes().domain_size(domain)};
412 evaluator.set_selection(selection_field);
413 evaluator.add(scale_field);
414 evaluator.add(center_field);
415 if (scale_mode == GEO_NODE_SCALE_ELEMENTS_SINGLE_AXIS) {
416 evaluator.add(params.get_input<Field<float3>>("Axis"_ustr));
417 }
418 evaluator.evaluate();
420 if (mask.is_empty()) {
421 return;
422 }
423
424 Array<int> item_offsets;
425 Array<int> item_indices;
426
427 Array<int> vert_offsets;
428 Array<int> vert_indices;
429
430 switch (domain) {
431 case AttrDomain::Face:
432 gather_face_islands(*mesh, mask, item_offsets, item_indices, vert_offsets, vert_indices);
433 break;
434 case AttrDomain::Edge:
435 gather_edge_islands(*mesh, mask, item_offsets, item_indices, vert_offsets, vert_indices);
436 break;
437 default:
439 }
440
441 const GroupedSpan<int> item_islands(item_offsets.as_span(), item_indices);
442 const GroupedSpan<int> vert_islands(vert_offsets.as_span(), vert_indices);
443
444 const VArray<float> scale_varray = evaluator.get_evaluated<float>(0);
445 const VArray<float3> center_varray = evaluator.get_evaluated<float3>(1);
446
447 switch (scale_mode) {
449 scale_uniformly(item_islands, vert_islands, scale_varray, center_varray, *mesh);
450 break;
452 const VArray<float3> axis_varray = evaluator.get_evaluated<float3>(2);
454 item_islands, vert_islands, scale_varray, center_varray, axis_varray, *mesh);
455 break;
456 }
457 }
458 mesh->tag_positions_changed();
459 }
460 });
461
462 params.set_output("Geometry"_ustr, std::move(geometry));
463}
464
465static void node_rna(StructRNA *srna)
466{
467 static const EnumPropertyItem domain_items[] = {
468 {int(AttrDomain::Face),
469 "FACE",
470 ICON_NONE,
471 "Face",
472 "Scale individual faces or neighboring face islands"},
473 {int(AttrDomain::Edge),
474 "EDGE",
475 ICON_NONE,
476 "Edge",
477 "Scale individual edges or neighboring edge islands"},
478 {0, nullptr, 0, nullptr, nullptr},
479 };
480
482 "domain",
483 "Domain",
484 "Element type to transform",
485 domain_items,
487 int(AttrDomain::Face));
488}
489
490static void node_register()
491{
492 static bke::bNodeType ntype;
493
494 geo_node_type_base(&ntype, "GeometryNodeScaleElements"_ustr, GEO_NODE_SCALE_ELEMENTS);
495 ntype.ui_name = "Scale Elements";
496 ntype.ui_description = "Scale groups of connected edges and faces";
497 ntype.enum_name_legacy = "SCALE_ELEMENTS";
500 ntype.declare = node_declare;
502 ntype.initfunc = node_init;
504
505 node_rna(ntype.rna_ext.srna);
506}
507NOD_REGISTER_NODE(node_register)
508
509} // namespace blender::nodes::node_geo_scale_elements_cc
#define NODE_CLASS_GEOMETRY
Definition BKE_node.hh:492
#define GEO_NODE_SCALE_ELEMENTS
#define NOD_REGISTER_NODE(REGISTER_FUNC)
#define NOD_inline_enum_accessors(member)
#define UI_ITEM_NONE
#define BLI_assert_unreachable()
Span< T > as_span() const
Definition BLI_array.hh:254
MutableSpan< T > as_mutable_span()
Definition BLI_array.hh:259
int calc_reduced_ids(MutableSpan< int > result) const
constexpr int64_t size() const
constexpr Span drop_front(int64_t n) const
Definition BLI_span.hh:175
constexpr Span slice(int64_t start, int64_t size) const
Definition BLI_span.hh:141
constexpr const T & first() const
Definition BLI_span.hh:319
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
constexpr bool is_empty() const
Definition BLI_span.hh:264
std::optional< T > get_if_single() const
void set_selection(Field< bool > selection)
int add(GField field, GVArray *varray_ptr)
IndexMask get_evaluated_selection_as_mask() const
const GVArray & get_evaluated(const int field_index) const
void foreach_index_optimized(Fn &&fn, Mode mode=exec_mode::serial) const
void to_indices(MutableSpan< T > r_indices) const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
T extract_input(const UString identifier)
T get_input(const UString identifier) const
void set_output(const UString identifier, T &&value)
IMETHOD Vector diff(const Vector &a, const Vector &b, double dt)
Definition frames.inl:1166
#define position
float3x3 scale(float3x3 mat, float2 scale)
#define T
void gather(const GVArray &src, const IndexMask &indices, GMutableSpan dst, exec_mode::Mode mode=exec_mode::parallel)
void node_register_type(bNodeType &ntype)
Definition node.cc:2920
constexpr ParallelGrainSize grain_size(int grain_size)
void foreach_real_geometry(bke::GeometrySet &geometry, FunctionRef< void(bke::GeometrySet &geometry_set)> fn)
IndexMask vert_selection_from_face(OffsetIndices< int > faces, const IndexMask &face_mask, Span< int > corner_verts, int verts_num, IndexMaskMemory &memory)
IndexMask vert_selection_from_edge(Span< int2 > edges, const IndexMask &edge_mask, int verts_num, IndexMaskMemory &memory)
void build_reverse_map(const IndexMask &mask, MutableSpan< T > r_map)
Definition index_mask.cc:36
MatBase< T, NumCol, NumRow > transpose(const MatBase< T, NumRow, NumCol > &mat)
bool is_zero(const T &a)
AxisSigned cross(const AxisSigned a, const AxisSigned b)
MatBase< T, NumCol, NumRow > normalize(const MatBase< T, NumCol, NumRow > &a)
static int face_to_vert_islands(const Mesh &mesh, const IndexMask &face_mask, const IndexMask &vert_mask, MutableSpan< int > face_island_indices, MutableSpan< int > vert_island_indices)
static float3 transform_with_uniform_scale(const float3 &position, const float3 &center, const float scale)
static T gather_mean(const VArray< T > &values, const Span< int > indices)
static int edge_to_vert_islands(const Mesh &mesh, const IndexMask &edge_mask, const IndexMask &vert_mask, MutableSpan< int > edge_island_indices, MutableSpan< int > vert_island_indices)
static void node_declare(NodeDeclarationBuilder &b)
static void node_init(bNodeTree *, bNode *node)
static void scale_on_axis(const GroupedSpan< int > elem_islands, const GroupedSpan< int > vert_islands, const VArray< float > &scale_varray, const VArray< float3 > &center_varray, const VArray< float3 > &axis_varray, Mesh &mesh)
static void gather_edge_islands(const Mesh &mesh, const IndexMask &edge_mask, Array< int > &r_item_offsets, Array< int > &r_item_indices, Array< int > &r_vert_offsets, Array< int > &r_vert_indices)
static void gather_face_islands(const Mesh &mesh, const IndexMask &face_mask, Array< int > &r_item_offsets, Array< int > &r_item_indices, Array< int > &r_vert_offsets, Array< int > &r_vert_indices)
static float4x4 create_single_axis_transform(const float3 &center, const float3 &axis, const float scale)
static void node_geo_exec(GeoNodeExecParams params)
static void gather_means(const VArray< T > &values, GroupedSpan< int > groups, MutableSpan< T > means)
static void node_layout(ui::Layout &layout, bContext *, PointerRNA *ptr)
static void scale_uniformly(const GroupedSpan< int > elem_islands, const GroupedSpan< int > vert_islands, const VArray< float > &scale_varray, const VArray< float3 > &center_varray, Mesh &mesh)
PropertyRNA * RNA_def_node_enum(StructRNA *srna, const char *identifier, const char *ui_name, const char *ui_description, const EnumPropertyItem *static_items, const EnumRNAAccessors accessors, std::optional< int > default_value, const EnumPropertyItemFunc item_func, const bool allow_animation)
GroupedSpan< int > build_groups_from_indices(Span< int > indices, int groups_num, Array< int > &offset_data, Array< int > &index_data)
Value parallel_deterministic_reduce(IndexRange range, int64_t grain_size, const Value &identity, const Function &function, const Reduction &reduction)
Definition BLI_task.hh:170
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
Definition BLI_task.hh:69
auto accumulated_task_sizes(Fn &&fn)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void devirtualize_varray(const VArray< T > &varray, const Func &func, bool enable=true)
MatBase< float, 4, 4 > float4x4
VecBase< int32_t, 2 > int2
ATTR_WARN_UNUSED_RESULT const BMVert * v2
GeometryNodeScaleElementsMode
@ GEO_NODE_SCALE_ELEMENTS_UNIFORM
@ GEO_NODE_SCALE_ELEMENTS_SINGLE_AXIS
VecBase< float, 3 > float3
@ PROP_TRANSLATION
Definition RNA_types.hh:318
void geo_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
signed short int16_t
Definition BKE_text.h:77
Defines a node type.
Definition BKE_node.hh:265
void(*) draw_buttons(ui::Layout &, bContext *C, PointerRNA *ptr)
Definition BKE_node.hh:290
std::string ui_description
Definition BKE_node.hh:271
NodeGeometryExecFunction geometry_node_execute
Definition BKE_node.hh:385
void(*) initfunc(bNodeTree *ntree, bNode *node)
Definition BKE_node.hh:320
const char * enum_name_legacy
Definition BKE_node.hh:274
NodeDeclareFunction declare
Definition BKE_node.hh:393
void prop(PointerRNA *ptr, PropertyRNA *prop, int index, int value, eUI_Item_Flag flag, std::optional< StringRef > name_opt, int icon, std::optional< StringRef > placeholder=std::nullopt)
#define N_(msgid)