Blender V5.3
blenkernel/intern/modifier.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
10
11/* Allow using deprecated functionality for .blend file I/O. */
12#define DNA_DEPRECATED_ALLOW
13
14#include <cfloat>
15#include <chrono>
16#include <cstdarg>
17#include <cstddef>
18#include <cstdlib>
19#include <cstring>
20
21#include "MEM_guardedalloc.h"
22
23#include "DNA_armature_types.h"
24#include "DNA_cloth_types.h"
25#include "DNA_colorband_types.h"
27#include "DNA_fluid_types.h"
28#include "DNA_layer_types.h"
29#include "DNA_mesh_types.h"
32#include "DNA_object_types.h"
33#include "DNA_particle_types.h"
34#include "DNA_scene_types.h"
35#include "DNA_screen_types.h"
36
37#include "BLI_linklist.hh"
38#include "BLI_listbase.hh"
39#include "BLI_path_utils.hh"
40#include "BLI_rand.hh"
41#include "BLI_string.hh"
42#include "BLI_string_utf8.hh"
43#include "BLI_string_utils.hh"
44#include "BLI_threads.hh"
45#include "BLI_utildefines.hh"
46
47#include "BLT_translation.hh"
48
49#include "BKE_appdir.hh"
50#include "BKE_editmesh.hh"
51#include "BKE_editmesh_cache.hh"
52#include "BKE_effect.h"
53#include "BKE_fluid.h"
54#include "BKE_geometry_set.hh"
55#include "BKE_global.hh"
56#include "BKE_idprop.hh"
57#include "BKE_idtype.hh"
58#include "BKE_key.hh"
59#include "BKE_lib_id.hh"
60#include "BKE_lib_query.hh"
61#include "BKE_library.hh"
62#include "BKE_mesh.hh"
64#include "BKE_mesh_wrapper.hh"
65#include "BKE_multires.hh"
66#include "BKE_object.hh"
67#include "BKE_pointcache.h"
68#include "BKE_report.hh"
69#include "BKE_screen.hh"
70
71/* may move these, only for BKE_modifier_path_relbase */
72#include "BKE_main.hh"
73/* end */
74
75#include "DEG_depsgraph.hh"
77
78#include "MOD_modifiertypes.hh"
79
80#include "BLO_read_write.hh"
81
82#include "CLG_log.h"
83
84namespace blender {
85
86static CLG_LogRef LOG = {"object.modifier"};
89
119
121{
122 if (type >= 0 && type < NUM_MODIFIER_TYPES && modifier_types[type] &&
123 modifier_types[type]->name[0] != '\0')
124 {
125 return modifier_types[type];
126 }
127
128 return nullptr;
129}
130
131void BKE_modifier_type_panel_id(ModifierType type, char *r_idname)
132{
133 const ModifierTypeInfo *mti = BKE_modifier_get_info(type);
135}
136
141
142/***/
143
145{
146 const ModifierTypeInfo *mti = BKE_modifier_get_info(type);
147 ModifierData *md = static_cast<ModifierData *>(
149
150 /* NOTE: this name must be made unique later. */
151 STRNCPY_UTF8(md->name, DATA_(mti->name));
152
153 md->type = type;
156 /* Only open the main panel at the beginning, not the sub-panels. */
158
161 }
162
163 if (mti->init_data) {
164 mti->init_data(md);
165 }
166
167 return md;
168}
169
171{
173 return md;
174}
175
176static void modifier_free_data_id_us_cb(void * /*user_data*/,
177 Object * /*ob*/,
178 ID **idpoin,
179 const LibraryForeachIDCallbackFlag cb_flag)
180{
181 ID *id = *idpoin;
182 if (id != nullptr && (cb_flag & IDWALK_CB_USER) != 0) {
183 id_us_min(id);
184 }
185}
186
187void BKE_modifier_free_ex(ModifierData *md, const int flag)
188{
190
191 if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
192 if (mti->foreach_ID_link) {
193 mti->foreach_ID_link(md, nullptr, modifier_free_data_id_us_cb, nullptr);
194 }
195 }
196
197 if (mti->free_data) {
198 mti->free_data(md);
199 }
200 if (md->error) {
201 MEM_delete(md->error);
202 }
203 if (md->system_properties != nullptr) {
205 }
206
207 MEM_delete(md);
208}
209
214
216{
217 BLI_assert(BLI_findindex(&ob->modifiers, md) != -1);
218
219 if (md->flag & eModifierFlag_Active) {
220 /* Prefer the next modifier but use the previous if this modifier is the last in the list. */
221 if (md->next != nullptr) {
223 }
224 else if (md->prev != nullptr) {
226 }
227 }
228
229 BLI_remlink(&ob->modifiers, md);
230}
231
232void BKE_modifier_unique_name(ListBaseT<ModifierData> *modifiers, ModifierData *md)
233{
234 if (modifiers && md) {
236
238 modifiers, md, DATA_(mti->name), '.', offsetof(ModifierData, name), sizeof(md->name));
239 }
240}
241
243{
245
246 return mti->depends_on_time && mti->depends_on_time(scene, md);
247}
248
256
258{
259 for (ModifierData &md : ob->modifiers) {
260 if (md.type == type) {
261 return &md;
262 }
263 }
264 return nullptr;
265}
266
267ModifierData *BKE_modifiers_findby_name(const Object *ob, const char *name)
268{
269 return static_cast<ModifierData *>(
270 BLI_findstring(&(ob->modifiers), name, offsetof(ModifierData, name)));
271}
272
273ModifierData *BKE_modifiers_findby_persistent_uid(const Object *ob, const int persistent_uid)
274{
275 for (ModifierData &md : ob->modifiers) {
276 if (md.persistent_uid == persistent_uid) {
277 return &md;
278 }
279 }
280 return nullptr;
281}
282
284{
285 for (ModifierData &md : ob->modifiers) {
286 if (md.error) {
287 MEM_delete(md.error);
288 md.error = nullptr;
289 }
290 }
291}
292
293void BKE_modifiers_foreach_ID_link(Object *ob, IDWalkFunc walk, void *user_data)
294{
295 for (ModifierData &md : ob->modifiers) {
298 walk(user_data, ob, (ID **)&id_prop->data.pointer, IDWALK_CB_USER);
299 });
300 if (mti->foreach_ID_link) {
301 mti->foreach_ID_link(&md, ob, walk, user_data);
302 }
303 }
304}
305
306void BKE_modifiers_foreach_tex_link(Object *ob, TexWalkFunc walk, void *user_data)
307{
308 for (ModifierData &md : ob->modifiers) {
310 if (mti->foreach_tex_link) {
311 mti->foreach_tex_link(&md, ob, walk, user_data);
312 }
313 }
314}
315
317{
319
320 STRNCPY_UTF8(md_dst->name, md->name);
321 BKE_modifier_copydata_ex(md, md_dst, flag);
322
323 return md_dst;
324}
325
327 ModifierData *md_dst,
328 const int /*flag*/)
329{
330 const ModifierTypeInfo *mti = BKE_modifier_get_info(md_src->type);
331
332 /* `md_dst` may have already be fully initialized with some extra allocated data,
333 * we need to free it now to avoid a memory leak. */
334 if (mti->free_data) {
335 mti->free_data(md_dst);
336 }
337
338 const size_t data_size = sizeof(ModifierData);
339 const char *md_src_data = (reinterpret_cast<const char *>(md_src)) + data_size;
340 char *md_dst_data = (reinterpret_cast<char *>(md_dst)) + data_size;
341 BLI_assert(data_size <= size_t(mti->struct_size));
342 memcpy(md_dst_data, md_src_data, size_t(mti->struct_size) - data_size);
343
344 /* Runtime fields are never to be preserved. */
345 md_dst->runtime = nullptr;
346}
347
348static void modifier_copy_data_id_us_cb(void * /*user_data*/,
349 Object * /*ob*/,
350 ID **idpoin,
351 const LibraryForeachIDCallbackFlag cb_flag)
352{
353 ID *id = *idpoin;
354 if (id != nullptr && (cb_flag & IDWALK_CB_USER) != 0) {
355 id_us_plus(id);
356 }
357}
358
359void BKE_modifier_copydata_ex(const ModifierData *md, ModifierData *target, const int flag)
360{
362
363 target->mode = md->mode;
364 target->flag = md->flag;
365 target->ui_expand_flag = md->ui_expand_flag;
366 target->persistent_uid = md->persistent_uid;
367
368 if (mti->copy_data) {
369 mti->copy_data(md, target, flag);
370 }
371
372 if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
373 if (mti->foreach_ID_link) {
374 mti->foreach_ID_link(target, nullptr, modifier_copy_data_id_us_cb, nullptr);
375 }
376 }
377
378 if (md->system_properties) {
380 }
381}
382
384{
385 BKE_modifier_copydata_ex(md, target, 0);
386}
387
389{
391
392 return ((!mti->is_disabled || !mti->is_disabled(scene, md, false)) &&
394}
395
397{
399
400 return ((md->mode & eModifierMode_Realtime) && (md->mode & eModifierMode_Editmode) &&
401 (!mti->is_disabled || !mti->is_disabled(scene, md, false)) &&
403}
404
410
416
417void BKE_modifier_set_error(const Object *ob, ModifierData *md, const char *_format, ...)
418{
419 char buffer[512];
420 va_list ap;
421 const char *format = RPT_(_format);
422
423 va_start(ap, _format);
424 vsnprintf(buffer, sizeof(buffer), format, ap);
425 va_end(ap);
426 buffer[sizeof(buffer) - 1] = '\0';
427
428 if (md->error) {
429 MEM_delete(md->error);
430 }
431
432 md->error = BLI_strdup(buffer);
433
434#ifndef NDEBUG
435 if ((md->mode & eModifierMode_Virtual) == 0) {
436 /* Ensure correct object is passed in. */
437 BLI_assert(BKE_modifier_get_original(ob, md) != nullptr);
438 }
439#endif
440
441 CLOG_WARN(&LOG, "Object: \"%s\", Modifier: \"%s\", %s", ob->id.name + 2, md->name, md->error);
442}
443
444void BKE_modifier_set_warning(const Object *ob, ModifierData *md, const char *_format, ...)
445{
446 char buffer[512];
447 va_list ap;
448 const char *format = RPT_(_format);
449
450 va_start(ap, _format);
451 vsnprintf(buffer, sizeof(buffer), format, ap);
452 va_end(ap);
453 buffer[sizeof(buffer) - 1] = '\0';
454
455 /* Store the warning in the same field as the error.
456 * It is not expected to have both error and warning and having a single place to store the
457 * message simplifies interface code. */
458
459 if (md->error) {
460 MEM_delete(md->error);
461 }
462
463 md->error = BLI_strdup(buffer);
464
465#ifndef NDEBUG
466 if ((md->mode & eModifierMode_Virtual) == 0) {
467 /* Ensure correct object is passed in. */
468 BLI_assert(BKE_modifier_get_original(ob, md) != nullptr);
469 }
470#endif
471
473}
474
476 Object *ob,
477 int *r_lastPossibleCageIndex,
478 bool is_virtual)
479{
480 VirtualModifierData virtual_modifier_data;
481 ModifierData *md = (is_virtual) ?
482 BKE_modifiers_get_virtual_modifierlist(ob, &virtual_modifier_data) :
483 ob->modifiers.first();
484
485 if (r_lastPossibleCageIndex) {
486 /* ensure the value is initialized */
487 *r_lastPossibleCageIndex = -1;
488 }
489
490 /* Find the last modifier acting on the cage. */
491 int cageIndex = -1;
492 for (int i = 0; md; i++, md = md->next) {
494 bool supports_mapping;
495
496 if (mti->is_disabled && mti->is_disabled(scene, md, false)) {
497 continue;
498 }
500 continue;
501 }
503 continue;
504 }
505
506 supports_mapping = BKE_modifier_supports_mapping(md);
507 if (r_lastPossibleCageIndex && supports_mapping) {
508 *r_lastPossibleCageIndex = i;
509 }
510
511 if (!(md->mode & eModifierMode_Realtime)) {
512 continue;
513 }
514 if (!(md->mode & eModifierMode_Editmode)) {
515 continue;
516 }
517
518 if (!supports_mapping) {
519 break;
520 }
521
522 if (md->mode & eModifierMode_OnCage) {
523 cageIndex = i;
524 }
525 }
526
527 return cageIndex;
528}
529
530bool BKE_modifier_is_enabled(const Scene *scene, ModifierData *md, int required_mode)
531{
533
534 if ((md->mode & required_mode) != required_mode) {
535 return false;
536 }
537 if (scene != nullptr && mti->is_disabled &&
538 mti->is_disabled(scene, md, required_mode == eModifierMode_Render))
539 {
540 return false;
541 }
543 return false;
544 }
545 if ((required_mode & eModifierMode_Editmode) &&
547 {
548 return false;
549 }
550
551 return true;
552}
553
555{
556 return (ID_IS_OVERRIDE_LIBRARY(ob) &&
557 (md == nullptr || (md->flag & eModifierFlag_OverrideLibrary_Local) == 0));
558}
559
561 ModifierData *md,
562 CustomData_MeshMasks *final_datamask,
563 int required_mode)
564{
565 CDMaskLink *dataMasks = nullptr;
566 CDMaskLink *curr, *prev;
567 bool have_deform_modifier = false;
568
569 /* build a list of modifier data requirements in reverse order */
570 for (; md; md = md->next) {
572
573 curr = MEM_new<CDMaskLink>(__func__);
574
575 if (BKE_modifier_is_enabled(scene, md, required_mode)) {
577 have_deform_modifier = true;
578 }
579
580 if (mti->required_data_mask) {
581 mti->required_data_mask(md, &curr->mask);
582 }
583 }
584
585 if (!have_deform_modifier) {
586 /* Don't create orco layer when there is no deformation, we fall
587 * back to regular vertex coordinates */
588 curr->mask.vmask &= ~CD_MASK_ORCO;
589 }
590
591 /* prepend new datamask */
592 curr->next = dataMasks;
593 dataMasks = curr;
594 }
595
596 if (!have_deform_modifier) {
597 final_datamask->vmask &= ~CD_MASK_ORCO;
598 }
599
600 /* build the list of required data masks - each mask in the list must
601 * include all elements of the masks that follow it
602 *
603 * note the list is currently in reverse order, so "masks that follow it"
604 * actually means "masks that precede it" at the moment
605 */
606 for (curr = dataMasks, prev = nullptr; curr; prev = curr, curr = curr->next) {
607 if (prev) {
608 CustomData_MeshMasks_update(&curr->mask, &prev->mask);
609 }
610 else {
611 CustomData_MeshMasks_update(&curr->mask, final_datamask);
612 }
613 }
614
615 /* reverse the list so it's in the correct order */
616 BLI_linklist_reverse(reinterpret_cast<LinkNode **>(&dataMasks));
617
618 return dataMasks;
619}
620
622 VirtualModifierData *virtual_modifier_data)
623{
624 ModifierData *md = ob->modifiers.first();
625
626 *virtual_modifier_data = virtualModifierCommonData;
627
628 if (ob->parent) {
629 if (ob->parent->type == OB_ARMATURE && ob->partype == PARSKEL) {
630 virtual_modifier_data->amd.object = ob->parent;
631 virtual_modifier_data->amd.modifier.next = md;
632 virtual_modifier_data->amd.deformflag = (id_cast<bArmature *>(ob->parent->data))->deformflag;
633 md = &virtual_modifier_data->amd.modifier;
634 }
635 else if (ob->parent->type == OB_CURVES_LEGACY && ob->partype == PARSKEL) {
636 virtual_modifier_data->cmd.object = ob->parent;
637 virtual_modifier_data->cmd.defaxis = CurveModifierDefaultAxis(ob->trackflag + 1);
638 virtual_modifier_data->cmd.modifier.next = md;
639 md = &virtual_modifier_data->cmd.modifier;
640 }
641 else if (ob->parent->type == OB_LATTICE && ob->partype == PARSKEL) {
642 virtual_modifier_data->lmd.object = ob->parent;
643 virtual_modifier_data->lmd.modifier.next = md;
644 md = &virtual_modifier_data->lmd.modifier;
645 }
646 }
647
648 /* shape key modifier, not yet for curves */
649 if (ELEM(ob->type, OB_MESH, OB_LATTICE) && BKE_key_from_object(const_cast<Object *>(ob))) {
650 if (ob->type == OB_MESH && (ob->shapeflag & OB_SHAPE_EDIT_MODE)) {
651 virtual_modifier_data->smd.modifier.mode |= eModifierMode_Editmode | eModifierMode_OnCage;
652 }
653 else {
654 virtual_modifier_data->smd.modifier.mode &= ~eModifierMode_Editmode;
655 }
656
657 virtual_modifier_data->smd.modifier.next = md;
658 md = &virtual_modifier_data->smd.modifier;
659 }
660
661 return md;
662}
663
665{
666 VirtualModifierData virtual_modifier_data;
667 ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtual_modifier_data);
668
669 Object *armature = nullptr;
670 /* return the first selected armature, this lets us use multiple armatures */
671 if (ob->type == OB_GREASE_PENCIL) {
672 for (; md; md = md->next) {
674 auto *amd = reinterpret_cast<GreasePencilArmatureModifierData *>(md);
675 armature = amd->object;
676 if (armature && (armature->base_flag & BASE_SELECTED)) {
677 return armature;
678 }
679 }
680 }
681 }
682 else {
683 for (; md; md = md->next) {
684 if (md->type == eModifierType_Armature) {
685 auto *amd = reinterpret_cast<ArmatureModifierData *>(md);
686 armature = amd->object;
687 if (armature && (armature->base_flag & BASE_SELECTED)) {
688 return armature;
689 }
690 }
691 }
692 }
693 /* If we're still here then return the last armature. */
694 return armature;
695}
696
698{
699 VirtualModifierData virtual_modifier_data;
700 ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtual_modifier_data);
701 MeshDeformModifierData *mdmd = nullptr;
702
703 /* return the first selected armature, this lets us use multiple armatures */
704 for (; md; md = md->next) {
705 if (md->type == eModifierType_MeshDeform) {
706 mdmd = reinterpret_cast<MeshDeformModifierData *>(md);
707 if (mdmd->object && (mdmd->object->base_flag & BASE_SELECTED)) {
708 return mdmd->object;
709 }
710 }
711 }
712
713 if (mdmd) { /* if we're still here then return the last armature */
714 return mdmd->object;
715 }
716
717 return nullptr;
718}
719
721{
722 VirtualModifierData virtual_modifier_data;
723 ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtual_modifier_data);
724
725 if (ob->type == OB_GREASE_PENCIL) {
726 GreasePencilLatticeModifierData *gplmd = nullptr;
727 /* return the first selected lattice, this lets us use multiple lattices */
728 for (; md; md = md->next) {
730 gplmd = reinterpret_cast<GreasePencilLatticeModifierData *>(md);
731 if (gplmd->object && (gplmd->object->base_flag & BASE_SELECTED)) {
732 return gplmd->object;
733 }
734 }
735 }
736 if (gplmd) { /* if we're still here then return the last lattice */
737 return gplmd->object;
738 }
739 return nullptr;
740 }
741
742 LatticeModifierData *lmd = nullptr;
743
744 /* return the first selected lattice, this lets us use multiple lattices */
745 for (; md; md = md->next) {
746 if (md->type == eModifierType_Lattice) {
747 lmd = reinterpret_cast<LatticeModifierData *>(md);
748 if (lmd->object && (lmd->object->base_flag & BASE_SELECTED)) {
749 return lmd->object;
750 }
751 }
752 }
753
754 if (lmd) { /* if we're still here then return the last lattice */
755 return lmd->object;
756 }
757
758 return nullptr;
759}
760
762{
763 VirtualModifierData virtual_modifier_data;
764 ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtual_modifier_data);
765 CurveModifierData *cmd = nullptr;
766
767 /* return the first selected curve, this lets us use multiple curves */
768 for (; md; md = md->next) {
769 if (md->type == eModifierType_Curve) {
770 cmd = reinterpret_cast<CurveModifierData *>(md);
771 if (cmd->object && (cmd->object->base_flag & BASE_SELECTED)) {
772 return cmd->object;
773 }
774 }
775 }
776
777 if (cmd) { /* if we're still here then return the last curve */
778 return cmd->object;
779 }
780
781 return nullptr;
782}
783
785{
786 VirtualModifierData virtual_modifier_data;
787 ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtual_modifier_data);
788 MultiresModifierData *mmd = nullptr;
789
790 for (; md; md = md->next) {
791 if (md->type == eModifierType_Multires) {
792 mmd = reinterpret_cast<MultiresModifierData *>(md);
793 if (mmd->totlvl != 0) {
794 return true;
795 }
796 }
797 }
798 return false;
799}
800
802{
803 VirtualModifierData virtual_modifier_data;
804 ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtual_modifier_data);
805
806 for (; md; md = md->next) {
807 if (md->type == eModifierType_Armature) {
808 ArmatureModifierData *amd = reinterpret_cast<ArmatureModifierData *>(md);
809 if (amd->object && amd->object->data == id_cast<ID *>(arm)) {
810 return true;
811 }
812 }
815 md);
816 if (amd->object && amd->object->data == id_cast<ID *>(arm)) {
817 return true;
818 }
819 }
820 }
821
822 return false;
823}
824
826{
828 return mti->deform_matrices_EM != nullptr;
829}
830
832{
833 VirtualModifierData virtual_modifier_data;
834 ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtual_modifier_data);
835 int required_mode = eModifierMode_Realtime;
836
837 if (ob->mode == OB_MODE_EDIT) {
838 required_mode |= eModifierMode_Editmode;
839 }
840 for (; md; md = md->next) {
841 if (!BKE_modifier_is_enabled(scene, md, required_mode)) {
842 /* pass */
843 }
845 return true;
846 }
847 }
848 return false;
849}
850
852{
853 if (md->type == eModifierType_Armature) {
854 ArmatureModifierData *amd = reinterpret_cast<ArmatureModifierData *>(md);
855
856 MEM_SAFE_DELETE(amd->vert_coords_prev);
857 }
858}
859
861{
862 ModifierData *next_md = nullptr;
863 for (ModifierData &md : ob->modifiers.items_reversed()) {
864 if (md.flag & eModifierFlag_PinLast) {
865 next_md = &md;
866 }
867 else {
868 break;
869 }
870 }
871
872 const ModifierType mt = new_md->type;
874 const bool check_deform_only = (mti->flags & eModifierTypeFlag_RequiresOriginalData) ||
875 (mt == eModifierType_Hook);
876 if (check_deform_only) {
877 next_md = ob->modifiers.first();
878
879 while (next_md && BKE_modifier_get_info(next_md->type)->type == ModifierTypeType::OnlyDeform) {
880 if (next_md->next && (next_md->next->flag & eModifierFlag_PinLast) != 0) {
881 break;
882 }
883 next_md = next_md->next;
884 }
885 }
886
887 BLI_insertlinkbefore(&ob->modifiers, next_md, new_md);
888}
889
891{
892 /* just multires checked for now, since only multires
893 * modifies mesh data */
894
895 if (ob->type != OB_MESH) {
896 return;
897 }
898
899 for (ModifierData &md : ob->modifiers) {
900 if (md.type == eModifierType_Multires) {
901 MultiresModifierData *mmd = reinterpret_cast<MultiresModifierData *>(&md);
902
904 }
905 }
906}
907
908const char *BKE_modifier_path_relbase(Main *bmain, Object *ob)
909{
910 /* - If the ID is from a library, return library path.
911 * - Else if the file has been saved return the blend file path.
912 * - Else if the file isn't saved and the ID isn't from a library, return the temp directory.
913 */
914 if ((bmain->filepath[0] != '\0') || ID_IS_LINKED(ob)) {
915 return ID_BLEND_PATH(bmain, &ob->id);
916 }
917
918 /* Last resort, better than using "" which resolves to the current working directory. */
919 return BKE_tempdir_session();
920}
921
926
927void BKE_modifier_path_init(char *path, int path_maxncpy, const char *name)
928{
929 const char *blendfile_path = BKE_main_blendfile_path_from_global();
930 BLI_path_join(path, path_maxncpy, blendfile_path[0] ? "//" : BKE_tempdir_session(), name);
931}
932
939{
940 switch (mesh->runtime->wrapper_type) {
942 bke::EditMeshData &edit_data = *mesh->runtime->edit_data;
943 if (!edit_data.vert_positions.is_empty()) {
944 /* Note that 'ensure' is acceptable here since these values aren't modified in-place.
945 * If that changes we'll need to recalculate. */
947 }
948 else {
951 }
952 break;
953 }
955 /* Not an expected case. */
956 break;
958 /* Normals are calculated lazily. */
959 break;
960 }
961}
962
963/* wrapper around ModifierTypeInfo.modify_mesh that ensures valid normals */
964
966{
968
969 if (mesh->runtime->wrapper_type == ME_WRAPPER_TYPE_BMESH) {
970 if ((mti->flags & eModifierTypeFlag_AcceptsBMesh) == 0) {
972 }
973 }
974
975 return mti->modify_mesh(md, ctx, mesh);
976}
977
979 const ModifierEvalContext *ctx,
980 Mesh *mesh,
981 MutableSpan<float3> positions)
982{
983 using namespace blender::bke;
985
986 if (mti->deform_verts) {
987 mti->deform_verts(md, ctx, mesh, positions);
988 if (mesh) {
989 mesh->tag_positions_changed();
990 }
991 return true;
992 }
993 /* Try to emulate #deform_verts by deforming a mesh. */
994 if (mti->modify_geometry_set) {
995 /* Prepare mesh with vertices at the given positions. */
997 if (mesh) {
999 }
1000 else {
1002 }
1003 Mesh *mesh_to_deform = geometry.get_mesh_for_write();
1004 mesh_to_deform->vert_positions_for_write().copy_from(positions);
1005 mesh_to_deform->tag_positions_changed();
1006
1007 /* Remember the topology of the mesh before passing it to the modifier. */
1008 const MeshTopologyState old_topology{*mesh_to_deform};
1009
1010 /* Call the modifier and "hope" that it just deforms the mesh. */
1011 mti->modify_geometry_set(md, ctx, &geometry);
1012
1013 /* Extract the deformed vertex positions if the topology has not changed. */
1014 if (const Mesh *deformed_mesh = geometry.get_mesh()) {
1015 if (old_topology.same_topology_as(*deformed_mesh)) {
1016 positions.copy_from(deformed_mesh->vert_positions());
1017 if (mesh) {
1018 mesh->tag_positions_changed();
1019 }
1020 return true;
1021 }
1022 }
1023 }
1024 return false;
1025}
1026
1028 const ModifierEvalContext *ctx,
1029 Mesh *mesh,
1030 MutableSpan<float3> positions)
1031{
1033 if (mesh && mti->depends_on_normals && mti->depends_on_normals(md)) {
1035 }
1036 mti->deform_verts_EM(md, ctx, mesh, positions);
1037}
1038
1039/* end modifier callback wrappers */
1040
1042{
1043 if (!DEG_object_geometry_is_evaluated(*ob_eval)) {
1044 return nullptr;
1045 }
1046
1047 Mesh *mesh = nullptr;
1048
1049 if ((ob_eval->type == OB_MESH) && (ob_eval->mode & OB_MODE_EDIT)) {
1050 /* In EditMode, evaluated mesh is stored in BMEditMesh, not the object... */
1052 /* 'em' might not exist yet in some cases, just after loading a .blend file, see #57878. */
1053 if (em != nullptr) {
1054 mesh = const_cast<Mesh *>(BKE_object_get_editmesh_eval_final(ob_eval));
1055 if (mesh != nullptr) {
1057 }
1058 }
1059 }
1060 if (mesh == nullptr) {
1062 }
1063
1064 return mesh;
1065}
1066
1068{
1069 const Object *object_orig = DEG_get_original(const_cast<Object *>(object));
1070 return BKE_modifiers_findby_persistent_uid(object_orig, md->persistent_uid);
1071}
1072
1074{
1075 Object *object_eval = DEG_get_evaluated(depsgraph, object);
1076 if (object_eval == object) {
1077 return md;
1078 }
1079 return BKE_modifiers_findby_persistent_uid(object_eval, md->persistent_uid);
1080}
1081
1083{
1085 if (ID_IS_LINKED(&object)) {
1086 hash = get_default_hash(hash, StringRef(object.id.lib->runtime->filepath_abs));
1087 }
1088 if (ID_IS_OVERRIDE_LIBRARY_REAL(&object)) {
1089 BLI_assert(ID_IS_LINKED(object.id.override_library->reference));
1091 hash, StringRef(object.id.override_library->reference->lib->runtime->filepath_abs));
1092 }
1094 while (true) {
1095 const int new_uid = rng.get_int32();
1096 if (new_uid <= 0) {
1097 continue;
1098 }
1099 if (BKE_modifiers_findby_persistent_uid(&object, new_uid) != nullptr) {
1100 continue;
1101 }
1102 md.persistent_uid = new_uid;
1103 break;
1104 }
1105}
1106
1108{
1109 Set<int> uids;
1110 int modifiers_num = 0;
1111 for (const ModifierData &md : object.modifiers) {
1112 if (md.persistent_uid <= 0) {
1113 return false;
1114 }
1115 uids.add(md.persistent_uid);
1116 modifiers_num++;
1117 }
1118 if (uids.size() != modifiers_num) {
1119 return false;
1120 }
1121 return true;
1122}
1123
1125 const ID *id_owner,
1126 ListBaseT<ModifierData> *modbase)
1127{
1128 if (modbase == nullptr) {
1129 return;
1130 }
1131
1132 for (ModifierData &md : *modbase) {
1133 const ModifierTypeInfo *mti = BKE_modifier_get_info(md.type);
1134 if (mti == nullptr) {
1135 continue;
1136 }
1137
1138 if (md.system_properties) {
1139 IDP_BlendWrite(writer, md.system_properties);
1140 }
1141
1142 /* If the blend_write callback is defined, it should handle the whole writing process. */
1143 if (mti->blend_write != nullptr) {
1144 mti->blend_write(writer, id_owner, &md);
1145 continue;
1146 }
1147
1148 writer->write_struct_by_name(mti->struct_name, &md);
1149
1150 if (md.type == eModifierType_Cloth) {
1151 ClothModifierData *clmd = reinterpret_cast<ClothModifierData *>(&md);
1152
1153 writer->write_struct(clmd->sim_parms);
1154 writer->write_struct(clmd->coll_parms);
1155 writer->write_struct(clmd->sim_parms->effector_weights);
1156 BKE_ptcache_blend_write(writer, &clmd->ptcaches);
1157 }
1158 else if (md.type == eModifierType_Fluid) {
1159 FluidModifierData *fmd = reinterpret_cast<FluidModifierData *>(&md);
1160
1161 if (fmd->type & MOD_FLUID_TYPE_DOMAIN) {
1162 writer->write_struct(fmd->domain);
1163
1164 if (fmd->domain) {
1165 BKE_ptcache_blend_write(writer, &(fmd->domain->ptcaches[0]));
1166
1167 /* create fake pointcache so that old blender versions can read it */
1168 fmd->domain->point_cache[1] = BKE_ptcache_add(&fmd->domain->ptcaches[1]);
1170 fmd->domain->point_cache[1]->step = 1;
1171
1172 BKE_ptcache_blend_write(writer, &(fmd->domain->ptcaches[1]));
1173
1174 if (fmd->domain->coba) {
1175 writer->write_struct(fmd->domain->coba);
1176 }
1177
1178 /* cleanup the fake pointcache */
1180 fmd->domain->point_cache[1] = nullptr;
1181
1182 writer->write_struct(fmd->domain->effector_weights);
1183 }
1184 }
1185 else if (fmd->type & MOD_FLUID_TYPE_FLOW) {
1186 writer->write_struct(fmd->flow);
1187 }
1188 else if (fmd->type & MOD_FLUID_TYPE_EFFEC) {
1189 writer->write_struct(fmd->effector);
1190 }
1191 }
1192 else if (md.type == eModifierType_Fluidsim) {
1193 BLI_assert_unreachable(); /* Deprecated data, should never be written. */
1194 }
1195 else if (md.type == eModifierType_DynamicPaint) {
1196 DynamicPaintModifierData *pmd = reinterpret_cast<DynamicPaintModifierData *>(&md);
1197
1198 if (pmd->canvas) {
1199 writer->write_struct(pmd->canvas);
1200
1201 /* write surfaces */
1202 for (DynamicPaintSurface &surface : pmd->canvas->surfaces) {
1203 writer->write_struct(&surface);
1204 }
1205 /* write caches and effector weights */
1206 for (DynamicPaintSurface &surface : pmd->canvas->surfaces) {
1207 BKE_ptcache_blend_write(writer, &(surface.ptcaches));
1208
1209 writer->write_struct(surface.effector_weights);
1210 }
1211 }
1212 if (pmd->brush) {
1213 writer->write_struct(pmd->brush);
1214 writer->write_struct(pmd->brush->paint_ramp);
1215 writer->write_struct(pmd->brush->vel_ramp);
1216 }
1217 }
1218 else if (md.type == eModifierType_Collision) {
1219
1220#if 0
1222 /* TODO: CollisionModifier should use pointcache
1223 * + have proper reset events before enabling this. */
1224 writestruct(wd, DATA, float[3], collmd->numverts, collmd->x);
1225 writestruct(wd, DATA, float[3], collmd->numverts, collmd->xnew);
1226 writestruct(wd, DATA, MFace, collmd->numfaces, collmd->mfaces);
1227#endif
1228 }
1229 }
1230}
1231
1232/* TODO(sergey): Find a better place for this.
1233 *
1234 * Unfortunately, this can not be done as a regular do_versions() since the modifier type is
1235 * set to NONE, so the do_versions code wouldn't know where the modifier came from.
1236 *
1237 * The best approach seems to have the functionality in `versioning_280.cc` but still call the
1238 * function from #BKE_modifier_blend_read_data().
1239 */
1240
1241/* Domain, inflow, ... */
1242static void modifier_ensure_type(FluidModifierData *fluid_modifier_data, FluidModifierType type)
1243{
1244 fluid_modifier_data->type = type;
1245 BKE_fluid_modifier_free(fluid_modifier_data);
1246 BKE_fluid_modifier_create_type_data(fluid_modifier_data);
1247}
1248
1254 Object *object,
1255 ListBaseT<ModifierData> *modifiers,
1256 ModifierData *old_modifier_data)
1257{
1259 FluidModifierData *fluid_modifier_data = reinterpret_cast<FluidModifierData *>(
1260 new_modifier_data);
1261
1262 if (old_modifier_data->type == eModifierType_Fluidsim) {
1263 FluidsimModifierData *old_fluidsim_modifier_data = reinterpret_cast<FluidsimModifierData *>(
1264 old_modifier_data);
1265 /* Only get access to the data, do not mark it as used, otherwise there will be memory leak
1266 * since readfile code won't free it. */
1267 FluidsimSettings *old_fluidsim_settings = old_fluidsim_modifier_data->fss;
1268 BLO_read_struct_no_us(reader, FluidsimSettings, &old_fluidsim_settings);
1269 if (old_fluidsim_settings) {
1270 switch (old_fluidsim_settings->type) {
1271 case OB_FLUIDSIM_ENABLE:
1272 modifier_ensure_type(fluid_modifier_data, FluidModifierType{});
1273 break;
1274 case OB_FLUIDSIM_DOMAIN:
1275 modifier_ensure_type(fluid_modifier_data, MOD_FLUID_TYPE_DOMAIN);
1276 BKE_fluid_domain_type_set(object, fluid_modifier_data->domain, FLUID_DOMAIN_TYPE_LIQUID);
1277 break;
1278 case OB_FLUIDSIM_FLUID:
1279 modifier_ensure_type(fluid_modifier_data, MOD_FLUID_TYPE_FLOW);
1280 BKE_fluid_flow_type_set(object, fluid_modifier_data->flow, FLUID_FLOW_TYPE_LIQUID);
1281 /* No need to emit liquid far away from surface. */
1282 fluid_modifier_data->flow->surface_distance = 0.0f;
1283 break;
1285 modifier_ensure_type(fluid_modifier_data, MOD_FLUID_TYPE_EFFEC);
1287 object, fluid_modifier_data->effector, FLUID_EFFECTOR_TYPE_COLLISION);
1288 break;
1289 case OB_FLUIDSIM_INFLOW:
1290 modifier_ensure_type(fluid_modifier_data, MOD_FLUID_TYPE_FLOW);
1291 BKE_fluid_flow_type_set(object, fluid_modifier_data->flow, FLUID_FLOW_TYPE_LIQUID);
1293 object, fluid_modifier_data->flow, FLUID_FLOW_BEHAVIOR_INFLOW);
1294 /* No need to emit liquid far away from surface. */
1295 fluid_modifier_data->flow->surface_distance = 0.0f;
1296 break;
1298 modifier_ensure_type(fluid_modifier_data, MOD_FLUID_TYPE_FLOW);
1299 BKE_fluid_flow_type_set(object, fluid_modifier_data->flow, FLUID_FLOW_TYPE_LIQUID);
1301 object, fluid_modifier_data->flow, FLUID_FLOW_BEHAVIOR_OUTFLOW);
1302 break;
1304 /* "Particle" type objects not being used by Mantaflow fluid simulations.
1305 * Skip this object, secondary particles can only be enabled through the domain
1306 * object. */
1307 break;
1309 /* "Control" type objects not being used by Mantaflow fluid simulations.
1310 * Use guiding type instead which is similar. */
1311 modifier_ensure_type(fluid_modifier_data, MOD_FLUID_TYPE_EFFEC);
1313 object, fluid_modifier_data->effector, FLUID_EFFECTOR_TYPE_GUIDE);
1314 break;
1315 }
1316 }
1317 }
1318 else if (old_modifier_data->type == eModifierType_Smoke) {
1319 SmokeModifierData *old_smoke_modifier_data = reinterpret_cast<SmokeModifierData *>(
1320 old_modifier_data);
1321 modifier_ensure_type(fluid_modifier_data, FluidModifierType(old_smoke_modifier_data->type));
1322 if (fluid_modifier_data->type == MOD_FLUID_TYPE_DOMAIN) {
1323 BKE_fluid_domain_type_set(object, fluid_modifier_data->domain, FLUID_DOMAIN_TYPE_GAS);
1324 }
1325 else if (fluid_modifier_data->type == MOD_FLUID_TYPE_FLOW) {
1326 BKE_fluid_flow_type_set(object, fluid_modifier_data->flow, FLUID_FLOW_TYPE_SMOKE);
1327 }
1328 else if (fluid_modifier_data->type == MOD_FLUID_TYPE_EFFEC) {
1330 object, fluid_modifier_data->effector, FLUID_EFFECTOR_TYPE_COLLISION);
1331 }
1332 }
1333
1334 /* Replace modifier data in the stack. */
1335 new_modifier_data->next = old_modifier_data->next;
1336 new_modifier_data->prev = old_modifier_data->prev;
1337 if (new_modifier_data->prev != nullptr) {
1338 new_modifier_data->prev->next = new_modifier_data;
1339 }
1340 if (new_modifier_data->next != nullptr) {
1341 new_modifier_data->next->prev = new_modifier_data;
1342 }
1343 if (modifiers->first() == old_modifier_data) {
1344 modifiers->first_ = new_modifier_data;
1345 }
1346 if (modifiers->last_ == old_modifier_data) {
1347 modifiers->last_ = new_modifier_data;
1348 }
1349
1350 /* Free old modifier data. */
1351 MEM_delete(old_modifier_data);
1352
1353 return new_modifier_data;
1354}
1355
1356static size_t modifier_struct_size(const ModifierType type)
1357{
1358 switch (type) {
1359 /* Deprecated modifier types without typeinfo, still needed for versioning. */
1361 return sizeof(FluidsimModifierData);
1362 case eModifierType_Smoke:
1363 return sizeof(SmokeModifierData);
1364 default: {
1365 const ModifierTypeInfo *mti = BKE_modifier_get_info(type);
1366 return mti ? size_t(mti->struct_size) : sizeof(ModifierData);
1367 }
1368 }
1369}
1370
1371void BKE_modifier_blend_read_data(BlendDataReader *reader, ListBaseT<ModifierData> *lb, Object *ob)
1372{
1374 reader, lb, [](const ModifierData &md) { return modifier_struct_size(md.type); });
1375
1376 for (ModifierData &md_iter : lb->items_mutable()) {
1377 ModifierData *md = &md_iter;
1378 md->error = nullptr;
1379 md->runtime = nullptr;
1380
1383
1384 /* If linking from a library, clear 'local' library override flag. */
1385 if (ID_IS_LINKED(ob)) {
1387 }
1388
1389 /* Modifier data has been allocated as a part of data migration process and
1390 * no reading of nested fields from file is needed. */
1391 bool is_allocated = false;
1392
1393 if (md->type == eModifierType_Fluidsim) {
1395 BLO_read_data_reports(reader),
1397 RPT_("Possible data loss when saving this file! %s modifier is deprecated (Object: %s)"),
1398 md->name,
1399 ob->id.name + 2);
1400 md = modifier_replace_with_fluid(reader, ob, lb, md);
1401 is_allocated = true;
1402 }
1403 else if (md->type == eModifierType_Smoke) {
1405 BLO_read_data_reports(reader),
1407 RPT_("Possible data loss when saving this file! %s modifier is deprecated (Object: %s)"),
1408 md->name,
1409 ob->id.name + 2);
1410 md = modifier_replace_with_fluid(reader, ob, lb, md);
1411 is_allocated = true;
1412 }
1413
1415
1416 /* if modifiers disappear, or for upward compatibility */
1417 if (mti == nullptr) {
1419 }
1420
1421 if (is_allocated) {
1422 /* All the fields has been properly allocated. */
1423 }
1424 else if (md->type == eModifierType_Cloth) {
1425 ClothModifierData *clmd = reinterpret_cast<ClothModifierData *>(md);
1426
1427 clmd->clothObject = nullptr;
1428 clmd->hairdata = nullptr;
1429
1432
1433 BKE_ptcache_blend_read_data(reader, &clmd->ptcaches, &clmd->point_cache, 0);
1434
1435 if (clmd->sim_parms) {
1436 if (clmd->sim_parms->presets > 10) {
1437 clmd->sim_parms->presets = 0;
1438 }
1439
1440 clmd->sim_parms->reset = 0;
1441
1443
1444 if (!clmd->sim_parms->effector_weights) {
1446 }
1447 }
1448
1449 clmd->solver_result = nullptr;
1450 }
1451 else if (md->type == eModifierType_Fluid) {
1452
1453 FluidModifierData *fmd = reinterpret_cast<FluidModifierData *>(md);
1454
1455 if (fmd->type == MOD_FLUID_TYPE_DOMAIN) {
1456 fmd->flow = nullptr;
1457 fmd->effector = nullptr;
1459 fmd->domain->fmd = fmd;
1460
1461 fmd->domain->fluid = nullptr;
1463 fmd->domain->tex_density = nullptr;
1464 fmd->domain->tex_color = nullptr;
1465 fmd->domain->tex_shadow = nullptr;
1466 fmd->domain->tex_flame = nullptr;
1467 fmd->domain->tex_flame_coba = nullptr;
1468 fmd->domain->tex_coba = nullptr;
1469 fmd->domain->tex_field = nullptr;
1470 fmd->domain->tex_velocity_x = nullptr;
1471 fmd->domain->tex_velocity_y = nullptr;
1472 fmd->domain->tex_velocity_z = nullptr;
1473 fmd->domain->tex_wt = nullptr;
1474 BLO_read_struct(reader, ColorBand, &fmd->domain->coba);
1475
1477 if (!fmd->domain->effector_weights) {
1479 }
1480
1482 reader, &(fmd->domain->ptcaches[0]), &(fmd->domain->point_cache[0]), 1);
1483
1484 /* Manta sim uses only one cache from now on, so store pointer convert */
1485 if (fmd->domain->ptcaches[1].first() || fmd->domain->point_cache[1]) {
1486 PointCache *cache = fmd->domain->point_cache[1];
1487 if (BLO_read_struct_no_us_nonnull(reader, PointCache, &cache)) {
1488 if (cache->flag & PTCACHE_FAKE_SMOKE) {
1489 /* Manta-sim/smoke was already saved in "new format" and this cache is fake. */
1490 }
1491 else {
1492 printf(
1493 "High resolution manta cache not available due to pointcache update. Please "
1494 "reset the simulation.\n");
1495 }
1496 }
1498 fmd->domain->point_cache[1] = nullptr;
1499 }
1500
1501 /* Flag for refreshing the simulation after loading */
1503 }
1504 }
1505 else if (fmd->type == MOD_FLUID_TYPE_FLOW) {
1506 fmd->domain = nullptr;
1507 fmd->effector = nullptr;
1508 if (BLO_read_struct_nonnull(reader, FluidFlowSettings, &fmd->flow)) {
1509 fmd->flow->fmd = fmd;
1510 fmd->flow->mesh = nullptr;
1511 fmd->flow->verts_old = nullptr;
1512 fmd->flow->numverts = 0;
1513 BLO_read_struct(reader, ParticleSystem, &fmd->flow->psys);
1514
1516 }
1517 }
1518 else if (fmd->type == MOD_FLUID_TYPE_EFFEC) {
1519 fmd->flow = nullptr;
1520 fmd->domain = nullptr;
1522 fmd->effector->fmd = fmd;
1523 fmd->effector->verts_old = nullptr;
1524 fmd->effector->numverts = 0;
1525 fmd->effector->mesh = nullptr;
1526
1528 }
1529 else {
1530 fmd->type = FluidModifierType{};
1531 fmd->flow = nullptr;
1532 fmd->domain = nullptr;
1533 fmd->effector = nullptr;
1534 }
1535 }
1536 }
1537 else if (md->type == eModifierType_DynamicPaint) {
1538 DynamicPaintModifierData *pmd = reinterpret_cast<DynamicPaintModifierData *>(md);
1539
1541 pmd->canvas->pmd = pmd;
1542 pmd->canvas->flags &= ~MOD_DPAINT_BAKING; /* just in case */
1543
1544 if (pmd->canvas->surfaces.first()) {
1546
1547 for (DynamicPaintSurface &surface : pmd->canvas->surfaces) {
1548 surface.canvas = pmd->canvas;
1549 surface.data = nullptr;
1550 BKE_ptcache_blend_read_data(reader, &(surface.ptcaches), &(surface.pointcache), 1);
1551
1553 if (surface.effector_weights == nullptr) {
1554 surface.effector_weights = BKE_effector_add_weights(nullptr);
1555 }
1556 }
1557 }
1558 }
1560 pmd->brush->pmd = pmd;
1561 BLO_read_struct(reader, ParticleSystem, &pmd->brush->psys);
1562 BLO_read_struct(reader, ColorBand, &pmd->brush->paint_ramp);
1563 BLO_read_struct(reader, ColorBand, &pmd->brush->vel_ramp);
1564 }
1565 }
1566
1567 if ((mti != nullptr) && (mti->blend_read != nullptr)) {
1568 mti->blend_read(reader, md);
1569 }
1570 }
1571}
1572
1573namespace bke {
1574
1575using Clock = std::chrono::high_resolution_clock;
1576
1578{
1579 return std::chrono::duration<double, std::chrono::seconds::period>(
1580 Clock::now().time_since_epoch())
1581 .count();
1582}
1583
1588
1590{
1591 const double end_time = get_current_time_in_seconds();
1592 const double duration = end_time - start_time_;
1593 md_.execution_time = duration;
1594}
1595
1596} // namespace bke
1597} // namespace blender
#define G_MAIN
#define IDP_BlendDataRead(reader, prop)
#define MODIFIER_TYPE_PANEL_PREFIX
General operations, lookup, etc. for blender objects.
#define BLI_path_join(...)
#define STRNCPY_UTF8(dst, src)
#define BLI_string_join(...)
#define BLO_read_struct_nonnull(reader, struct_name, ptr_p)
#define BLO_read_struct_no_us_nonnull(reader, struct_name, ptr_p)
#define BLO_read_struct_list(reader, struct_name, list)
#define BLO_read_struct(reader, struct_name, ptr_p)
#define BLO_read_struct_no_us(reader, struct_name, ptr_p)
#define RPT_(msgid)
#define DATA_(msgid)
#define CLOG_WARN(clg_ref,...)
Definition CLG_log.h:189
#define ID_IS_OVERRIDE_LIBRARY_REAL(_id)
Definition DNA_ID.h:729
#define ID_IS_LINKED(_id)
Definition DNA_ID.h:697
#define ID_BLEND_PATH(_bmain, _id)
Definition DNA_ID.h:688
#define ID_IS_OVERRIDE_LIBRARY(_id)
Definition DNA_ID.h:736
Object is a sort of wrapper for general info.
Read Blender memory allocation and freeing.
#define BLI_assert_unreachable()
#define UNUSED_VARS_NDEBUG(...)
#define ELEM(...)
#define CD_MASK_ORCO
bool is_empty() const
Definition BLI_array.hh:275
constexpr int64_t size() const
Definition BLI_span.hh:499
constexpr void copy_from(Span< T > values) const
Definition BLI_span.hh:745
int64_t size() const
Definition BLI_set.hh:606
bool add(const Key &key)
Definition BLI_set.hh:248
constexpr StringRef()
bool same_topology_as(const Mesh &mesh) const
#define DATA(x, y)
#define offsetof(t, d)
static double get_current_time_in_seconds()
std::chrono::high_resolution_clock Clock
BMesh Iterators.
void CustomData_MeshMasks_update(CustomData_MeshMasks *mask_dst, const CustomData_MeshMasks *mask_src)
Definition customdata.cc:89
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
Span< float3 > BKE_editmesh_cache_ensure_vert_normals(BMesh &bm, bke::EditMeshData &emd)
void BKE_modifier_copydata(const ModifierData *md, ModifierData *target)
void BKE_modifier_copydata_ex(const ModifierData *md, ModifierData *target, int flag)
CDMaskLink * BKE_modifier_calc_data_masks(const Scene *scene, ModifierData *md, CustomData_MeshMasks *final_datamask, int required_mode)
@ UI_PANEL_DATA_EXPAND_ROOT
unsigned __int64 uint64_t
Definition BKE_text.h:91
ModifierData * BKE_modifiers_findby_name(const Object *ob, const char *name)
void IDP_FreeProperty_ex(IDProperty *prop, bool do_id_user)
Definition idprop.cc:1398
void modifier_type_init(ModifierTypeInfo *types[])
Definition MOD_util.cc:204
static void modifier_copy_data_id_us_cb(void *, Object *, ID **idpoin, const LibraryForeachIDCallbackFlag cb_flag)
void BKE_modifier_set_error(const Object *ob, ModifierData *md, const char *format,...) ATTR_PRINTF_FORMAT(3
@ RPT_WARNING
Definition BKE_report.hh:40
void void BKE_modifier_set_warning(const Object *ob, ModifierData *md, const char *format,...) ATTR_PRINTF_FORMAT(3
BMesh * BKE_editmesh_bmesh_get_for_write(Mesh *mesh)
Definition editmesh.cc:79
bool BKE_modifier_is_nonlocal_in_liboverride(const Object *ob, const ModifierData *md)
BlendFileReadReport * BLO_read_data_reports(BlendDataReader *reader)
Definition readfile.cc:6834
@ FLUID_FLOW_BEHAVIOR_OUTFLOW
@ FLUID_FLOW_BEHAVIOR_INFLOW
void BKE_modifier_blend_read_data(BlendDataReader *reader, ListBaseT< ModifierData > *lb, Object *ob)
bool BKE_modifiers_is_correctable_deformed(const Scene *scene, Object *ob)
void id_us_plus(ID *id)
Definition lib_id.cc:433
ThreadRWMutex * BLI_rw_mutex_alloc()
Definition threads.cc:490
BLI_INLINE void BLI_listbase_clear(ListBase *lb)
void BKE_fluid_effector_type_set(struct Object *object, struct FluidEffectorSettings *settings, eFluidEffector_Type type)
Definition fluid.cc:4602
void IDP_BlendWrite(BlendWriter *writer, const IDProperty *prop)
Definition idprop.cc:1696
bool BKE_modifier_is_non_geometrical(ModifierData *md)
Object * BKE_modifiers_is_deformed_by_curve(Object *ob)
@ eModifierType_GreasePencilLattice
@ eModifierType_GreasePencilArmature
@ eModifierType_DynamicPaint
void IDP_foreach_property(IDProperty *id_property_root, int type_filter, FunctionRef< void(IDProperty *id_property)> callback)
void(*)(void *user_data, Object *ob, ID **idpoin, LibraryForeachIDCallbackFlag cb_flag) IDWalkFunc
Object * BKE_modifiers_is_deformed_by_armature(Object *ob)
void void void BKE_modifiers_foreach_ID_link(Object *ob, IDWalkFunc walk, void *user_data)
const Mesh * BKE_object_get_editmesh_eval_final(const Object *object)
Definition object.cc:4477
bool BKE_modifier_supports_mapping(ModifierData *md)
void * BLI_findstring(const ListBase *listbase, const char *id, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:615
void BKE_mesh_wrapper_ensure_mdata(Mesh *mesh)
void BKE_modifier_blend_write(BlendWriter *writer, const ID *id_owner, ListBaseT< ModifierData > *modbase)
ModifierData * BKE_modifier_get_evaluated(Depsgraph *depsgraph, Object *object, ModifierData *md)
const char * BKE_main_blendfile_path_from_global()
Definition main.cc:1063
static ModifierData * modifier_replace_with_fluid(BlendDataReader *reader, Object *object, ListBaseT< ModifierData > *modifiers, ModifierData *old_modifier_data)
void BKE_fluid_domain_type_set(struct Object *object, struct FluidDomainSettings *settings, eFluidDomain_Type type)
Definition fluid.cc:4551
bool BKE_modifier_supports_cage(Scene *scene, ModifierData *md)
const char * BKE_tempdir_session() ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL
Definition appdir.cc:1283
void BKE_modifiers_persistent_uid_init(const Object &object, ModifierData &md)
@ FLUID_DOMAIN_FILE_LOAD
void BKE_modifier_panel_expand(ModifierData *md)
@ LIB_ID_CREATE_NO_USER_REFCOUNT
ModifierData * BKE_modifiers_findby_persistent_uid(const Object *ob, int persistent_uid)
void BKE_modifier_free_temporary_data(ModifierData *md)
static void modifier_free_data_id_us_cb(void *, Object *, ID **idpoin, const LibraryForeachIDCallbackFlag cb_flag)
void BKE_ptcache_blend_read_data(struct BlendDataReader *reader, ListBaseT< PointCache > *ptcaches, struct PointCache **ocache, int force_disk)
void BKE_modifier_unique_name(ListBaseT< ModifierData > *modifiers, ModifierData *md)
ModifierData * BKE_modifier_copy_ex(const ModifierData *md, int flag)
const char * BKE_modifier_path_relbase(Main *bmain, Object *ob)
Mesh * BKE_modifier_get_evaluated_mesh_from_evaluated_object(Object *ob_eval)
void BKE_fluid_modifier_free(struct FluidModifierData *fmd)
Definition fluid.cc:4763
static void modifier_ensure_type(FluidModifierData *fluid_modifier_data, FluidModifierType type)
unsigned int uint32_t
Definition BKE_text.h:81
void BLI_uniquename(const ListBase *list, void *vlink, const char *defname, char delim, int name_offset, size_t name_maxncpy) ATTR_NONNULL(1
int BLI_findindex(const ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:593
bool BKE_modifier_deform_verts(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh, MutableSpan< float3 > positions)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
@ FLUID_EFFECTOR_NEEDS_UPDATE
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:138
@ eModifierMode_DisableTemporary
T * DEG_get_evaluated(const Depsgraph *depsgraph, T *id)
void BKE_modifiers_add_at_end_if_possible(Object *ob, ModifierData *new_md)
ModifierData * BKE_modifier_new(int type)
Mesh * BKE_mesh_new_nomain(int verts_num, int edges_num, int faces_num, int corners_num)
ModifierData * BKE_modifiers_get_virtual_modifierlist(const Object *ob, VirtualModifierData *data)
static VirtualModifierData virtualModifierCommonData
void BKE_modifier_free(ModifierData *md)
void BLO_read_struct_list_with_type_size(BlendDataReader *reader, size_t base_size, ListBase *list, FunctionRef< size_t(const void *data)> type_size_fn)
Definition readfile.cc:6591
int BKE_modifiers_get_cage_index(const Scene *scene, Object *ob, int *r_lastPossibleCageIndex, bool is_virtual)
void BKE_modifiers_clear_errors(Object *ob)
void BKE_modifier_remove_from_list(Object *ob, ModifierData *md)
void BLO_reportf_wrap(BlendFileReadReport *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
Definition readfile.cc:237
static size_t modifier_struct_size(const ModifierType type)
@ eModifierTypeFlag_SupportsMapping
@ eModifierTypeFlag_EnableInEditmode
@ eModifierTypeFlag_SupportsEditmode
@ eModifierTypeFlag_AcceptsBMesh
@ eModifierTypeFlag_RequiresOriginalData
bool BKE_modifiers_uses_multires(Object *ob)
void BLI_insertlinkbefore(ListBase *listbase, void *vnextlink, void *vnewlink) ATTR_NONNULL(1)
Definition listbase.cc:378
static void ensure_non_lazy_normals(Mesh *mesh)
void BKE_fluid_flow_behavior_set(struct Object *object, struct FluidFlowSettings *settings, eFluidFlow_Behavior behavior)
Definition fluid.cc:4580
BMEditMesh * BKE_editmesh_from_object(Object *ob)
Return the BMEditMesh for a given object.
Definition editmesh.cc:59
void BKE_modifier_free_ex(ModifierData *md, int flag)
ModifierData * BKE_modifiers_findby_type(const Object *ob, ModifierType type)
Mesh * BKE_modifier_modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh)
static ModifierData * modifier_allocate_and_init(ModifierType type)
T * DEG_get_original(T *id)
void BKE_ptcache_free_list(ListBaseT< PointCache > *ptcaches)
char * BLI_strdup(const char *str) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1) ATTR_MALLOC
bool BKE_modifiers_uses_armature(Object *ob, bArmature *arm)
void BKE_modifiers_test_object(Object *ob)
void BLI_linklist_reverse(LinkNode **listp) ATTR_NONNULL(1)
void BKE_modifier_deform_vertsEM(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh, MutableSpan< float3 > positions)
bool BKE_modifier_is_correctable_deformed(ModifierData *md)
@ FLUID_FLOW_TYPE_LIQUID
@ FLUID_FLOW_TYPE_SMOKE
void BKE_fluid_flow_type_set(struct Object *object, struct FluidFlowSettings *settings, eFluidFlow_Type type)
Definition fluid.cc:4587
bool BKE_modifier_is_same_topology(ModifierData *md)
@ eModifierFlag_OverrideLibrary_Local
struct PointCache * BKE_ptcache_add(ListBaseT< PointCache > *ptcaches)
static CLG_LogRef LOG
Definition logging.cpp:12
void BKE_ptcache_blend_write(struct BlendWriter *writer, ListBaseT< PointCache > *ptcaches)
void BKE_modifier_type_panel_id(ModifierType type, char *r_idname)
static ModifierTypeInfo * modifier_types[NUM_MODIFIER_TYPES]
bool BKE_modifier_couldbe_cage(Scene *scene, ModifierData *md)
LibraryForeachIDCallbackFlag
@ ME_WRAPPER_TYPE_SUBD
@ ME_WRAPPER_TYPE_MDATA
@ ME_WRAPPER_TYPE_BMESH
Key * BKE_key_from_object(Object *ob)
Definition key.cc:1311
void BKE_object_modifier_set_active(Object *ob, ModifierData *md)
Definition object.cc:1415
bool BKE_modifiers_persistent_uids_are_valid(const Object &object)
IDProperty * IDP_CopyProperty_ex(const IDProperty *prop, int flag) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
Definition idprop.cc:968
@ FLUID_FLOW_NEEDS_UPDATE
Object * BKE_modifiers_is_deformed_by_meshdeform(Object *ob)
bool DEG_object_geometry_is_evaluated(const Object &object)
bool BKE_modifier_is_enabled(const Scene *scene, ModifierData *md, int required_mode)
const char * BKE_modifier_path_relbase_from_global(Object *ob)
ModifierData * BKE_modifier_get_original(const Object *object, ModifierData *md)
void multiresModifier_set_levels_from_disps(MultiresModifierData *mmd, Object *ob)
Definition multires.cc:389
struct EffectorWeights * BKE_effector_add_weights(struct Collection *collection)
Definition effect.cc:63
void(*)(void *user_data, Object *ob, ModifierData *md, const PointerRNA *ptr, PropertyRNA *texture_prop) TexWalkFunc
void id_us_min(ID *id)
Definition lib_id.cc:441
Mesh * BKE_mesh_wrapper_ensure_subdivision(Mesh *mesh)
void BKE_modifiers_foreach_tex_link(Object *ob, TexWalkFunc walk, void *user_data)
void BKE_modifier_path_init(char *path, int path_maxncpy, const char *name)
const ModifierTypeInfo * BKE_modifier_get_info(ModifierType type)
constexpr uint64_t get_default_hash(const T &v, const Args &...args)
Definition BLI_hash.hh:252
bool BKE_modifier_depends_ontime(Scene *scene, ModifierData *md)
void BKE_fluid_modifier_create_type_data(struct FluidModifierData *fmd)
Definition fluid.cc:4774
@ IDP_TYPE_FILTER_ID
@ FLUID_EFFECTOR_TYPE_COLLISION
@ FLUID_EFFECTOR_TYPE_GUIDE
void BM_mesh_normals_update(BMesh *bm)
@ FLUID_DOMAIN_TYPE_LIQUID
@ FLUID_DOMAIN_TYPE_GAS
Mesh * BKE_object_get_evaluated_mesh(const Object *object_eval)
Definition object.cc:4436
Object * BKE_modifiers_is_deformed_by_lattice(Object *ob)
void BKE_modifier_copydata_generic(const ModifierData *md, ModifierData *md_dst, int flag)
#define hash
Definition noise_c.cc:156
void write_struct_by_name(const char *struct_name, const void *data, BlendStructWriterFn fn=nullptr)
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
struct ClothSolverResult * solver_result
struct ClothHairData * hairdata
struct ClothSimSettings * sim_parms
struct PointCache * point_cache
struct ListBaseT< PointCache > ptcaches
struct ClothCollSettings * coll_parms
struct EffectorWeights * effector_weights
CurveModifierDefaultAxis defaxis
struct DynamicPaintModifierData * pmd
ListBaseT< DynamicPaintSurface > surfaces
struct DynamicPaintModifierData * pmd
struct DynamicPaintBrushSettings * brush
struct DynamicPaintCanvasSettings * canvas
struct DynamicPaintCanvasSettings * canvas
struct EffectorWeights * effector_weights
struct ListBaseT< PointCache > ptcaches[2]
struct EffectorWeights * effector_weights
struct PointCache * point_cache[2]
struct FluidModifierData * fmd
struct FluidModifierData * fmd
struct ParticleSystem * psys
struct FluidModifierData * fmd
struct FluidEffectorSettings * effector
struct FluidFlowSettings * flow
struct FluidDomainSettings * domain
struct FluidsimSettings * fss
static GeometrySet from_mesh(Mesh *mesh, GeometryOwnershipType ownership=GeometryOwnershipType::Owned)
char name[258]
Definition DNA_ID.h:433
char filepath[1024]
Definition BKE_main.hh:267
struct ModifierData * next
struct ModifierData * prev
struct IDProperty * system_properties
void(*) foreach_tex_link(ModifierData *md, Object *ob, TexWalkFunc walk, void *user_data)
void(*) init_data(ModifierData *md)
void(*) required_data_mask(ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
void(*) deform_verts(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh, MutableSpan< float3 > positions)
bool(*) depends_on_time(Scene *scene, ModifierData *md)
void(*) free_data(ModifierData *md)
void(*) copy_data(const ModifierData *md, ModifierData *target, int flag)
Mesh *(*) modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh)
void(*) blend_read(BlendDataReader *reader, ModifierData *md)
void(*) deform_verts_EM(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh, MutableSpan< float3 > positions)
void(*) deform_matrices_EM(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh, MutableSpan< float3 > positions, MutableSpan< float3x3 > matrices)
void(*) foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
bool(*) depends_on_normals(ModifierData *md)
bool(*) is_disabled(const Scene *scene, ModifierData *md, bool use_render_params)
void(*) modify_geometry_set(ModifierData *md, const ModifierEvalContext *ctx, bke::GeometrySet *geometry_set)
void(*) blend_write(BlendWriter *writer, const ID *id_owner, const ModifierData *md)
struct Object * parent
ListBaseT< ModifierData > modifiers
eObject_Partype partype
eObject_ShapeFlag shapeflag
eObject_Axis trackflag
char idname[BKE_ST_MAXNAME]
ShapeKeyModifierData smd
ArmatureModifierData amd
#define writestruct(wd, filecode, struct_id, nr, adr, fn)