Blender V5.3
MOD_grease_pencil_offset.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2024 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "BLI_hash_c.hh"
10#include "BLI_math_matrix.hh"
11#include "BLI_rand_c.hh"
12
13#include "DNA_modifier_types.h"
14
15#include "BKE_curves.hh"
16#include "BKE_geometry_set.hh"
17#include "BKE_grease_pencil.hh"
18#include "BKE_material.hh"
19#include "BKE_modifier.hh"
20#include "BKE_screen.hh"
21
22#include "BLO_read_write.hh"
23
25#include "UI_resources.hh"
26
27#include "BLT_translation.hh"
28
29#include "WM_types.hh"
30
31#include "RNA_access.hh"
32#include "RNA_prototypes.hh"
33
35#include "MOD_modifiertypes.hh"
36#include "MOD_ui_common.hh"
37
38namespace blender {
39
40static void init_data(ModifierData *md)
41{
42 auto *omd = reinterpret_cast<GreasePencilOffsetModifierData *>(md);
44 modifier::greasepencil::init_influence_data(&omd->influence, false);
45}
46
47static void copy_data(const ModifierData *md, ModifierData *target, const int flag)
48{
49 const auto *omd = reinterpret_cast<const GreasePencilOffsetModifierData *>(md);
50 auto *tomd = reinterpret_cast<GreasePencilOffsetModifierData *>(target);
51
53
54 BKE_modifier_copydata_generic(md, target, flag);
55 modifier::greasepencil::copy_influence_data(&omd->influence, &tomd->influence, flag);
56}
57
58static void free_data(ModifierData *md)
59{
60 auto *omd = reinterpret_cast<GreasePencilOffsetModifierData *>(md);
62}
63
64static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
65{
66 auto *omd = reinterpret_cast<GreasePencilOffsetModifierData *>(md);
67 modifier::greasepencil::foreach_influence_ID_link(&omd->influence, ob, walk, user_data);
68}
69
71{
73 ctx->node, ctx->object, DEG_OB_COMP_TRANSFORM, "Grease Pencil Offset Modifier");
74}
75
77 const VArray<float> &weights,
78 const IndexRange &points,
79 const float3 &loc_factor,
80 const float3 &rot_factor,
81 const float3 &scale_factor,
82 const MutableSpan<float3> positions,
83 const MutableSpan<float> radii)
84{
85 const bool has_global_offset = !(math::is_zero(float3(omd.loc)) &&
86 math::is_zero(float3(omd.rot)) &&
88 const bool has_stroke_offset = !(math::is_zero(float3(omd.stroke_loc)) &&
91
92 for (const int64_t i : points) {
93 const float weight = weights[i];
94 float3 &pos = positions[i];
95 float &radius = radii[i];
96
97 /* Add per-stroke offset. */
98 if (has_stroke_offset) {
100 omd.stroke_loc * loc_factor * weight,
101 omd.stroke_rot * rot_factor * weight,
102 float3(1.0f) + omd.stroke_scale * scale_factor * weight);
103 pos = math::transform_point(matrix, pos);
104 }
105 /* Add global offset. */
106 if (has_global_offset) {
107 const float3 scale = float3(1.0f) + float3(omd.scale) * weight;
109 float3(omd.loc) * weight, float3(omd.rot) * weight, scale);
110 pos = math::transform_point(matrix, pos);
111
112 /* Apply scale to thickness. */
113 const float unit_scale = (math::abs(scale.x) + math::abs(scale.y) + math::abs(scale.z)) /
114 3.0f;
115 radius *= unit_scale;
116 }
117 }
118}
119
121static void modify_stroke_random(const Object &ob,
123 const IndexMask &curves_mask,
125{
126 const bool use_uniform_scale = (omd.flag & MOD_GREASE_PENCIL_OFFSET_UNIFORM_RANDOM_SCALE);
127
128 const OffsetIndices<int> points_by_curve = curves.points_by_curve();
129 bke::MutableAttributeAccessor attributes = curves.attributes_for_write();
131 "radius", bke::AttrDomain::Point);
132 const MutableSpan<float3> positions = curves.positions_for_write();
134 curves, omd.influence);
135
136 /* Make sure different modifiers get different seeds. */
137 const int seed = omd.seed + BLI_hash_string(ob.id.name + 2) + BLI_hash_string(omd.modifier.name);
138 const float rand_offset = BLI_hash_int_01(seed);
139
140 /* Generates a random number for loc/rot/scale channels, based on seed and a per-stroke random
141 * value r. */
142 auto get_random_channel = [&](const char channel, const double r) {
143 float rand = fmodf(r * 2.0f - 1.0f + rand_offset, 1.0f);
144 return fmodf(sin(rand * 12.9898f + channel * 78.233f) * 43758.5453f, 1.0f);
145 };
146
147 auto get_random_value = [&](const char channel, const int64_t curve_i) {
148 const uint halton_primes[3] = {2, 3, 7};
149 double halton_offset[3] = {0.0f, 0.0f, 0.0f};
150 double r[3];
151 /* To ensure a nice distribution, we use halton sequence and offset using the curve index. */
152 BLI_halton_3d(halton_primes, halton_offset, curve_i, r);
153 return get_random_channel(channel, r[0]);
154 };
155
156 auto get_random_vector = [&](const char channel, const int64_t curve_i) {
157 const uint halton_primes[3] = {2, 3, 7};
158 double halton_offset[3] = {0.0f, 0.0f, 0.0f};
159 double r[3];
160 /* To ensure a nice distribution, we use halton sequence and offset using the curve index. */
161 BLI_halton_3d(halton_primes, halton_offset, curve_i, r);
162 return float3(get_random_channel(channel, r[0]),
163 get_random_channel(channel, r[1]),
164 get_random_channel(channel, r[2]));
165 };
166
167 curves_mask.foreach_index(
168 [&](const int64_t curve_i) {
169 const IndexRange points = points_by_curve[curve_i];
170
171 /* Randomness factors for loc/rot/scale per curve. */
172 const float3 loc_factor = get_random_vector(0, curve_i);
173 const float3 rot_factor = get_random_vector(1, curve_i);
174 const float3 scale_factor = use_uniform_scale ? float3(get_random_value(2, curve_i)) :
175 get_random_vector(2, curve_i);
176
178 vgroup_weights,
179 points,
180 loc_factor,
181 rot_factor,
182 scale_factor,
183 positions,
184 radii.span);
185 },
187
188 radii.finish();
189}
190
191/* This is a very weird/broken formula, but kept for compatibility. */
193 const int size,
194 const int index)
195{
196 const int step = max_ii(omd.stroke_step, 1);
197 const int start_offset = omd.stroke_start_offset;
198 return ((size - (index / step + start_offset % size) % size * step % size) - 1) / float(size);
199}
200
203 const IndexMask &curves_mask,
205{
206 const OffsetIndices<int> points_by_curve = curves.points_by_curve();
207 bke::MutableAttributeAccessor attributes = curves.attributes_for_write();
209 "radius", bke::AttrDomain::Point);
210 const MutableSpan<float3> positions = curves.positions_for_write();
212 curves, omd.influence);
213
214 curves_mask.foreach_index(
215 [&](const int64_t curve_i) {
216 const IndexRange points = points_by_curve[curve_i];
217 const float factor = get_factor_from_index(omd, curves.curves_num(), curve_i);
219 vgroup_weights,
220 points,
221 float3(factor),
222 float3(factor),
223 float3(factor),
224 positions,
225 radii.span);
226 },
228
229 radii.finish();
230}
231
233static void modify_stroke_by_material(const Object &ob,
235 const IndexMask &curves_mask,
237{
238 const short *totcolp = BKE_object_material_len_p(const_cast<Object *>(&ob));
239 const short totcol = totcolp ? *totcolp : 0;
240
241 const OffsetIndices<int> points_by_curve = curves.points_by_curve();
242 bke::MutableAttributeAccessor attributes = curves.attributes_for_write();
244 "radius", bke::AttrDomain::Point);
245 const MutableSpan<float3> positions = curves.positions_for_write();
247 curves, omd.influence);
248 const VArray<int> stroke_materials = *attributes.lookup_or_default<int>(
249 "material_index", bke::AttrDomain::Curve, 0);
250
251 curves_mask.foreach_index(
252 [&](const int64_t curve_i) {
253 const IndexRange points = points_by_curve[curve_i];
254 const float factor = get_factor_from_index(omd, totcol, stroke_materials[curve_i]);
256 vgroup_weights,
257 points,
258 float3(factor),
259 float3(factor),
260 float3(factor),
261 positions,
262 radii.span);
263 },
265
266 radii.finish();
267}
268
271 const int layer_index,
272 const int layers_num,
273 const IndexMask &curves_mask,
275{
276 const OffsetIndices<int> points_by_curve = curves.points_by_curve();
277 bke::MutableAttributeAccessor attributes = curves.attributes_for_write();
279 "radius", bke::AttrDomain::Point);
280 const MutableSpan<float3> positions = curves.positions_for_write();
282 curves, omd.influence);
283
284 const float factor = get_factor_from_index(omd, layers_num, layer_index);
285
286 curves_mask.foreach_index(
287 [&](const int64_t curve_i) {
288 const IndexRange points = points_by_curve[curve_i];
290 vgroup_weights,
291 points,
292 float3(factor),
293 float3(factor),
294 float3(factor),
295 positions,
296 radii.span);
297 },
299
300 radii.finish();
301}
302
303static void modify_drawing(const ModifierData &md,
304 const ModifierEvalContext &ctx,
306{
307 const auto &omd = reinterpret_cast<const GreasePencilOffsetModifierData &>(md);
308
310
312 IndexMaskMemory mask_memory;
314 ctx.object, curves, omd.influence, mask_memory);
315
316 switch (omd.offset_mode) {
318 modify_stroke_random(*ctx.object, omd, curves_mask, curves);
319 break;
321 modify_stroke_by_material(*ctx.object, omd, curves_mask, curves);
322 break;
324 modify_stroke_by_index(omd, curves_mask, curves);
325 break;
328 break;
329 }
330
331 drawing.tag_positions_changed();
332}
333
335 const ModifierEvalContext &ctx,
337 int layer_index,
338 int layers_num)
339{
340 const auto &omd = reinterpret_cast<const GreasePencilOffsetModifierData &>(md);
341
343 IndexMaskMemory mask_memory;
345 ctx.object, curves, omd.influence, mask_memory);
346
347 switch (omd.offset_mode) {
349 modify_stroke_by_layer(omd, layer_index, layers_num, curves_mask, curves);
350 break;
355 break;
356 }
357}
358
360 const ModifierEvalContext *ctx,
361 bke::GeometrySet *geometry_set)
362{
365
366 auto *omd = reinterpret_cast<GreasePencilOffsetModifierData *>(md);
367
368 if (!geometry_set->has_grease_pencil()) {
369 return;
370 }
372 const int frame = grease_pencil.runtime->eval_frame;
373
374 IndexMaskMemory mask_memory;
376 grease_pencil, omd->influence, mask_memory);
377
378 if (omd->offset_mode == MOD_GREASE_PENCIL_OFFSET_LAYER) {
380 grease_pencil, layer_mask, frame);
381 threading::parallel_for_each(drawings, [&](const LayerDrawingInfo &info) {
383 *md, *ctx, *info.drawing, info.layer_index, grease_pencil.layers().size());
384 });
385 }
386 else {
388 grease_pencil, layer_mask, frame);
390 [&](Drawing *drawing) { modify_drawing(*md, *ctx, *drawing); });
391 }
392}
393
394static void panel_draw(const bContext *C, Panel *panel)
395{
396 ui::Layout &layout = *panel->layout;
397
398 PointerRNA ob_ptr;
400 const auto offset_mode = GreasePencilOffsetModifierMode(RNA_enum_get(ptr, "offset_mode"));
401
402 layout.use_property_split_set(true);
403 if (ui::Layout *general_panel = layout.panel_prop(
404 C, ptr, "open_general_panel", IFACE_("General")))
405 {
406 general_panel->use_property_split_set(true);
407 general_panel->prop(ptr, "location", UI_ITEM_NONE, std::nullopt, ICON_NONE);
408 general_panel->prop(ptr, "rotation", UI_ITEM_NONE, std::nullopt, ICON_NONE);
409 general_panel->prop(ptr, "scale", UI_ITEM_NONE, std::nullopt, ICON_NONE);
410 }
411
413 panel, "advanced", true);
414 PointerRNA advanced_state_ptr = RNA_pointer_create_discrete(
415 nullptr, RNA_LayoutPanelState, advanced_panel_state);
416 if (ui::Layout *advanced_panel = layout.panel_prop(
417 C, &advanced_state_ptr, "is_open", IFACE_("Advanced")))
418 {
419 advanced_panel->prop(ptr, "offset_mode", UI_ITEM_NONE, std::nullopt, ICON_NONE);
420
421 advanced_panel->prop(ptr, "stroke_location", UI_ITEM_NONE, IFACE_("Offset"), ICON_NONE);
422 advanced_panel->prop(ptr, "stroke_rotation", UI_ITEM_NONE, IFACE_("Rotation"), ICON_NONE);
423 advanced_panel->prop(ptr, "stroke_scale", UI_ITEM_NONE, IFACE_("Scale"), ICON_NONE);
424
425 ui::Layout &col = advanced_panel->column(true);
426 switch (offset_mode) {
428 advanced_panel->prop(
429 ptr, "use_uniform_random_scale", UI_ITEM_NONE, std::nullopt, ICON_NONE);
430 advanced_panel->prop(ptr, "seed", UI_ITEM_NONE, std::nullopt, ICON_NONE);
431 break;
433 col.prop(ptr, "stroke_step", UI_ITEM_NONE, IFACE_("Stroke Step"), ICON_NONE);
434 col.prop(ptr, "stroke_start_offset", UI_ITEM_NONE, IFACE_("Offset"), ICON_NONE);
435 break;
437 col.prop(ptr, "stroke_step", UI_ITEM_NONE, IFACE_("Material Step"), ICON_NONE);
438 col.prop(ptr, "stroke_start_offset", UI_ITEM_NONE, IFACE_("Offset"), ICON_NONE);
439 break;
441 col.prop(ptr, "stroke_step", UI_ITEM_NONE, IFACE_("Layer Step"), ICON_NONE);
442 col.prop(ptr, "stroke_start_offset", UI_ITEM_NONE, IFACE_("Offset"), ICON_NONE);
443 break;
444 }
445 }
446
447 if (ui::Layout *influence_panel = layout.panel_prop(
448 C, ptr, "open_influence_panel", IFACE_("Influence")))
449 {
453 }
454
455 modifier_error_message_draw(layout, ptr);
456}
457
462
463static void blend_write(BlendWriter *writer, const ID * /*id_owner*/, const ModifierData *md)
464{
465 const auto *omd = reinterpret_cast<const GreasePencilOffsetModifierData *>(md);
466
467 writer->write_struct(omd);
468 modifier::greasepencil::write_influence_data(writer, &omd->influence);
469}
470
471static void blend_read(BlendDataReader *reader, ModifierData *md)
472{
473 auto *omd = reinterpret_cast<GreasePencilOffsetModifierData *>(md);
474
475 modifier::greasepencil::read_influence_data(reader, &omd->influence);
476}
477
479 /*idname*/ "GreasePencilOffset",
480 /*name*/ N_("Offset"),
481 /*struct_name*/ "GreasePencilOffsetModifierData",
482 /*struct_size*/ sizeof(GreasePencilOffsetModifierData),
483 /*srna*/ &RNA_GreasePencilOffsetModifier,
487 /*icon*/ ICON_MOD_OFFSET,
488
489 /*copy_data*/ copy_data,
490
491 /*deform_verts*/ nullptr,
492 /*deform_matrices*/ nullptr,
493 /*deform_verts_EM*/ nullptr,
494 /*deform_matrices_EM*/ nullptr,
495 /*modify_mesh*/ nullptr,
496 /*modify_geometry_set*/ modify_geometry_set,
497
498 /*init_data*/ init_data,
499 /*required_data_mask*/ nullptr,
500 /*free_data*/ free_data,
501 /*is_disabled*/ nullptr,
502 /*update_depsgraph*/ update_depsgraph,
503 /*depends_on_time*/ nullptr,
504 /*depends_on_normals*/ nullptr,
505 /*foreach_ID_link*/ foreach_ID_link,
506 /*foreach_tex_link*/ nullptr,
507 /*free_runtime_data*/ nullptr,
508 /*panel_register*/ panel_register,
509 /*blend_write*/ blend_write,
510 /*blend_read*/ blend_read,
511};
512
513} // namespace blender
Low-level operations for curves.
Low-level operations for grease pencil.
General operations, lookup, etc. for materials.
Random number functions.
#define IFACE_(msgid)
#define C
Definition RandGen.cpp:29
#define UI_ITEM_NONE
#define BLI_assert_unreachable()
#define INIT_DEFAULT_STRUCT_AFTER(struct_dst, member)
GAttributeReader lookup_or_default(StringRef name, AttrDomain domain, AttrType data_type, const void *default_value=nullptr) const
GSpanAttributeWriter lookup_or_add_for_write_span(StringRef name, AttrDomain domain, AttrType data_type, const AttributeInit &initializer=AttributeInitDefaultValue())
bke::CurvesGeometry & strokes_for_write()
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
#define fmodf(x, y)
#define sin
VecBase< float, D > step(VecOp< float, D >, VecOp< float, D >) RET
float3x3 scale(float3x3 mat, float2 scale)
constexpr ParallelGrainSize grain_size(int grain_size)
bool is_zero(const T &a)
T abs(const T &a)
MatT from_loc_rot_scale(const typename MatT::loc_type &location, const RotationT &rotation, const VecBase< typename MatT::base_type, ScaleDim > &scale)
VecBase< T, 3 > transform_point(const CartesianBasis &basis, const VecBase< T, 3 > &v)
void read_influence_data(BlendDataReader *reader, GreasePencilModifierInfluenceData *influence_data)
void draw_material_filter_settings(const bContext *, ui::Layout &layout, PointerRNA *ptr)
void init_influence_data(GreasePencilModifierInfluenceData *influence_data, const bool has_custom_curve)
Vector< LayerDrawingInfo > get_drawing_infos_by_layer(GreasePencil &grease_pencil, const IndexMask &layer_mask, const int frame)
void write_influence_data(BlendWriter *writer, const GreasePencilModifierInfluenceData *influence_data)
void draw_layer_filter_settings(const bContext *, ui::Layout &layout, PointerRNA *ptr)
IndexMask get_filtered_layer_mask(const GreasePencil &grease_pencil, const GreasePencilModifierInfluenceData &influence_data, IndexMaskMemory &memory)
VArray< float > get_influence_vertex_weights(const bke::CurvesGeometry &curves, const GreasePencilModifierInfluenceData &influence_data)
Vector< bke::greasepencil::Drawing * > get_drawings_for_write(GreasePencil &grease_pencil, const IndexMask &layer_mask, const int frame)
IndexMask get_filtered_stroke_mask(const Object *ob, const bke::CurvesGeometry &curves, const GreasePencilModifierInfluenceData &influence_data, IndexMaskMemory &memory)
void draw_vertex_group_settings(const bContext *, ui::Layout &layout, PointerRNA *ptr)
void free_influence_data(GreasePencilModifierInfluenceData *influence_data)
void foreach_influence_ID_link(GreasePencilModifierInfluenceData *influence_data, Object *ob, IDWalkFunc walk, void *user_data)
void copy_influence_data(const GreasePencilModifierInfluenceData *influence_data_src, GreasePencilModifierInfluenceData *influence_data_dst, const int)
void ensure_no_bezier_curves(Drawing &drawing)
void parallel_for_each(Range &&range, const Function &function)
Definition BLI_task.hh:31
BMesh Iterators.
static void copy_data(const ModifierData *md, ModifierData *target, const int flag)
__int64 int64_t
Definition BKE_text.h:90
int RNA_enum_get(PointerRNA *ptr, const char *name)
static void blend_write(BlendWriter *writer, const ID *, const ModifierData *md)
Definition MOD_bevel.cc:454
PointerRNA * modifier_panel_get_property_pointers(Panel *panel, PointerRNA *r_ob_ptr)
unsigned int uint
Definition BKE_text.h:55
short * BKE_object_material_len_p(Object *ob)
@ eModifierType_GreasePencilOffset
static void init_data(ModifierData *md)
void(*)(void *user_data, Object *ob, ID **idpoin, LibraryForeachIDCallbackFlag cb_flag) IDWalkFunc
static void update_depsgraph(tGraphSliderOp *gso)
static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
MINLINE int max_ii(int a, int b)
void DEG_add_object_relation(DepsNodeHandle *node_handle, Object *object, eDepsObjectComponentType component, const char *description)
MatBase< float, 4, 4 > float4x4
BLI_INLINE float BLI_hash_int_01(unsigned int k)
Definition BLI_hash_c.hh:94
@ MOD_GREASE_PENCIL_OFFSET_UNIFORM_RANDOM_SCALE
static void modify_geometry_set(ModifierData *md, const ModifierEvalContext *ctx, bke::GeometrySet *geometry_set)
void modifier_error_message_draw(ui::Layout &layout, PointerRNA *ptr)
static void modify_stroke_by_index(const GreasePencilOffsetModifierData &omd, const IndexMask &curves_mask, bke::CurvesGeometry &curves)
void BLI_halton_3d(const unsigned int prime[3], double offset[3], int n, double *r)
Definition rand.cc:252
static void free_data(ModifierData *md)
@ MOD_GREASE_PENCIL_OFFSET_RANDOM
@ MOD_GREASE_PENCIL_OFFSET_STROKE
@ MOD_GREASE_PENCIL_OFFSET_MATERIAL
@ MOD_GREASE_PENCIL_OFFSET_LAYER
static void panel_register(ARegionType *region_type)
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
static void apply_stroke_transform(const GreasePencilOffsetModifierData &omd, const VArray< float > &weights, const IndexRange &points, const float3 &loc_factor, const float3 &rot_factor, const float3 &scale_factor, const MutableSpan< float3 > positions, const MutableSpan< float > radii)
LayoutPanelState * BKE_panel_layout_panel_state_ensure(Panel *panel, StringRef idname, bool default_closed)
Definition screen.cc:656
ModifierTypeInfo modifierType_GreasePencilOffset
@ eModifierTypeFlag_SupportsMapping
@ eModifierTypeFlag_AcceptsGreasePencil
@ eModifierTypeFlag_EnableInEditmode
@ eModifierTypeFlag_SupportsEditmode
static void modify_drawing(const GreasePencilArrayModifierData &mmd, const ModifierEvalContext &ctx, bke::greasepencil::Drawing &drawing)
static void blend_read(BlendDataReader *, ModifierData *md)
static void modify_drawing_by_layer(const ModifierData &md, const ModifierEvalContext &ctx, bke::greasepencil::Drawing &drawing, int layer_index, int layers_num)
BLI_INLINE unsigned int BLI_hash_string(const char *str)
Definition BLI_hash_c.hh:69
static float get_factor_from_index(const GreasePencilOffsetModifierData &omd, const int size, const int index)
PanelType * modifier_panel_register(ARegionType *region_type, ModifierType type, PanelDrawFn draw)
static void modify_stroke_random(const Object &ob, const GreasePencilOffsetModifierData &omd, const IndexMask &curves_mask, bke::CurvesGeometry &curves)
static void panel_draw(const bContext *, Panel *panel)
VecBase< float, 3 > float3
static void modify_stroke_by_material(const Object &ob, const GreasePencilOffsetModifierData &omd, const IndexMask &curves_mask, bke::CurvesGeometry &curves)
static void modify_stroke_by_layer(const GreasePencilOffsetModifierData &omd, const int layer_index, const int layers_num, const IndexMask &curves_mask, bke::CurvesGeometry &curves)
void BKE_modifier_copydata_generic(const ModifierData *md, ModifierData *md_dst, int flag)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
GreasePencilModifierInfluenceData influence
char name[258]
Definition DNA_ID.h:433
ui::Layout * layout
GreasePencil * get_grease_pencil_for_write()
void use_property_split_set(bool is_sep)
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)
Layout & column(bool align)
PanelLayout panel_prop(const bContext *C, PointerRNA *open_prop_owner, StringRefNull open_prop_name)
#define N_(msgid)