Blender V5.3
multires.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2007 by Nicholas Bishop. All rights reserved.
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "MEM_guardedalloc.h"
10
11/* for reading old multires */
12#define DNA_DEPRECATED_ALLOW
13
14#include "DNA_mesh_types.h"
15#include "DNA_meshdata_types.h"
16#include "DNA_object_types.h"
17#include "DNA_scene_types.h"
18
19#include "BLI_bitmap.hh"
20#include "BLI_index_mask.hh"
21#include "BLI_listbase.hh"
22#include "BLI_math_matrix_c.hh"
23#include "BLI_math_vector_c.hh"
24#include "BLI_task_c.hh"
25
26#include "BKE_ccg.hh"
27#include "BKE_editmesh.hh"
28#include "BKE_lib_id.hh"
29#include "BKE_mesh.h"
30#include "BKE_mesh_runtime.hh"
31#include "BKE_mesh_types.hh"
32#include "BKE_modifier.hh"
33#include "BKE_multires.hh"
34#include "BKE_paint.hh"
35#include "BKE_paint_bvh.hh"
36#include "BKE_scene.hh"
37#include "BKE_subdiv.hh"
38#include "BKE_subdiv_ccg.hh"
39
40#include "BKE_object.hh"
41
43
44#include <cmath>
45#include <cstring>
46
47namespace blender {
48
49/* MULTIRES MODIFIER */
50static const int multires_grid_tot[] = {
51 0, 4, 9, 25, 81, 289, 1089, 4225, 16641, 66049, 263169, 1050625, 4198401, 16785409};
52static const int multires_side_tot[] = {
53 0, 2, 3, 5, 9, 17, 33, 65, 129, 257, 513, 1025, 2049, 4097};
54
56
58{
60 /* CustomData_external_remove is used here only to mark layer
61 * as non-external for further freeing, so zero element count
62 * looks safer than `bm->totface`. */
64
67 }
68
71 }
72 }
73 else {
74 CustomData_external_remove(&mesh->corner_data, &mesh->id, CD_MDISPS, mesh->corners_num);
76
78 }
79}
80
82 const int old_level,
83 const int new_level)
84{
85 const int new_gridsize = CCG_grid_size(new_level);
86 const int old_gridsize = CCG_grid_size(old_level);
87
88 BLI_assert(new_level <= old_level);
89 const int factor = CCG_grid_factor(new_level, old_level);
90 BLI_bitmap *new_hidden = BLI_BITMAP_NEW(square_i(new_gridsize), "downsample hidden");
91
92 for (int y = 0; y < new_gridsize; y++) {
93 for (int x = 0; x < new_gridsize; x++) {
94 const int old_value = BLI_BITMAP_TEST(old_hidden, factor * y * old_gridsize + x * factor);
95
96 BLI_BITMAP_SET(new_hidden, y * new_gridsize + x, old_value);
97 }
98 }
99
100 return new_hidden;
101}
102
103Mesh *BKE_multires_create_mesh(Depsgraph *depsgraph, Object *object, MultiresModifierData *mmd)
104{
105 Object *object_eval = DEG_get_evaluated(depsgraph, object);
106 Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
107 const Mesh *deformed_mesh = bke::mesh_get_eval_deform(
108 depsgraph, scene_eval, object_eval, &CD_MASK_BAREMESH);
109 ModifierEvalContext modifier_ctx{};
110 modifier_ctx.depsgraph = depsgraph;
111 modifier_ctx.object = object_eval;
113
114 Mesh *input_i = BKE_mesh_copy_for_eval(*deformed_mesh);
115
117 Mesh *result = mti->modify_mesh(&mmd->modifier, &modifier_ctx, input_i);
118
119 if (result != input_i) {
120 BKE_id_free(nullptr, input_i);
121 }
122 return result;
123}
124
126 Object *object,
128{
129 Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
130 Object *object_eval = DEG_get_evaluated(depsgraph, object);
131
132 Object object_for_eval = dna::shallow_copy(*object_eval);
133 bke::ObjectRuntime runtime = *object_eval->runtime;
134 object_for_eval.runtime = &runtime;
135
136 object_for_eval.data = object->data;
137 object_for_eval.runtime->sculpt_session = nullptr;
138
139 const bool use_render = (DEG_get_mode(depsgraph) == DAG_EVAL_RENDER);
140 ModifierEvalContext mesh_eval_context = {depsgraph, &object_for_eval, ModifierApplyFlag(0)};
141 if (use_render) {
142 mesh_eval_context.flag |= MOD_APPLY_RENDER;
143 }
144 const int required_mode = use_render ? eModifierMode_Render : eModifierMode_Realtime;
145
146 VirtualModifierData virtual_modifier_data;
147 ModifierData *first_md = BKE_modifiers_get_virtual_modifierlist(&object_for_eval,
148 &virtual_modifier_data);
149
150 Mesh *base_mesh = id_cast<Mesh *>(object->data);
151
152 Array<float3> deformed_verts(base_mesh->vert_positions());
153
154 for (ModifierData *md = first_md; md != nullptr; md = md->next) {
155 const ModifierTypeInfo *mti = BKE_modifier_get_info(md->type);
156 if (md == &mmd->modifier) {
157 break;
158 }
159 if (!BKE_modifier_is_enabled(scene_eval, md, required_mode)) {
160 continue;
161 }
163 break;
164 }
165 BKE_modifier_deform_verts(md, &mesh_eval_context, base_mesh, deformed_verts);
166 }
167
168 return deformed_verts;
169}
170
172{
173
174 for (ModifierData *md = lastmd; md; md = md->prev) {
175 if (md->type == eModifierType_Multires) {
177 return reinterpret_cast<MultiresModifierData *>(md);
178 }
179 }
180 }
181
182 return nullptr;
183}
184
185MultiresModifierData *get_multires_modifier(Scene *scene, Object *ob, const bool use_first)
186{
187 MultiresModifierData *mmd = nullptr, *firstmmd = nullptr;
188
189 /* find first active multires modifier */
190 for (ModifierData &md : ob->modifiers) {
191 if (md.type == eModifierType_Multires) {
192 if (!firstmmd) {
193 firstmmd = reinterpret_cast<MultiresModifierData *>(&md);
194 }
195
197 mmd = reinterpret_cast<MultiresModifierData *>(&md);
198 break;
199 }
200 }
201 }
202
203 if (!mmd && use_first) {
204 /* active multires have not been found
205 * try to use first one */
206 return firstmmd;
207 }
208
209 return mmd;
210}
211
212int multires_get_level(const Scene *scene,
213 const Object *ob,
214 const MultiresModifierData *mmd,
215 const bool render,
216 const bool ignore_simplify)
217{
218 if (render) {
219 return (scene != nullptr) ? get_render_subsurf_level(&scene->r, mmd->renderlvl, true) :
220 mmd->renderlvl;
221 }
222 if (ob->mode == OB_MODE_SCULPT) {
223 return mmd->sculptlvl;
224 }
225 if (ignore_simplify) {
226 return mmd->lvl;
227 }
228
229 return (scene != nullptr) ? get_render_subsurf_level(&scene->r, mmd->lvl, false) : mmd->lvl;
230}
231
233{
234 mmd->totlvl = lvl;
235
236 if (ob->mode != OB_MODE_SCULPT) {
237 mmd->lvl = std::clamp<char>(std::max<char>(mmd->lvl, lvl), 0, mmd->totlvl);
238 }
239
240 mmd->sculptlvl = std::clamp<char>(std::max<char>(mmd->sculptlvl, lvl), 0, mmd->totlvl);
241 mmd->renderlvl = std::clamp<char>(std::max<char>(mmd->renderlvl, lvl), 0, mmd->totlvl);
242}
243
245{
246 if (flags & MULTIRES_COORDS_MODIFIED) {
247 subdiv_ccg->dirty.coords = true;
248 }
249 if (flags & MULTIRES_HIDDEN_MODIFIED) {
250 subdiv_ccg->dirty.hidden = true;
251 }
252}
253
254void multires_mark_as_modified(Depsgraph *depsgraph,
255 Object *object,
256 const MultiresModifiedFlags flags)
257{
258 if (object == nullptr) {
259 return;
260 }
261 /* NOTE: CCG live inside of evaluated object.
262 *
263 * While this is a bit weird to tag the only one, this is how other areas were built
264 * historically: they are tagging multires for update and then rely on object re-evaluation to
265 * do an actual update.
266 *
267 * In a longer term maybe special dependency graph tag can help sanitizing this a bit. */
268 Object *object_eval = DEG_get_evaluated(depsgraph, object);
269 Mesh *mesh = id_cast<Mesh *>(object_eval->data);
270 SubdivCCG *subdiv_ccg = mesh->runtime->subdiv_ccg.get();
271 if (subdiv_ccg == nullptr) {
272 return;
273 }
274 multires_ccg_mark_as_modified(subdiv_ccg, flags);
275}
276
278{
279 if (object == nullptr || object->runtime->sculpt_session == nullptr) {
280 return;
281 }
283 if (!pbvh) {
284 return;
285 }
286
287 SculptSession *sculpt_session = object->runtime->sculpt_session;
288 if (pbvh->type() != bke::pbvh::Type::Grids || sculpt_session->multires_modifier == nullptr) {
289 return;
290 }
291
292 SubdivCCG *subdiv_ccg = sculpt_session->subdiv_ccg;
293 if (subdiv_ccg == nullptr) {
294 return;
295 }
296
297 if (!subdiv_ccg->dirty.coords && !subdiv_ccg->dirty.hidden) {
298 return;
299 }
300
301 Mesh *mesh = id_cast<Mesh *>(object->data);
302
303 /* Check that the multires modifier still exists.
304 * Fixes crash when deleting multires modifier
305 * from within sculpt mode.
306 */
307 MultiresModifierData *mmd = nullptr;
308 VirtualModifierData virtual_modifier_data;
309
310 for (ModifierData *md = BKE_modifiers_get_virtual_modifierlist(object, &virtual_modifier_data);
311 md;
312 md = md->next)
313 {
314 if (md->type == eModifierType_Multires) {
316 mmd = reinterpret_cast<MultiresModifierData *>(md);
317 }
318 }
319 }
320
321 if (!mmd) {
322 return;
323 }
324
326 sculpt_session->multires_modifier->totlvl, mesh, sculpt_session->subdiv_ccg);
327
328 subdiv_ccg->dirty.coords = false;
329 subdiv_ccg->dirty.hidden = false;
330}
331
333{
335
336 if (object == nullptr || object->runtime->sculpt_session == nullptr) {
337 return;
338 }
339
341}
342
344{
345 Mesh *mesh = BKE_mesh_from_object(object);
346
347 CustomData_external_reload(&mesh->corner_data, &mesh->id, CD_MASK_MDISPS, mesh->corners_num);
349}
350
351/* reset the multires levels to match the number of mdisps */
353{
354 Mesh *mesh = id_cast<Mesh *>(ob->data);
355 const OffsetIndices faces = mesh->faces();
356 int totlvl = 0;
357
358 const MDisps *mdisp = static_cast<const MDisps *>(
359 CustomData_get_layer(&mesh->corner_data, CD_MDISPS));
360
361 for (const int i : faces.index_range()) {
362 for (const int corner : faces[i]) {
363 const MDisps *md = &mdisp[corner];
364 if (md->totdisp == 0) {
365 continue;
366 }
367
368 while (true) {
369 const int side = (1 << (totlvl - 1)) + 1;
370 const int lvl_totdisp = side * side;
371 if (md->totdisp == lvl_totdisp) {
372 break;
373 }
374 if (md->totdisp < lvl_totdisp) {
375 totlvl--;
376 }
377 else {
378 totlvl++;
379 }
380 }
381
382 break;
383 }
384 }
385
386 return totlvl;
387}
388
390{
391 Mesh *mesh = id_cast<Mesh *>(ob->data);
392 const MDisps *mdisp;
393
394 if (const BMesh *bm = BKE_editmesh_bmesh_get(mesh)) {
395 mdisp = static_cast<const MDisps *>(CustomData_get_layer(&bm->ldata, CD_MDISPS));
396 }
397 else {
398 mdisp = static_cast<const MDisps *>(CustomData_get_layer(&mesh->corner_data, CD_MDISPS));
399 }
400
401 if (mdisp) {
402 mmd->totlvl = get_levels_from_disps(ob);
403 mmd->lvl = std::min(mmd->lvl, mmd->totlvl);
404 mmd->sculptlvl = std::min(mmd->sculptlvl, mmd->totlvl);
405 mmd->renderlvl = std::min(mmd->renderlvl, mmd->totlvl);
406 }
407}
408
409static void multires_set_tot_mdisps(Mesh *mesh, const int lvl)
410{
411 MDisps *mdisps = static_cast<MDisps *>(
412 CustomData_get_layer_for_write(&mesh->corner_data, CD_MDISPS, mesh->corners_num));
413
414 if (mdisps) {
415 for (int i = 0; i < mesh->corners_num; i++, mdisps++) {
416 mdisps->totdisp = multires_grid_tot[lvl];
417 }
418 }
419}
420
421static void multires_copy_grid(float (*gridA)[3],
422 float (*gridB)[3],
423 const int sizeA,
424 const int sizeB)
425{
426 int x, y, j, skip;
427
428 if (sizeA > sizeB) {
429 skip = (sizeA - 1) / (sizeB - 1);
430
431 for (j = 0, y = 0; y < sizeB; y++) {
432 for (x = 0; x < sizeB; x++, j++) {
433 copy_v3_v3(gridA[y * skip * sizeA + x * skip], gridB[j]);
434 }
435 }
436 }
437 else {
438 skip = (sizeB - 1) / (sizeA - 1);
439
440 for (j = 0, y = 0; y < sizeA; y++) {
441 for (x = 0; x < sizeA; x++, j++) {
442 copy_v3_v3(gridA[j], gridB[y * skip * sizeB + x * skip]);
443 }
444 }
445 }
446}
447
448/* Reallocate gpm->data at a lower resolution and copy values over
449 * from the original high-resolution data */
450static void multires_grid_paint_mask_downsample(GridPaintMask *gpm, const int level)
451{
452 if (level < gpm->level) {
453 const int gridsize = CCG_grid_size(level);
454 float *data = MEM_new_array_zeroed<float>(size_t(square_i(gridsize)), __func__);
455
456 for (int y = 0; y < gridsize; y++) {
457 for (int x = 0; x < gridsize; x++) {
458 data[y * gridsize + x] = BKE_paint_grid_paint_mask(gpm, level, x, y);
459 }
460 }
461
462 MEM_delete(gpm->data);
463 gpm->data = data;
464 gpm->level = level;
465 }
466}
467
468static void multires_del_higher(MultiresModifierData *mmd, Object *ob, const int lvl)
469{
470 Mesh *mesh = id_cast<Mesh *>(ob->data);
471 const OffsetIndices faces = mesh->faces();
472 const int levels = mmd->totlvl - lvl;
473 MDisps *mdisps;
474 GridPaintMask *gpm;
475
478 mdisps = static_cast<MDisps *>(
479 CustomData_get_layer_for_write(&mesh->corner_data, CD_MDISPS, mesh->corners_num));
480 gpm = static_cast<GridPaintMask *>(
481 CustomData_get_layer_for_write(&mesh->corner_data, CD_GRID_PAINT_MASK, mesh->corners_num));
482
484
485 if (mdisps && levels > 0) {
486 if (lvl > 0) {
487 const int nsize = multires_side_tot[lvl];
488 const int hsize = multires_side_tot[mmd->totlvl];
489
490 for (const int i : faces.index_range()) {
491 for (const int corner : faces[i]) {
492 MDisps *mdisp = &mdisps[corner];
493 const int totdisp = multires_grid_tot[lvl];
494
495 float (*disps)[3] = MEM_new_array_zeroed<float[3]>(totdisp, "multires disps");
496
497 if (mdisp->disps != nullptr) {
498 float (*ndisps)[3] = disps;
499 float (*hdisps)[3] = mdisp->disps;
500
501 multires_copy_grid(ndisps, hdisps, nsize, hsize);
502 if (mdisp->hidden) {
504 MEM_delete(mdisp->hidden);
505 mdisp->hidden = gh;
506 }
507
508 MEM_delete(mdisp->disps);
509 }
510
511 mdisp->disps = disps;
512 mdisp->totdisp = totdisp;
513
514 if (gpm) {
515 multires_grid_paint_mask_downsample(&gpm[corner], lvl);
516 }
517 }
518 }
519 }
520 else {
522 }
523 }
524
525 multires_set_tot_level(ob, mmd, lvl);
526}
527
529 Scene *scene,
530 Object *ob,
531 const int direction)
532{
534 const int lvl = multires_get_level(scene, ob, mmd, false, true);
535 const int levels = mmd->totlvl - lvl;
536
539 MDisps *mdisps = static_cast<MDisps *>(
540 CustomData_get_layer_for_write(&mesh->corner_data, CD_MDISPS, mesh->corners_num));
541
543
544 if (mdisps && levels > 0 && direction == 1) {
545 multires_del_higher(mmd, ob, lvl);
546 }
547
548 multires_set_tot_level(ob, mmd, lvl);
549}
550
552{
553 if (ob == nullptr) {
554 return;
555 }
556 SculptSession *sculpt_session = ob->runtime->sculpt_session;
557 if (sculpt_session == nullptr) {
558 return;
559 }
560 SubdivCCG *subdiv_ccg = sculpt_session->subdiv_ccg;
561 if (subdiv_ccg == nullptr) {
562 return;
563 }
566 BKE_subdiv_ccg_average_stitch_faces(*subdiv_ccg, IndexMask(subdiv_ccg->faces.size()));
567}
568
569void old_mdisps_bilinear(float out[3], float (*disps)[3], const int st, float u, float v)
570{
571 const int st_max = st - 1;
572 float d[4][3], d2[2][3];
573
574 if (!disps || isnan(u) || isnan(v)) {
575 return;
576 }
577
578 if (u < 0) {
579 u = 0;
580 }
581 else if (u >= st) {
582 u = st_max;
583 }
584 if (v < 0) {
585 v = 0;
586 }
587 else if (v >= st) {
588 v = st_max;
589 }
590
591 const int x = floor(u);
592 const int y = floor(v);
593 int x2 = x + 1;
594 int y2 = y + 1;
595
596 if (x2 >= st) {
597 x2 = st_max;
598 }
599 if (y2 >= st) {
600 y2 = st_max;
601 }
602
603 const float urat = u - x;
604 const float vrat = v - y;
605 const float uopp = 1 - urat;
606
607 mul_v3_v3fl(d[0], disps[y * st + x], uopp);
608 mul_v3_v3fl(d[1], disps[y * st + x2], urat);
609 mul_v3_v3fl(d[2], disps[y2 * st + x], uopp);
610 mul_v3_v3fl(d[3], disps[y2 * st + x2], urat);
611
612 add_v3_v3v3(d2[0], d[0], d[1]);
613 add_v3_v3v3(d2[1], d[2], d[3]);
614 mul_v3_fl(d2[0], 1 - vrat);
615 mul_v3_fl(d2[1], vrat);
616
617 add_v3_v3v3(out, d2[0], d2[1]);
618}
619
621 const MultiresModifierData *mmd_src,
622 MultiresModifierData *mmd_dst)
623{
624 if (mmd_src->totlvl == mmd_dst->totlvl) {
625 return;
626 }
627
628 if (mmd_src->totlvl > mmd_dst->totlvl) {
630 ob_dst, mmd_dst, mmd_src->totlvl, MultiresSubdivideModeType::CatmullClark);
631 }
632 else {
633 multires_del_higher(mmd_dst, ob_dst, mmd_src->totlvl);
634 }
635}
636
637static void multires_sync_levels(Scene *scene, Object *ob_src, Object *ob_dst)
638{
639 MultiresModifierData *mmd_src = get_multires_modifier(scene, ob_src, true);
640 MultiresModifierData *mmd_dst = get_multires_modifier(scene, ob_dst, true);
641
642 if (!mmd_src) {
643 /* NOTE(@sergey): object could have MDISP even when there is no multires modifier
644 * this could lead to troubles due to I've got no idea how mdisp could be
645 * up-sampled correct without modifier data. Just remove mdisps if no multires present. */
646 multires_customdata_delete(id_cast<Mesh *>(ob_src->data));
647 }
648
649 if (mmd_src && mmd_dst) {
650 multiresModifier_sync_levels_ex(ob_dst, mmd_src, mmd_dst);
651 }
652}
653
654static void multires_apply_uniform_scale(Object *object, const float scale)
655{
656 Mesh *mesh = id_cast<Mesh *>(object->data);
657 MDisps *mdisps = static_cast<MDisps *>(
658 CustomData_get_layer_for_write(&mesh->corner_data, CD_MDISPS, mesh->corners_num));
659 for (int i = 0; i < mesh->corners_num; i++) {
660 MDisps *grid = &mdisps[i];
661 for (int j = 0; j < grid->totdisp; j++) {
662 mul_v3_fl(grid->disps[j], scale);
663 }
664 }
665}
666
667static void multires_apply_smat(Depsgraph * /*depsgraph*/,
668 Scene *scene,
669 Object *object,
670 const float smat[3][3])
671{
672 const MultiresModifierData *mmd = get_multires_modifier(scene, object, true);
673 if (mmd == nullptr || mmd->totlvl == 0) {
674 return;
675 }
676 /* Make sure layer present. */
677 Mesh *mesh = id_cast<Mesh *>(object->data);
679 if (!CustomData_get_layer(&mesh->corner_data, CD_MDISPS)) {
680 return;
681 }
682 if (is_uniform_scaled_m3(smat)) {
683 const float scale = mat3_to_scale(smat);
685 }
686 else {
687 /* TODO(@sergey): This branch of code actually requires more work to
688 * preserve all the details. */
689 const float scale = mat3_to_scale(smat);
691 }
692}
693
695{
696 int lvl = 13;
697
698 while (lvl > 0) {
699 const int side = (1 << (lvl - 1)) + 1;
700 if ((s->totdisp % (side * side)) == 0) {
701 return s->totdisp / (side * side);
702 }
703 lvl--;
704 }
705
706 return 0;
707}
708
709void multiresModifier_scale_disp(Depsgraph *depsgraph, Scene *scene, Object *ob)
710{
711 float smat[3][3];
712
713 /* object's scale matrix */
714 BKE_object_scale_to_mat3(ob, smat);
715
716 multires_apply_smat(depsgraph, scene, ob, smat);
717}
718
719void multiresModifier_prepare_join(Depsgraph *depsgraph, Scene *scene, Object *ob, Object *to_ob)
720{
721 float smat[3][3], tmat[3][3], mat[3][3];
722 multires_sync_levels(scene, to_ob, ob);
723
724 /* construct scale matrix for displacement */
725 BKE_object_scale_to_mat3(to_ob, tmat);
726 invert_m3(tmat);
727 BKE_object_scale_to_mat3(ob, smat);
728 mul_m3_m3m3(mat, smat, tmat);
729
730 multires_apply_smat(depsgraph, scene, ob, mat);
731}
732
734{
735 CustomData_external_read(&mesh->corner_data, "", &mesh->id, CD_MASK_MDISPS, mesh->corners_num);
736 MDisps *mdisp = static_cast<MDisps *>(
737 CustomData_get_layer_for_write(&mesh->corner_data, CD_MDISPS, mesh->corners_num));
738
739 if (!mdisp) {
740 return;
741 }
742
743 MDisps *cur = mdisp;
744 int grid = 0;
745 for (int i = 0; i < mesh->corners_num; i++, cur++) {
746 if (cur->totdisp) {
747 grid = mdisp->totdisp;
748
749 break;
750 }
751 }
752
753 for (int i = 0; i < mesh->corners_num; i++, mdisp++) {
754 /* allocate memory for mdisp, the whole disp layer would be erased otherwise */
755 if (!mdisp->totdisp || !mdisp->disps) {
756 if (grid) {
757 mdisp->totdisp = grid;
758 mdisp->disps = MEM_new_array_zeroed<float[3]>(mdisp->totdisp, "mdisp topology");
759 }
760
761 continue;
762 }
763 }
764}
765
766void multires_ensure_external_read(Mesh *mesh, const int top_level)
767{
768 if (!CustomData_external_test(&mesh->corner_data, CD_MDISPS)) {
769 return;
770 }
771
772 /* Modify the data array from the original mesh, not the evaluated mesh.
773 * When multiple objects share the same mesh, this can lead to memory leaks. */
774 MDisps *mdisps = const_cast<MDisps *>(
775 static_cast<const MDisps *>(CustomData_get_layer(&mesh->corner_data, CD_MDISPS)));
776 if (mdisps == nullptr) {
777 mdisps = static_cast<MDisps *>(
778 CustomData_add_layer(&mesh->corner_data, CD_MDISPS, CD_SET_DEFAULT, mesh->corners_num));
779 }
780
781 const int totloop = mesh->corners_num;
782
783 const int grid_size = bke::subdiv::grid_size_from_level(top_level);
784 const int grid_area = grid_size * grid_size;
785
786 for (int i = 0; i < totloop; ++i) {
787 if (mdisps[i].totdisp != grid_area) {
788 MEM_SAFE_DELETE(mdisps[i].disps);
789 }
790
791 /* NOTE: CustomData_external_read will take care of allocation of displacement vectors if
792 * they are missing. */
793
794 const int totdisp = multires_grid_tot[top_level];
795 mdisps[i].totdisp = totdisp;
796 }
797
798 CustomData_external_read(&mesh->corner_data, "", &mesh->id, CD_MASK_MDISPS, mesh->corners_num);
799}
804
805} // namespace blender
General operations, lookup, etc. for blender objects.
A BVH for high poly meshes.
#define BLI_BITMAP_NEW(_num, _alloc_string)
Definition BLI_bitmap.hh:39
#define BLI_BITMAP_TEST(_bitmap, _index)
Definition BLI_bitmap.hh:63
#define BLI_BITMAP_SET(_bitmap, _index, _set)
Object is a sort of wrapper for general info.
Read Blender memory allocation and freeing.
#define CD_MASK_MDISPS
#define isnan
#define floor
float3x3 scale(float3x3 mat, float2 scale)
pbvh::Tree * pbvh_get(Object &object)
BLI_INLINE int grid_size_from_level(int level)
const Mesh * mesh_get_eval_deform(Depsgraph *depsgraph, const Scene *scene, Object *ob, const CustomData_MeshMasks *dataMask)
internal::ShallowDataConstRef< T > shallow_copy(const T &other)
Definition DNA_defs.h:147
BMesh Iterators.
bool CustomData_external_test(CustomData *data, eCustomDataType type)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void multires_topology_changed(Mesh *mesh)
Definition multires.cc:733
void multires_mark_as_modified(Depsgraph *depsgraph, Object *object, MultiresModifiedFlags flags)
Definition multires.cc:254
const CustomData_MeshMasks CD_MASK_BAREMESH
bool CustomData_free_layer_active(CustomData *data, eCustomDataType type)
BMesh * BKE_editmesh_bmesh_get_for_write(Mesh *mesh)
Definition editmesh.cc:79
MINLINE void copy_v3_v3(float r[3], const float a[3])
Mesh * BKE_multires_create_mesh(Depsgraph *depsgraph, Object *object, MultiresModifierData *mmd)
Definition multires.cc:103
static const int multires_grid_tot[]
Definition multires.cc:50
MINLINE void add_v3_v3v3(float r[3], const float a[3], const float b[3])
MINLINE int square_i(int a)
bool CustomData_has_layer(const CustomData *data, eCustomDataType type)
static void multires_apply_uniform_scale(Object *object, const float scale)
Definition multires.cc:654
Mesh * BKE_mesh_copy_for_eval(const Mesh &source)
void multiresModifier_scale_disp(Depsgraph *depsgraph, Scene *scene, Object *ob)
Definition multires.cc:709
int get_render_subsurf_level(const RenderData *r, int lvl, bool for_render)
Definition scene.cc:3006
bool is_uniform_scaled_m3(const float m[3][3])
static void multires_sync_levels(Scene *scene, Object *ob_src, Object *ob_dst)
Definition multires.cc:637
void multiresModifier_subdivide_to_level(Object *object, MultiresModifierData *mmd, int top_level, MultiresSubdivideModeType mode)
int CCG_grid_factor(int low_level, int high_level)
Definition BKE_ccg.hh:112
ATTR_WARN_UNUSED_RESULT const BMVert * v
void BM_data_layer_free(BMesh *bm, CustomData *data, int type)
static int get_levels_from_disps(Object *ob)
Definition multires.cc:352
void BKE_sculptsession_free_pbvh(Object &object)
void multiresModifier_del_levels(MultiresModifierData *mmd, Scene *scene, Object *object, int direction)
Definition multires.cc:528
static void multires_apply_smat(Depsgraph *, Scene *scene, Object *object, const float smat[3][3])
Definition multires.cc:667
void CustomData_external_reload(CustomData *data, ID *id, eCustomDataMask mask, int totelem)
MINLINE void mul_v3_fl(float r[3], float f)
void multires_flush_sculpt_updates(Object *object)
Definition multires.cc:277
Array< float3 > BKE_multires_create_deformed_base_mesh_vert_coords(Depsgraph *depsgraph, Object *object, MultiresModifierData *mmd)
Definition multires.cc:125
void multires_customdata_delete(Mesh *mesh)
Definition multires.cc:57
void multires_force_external_reload(Object *object)
Definition multires.cc:343
bool BKE_modifier_deform_verts(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh, MutableSpan< float3 > positions)
void old_mdisps_bilinear(float out[3], float(*disps)[3], int st, float u, float v)
Definition multires.cc:569
int multires_mdisp_corners(const MDisps *s)
Definition multires.cc:694
void BKE_object_scale_to_mat3(const Object *ob, float r_mat[3][3])
Definition object.cc:2899
MultiresModifierData * get_multires_modifier(Scene *scene, Object *ob, bool use_first)
Definition multires.cc:185
BMesh const char void * data
Mesh * BKE_mesh_from_object(Object *ob)
T * DEG_get_evaluated(const Depsgraph *depsgraph, T *id)
MultiresModifiedFlags
@ MULTIRES_COORDS_MODIFIED
@ MULTIRES_HIDDEN_MODIFIED
@ MOD_APPLY_IGNORE_SIMPLIFY
@ MOD_APPLY_USECACHE
void multires_stitch_grids(Object *)
Definition multires.cc:551
ModifierData * BKE_modifiers_get_virtual_modifierlist(const Object *ob, VirtualModifierData *data)
void multiresModifier_ensure_external_read(Mesh *mesh, const MultiresModifierData *mmd)
Definition multires.cc:800
static BLI_bitmap * multires_mdisps_downsample_hidden(const BLI_bitmap *old_hidden, const int old_level, const int new_level)
Definition multires.cc:81
const void * CustomData_get_layer(const CustomData *data, eCustomDataType type)
static void multires_grid_paint_mask_downsample(GridPaintMask *gpm, const int level)
Definition multires.cc:450
void multires_force_sculpt_rebuild(Object *object)
Definition multires.cc:332
static const int multires_side_tot[]
Definition multires.cc:52
void multiresModifier_sync_levels_ex(Object *ob_dst, const MultiresModifierData *mmd_src, MultiresModifierData *mmd_dst)
Definition multires.cc:620
void multires_set_tot_level(Object *ob, MultiresModifierData *mmd, int lvl)
Definition multires.cc:232
void BKE_id_free(Main *bmain, void *idv)
void multires_ensure_external_read(Mesh *mesh, int top_level)
Definition multires.cc:766
void CustomData_external_remove(CustomData *data, ID *id, eCustomDataType type, int totelem)
eEvaluationMode DEG_get_mode(const Depsgraph *graph)
float BKE_paint_grid_paint_mask(const GridPaintMask *gpm, uint level, uint x, uint y)
static void multires_copy_grid(float(*gridA)[3], float(*gridB)[3], const int sizeA, const int sizeB)
Definition multires.cc:421
bool invert_m3(float mat[3][3])
MINLINE void mul_v3_v3fl(float r[3], const float a[3], float f)
int multires_get_level(const Scene *scene, const Object *ob, const MultiresModifierData *mmd, bool render, bool ignore_simplify)
Definition multires.cc:212
unsigned int BLI_bitmap
Definition BLI_bitmap.hh:15
MultiresModifierData * find_multires_modifier_before(Scene *scene, ModifierData *lastmd)
Definition multires.cc:171
bool multiresModifier_reshapeFromCCG(int tot_level, Mesh *coarse_mesh, SubdivCCG *subdiv_ccg)
static void multires_ccg_mark_as_modified(SubdivCCG *subdiv_ccg, const MultiresModifiedFlags flags)
Definition multires.cc:244
int CCG_grid_size(const int level)
Definition BKE_ccg.hh:106
const BMesh * BKE_editmesh_bmesh_get(const Object *ob)
Definition editmesh.cc:65
void * CustomData_get_layer_for_write(CustomData *data, eCustomDataType type, int totelem)
void mul_m3_m3m3(float R[3][3], const float A[3][3], const float B[3][3])
void BKE_subdiv_ccg_average_stitch_faces(SubdivCCG &subdiv_ccg, const IndexMask &face_mask)
Scene * DEG_get_evaluated_scene(const Depsgraph *graph)
void CustomData_external_read(CustomData *data, StringRefNull basepath, ID *id, eCustomDataMask mask, int totelem)
bool BKE_modifier_is_enabled(const Scene *scene, ModifierData *md, int required_mode)
void multiresModifier_set_levels_from_disps(MultiresModifierData *mmd, Object *ob)
Definition multires.cc:389
const ModifierTypeInfo * BKE_modifier_get_info(ModifierType type)
float mat3_to_scale(const float mat[3][3])
static void multires_set_tot_mdisps(Mesh *mesh, const int lvl)
Definition multires.cc:409
void multiresModifier_prepare_join(Depsgraph *depsgraph, Scene *scene, Object *ob, Object *to_ob)
Definition multires.cc:719
static void multires_del_higher(MultiresModifierData *mmd, Object *ob, const int lvl)
Definition multires.cc:468
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
void * CustomData_add_layer(CustomData *data, eCustomDataType type, eCDAllocType alloctype, int totelem)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
unsigned int * hidden
struct ModifierData * next
struct ModifierData * prev
Mesh *(*) modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh)
ListBaseT< ModifierData > modifiers
bke::ObjectRuntime * runtime
struct RenderData r
MultiresModifierData * multires_modifier
Definition BKE_paint.hh:385
OffsetIndices< int > faces
struct blender::SubdivCCG::@356361271106267377043074237104234372210112141040 dirty