Blender V5.3
MOD_multires.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
11#include "MEM_guardedalloc.h"
12
13#include "BLI_utildefines.hh"
14
15#include "BLT_translation.hh"
16
17#include "DNA_mesh_types.h"
18#include "DNA_object_types.h"
19#include "DNA_screen_types.h"
20
21#include "BKE_context.hh"
22#include "BKE_customdata.hh"
23#include "BKE_mesh.hh"
24#include "BKE_modifier.hh"
25#include "BKE_multires.hh"
26#include "BKE_paint.hh"
27#include "BKE_subdiv.hh"
28#include "BKE_subdiv_ccg.hh"
29#include "BKE_subdiv_deform.hh"
30#include "BKE_subdiv_mesh.hh"
31
32#include "UI_interface.hh"
34#include "UI_resources.hh"
35
36#include "RNA_access.hh"
37#include "RNA_prototypes.hh"
38
39#include "WM_types.hh" /* For subdivide operator UI. */
40
42
43#include "MOD_ui_common.hh"
44
45namespace blender {
46
48 /* Cached subdivision surface descriptor, with topology and settings. */
50};
51
52static void init_data(ModifierData *md)
53{
54 MultiresModifierData *mmd = reinterpret_cast<MultiresModifierData *>(md);
56
57 /* Open subdivision panels by default. */
59}
60
61static void copy_data(const ModifierData *md_src, ModifierData *md_dst, const int flag)
62{
63 BKE_modifier_copydata_generic(md_src, md_dst, flag);
64}
65
66static void free_runtime_data(void *runtime_data_v)
67{
68 if (runtime_data_v == nullptr) {
69 return;
70 }
71 MultiresRuntimeData *runtime_data = static_cast<MultiresRuntimeData *>(runtime_data_v);
72 if (runtime_data->subdiv != nullptr) {
73 bke::subdiv::free(runtime_data->subdiv);
74 }
75 MEM_delete(runtime_data);
76}
77
78static void free_data(ModifierData *md)
79{
80 MultiresModifierData *mmd = reinterpret_cast<MultiresModifierData *>(md);
82}
83
85{
86 MultiresRuntimeData *runtime_data = static_cast<MultiresRuntimeData *>(mmd->modifier.runtime);
87 if (runtime_data == nullptr) {
88 runtime_data = MEM_new_zeroed<MultiresRuntimeData>(__func__);
89 mmd->modifier.runtime = runtime_data;
90 }
91 return runtime_data;
92}
93
94/* Main goal of this function is to give usable subdivision surface descriptor
95 * which matches settings and topology. */
97 const bke::subdiv::Settings *subdiv_settings,
98 const Mesh *mesh)
99{
100 MultiresRuntimeData *runtime_data = static_cast<MultiresRuntimeData *>(mmd->modifier.runtime);
102 runtime_data->subdiv, subdiv_settings, mesh);
103 runtime_data->subdiv = subdiv;
104 return subdiv;
105}
106
107/* Subdivide into fully qualified mesh. */
108
110 const ModifierEvalContext *ctx,
111 Mesh *mesh,
113{
114 Mesh *result = mesh;
115 const bool use_render_params = (ctx->flag & MOD_APPLY_RENDER);
116 const bool ignore_simplify = (ctx->flag & MOD_APPLY_IGNORE_SIMPLIFY);
117 const bool ignore_control_edges = (ctx->flag & MOD_APPLY_TO_ORIGINAL);
118 const Scene *scene = DEG_get_evaluated_scene(ctx->depsgraph);
119 Object *object = ctx->object;
120 bke::subdiv::ToMeshSettings mesh_settings;
122 scene,
123 object,
124 mmd,
125 use_render_params,
126 ignore_simplify,
127 ignore_control_edges);
128 if (mesh_settings.resolution < 3) {
129 return result;
130 }
132 result = bke::subdiv::subdiv_to_mesh(subdiv, &mesh_settings, mesh);
133 return result;
134}
135
136/* Subdivide into CCG. */
137
139 const MultiresModifierData *mmd,
140 const ModifierEvalContext *ctx,
141 const Mesh *mesh)
142{
143 const bool has_mask = CustomData_has_layer(&mesh->corner_data, CD_GRID_PAINT_MASK);
144 const bool use_render_params = (ctx->flag & MOD_APPLY_RENDER);
145 const bool ignore_simplify = (ctx->flag & MOD_APPLY_IGNORE_SIMPLIFY);
146 const Scene *scene = DEG_get_evaluated_scene(ctx->depsgraph);
147 Object *object = ctx->object;
148 const int level = multires_get_level(scene, object, mmd, use_render_params, ignore_simplify);
149 settings->resolution = (1 << level) + 1;
150 settings->need_normal = true;
151 settings->need_mask = has_mask;
152}
153
155 const ModifierEvalContext *ctx,
156 Mesh *mesh,
158{
159 Mesh *result = mesh;
160 SubdivToCCGSettings ccg_settings;
161 multires_ccg_settings_init(&ccg_settings, mmd, ctx, mesh);
162 if (ccg_settings.resolution < 3) {
163 return result;
164 }
166 result = BKE_subdiv_to_ccg_mesh(*subdiv, ccg_settings, *mesh);
167
168 /* NOTE: CCG becomes an owner of Subdiv descriptor, so can not share
169 * this pointer. Not sure if it's needed, but might have a second look
170 * on the ownership model here. */
171 MultiresRuntimeData *runtime_data = static_cast<MultiresRuntimeData *>(mmd->modifier.runtime);
172 runtime_data->subdiv = nullptr;
173
174 return result;
175}
176
178{
179 Mesh *result = mesh;
180#if !defined(WITH_OPENSUBDIV)
181 BKE_modifier_set_error(ctx->object, md, "Disabled, built without OpenSubdiv");
182 return result;
183#endif
184 MultiresModifierData *mmd = reinterpret_cast<MultiresModifierData *>(md);
185 bke::subdiv::Settings subdiv_settings;
186 BKE_multires_subdiv_settings_init(&subdiv_settings, mmd);
187 if (subdiv_settings.level == 0) {
188 return result;
189 }
190 MultiresRuntimeData *runtime_data = multires_ensure_runtime(mmd);
191 bke::subdiv::Subdiv *subdiv = subdiv_descriptor_ensure(mmd, &subdiv_settings, mesh);
192 if (subdiv == nullptr) {
193 /* Happens on bad topology, also on empty input mesh. */
194 return result;
195 }
196 const bool use_clnors = mmd->flags & eMultiresModifierFlag_UseCustomNormals &&
197 mesh->normals_domain() == bke::MeshNormalDomain::Corner;
198 /* NOTE: Orco needs final coordinates on CPU side, which are expected to be
199 * accessible via mesh vertices. For this reason we do not evaluate multires to
200 * grids when orco is requested. */
201 const bool for_orco = (ctx->flag & MOD_APPLY_ORCO) != 0;
202 /* Needed when rendering or baking will in sculpt mode. */
203 const bool for_render = (ctx->flag & MOD_APPLY_RENDER) != 0;
204
205 const bool sculpt_base_mesh = mmd->flags & eMultiresModifierFlag_UseSculptBaseMesh;
206
207 if ((ctx->object->mode & OB_MODE_SCULPT) && !for_orco && !for_render && !sculpt_base_mesh) {
208 /* NOTE: CCG takes ownership over Subdiv. */
209 result = multires_as_ccg(mmd, ctx, mesh, subdiv);
210 result->runtime->subdiv_ccg_tot_level = mmd->totlvl;
211 /* TODO(sergey): Usually it is sculpt stroke's update variants which
212 * takes care of this, but is possible that we need this before the
213 * stroke: i.e. when exiting blender right after stroke is done.
214 * Annoying and not so much black-boxed as far as sculpting goes, and
215 * surely there is a better way of solving this. */
216 if (ctx->object->runtime->sculpt_session != nullptr) {
217 SculptSession *sculpt_session = ctx->object->runtime->sculpt_session;
218 sculpt_session->subdiv_ccg = result->runtime->subdiv_ccg.get();
219 sculpt_session->multires_modifier = mmd;
220 }
221 // bke::subdiv::stats_print(&subdiv->stats);
222 }
223 else {
224 if (use_clnors) {
226 &mesh->corner_data, CD_NORMAL, CD_CONSTRUCT, mesh->corners_num);
227 memcpy(data, mesh->corner_normals().data(), mesh->corner_normals().size_in_bytes());
228 }
229
230 result = multires_as_mesh(mmd, ctx, mesh, subdiv);
231
232 if (use_clnors) {
234 *result,
236 &result->corner_data, CD_NORMAL, result->corners_num)),
237 result->corners_num});
239 }
240 // bke::subdiv::stats_print(&subdiv->stats);
241 if (subdiv != runtime_data->subdiv) {
243 }
244 }
245 return result;
246}
247
249 const ModifierEvalContext *ctx,
250 Mesh *mesh,
251 MutableSpan<float3> positions,
252 MutableSpan<float3x3> /*matrices*/)
253
254{
255#if !defined(WITH_OPENSUBDIV)
256 BKE_modifier_set_error(ctx->object, md, "Disabled, built without OpenSubdiv");
257 return;
258#endif
259
260 MultiresModifierData *mmd = reinterpret_cast<MultiresModifierData *>(md);
261
262 bke::subdiv::Settings subdiv_settings;
263 BKE_multires_subdiv_settings_init(&subdiv_settings, mmd);
264 if (subdiv_settings.level == 0) {
265 return;
266 }
267
268 SubdivToCCGSettings ccg_settings;
269 multires_ccg_settings_init(&ccg_settings, mmd, ctx, mesh);
270 if (ccg_settings.resolution < 3) {
271 return;
272 }
273
274 MultiresRuntimeData *runtime_data = multires_ensure_runtime(mmd);
275 bke::subdiv::Subdiv *subdiv = subdiv_descriptor_ensure(mmd, &subdiv_settings, mesh);
276 if (subdiv == nullptr) {
277 /* Happens on bad topology, also on empty input mesh. */
278 return;
279 }
282 if (subdiv != runtime_data->subdiv) {
284 }
285}
286
287static void panel_draw(const bContext *C, Panel *panel)
288{
289 ui::Layout &layout = *panel->layout;
290
292
293 layout.use_property_split_set(true);
294
295 ui::Layout &col = layout.column(true);
296 col.prop(ptr, "levels", UI_ITEM_NONE, IFACE_("Levels Viewport"), ICON_NONE);
297 col.prop(ptr, "sculpt_levels", UI_ITEM_NONE, IFACE_("Sculpt"), ICON_NONE);
298 col.prop(ptr, "render_levels", UI_ITEM_NONE, IFACE_("Render"), ICON_NONE);
299
300 const bool is_sculpt_mode = CTX_data_active_object(C)->mode & OB_MODE_SCULPT;
301 ui::Block *block = layout.block();
302 block_lock_set(block, !is_sculpt_mode, N_("Sculpt Base Mesh"));
303 col.prop(ptr, "use_sculpt_base_mesh", UI_ITEM_NONE, IFACE_("Sculpt Base Mesh"), ICON_NONE);
304 block_lock_clear(block);
305
306 layout.prop(ptr, "show_only_control_edges", UI_ITEM_NONE, std::nullopt, ICON_NONE);
307
308 modifier_error_message_draw(layout, ptr);
309}
310
311static void subdivisions_panel_draw(const bContext * /*C*/, Panel *panel)
312{
313 ui::Layout &layout = *panel->layout;
314
315 PointerRNA ob_ptr;
317
318 layout.enabled_set(RNA_enum_get(&ob_ptr, "mode") != OB_MODE_EDIT);
319
320 MultiresModifierData *mmd = static_cast<MultiresModifierData *>(ptr->data);
321
332
333 PointerRNA op_ptr;
334 op_ptr = layout.op("OBJECT_OT_multires_subdivide",
335 IFACE_("Subdivide"),
336 ICON_NONE,
340 RNA_string_set(&op_ptr, "modifier", reinterpret_cast<ModifierData *>(mmd)->name);
341
342 ui::Layout &row = layout.row(false);
343 op_ptr = row.op("OBJECT_OT_multires_subdivide",
344 IFACE_("Simple"),
345 ICON_NONE,
349 RNA_string_set(&op_ptr, "modifier", reinterpret_cast<ModifierData *>(mmd)->name);
350 op_ptr = row.op("OBJECT_OT_multires_subdivide",
351 IFACE_("Linear"),
352 ICON_NONE,
356 RNA_string_set(&op_ptr, "modifier", reinterpret_cast<ModifierData *>(mmd)->name);
357
358 layout.separator();
359
360 layout.op("OBJECT_OT_multires_unsubdivide", IFACE_("Unsubdivide"), ICON_NONE);
361 layout.op("OBJECT_OT_multires_higher_levels_delete", IFACE_("Delete Higher"), ICON_NONE);
362}
363
364static void shape_panel_draw(const bContext * /*C*/, Panel *panel)
365{
366 ui::Layout &layout = *panel->layout;
367
368 PointerRNA ob_ptr;
370
371 layout.enabled_set(RNA_enum_get(&ob_ptr, "mode") != OB_MODE_EDIT);
372
373 PointerRNA op_ptr;
374 ui::Layout *row = &layout.row(false);
375 row->op("OBJECT_OT_multires_reshape", IFACE_("Reshape"), ICON_NONE);
376
377 row = &layout.row(false);
378 op_ptr = row->op("OBJECT_OT_multires_base_apply", IFACE_("Apply Base"), ICON_NONE);
379 RNA_boolean_set(&op_ptr, "apply_heuristic", true);
380 op_ptr = row->op("OBJECT_OT_multires_base_apply", IFACE_("Conform Base"), ICON_NONE);
381 RNA_boolean_set(&op_ptr, "apply_heuristic", false);
382}
383
384static void generate_panel_draw(const bContext * /*C*/, Panel *panel)
385{
386 ui::Layout &layout = *panel->layout;
387
389 MultiresModifierData *mmd = static_cast<MultiresModifierData *>(ptr->data);
390
391 bool is_external = RNA_boolean_get(ptr, "is_external");
392
393 if (mmd->totlvl == 0) {
394 layout.op("OBJECT_OT_multires_rebuild_subdiv", IFACE_("Rebuild Subdivisions"), ICON_NONE);
395 }
396
397 ui::Layout &col = layout.column(false);
398 ui::Layout *row = &col.row(false);
399 if (is_external) {
400 row->op("OBJECT_OT_multires_external_pack", IFACE_("Pack External"), ICON_NONE);
401 col.use_property_split_set(true);
402 row = &col.row(false);
403 row->prop(ptr, "filepath", UI_ITEM_NONE, std::nullopt, ICON_NONE);
404 }
405 else {
406 col.op("OBJECT_OT_multires_external_save", IFACE_("Save External..."), ICON_NONE);
407 }
408}
409
410static void advanced_panel_draw(const bContext * /*C*/, Panel *panel)
411{
412 ui::Layout &layout = *panel->layout;
413
415
416 bool has_displacement = RNA_int_get(ptr, "total_levels") != 0;
417
418 layout.use_property_split_set(true);
419
420 layout.active_set(!has_displacement);
421
422 layout.prop(ptr, "quality", UI_ITEM_NONE, std::nullopt, ICON_NONE);
423
424 ui::Layout &col = layout.column(false);
425 col.active_set(true);
426 col.prop(ptr, "uv_smooth", UI_ITEM_NONE, std::nullopt, ICON_NONE);
427 col.prop(ptr, "boundary_smooth", UI_ITEM_NONE, std::nullopt, ICON_NONE);
428
429 layout.prop(ptr, "use_creases", UI_ITEM_NONE, std::nullopt, ICON_NONE);
430 layout.prop(ptr, "use_custom_normals", UI_ITEM_NONE, std::nullopt, ICON_NONE);
431}
432
433static void panel_register(ARegionType *region_type)
434{
437 region_type, "subdivide", "Subdivision", nullptr, subdivisions_panel_draw, panel_type);
438 modifier_subpanel_register(region_type, "shape", "Shape", nullptr, shape_panel_draw, panel_type);
440 region_type, "generate", "Generate", nullptr, generate_panel_draw, panel_type);
442 region_type, "advanced", "Advanced", nullptr, advanced_panel_draw, panel_type);
443}
444
446 /*idname*/ "Multires",
447 /*name*/ N_("Multires"),
448 /*struct_name*/ "MultiresModifierData",
449 /*struct_size*/ sizeof(MultiresModifierData),
450 /*srna*/ &RNA_MultiresModifier,
454 /*icon*/ ICON_MOD_MULTIRES,
455
456 /*copy_data*/ copy_data,
457
458 /*deform_verts*/ nullptr,
459 /*deform_matrices*/ deform_matrices,
460 /*deform_verts_EM*/ nullptr,
461 /*deform_matrices_EM*/ nullptr,
462 /*modify_mesh*/ modify_mesh,
463 /*modify_geometry_set*/ nullptr,
464
465 /*init_data*/ init_data,
466 /*required_data_mask*/ nullptr,
467 /*free_data*/ free_data,
468 /*is_disabled*/ nullptr,
469 /*update_depsgraph*/ nullptr,
470 /*depends_on_time*/ nullptr,
471 /*depends_on_normals*/ nullptr,
472 /*foreach_ID_link*/ nullptr,
473 /*foreach_tex_link*/ nullptr,
474 /*free_runtime_data*/ free_runtime_data,
475 /*panel_register*/ panel_register,
476 /*blend_write*/ nullptr,
477 /*blend_read*/ nullptr,
478 /*foreach_cache*/ nullptr,
479 /*foreach_working_space_color*/ nullptr,
480};
481
482} // namespace blender
CustomData interface, see also DNA_customdata_types.h.
#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)
void free(Subdiv *subdiv)
Definition subdiv.cc:192
void displacement_attach_from_multires(Subdiv *subdiv, const Mesh *mesh, const MultiresModifierData *mmd)
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)
Subdiv * update_from_mesh(Subdiv *subdiv, const Settings *settings, const Mesh *mesh)
Definition subdiv.cc:181
void mesh_set_custom_normals_normalized(Mesh &mesh, MutableSpan< float3 > corner_normals)
BMesh Iterators.
static void generate_panel_draw(const bContext *, Panel *panel)
static void copy_data(const ModifierData *md, ModifierData *target, const int flag)
@ UI_SUBPANEL_DATA_EXPAND_1
@ UI_PANEL_DATA_EXPAND_ROOT
static Mesh * multires_as_ccg(MultiresModifierData *mmd, const ModifierEvalContext *ctx, Mesh *mesh, bke::subdiv::Subdiv *subdiv)
int RNA_enum_get(PointerRNA *ptr, const char *name)
void BKE_modifier_set_error(const Object *ob, ModifierData *md, const char *format,...) ATTR_PRINTF_FORMAT(3
PointerRNA * modifier_panel_get_property_pointers(Panel *panel, PointerRNA *r_ob_ptr)
bool CustomData_free_layers(CustomData *data, eCustomDataType type)
bool CustomData_has_layer(const CustomData *data, eCustomDataType type)
void RNA_string_set(PointerRNA *ptr, const char *name, const char *value)
static void shape_panel_draw(const bContext *, Panel *panel)
static void init_data(ModifierData *md)
static void multires_ccg_settings_init(SubdivToCCGSettings *settings, const MultiresModifierData *mmd, const ModifierEvalContext *ctx, const Mesh *mesh)
int RNA_int_get(PointerRNA *ptr, const char *name)
void RNA_enum_set(PointerRNA *ptr, const char *name, int value)
void BKE_multires_subdiv_settings_init(bke::subdiv::Settings *settings, const MultiresModifierData *mmd)
void modifier_error_message_draw(ui::Layout &layout, PointerRNA *ptr)
static Mesh * multires_as_mesh(const MultiresModifierData *mmd, const ModifierEvalContext *ctx, Mesh *mesh, bke::subdiv::Subdiv *subdiv)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
BMesh const char void * data
static void free_data(ModifierData *md)
@ MOD_APPLY_TO_ORIGINAL
@ MOD_APPLY_IGNORE_SIMPLIFY
static void panel_register(ARegionType *region_type)
ModifierTypeInfo modifierType_Multires
void BKE_multires_subdiv_mesh_settings_init(bke::subdiv::ToMeshSettings *mesh_settings, const Scene *scene, const Object *object, const MultiresModifierData *mmd, bool use_render_params, bool ignore_simplify, bool ignore_control_edges)
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 bke::subdiv::Subdiv * subdiv_descriptor_ensure(MultiresModifierData *mmd, const bke::subdiv::Settings *subdiv_settings, const Mesh *mesh)
static Mesh * modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh)
Definition MOD_array.cc:873
@ eModifierTypeFlag_SupportsMapping
@ eModifierTypeFlag_AcceptsMesh
@ eModifierTypeFlag_RequiresOriginalData
void RNA_boolean_set(PointerRNA *ptr, const char *name, bool value)
int multires_get_level(const Scene *scene, const Object *ob, const MultiresModifierData *mmd, bool render, bool ignore_simplify)
Definition multires.cc:212
static void advanced_panel_draw(const bContext *, Panel *panel)
PanelType * modifier_panel_register(ARegionType *region_type, ModifierType type, PanelDrawFn draw)
@ eMultiresModifierFlag_UseSculptBaseMesh
@ eMultiresModifierFlag_UseCustomNormals
static void panel_draw(const bContext *, Panel *panel)
PanelType * modifier_subpanel_register(ARegionType *region_type, const char *name, const char *label, PanelDrawFn draw_header, PanelDrawFn draw, PanelType *parent)
static MultiresRuntimeData * multires_ensure_runtime(MultiresModifierData *mmd)
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)
void * CustomData_get_layer_for_write(CustomData *data, eCustomDataType type, int totelem)
VecBase< float, 3 > float3
Scene * DEG_get_evaluated_scene(const Depsgraph *graph)
Object * CTX_data_active_object(const bContext *C)
static void subdivisions_panel_draw(const bContext *, Panel *panel)
signed char int8_t
Definition BKE_text.h:76
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)
bke::subdiv::Subdiv * subdiv
bke::ObjectRuntime * runtime
ui::Layout * layout
MultiresModifierData * multires_modifier
Definition BKE_paint.hh:385
void enabled_set(bool enabled)
void use_property_split_set(bool is_sep)
PointerRNA op(wmOperatorType *ot, std::optional< StringRef > name, int icon, wm::OpCallContext context, eUI_Item_Flag flag)
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 & column(bool align)
void separator(float factor=1.0f, LayoutSeparatorType type=LayoutSeparatorType::Auto)
Layout & row(bool align)
#define N_(msgid)