Blender V5.3
MOD_subsurf.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2005 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <cstddef>
10#include <cstring>
11
12#include <fmt/format.h>
13
14#include "MEM_guardedalloc.h"
15
16#include "BLI_utildefines.hh"
17
18#include "BLT_translation.hh"
19
20#include "DNA_mesh_types.h"
21#include "DNA_modifier_types.h"
22#include "DNA_object_types.h"
23#include "DNA_scene_types.h"
24#include "DNA_screen_types.h"
25
26#include "BKE_context.hh"
27#include "BKE_editmesh.hh"
28#include "BKE_global.hh"
29#include "BKE_mesh.hh"
30#include "BKE_mesh_types.hh"
31#include "BKE_mesh_wrapper.hh"
32#include "BKE_scene.hh"
33#include "BKE_subdiv.hh"
34#include "BKE_subdiv_ccg.hh"
35#include "BKE_subdiv_deform.hh"
36#include "BKE_subdiv_mesh.hh"
38
40#include "UI_resources.hh"
41
42#include "RE_engine.h"
43
44#include "RNA_access.hh"
45#include "RNA_prototypes.hh"
46
47#include "DEG_depsgraph.hh"
49
50#include "MOD_modifiertypes.hh"
51#include "MOD_ui_common.hh"
52
53namespace blender {
54
55static void init_data(ModifierData *md)
56{
57 SubsurfModifierData *smd = reinterpret_cast<SubsurfModifierData *>(md);
59}
60
61static void free_runtime_data(void *runtime_data_v)
62{
63 if (runtime_data_v == nullptr) {
64 return;
65 }
66 SubsurfRuntimeData *runtime_data = static_cast<SubsurfRuntimeData *>(runtime_data_v);
67 if (runtime_data->subdiv_cpu != nullptr) {
68 bke::subdiv::free(runtime_data->subdiv_cpu);
69 }
70 if (runtime_data->subdiv_gpu != nullptr) {
71 bke::subdiv::free(runtime_data->subdiv_gpu);
72 }
73 MEM_delete(runtime_data);
74}
75
76static void free_data(ModifierData *md)
77{
78 SubsurfModifierData *smd = reinterpret_cast<SubsurfModifierData *>(md);
79
81}
82
83static bool is_disabled(const Scene *scene, ModifierData *md, bool use_render_params)
84{
85 SubsurfModifierData *smd = reinterpret_cast<SubsurfModifierData *>(md);
86 int levels = (use_render_params) ? smd->renderLevels : smd->levels;
87
88 return get_render_subsurf_level(&scene->r, levels, use_render_params != 0) == 0;
89}
90
92 const ModifierEvalContext *ctx)
93{
95 const bool use_render_params = (ctx->flag & MOD_APPLY_RENDER);
96 const int requested_levels = (use_render_params) ? smd->renderLevels : smd->levels;
97 return get_render_subsurf_level(&scene->r, requested_levels, use_render_params);
98}
99
100/* Subdivide into fully qualified mesh. */
101
103 const SubsurfModifierData *smd,
104 const ModifierEvalContext *ctx)
105{
106 const int level = subdiv_levels_for_modifier_get(smd, ctx);
107 settings->resolution = (1 << level) + 1;
109 !(ctx->flag & MOD_APPLY_TO_ORIGINAL);
110}
111
113 const ModifierEvalContext *ctx,
114 Mesh *mesh,
116{
117 Mesh *result = mesh;
118 bke::subdiv::ToMeshSettings mesh_settings;
119 subdiv_mesh_settings_init(&mesh_settings, smd, ctx);
120 if (mesh_settings.resolution < 3) {
121 return result;
122 }
123 result = bke::subdiv::subdiv_to_mesh(subdiv, &mesh_settings, mesh);
124 return result;
125}
126
127/* Subdivide into CCG. */
128
130 const SubsurfModifierData *smd,
131 const ModifierEvalContext *ctx)
132{
133 const int level = subdiv_levels_for_modifier_get(smd, ctx);
134 settings->resolution = (1 << level) + 1;
135 settings->need_normal = true;
136 settings->need_mask = false;
137}
138
140 const ModifierEvalContext *ctx,
141 Mesh *mesh,
143{
144 Mesh *result = mesh;
145 SubdivToCCGSettings ccg_settings;
146 subdiv_ccg_settings_init(&ccg_settings, smd, ctx);
147 if (ccg_settings.resolution < 3) {
148 return result;
149 }
150 result = BKE_subdiv_to_ccg_mesh(*subdiv, ccg_settings, *mesh);
151 return result;
152}
153
154/* Cache settings for lazy CPU evaluation. */
155
157 Mesh *mesh,
159 SubsurfRuntimeData *runtime_data,
160 const bool has_gpu_subdiv)
161{
162 bke::subdiv::ToMeshSettings mesh_settings;
163 subdiv_mesh_settings_init(&mesh_settings, smd, ctx);
164
165 runtime_data->has_gpu_subdiv = has_gpu_subdiv;
166 runtime_data->resolution = mesh_settings.resolution;
167 runtime_data->use_optimal_display = mesh_settings.use_optimal_display;
169
170 mesh->runtime->subsurf_runtime_data = runtime_data;
171}
172
174 const Object *ob,
175 int required_mode)
176{
177 ModifierData *md = ob->modifiers.last();
178
179 while (md) {
180 if (BKE_modifier_is_enabled(scene, md, required_mode)) {
181 break;
182 }
183
184 md = md->prev;
185 }
186
187 return md;
188}
189
190/* Modifier itself. */
191
193{
194 Mesh *result = mesh;
195#if !defined(WITH_OPENSUBDIV)
196 BKE_modifier_set_error(ctx->object, md, "Disabled, built without OpenSubdiv");
197 return result;
198#endif
199 SubsurfModifierData *smd = reinterpret_cast<SubsurfModifierData *>(md);
201 return result;
202 }
203
204 SubsurfRuntimeData *runtime_data = static_cast<SubsurfRuntimeData *>(smd->modifier.runtime);
205
206 /* Decrement the recent usage counters. */
207 if (runtime_data->used_cpu) {
208 runtime_data->used_cpu--;
209 }
210
211 if (runtime_data->used_gpu) {
212 runtime_data->used_gpu--;
213 }
214
215 /* Delay evaluation to the draw code if possible, provided we do not have to apply the modifier.
216 */
217 if ((ctx->flag & MOD_APPLY_TO_ORIGINAL) == 0) {
219
220 /* Same check as in `DRW_mesh_batch_cache_create_requested` to keep both code coherent. The
221 * difference is that here we do not check for the final edit mesh pointer as it is not yet
222 * assigned at this stage of modifier stack evaluation. */
223 const bool is_render_mode = (ctx->flag & MOD_APPLY_RENDER) != 0;
224 const bool is_editmode = (mesh->runtime->edit_mesh != nullptr);
225 const int required_mode = BKE_subsurf_modifier_eval_required_mode(is_render_mode, is_editmode);
226
227 /* Check if we are the last modifier in the stack. */
228 ModifierData *md = modifier_get_last_enabled_for_mode(scene, ctx->object, required_mode);
229 if (md == reinterpret_cast<const ModifierData *>(smd)) {
230 const bool has_gpu_subdiv = BKE_subsurf_modifier_can_do_gpu_subdiv(smd, mesh);
231 subdiv_cache_mesh_wrapper_settings(ctx, mesh, smd, runtime_data, has_gpu_subdiv);
232
233 /* Delay for:
234 * - Background mode: Not sure if we are going to use the tessellated mesh.
235 * - Render: Engine might do its own subdivision and not need this.
236 * - GPU subdivision support: Might only need to display and not access tessellated mesh.
237 *
238 * If we can't delay, we still create the wrapper so external renderers can get the base
239 * mesh. But we tessellate immediately to take advantage of better parallellization
240 * as part of multithreaded depsgraph evaluation. */
241 const bool delay = G.background || is_render_mode || has_gpu_subdiv;
242 if (!delay) {
244 }
245
246 return result;
247 }
248 }
249
251 runtime_data, mesh, false);
252 if (subdiv == nullptr) {
253 /* Happens on bad topology, but also on empty input mesh. */
254 return result;
255 }
256 const bool use_clnors = BKE_subsurf_modifier_use_custom_loop_normals(smd, mesh);
257 if (use_clnors) {
259 &mesh->corner_data, CD_NORMAL, CD_CONSTRUCT, mesh->corners_num);
260 memcpy(data, mesh->corner_normals().data(), mesh->corner_normals().size_in_bytes());
261 }
262 /* TODO(sergey): Decide whether we ever want to use CCG for subsurf,
263 * maybe when it is a last modifier in the stack? */
264 if (true) {
265 result = subdiv_as_mesh(smd, ctx, mesh, subdiv);
266 }
267 else {
268 result = subdiv_as_ccg(smd, ctx, mesh, subdiv);
269 }
270
271 if (use_clnors) {
273 *result,
274 {static_cast<float3 *>(
275 CustomData_get_layer_for_write(&result->corner_data, CD_NORMAL, result->corners_num)),
276 result->corners_num});
278 }
279 // bke::subdiv::stats_print(&subdiv->stats);
280 if (!ELEM(subdiv, runtime_data->subdiv_cpu, runtime_data->subdiv_gpu)) {
282 }
283 return result;
284}
285
287 const ModifierEvalContext *ctx,
288 Mesh *mesh,
289 MutableSpan<float3> positions,
290 MutableSpan<float3x3> /*matrices*/)
291{
292#if !defined(WITH_OPENSUBDIV)
293 BKE_modifier_set_error(ctx->object, md, "Disabled, built without OpenSubdiv");
294 return;
295#endif
296
297 /* Subsurf does not require extra space mapping, keep matrices as is. */
298
299 SubsurfModifierData *smd = reinterpret_cast<SubsurfModifierData *>(md);
301 return;
302 }
303 SubsurfRuntimeData *runtime_data = static_cast<SubsurfRuntimeData *>(smd->modifier.runtime);
305 runtime_data, mesh, false);
306 if (subdiv == nullptr) {
307 /* Happens on bad topology, but also on empty input mesh. */
308 return;
309 }
311 if (!ELEM(subdiv, runtime_data->subdiv_cpu, runtime_data->subdiv_gpu)) {
313 }
314}
315
316static bool get_show_adaptive_options(const bContext *C, Panel *panel)
317{
318 /* Don't show adaptive options if cycles isn't the active engine. */
319 const RenderEngineType *engine_type = CTX_data_engine_type(C);
320 if (!(STREQ(engine_type->idname, "CYCLES") && RE_engines_is_registered("CYCLES"))) {
321 return false;
322 }
323
324 /* Only show adaptive options if this is the last modifier. */
326 ModifierData *md = static_cast<ModifierData *>(ptr->data);
327 if (md->next != nullptr) {
328 return false;
329 }
330
331 return true;
332}
333
334static void panel_draw(const bContext *C, Panel *panel)
335{
336 ui::Layout &layout = *panel->layout;
337
338 PointerRNA ob_ptr;
340
341 layout.prop(ptr, "subdivision_type", ui::ITEM_R_EXPAND, std::nullopt, ICON_NONE);
342
343 layout.use_property_split_set(true);
344
345 {
346 ui::Layout &col = layout.column(true);
347 col.prop(ptr, "levels", UI_ITEM_NONE, IFACE_("Levels Viewport"), ICON_NONE);
348 col.prop(ptr, "render_levels", UI_ITEM_NONE, IFACE_("Render"), ICON_NONE);
349 }
350
351 layout.prop(ptr, "show_only_control_edges", UI_ITEM_NONE, std::nullopt, ICON_NONE);
352
353 Depsgraph *depsgraph = CTX_data_depsgraph_pointer(C);
354 SubsurfModifierData *smd = static_cast<SubsurfModifierData *>(ptr->data);
355 Object *ob = static_cast<Object *>(ob_ptr.data);
357 smd, id_cast<const Mesh *>(ob->data)))
358 {
359 layout.label(RPT_("Sharp edges or custom normals detected, disabling GPU subdivision"),
360 ICON_STATUS_INFO);
361 }
362 else if (Object *ob_eval = DEG_get_evaluated(depsgraph, ob)) {
363 if (ModifierData *md_eval = BKE_modifiers_findby_name(ob_eval, smd->modifier.name)) {
364 if (md_eval->type == eModifierType_Subsurf) {
365 SubsurfRuntimeData *runtime_data = static_cast<SubsurfRuntimeData *>(md_eval->runtime);
366
367 if (runtime_data && runtime_data->used_gpu) {
368 if (runtime_data->used_cpu) {
369 layout.label_multiline(RPT_("Using both CPU and GPU subdivision"), ICON_STATUS_INFO);
370 }
371 }
372 }
373 }
374 }
375
376 if (get_show_adaptive_options(C, panel)) {
377 ui::PanelLayout adaptive_panel = layout.panel_prop_with_bool_header(
378 C,
379 ptr,
380 "open_adaptive_subdivision_panel",
381 ptr,
382 "use_adaptive_subdivision",
383 IFACE_("Adaptive Subdivision"));
384 if (adaptive_panel.body) {
385 Scene *scene = CTX_data_scene(C);
386 PointerRNA scene_ptr = RNA_id_pointer_create(&scene->id);
387 PointerRNA cycles_ptr = RNA_pointer_get(&scene_ptr, "cycles");
388 const float render_rate = RNA_float_get(&cycles_ptr, "dicing_rate");
389 const float preview_rate = RNA_float_get(&cycles_ptr, "preview_dicing_rate");
390 std::string render_str, preview_str;
391
393 adaptive_panel.body->prop(ptr, "adaptive_space", UI_ITEM_NONE, IFACE_("Space"), ICON_NONE);
395 adaptive_panel.body->prop(
396 ptr, "adaptive_object_edge_length", UI_ITEM_NONE, std::nullopt, ICON_NONE);
397 preview_str = fmt::format("{:.5g}", preview_rate * smd->adaptive_object_edge_length);
398 render_str = fmt::format("{:.5g}", render_rate * smd->adaptive_object_edge_length);
399 }
400 else {
401 adaptive_panel.body->prop(
402 ptr, "adaptive_pixel_size", UI_ITEM_NONE, std::nullopt, ICON_NONE);
403 preview_str = fmt::format("{:.2f} px",
404 std::max(preview_rate * smd->adaptive_pixel_size, 0.1f));
405 render_str = fmt::format("{:.2f} px",
406 std::max(render_rate * smd->adaptive_pixel_size, 0.1f));
407 }
408
409 ui::Layout &split = adaptive_panel.body->split(0.4f, false);
410 ui::Layout *col = &split.column(true);
412 col->label(IFACE_("Viewport"), ICON_NONE);
413 col->label(IFACE_("Render"), ICON_NONE);
414 col = &split.column(true);
415 col->label(preview_str, ICON_NONE);
416 col->label(render_str, ICON_NONE);
417 }
418 }
419
420 if (ui::Layout *advanced_layout = layout.panel_prop(
421 C, ptr, "open_advanced_panel", IFACE_("Advanced")))
422 {
423 advanced_layout->use_property_split_set(true);
424
425 advanced_layout->prop(ptr, "use_limit_surface", UI_ITEM_NONE, std::nullopt, ICON_NONE);
426
427 ui::Layout &col = advanced_layout->column(true);
429 RNA_boolean_get(ptr, "use_limit_surface"));
430 col.prop(ptr, "quality", UI_ITEM_NONE, std::nullopt, ICON_NONE);
431
432 advanced_layout->prop(ptr, "uv_smooth", UI_ITEM_NONE, std::nullopt, ICON_NONE);
433 advanced_layout->prop(ptr, "boundary_smooth", UI_ITEM_NONE, std::nullopt, ICON_NONE);
434 advanced_layout->prop(ptr, "use_creases", UI_ITEM_NONE, std::nullopt, ICON_NONE);
435 advanced_layout->prop(ptr, "use_custom_normals", UI_ITEM_NONE, std::nullopt, ICON_NONE);
436 }
437
438 modifier_error_message_draw(layout, ptr);
439}
440
441static void panel_register(ARegionType *region_type)
442{
444}
445
447 /*idname*/ "Subdivision",
448 /*name*/ N_("Subdivision"),
449 /*struct_name*/ "SubsurfModifierData",
450 /*struct_size*/ sizeof(SubsurfModifierData),
451 /*srna*/ &RNA_SubsurfModifier,
456 /*icon*/ ICON_MOD_SUBSURF,
457
458 /*copy_data*/ BKE_modifier_copydata_generic,
459
460 /*deform_verts*/ nullptr,
461 /*deform_matrices*/ deform_matrices,
462 /*deform_verts_EM*/ nullptr,
463 /*deform_matrices_EM*/ nullptr,
464 /*modify_mesh*/ modify_mesh,
465 /*modify_geometry_set*/ nullptr,
466
467 /*init_data*/ init_data,
468 /*required_data_mask*/ nullptr,
469 /*free_data*/ free_data,
470 /*is_disabled*/ is_disabled,
471 /*update_depsgraph*/ nullptr,
472 /*depends_on_time*/ nullptr,
473 /*depends_on_normals*/ nullptr,
474 /*foreach_ID_link*/ nullptr,
475 /*foreach_tex_link*/ nullptr,
476 /*free_runtime_data*/ free_runtime_data,
477 /*panel_register*/ panel_register,
478 /*blend_write*/ nullptr,
479 /*blend_read*/ nullptr,
480 /*foreach_cache*/ nullptr,
481 /*foreach_working_space_color*/ nullptr,
482};
483
484} // namespace blender
#define RPT_(msgid)
#define IFACE_(msgid)
Object is a sort of wrapper for general info.
Read Blender memory allocation and freeing.
#define C
Definition RandGen.cpp:29
#define UI_ITEM_NONE
#define INIT_DEFAULT_STRUCT_AFTER(struct_dst, member)
#define ELEM(...)
#define STREQ(a, b)
void free(Subdiv *subdiv)
Definition subdiv.cc:192
void deform_coarse_vertices(Subdiv *subdiv, const Mesh *coarse_mesh, MutableSpan< float3 > vert_positions)
Mesh * subdiv_to_mesh(Subdiv *subdiv, const ToMeshSettings *settings, const Mesh *coarse_mesh)
void mesh_set_custom_normals_normalized(Mesh &mesh, MutableSpan< float3 > corner_normals)
void split(const std::string &s, const char delim, std::vector< std::string > &tokens)
Definition abc_util.cc:68
BMesh Iterators.
ModifierData * BKE_modifiers_findby_name(const Object *ob, const char *name)
void BKE_modifier_set_error(const Object *ob, ModifierData *md, const char *format,...) ATTR_PRINTF_FORMAT(3
bool BKE_subsurf_modifier_runtime_init(SubsurfModifierData *smd, bool use_render_params)
static ModifierData * modifier_get_last_enabled_for_mode(const Scene *scene, const Object *ob, int required_mode)
PointerRNA * modifier_panel_get_property_pointers(Panel *panel, PointerRNA *r_ob_ptr)
@ SUBSURF_ADAPTIVE_SPACE_OBJECT
bool RE_engines_is_registered(const char *idname)
bool BKE_subsurf_modifier_force_disable_gpu_evaluation_for_mesh(const SubsurfModifierData *smd, const Mesh *mesh)
bool CustomData_free_layers(CustomData *data, eCustomDataType type)
PointerRNA RNA_id_pointer_create(ID *id)
bool BKE_subsurf_modifier_use_custom_loop_normals(const SubsurfModifierData *smd, const Mesh *mesh)
Depsgraph * CTX_data_depsgraph_pointer(const bContext *C)
int get_render_subsurf_level(const RenderData *r, int lvl, bool for_render)
Definition scene.cc:3006
static void init_data(ModifierData *md)
RenderEngineType * CTX_data_engine_type(const bContext *C)
Global G
Definition blender.cc:57
void modifier_error_message_draw(ui::Layout &layout, PointerRNA *ptr)
@ eSubsurfModifierFlag_UseCustomNormals
@ eSubsurfModifierFlag_ControlEdges
@ eSubsurfModifierFlag_UseAdaptiveSubdivision
BMesh const char void * data
bool BKE_subsurf_modifier_can_do_gpu_subdiv(const SubsurfModifierData *smd, const Mesh *mesh)
T * DEG_get_evaluated(const Depsgraph *depsgraph, T *id)
static void free_data(ModifierData *md)
@ MOD_APPLY_TO_ORIGINAL
static void panel_register(ARegionType *region_type)
static Mesh * subdiv_as_mesh(SubsurfModifierData *smd, const ModifierEvalContext *ctx, Mesh *mesh, bke::subdiv::Subdiv *subdiv)
static void deform_matrices(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh, MutableSpan< float3 > positions, MutableSpan< float3x3 > matrices)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
static Mesh * modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh)
Definition MOD_array.cc:873
static void subdiv_mesh_settings_init(bke::subdiv::ToMeshSettings *settings, const SubsurfModifierData *smd, const ModifierEvalContext *ctx)
@ eModifierTypeFlag_SupportsMapping
@ eModifierTypeFlag_AcceptsCVs
@ eModifierTypeFlag_EnableInEditmode
@ eModifierTypeFlag_SupportsEditmode
@ eModifierTypeFlag_AcceptsMesh
PointerRNA RNA_pointer_get(PointerRNA *ptr, const char *name)
static bool get_show_adaptive_options(const bContext *C, Panel *panel)
bke::subdiv::Subdiv * BKE_subsurf_modifier_subdiv_descriptor_ensure(SubsurfRuntimeData *runtime_data, const Mesh *mesh, bool for_draw_code)
ModifierTypeInfo modifierType_Subsurf
PanelType * modifier_panel_register(ARegionType *region_type, ModifierType type, PanelDrawFn draw)
static void subdiv_cache_mesh_wrapper_settings(const ModifierEvalContext *ctx, Mesh *mesh, SubsurfModifierData *smd, SubsurfRuntimeData *runtime_data, const bool has_gpu_subdiv)
static void panel_draw(const bContext *, Panel *panel)
Scene * CTX_data_scene(const bContext *C)
static void free_runtime_data(void *runtime_data_v)
Mesh * BKE_subdiv_to_ccg_mesh(bke::subdiv::Subdiv &subdiv, const SubdivToCCGSettings &settings, const Mesh &coarse_mesh)
static void subdiv_ccg_settings_init(SubdivToCCGSettings *settings, const SubsurfModifierData *smd, const ModifierEvalContext *ctx)
void * CustomData_get_layer_for_write(CustomData *data, eCustomDataType type, int totelem)
VecBase< float, 3 > float3
static bool is_disabled(const Scene *, ModifierData *md, bool)
int BKE_subsurf_modifier_eval_required_mode(bool is_final_render, bool is_edit_mode)
Scene * DEG_get_evaluated_scene(const Depsgraph *graph)
bool BKE_modifier_is_enabled(const Scene *scene, ModifierData *md, int required_mode)
Mesh * BKE_mesh_wrapper_ensure_subdivision(Mesh *mesh)
float RNA_float_get(PointerRNA *ptr, const char *name)
static int subdiv_levels_for_modifier_get(const SubsurfModifierData *smd, const ModifierEvalContext *ctx)
static Mesh * subdiv_as_ccg(SubsurfModifierData *smd, const ModifierEvalContext *ctx, Mesh *mesh, bke::subdiv::Subdiv *subdiv)
void * CustomData_add_layer(CustomData *data, eCustomDataType type, eCDAllocType alloctype, int totelem)
void BKE_modifier_copydata_generic(const ModifierData *md, ModifierData *md_dst, int flag)
struct ModifierData * next
struct ModifierData * prev
ListBaseT< ModifierData > modifiers
ui::Layout * layout
struct RenderData r
eSubsurfAdaptiveSpace adaptive_space
bke::subdiv::Subdiv * subdiv_gpu
bke::subdiv::Subdiv * subdiv_cpu
void alignment_set(LayoutAlign alignment)
void label_multiline(StringRefNull label, int icon, FontStyleAlign align=UI_STYLE_TEXT_LEFT, int max_lines=0)
void use_property_split_set(bool is_sep)
void label(StringRef name, int icon)
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)
void active_set(bool active)
Layout & split(float percentage, bool align)
Layout & column(bool align)
PanelLayout panel_prop_with_bool_header(const bContext *C, PointerRNA *open_prop_owner, StringRefNull open_prop_name, PointerRNA *bool_prop_owner, StringRefNull bool_prop_name, std::optional< StringRef > label)
PanelLayout panel_prop(const bContext *C, PointerRNA *open_prop_owner, StringRefNull open_prop_name)
#define N_(msgid)