Blender V4.5
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_mesh_types.h"
31#include "DNA_object_types.h"
32#include "DNA_particle_types.h"
33#include "DNA_scene_types.h"
34#include "DNA_screen_types.h"
35
36#include "BLI_linklist.h"
37#include "BLI_listbase.h"
38#include "BLI_path_utils.hh"
39#include "BLI_rand.hh"
40#include "BLI_string.h"
41#include "BLI_string_utf8.h"
42#include "BLI_string_utils.hh"
43#include "BLI_utildefines.h"
44
45#include "BLT_translation.hh"
46
47#include "BKE_appdir.hh"
48#include "BKE_editmesh.hh"
49#include "BKE_editmesh_cache.hh"
50#include "BKE_effect.h"
51#include "BKE_fluid.h"
52#include "BKE_geometry_set.hh"
53#include "BKE_global.hh"
54#include "BKE_idtype.hh"
55#include "BKE_key.hh"
56#include "BKE_lib_id.hh"
57#include "BKE_lib_query.hh"
58#include "BKE_library.hh"
59#include "BKE_mesh.hh"
61#include "BKE_mesh_wrapper.hh"
62#include "BKE_multires.hh"
63#include "BKE_object.hh"
64#include "BKE_pointcache.h"
65#include "BKE_screen.hh"
66
67/* may move these, only for BKE_modifier_path_relbase */
68#include "BKE_main.hh"
69/* end */
70
71#include "DEG_depsgraph.hh"
73
74#include "MOD_modifiertypes.hh"
75
76#include "BLO_read_write.hh"
77
78#include "CLG_log.h"
79
80static CLG_LogRef LOG = {"bke.modifier"};
83
113
115{
116 if (type >= 0 && type < NUM_MODIFIER_TYPES && modifier_types[type] &&
117 modifier_types[type]->name[0] != '\0')
118 {
119 return modifier_types[type];
120 }
121
122 return nullptr;
123}
124
125void BKE_modifier_type_panel_id(ModifierType type, char *r_idname)
126{
127 const ModifierTypeInfo *mti = BKE_modifier_get_info(type);
129}
130
135
136/***/
137
139{
140 const ModifierTypeInfo *mti = BKE_modifier_get_info(type);
141 ModifierData *md = static_cast<ModifierData *>(MEM_callocN(mti->struct_size, mti->struct_name));
142
143 /* NOTE: this name must be made unique later. */
144 STRNCPY_UTF8(md->name, DATA_(mti->name));
145
146 md->type = type;
149 /* Only open the main panel at the beginning, not the sub-panels. */
151
154 }
155
156 if (mti->init_data) {
157 mti->init_data(md);
158 }
159
160 return md;
161}
162
164{
166 return md;
167}
168
169static void modifier_free_data_id_us_cb(void * /*user_data*/,
170 Object * /*ob*/,
171 ID **idpoin,
172 const LibraryForeachIDCallbackFlag cb_flag)
173{
174 ID *id = *idpoin;
175 if (id != nullptr && (cb_flag & IDWALK_CB_USER) != 0) {
176 id_us_min(id);
177 }
178}
179
180void BKE_modifier_free_ex(ModifierData *md, const int flag)
181{
183
184 if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
185 if (mti->foreach_ID_link) {
186 mti->foreach_ID_link(md, nullptr, modifier_free_data_id_us_cb, nullptr);
187 }
188 }
189
190 if (mti->free_data) {
191 mti->free_data(md);
192 }
193 if (md->error) {
194 MEM_freeN(md->error);
195 }
196
197 MEM_freeN(md);
198}
199
204
206{
207 BLI_assert(BLI_findindex(&ob->modifiers, md) != -1);
208
209 if (md->flag & eModifierFlag_Active) {
210 /* Prefer the previous modifier but use the next if this modifier is the first in the list. */
211 if (md->next != nullptr) {
213 }
214 else if (md->prev != nullptr) {
216 }
217 }
218
219 BLI_remlink(&ob->modifiers, md);
220}
221
223{
224 if (modifiers && md) {
226
228 modifiers, md, DATA_(mti->name), '.', offsetof(ModifierData, name), sizeof(md->name));
229 }
230}
231
233{
235
236 return mti->depends_on_time && mti->depends_on_time(scene, md);
237}
238
246
248{
250 if (md->type == type) {
251 return md;
252 }
253 }
254 return nullptr;
255}
256
257ModifierData *BKE_modifiers_findby_name(const Object *ob, const char *name)
258{
259 return static_cast<ModifierData *>(
260 BLI_findstring(&(ob->modifiers), name, offsetof(ModifierData, name)));
261}
262
263ModifierData *BKE_modifiers_findby_persistent_uid(const Object *ob, const int persistent_uid)
264{
266 if (md->persistent_uid == persistent_uid) {
267 return md;
268 }
269 }
270 return nullptr;
271}
272
274{
276 if (md->error) {
277 MEM_freeN(md->error);
278 md->error = nullptr;
279 }
280 }
281}
282
283void BKE_modifiers_foreach_ID_link(Object *ob, IDWalkFunc walk, void *user_data)
284{
287
288 if (mti->foreach_ID_link) {
289 mti->foreach_ID_link(md, ob, walk, user_data);
290 }
291 }
292}
293
294void BKE_modifiers_foreach_tex_link(Object *ob, TexWalkFunc walk, void *user_data)
295{
298
299 if (mti->foreach_tex_link) {
300 mti->foreach_tex_link(md, ob, walk, user_data);
301 }
302 }
303}
304
306{
308
309 STRNCPY(md_dst->name, md->name);
310 BKE_modifier_copydata_ex(md, md_dst, flag);
311
312 return md_dst;
313}
314
316 ModifierData *md_dst,
317 const int /*flag*/)
318{
320
321 /* `md_dst` may have already be fully initialized with some extra allocated data,
322 * we need to free it now to avoid a memory leak. */
323 if (mti->free_data) {
324 mti->free_data(md_dst);
325 }
326
327 const size_t data_size = sizeof(ModifierData);
328 const char *md_src_data = ((const char *)md_src) + data_size;
329 char *md_dst_data = ((char *)md_dst) + data_size;
330 BLI_assert(data_size <= size_t(mti->struct_size));
331 memcpy(md_dst_data, md_src_data, size_t(mti->struct_size) - data_size);
332
333 /* Runtime fields are never to be preserved. */
334 md_dst->runtime = nullptr;
335}
336
337static void modifier_copy_data_id_us_cb(void * /*user_data*/,
338 Object * /*ob*/,
339 ID **idpoin,
340 const LibraryForeachIDCallbackFlag cb_flag)
341{
342 ID *id = *idpoin;
343 if (id != nullptr && (cb_flag & IDWALK_CB_USER) != 0) {
344 id_us_plus(id);
345 }
346}
347
348void BKE_modifier_copydata_ex(const ModifierData *md, ModifierData *target, const int flag)
349{
351
352 target->mode = md->mode;
353 target->flag = md->flag;
354 target->ui_expand_flag = md->ui_expand_flag;
355 target->persistent_uid = md->persistent_uid;
356
357 if (mti->copy_data) {
358 mti->copy_data(md, target, flag);
359 }
360
361 if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
362 if (mti->foreach_ID_link) {
363 mti->foreach_ID_link(target, nullptr, modifier_copy_data_id_us_cb, nullptr);
364 }
365 }
366}
367
369{
370 BKE_modifier_copydata_ex(md, target, 0);
371}
372
374{
376
377 return ((!mti->is_disabled || !mti->is_disabled(scene, md, false)) &&
379}
380
382{
384
385 return ((md->mode & eModifierMode_Realtime) && (md->mode & eModifierMode_Editmode) &&
386 (!mti->is_disabled || !mti->is_disabled(scene, md, false)) &&
388}
389
395
401
402void BKE_modifier_set_error(const Object *ob, ModifierData *md, const char *_format, ...)
403{
404 char buffer[512];
405 va_list ap;
406 const char *format = RPT_(_format);
407
408 va_start(ap, _format);
409 vsnprintf(buffer, sizeof(buffer), format, ap);
410 va_end(ap);
411 buffer[sizeof(buffer) - 1] = '\0';
412
413 if (md->error) {
414 MEM_freeN(md->error);
415 }
416
417 md->error = BLI_strdup(buffer);
418
419#ifndef NDEBUG
420 if ((md->mode & eModifierMode_Virtual) == 0) {
421 /* Ensure correct object is passed in. */
422 BLI_assert(BKE_modifier_get_original(ob, md) != nullptr);
423 }
424#endif
425
426 CLOG_WARN(&LOG, "Object: \"%s\", Modifier: \"%s\", %s", ob->id.name + 2, md->name, md->error);
427}
428
429void BKE_modifier_set_warning(const Object *ob, ModifierData *md, const char *_format, ...)
430{
431 char buffer[512];
432 va_list ap;
433 const char *format = RPT_(_format);
434
435 va_start(ap, _format);
436 vsnprintf(buffer, sizeof(buffer), format, ap);
437 va_end(ap);
438 buffer[sizeof(buffer) - 1] = '\0';
439
440 /* Store the warning in the same field as the error.
441 * It is not expected to have both error and warning and having a single place to store the
442 * message simplifies interface code. */
443
444 if (md->error) {
445 MEM_freeN(md->error);
446 }
447
448 md->error = BLI_strdup(buffer);
449
450#ifndef NDEBUG
451 if ((md->mode & eModifierMode_Virtual) == 0) {
452 /* Ensure correct object is passed in. */
453 BLI_assert(BKE_modifier_get_original(ob, md) != nullptr);
454 }
455#endif
456
458}
459
461 Object *ob,
462 int *r_lastPossibleCageIndex,
463 bool is_virtual)
464{
465 VirtualModifierData virtual_modifier_data;
466 ModifierData *md = (is_virtual) ?
467 BKE_modifiers_get_virtual_modifierlist(ob, &virtual_modifier_data) :
468 static_cast<ModifierData *>(ob->modifiers.first);
469
470 if (r_lastPossibleCageIndex) {
471 /* ensure the value is initialized */
472 *r_lastPossibleCageIndex = -1;
473 }
474
475 /* Find the last modifier acting on the cage. */
476 int cageIndex = -1;
477 for (int i = 0; md; i++, md = md->next) {
479 bool supports_mapping;
480
481 if (mti->is_disabled && mti->is_disabled(scene, md, false)) {
482 continue;
483 }
485 continue;
486 }
488 continue;
489 }
490
491 supports_mapping = BKE_modifier_supports_mapping(md);
492 if (r_lastPossibleCageIndex && supports_mapping) {
493 *r_lastPossibleCageIndex = i;
494 }
495
496 if (!(md->mode & eModifierMode_Realtime)) {
497 continue;
498 }
499 if (!(md->mode & eModifierMode_Editmode)) {
500 continue;
501 }
502
503 if (!supports_mapping) {
504 break;
505 }
506
507 if (md->mode & eModifierMode_OnCage) {
508 cageIndex = i;
509 }
510 }
511
512 return cageIndex;
513}
514
515bool BKE_modifier_is_enabled(const Scene *scene, ModifierData *md, int required_mode)
516{
518
519 if ((md->mode & required_mode) != required_mode) {
520 return false;
521 }
522 if (scene != nullptr && mti->is_disabled &&
523 mti->is_disabled(scene, md, required_mode == eModifierMode_Render))
524 {
525 return false;
526 }
528 return false;
529 }
530 if ((required_mode & eModifierMode_Editmode) &&
532 {
533 return false;
534 }
535
536 return true;
537}
538
540{
541 return (ID_IS_OVERRIDE_LIBRARY(ob) &&
542 (md == nullptr || (md->flag & eModifierFlag_OverrideLibrary_Local) == 0));
543}
544
546 ModifierData *md,
547 CustomData_MeshMasks *final_datamask,
548 int required_mode)
549{
550 CDMaskLink *dataMasks = nullptr;
551 CDMaskLink *curr, *prev;
552 bool have_deform_modifier = false;
553
554 /* build a list of modifier data requirements in reverse order */
555 for (; md; md = md->next) {
557
558 curr = MEM_callocN<CDMaskLink>(__func__);
559
560 if (BKE_modifier_is_enabled(scene, md, required_mode)) {
562 have_deform_modifier = true;
563 }
564
565 if (mti->required_data_mask) {
566 mti->required_data_mask(md, &curr->mask);
567 }
568 }
569
570 if (!have_deform_modifier) {
571 /* Don't create orco layer when there is no deformation, we fall
572 * back to regular vertex coordinates */
573 curr->mask.vmask &= ~CD_MASK_ORCO;
574 }
575
576 /* prepend new datamask */
577 curr->next = dataMasks;
578 dataMasks = curr;
579 }
580
581 if (!have_deform_modifier) {
582 final_datamask->vmask &= ~CD_MASK_ORCO;
583 }
584
585 /* build the list of required data masks - each mask in the list must
586 * include all elements of the masks that follow it
587 *
588 * note the list is currently in reverse order, so "masks that follow it"
589 * actually means "masks that precede it" at the moment
590 */
591 for (curr = dataMasks, prev = nullptr; curr; prev = curr, curr = curr->next) {
592 if (prev) {
593 CustomData_MeshMasks_update(&curr->mask, &prev->mask);
594 }
595 else {
596 CustomData_MeshMasks_update(&curr->mask, final_datamask);
597 }
598 }
599
600 /* reverse the list so it's in the correct order */
601 BLI_linklist_reverse((LinkNode **)&dataMasks);
602
603 return dataMasks;
604}
605
607 VirtualModifierData *virtual_modifier_data)
608{
609 ModifierData *md = static_cast<ModifierData *>(ob->modifiers.first);
610
611 *virtual_modifier_data = virtualModifierCommonData;
612
613 if (ob->parent) {
614 if (ob->parent->type == OB_ARMATURE && ob->partype == PARSKEL) {
615 virtual_modifier_data->amd.object = ob->parent;
616 virtual_modifier_data->amd.modifier.next = md;
617 virtual_modifier_data->amd.deformflag = ((bArmature *)(ob->parent->data))->deformflag;
618 md = &virtual_modifier_data->amd.modifier;
619 }
620 else if (ob->parent->type == OB_CURVES_LEGACY && ob->partype == PARSKEL) {
621 virtual_modifier_data->cmd.object = ob->parent;
622 virtual_modifier_data->cmd.defaxis = ob->trackflag + 1;
623 virtual_modifier_data->cmd.modifier.next = md;
624 md = &virtual_modifier_data->cmd.modifier;
625 }
626 else if (ob->parent->type == OB_LATTICE && ob->partype == PARSKEL) {
627 virtual_modifier_data->lmd.object = ob->parent;
628 virtual_modifier_data->lmd.modifier.next = md;
629 md = &virtual_modifier_data->lmd.modifier;
630 }
631 }
632
633 /* shape key modifier, not yet for curves */
634 if (ELEM(ob->type, OB_MESH, OB_LATTICE) && BKE_key_from_object((Object *)ob)) {
635 if (ob->type == OB_MESH && (ob->shapeflag & OB_SHAPE_EDIT_MODE)) {
636 virtual_modifier_data->smd.modifier.mode |= eModifierMode_Editmode | eModifierMode_OnCage;
637 }
638 else {
640 }
641
642 virtual_modifier_data->smd.modifier.next = md;
643 md = &virtual_modifier_data->smd.modifier;
644 }
645
646 return md;
647}
648
650{
651 VirtualModifierData virtual_modifier_data;
652 ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtual_modifier_data);
653
654 Object *armature = nullptr;
655 /* return the first selected armature, this lets us use multiple armatures */
656 if (ob->type == OB_GREASE_PENCIL) {
657 for (; md; md = md->next) {
659 auto *amd = reinterpret_cast<GreasePencilArmatureModifierData *>(md);
660 armature = amd->object;
661 if (armature && (armature->base_flag & BASE_SELECTED)) {
662 return armature;
663 }
664 }
665 }
666 }
667 else {
668 for (; md; md = md->next) {
669 if (md->type == eModifierType_Armature) {
670 auto *amd = reinterpret_cast<ArmatureModifierData *>(md);
671 armature = amd->object;
672 if (armature && (armature->base_flag & BASE_SELECTED)) {
673 return armature;
674 }
675 }
676 }
677 }
678 /* If we're still here then return the last armature. */
679 return armature;
680}
681
683{
684 VirtualModifierData virtual_modifier_data;
685 ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtual_modifier_data);
686 MeshDeformModifierData *mdmd = nullptr;
687
688 /* return the first selected armature, this lets us use multiple armatures */
689 for (; md; md = md->next) {
690 if (md->type == eModifierType_MeshDeform) {
691 mdmd = (MeshDeformModifierData *)md;
692 if (mdmd->object && (mdmd->object->base_flag & BASE_SELECTED)) {
693 return mdmd->object;
694 }
695 }
696 }
697
698 if (mdmd) { /* if we're still here then return the last armature */
699 return mdmd->object;
700 }
701
702 return nullptr;
703}
704
706{
707 VirtualModifierData virtual_modifier_data;
708 ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtual_modifier_data);
709 LatticeModifierData *lmd = nullptr;
710
711 /* return the first selected lattice, this lets us use multiple lattices */
712 for (; md; md = md->next) {
713 if (md->type == eModifierType_Lattice) {
714 lmd = (LatticeModifierData *)md;
715 if (lmd->object && (lmd->object->base_flag & BASE_SELECTED)) {
716 return lmd->object;
717 }
718 }
719 }
720
721 if (lmd) { /* if we're still here then return the last lattice */
722 return lmd->object;
723 }
724
725 return nullptr;
726}
727
729{
730 VirtualModifierData virtual_modifier_data;
731 ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtual_modifier_data);
732 CurveModifierData *cmd = nullptr;
733
734 /* return the first selected curve, this lets us use multiple curves */
735 for (; md; md = md->next) {
736 if (md->type == eModifierType_Curve) {
737 cmd = (CurveModifierData *)md;
738 if (cmd->object && (cmd->object->base_flag & BASE_SELECTED)) {
739 return cmd->object;
740 }
741 }
742 }
743
744 if (cmd) { /* if we're still here then return the last curve */
745 return cmd->object;
746 }
747
748 return nullptr;
749}
750
752{
753 VirtualModifierData virtual_modifier_data;
754 ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtual_modifier_data);
755 MultiresModifierData *mmd = nullptr;
756
757 for (; md; md = md->next) {
758 if (md->type == eModifierType_Multires) {
759 mmd = (MultiresModifierData *)md;
760 if (mmd->totlvl != 0) {
761 return true;
762 }
763 }
764 }
765 return false;
766}
767
769{
770 VirtualModifierData virtual_modifier_data;
771 ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtual_modifier_data);
772
773 for (; md; md = md->next) {
774 if (md->type == eModifierType_Armature) {
775 ArmatureModifierData *amd = reinterpret_cast<ArmatureModifierData *>(md);
776 if (amd->object && amd->object->data == arm) {
777 return true;
778 }
779 }
782 md);
783 if (amd->object && amd->object->data == arm) {
784 return true;
785 }
786 }
787 }
788
789 return false;
790}
791
797
799{
800 VirtualModifierData virtual_modifier_data;
801 ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtual_modifier_data);
802 int required_mode = eModifierMode_Realtime;
803
804 if (ob->mode == OB_MODE_EDIT) {
805 required_mode |= eModifierMode_Editmode;
806 }
807 for (; md; md = md->next) {
808 if (!BKE_modifier_is_enabled(scene, md, required_mode)) {
809 /* pass */
810 }
812 return true;
813 }
814 }
815 return false;
816}
817
826
828{
829 /* just multires checked for now, since only multires
830 * modifies mesh data */
831
832 if (ob->type != OB_MESH) {
833 return;
834 }
835
837 if (md->type == eModifierType_Multires) {
839
841 }
842 }
843}
844
845const char *BKE_modifier_path_relbase(Main *bmain, Object *ob)
846{
847 /* - If the ID is from a library, return library path.
848 * - Else if the file has been saved return the blend file path.
849 * - Else if the file isn't saved and the ID isn't from a library, return the temp directory.
850 */
851 if ((bmain->filepath[0] != '\0') || ID_IS_LINKED(ob)) {
852 return ID_BLEND_PATH(bmain, &ob->id);
853 }
854
855 /* Last resort, better than using "" which resolves to the current working directory. */
856 return BKE_tempdir_session();
857}
858
863
864void BKE_modifier_path_init(char *path, int path_maxncpy, const char *name)
865{
866 const char *blendfile_path = BKE_main_blendfile_path_from_global();
867 BLI_path_join(path, path_maxncpy, blendfile_path[0] ? "//" : BKE_tempdir_session(), name);
868}
869
876{
877 switch (mesh->runtime->wrapper_type) {
879 blender::bke::EditMeshData &edit_data = *mesh->runtime->edit_data;
880 if (!edit_data.vert_positions.is_empty()) {
881 /* Note that 'ensure' is acceptable here since these values aren't modified in-place.
882 * If that changes we'll need to recalculate. */
883 BKE_editmesh_cache_ensure_vert_normals(*mesh->runtime->edit_mesh, edit_data);
884 }
885 else {
886 BM_mesh_normals_update(mesh->runtime->edit_mesh->bm);
887 }
888 break;
889 }
891 /* Not an expected case. */
892 break;
894 /* Normals are calculated lazily. */
895 break;
896 }
897}
898
899/* wrapper around ModifierTypeInfo.modify_mesh that ensures valid normals */
900
902{
904
905 if (mesh->runtime->wrapper_type == ME_WRAPPER_TYPE_BMESH) {
906 if ((mti->flags & eModifierTypeFlag_AcceptsBMesh) == 0) {
908 }
909 }
910
911 return mti->modify_mesh(md, ctx, mesh);
912}
913
915 const ModifierEvalContext *ctx,
916 Mesh *mesh,
918{
919 using namespace blender::bke;
921
922 if (mti->deform_verts) {
923 mti->deform_verts(md, ctx, mesh, positions);
924 if (mesh) {
925 mesh->tag_positions_changed();
926 }
927 return true;
928 }
929 /* Try to emulate #deform_verts by deforming a mesh. */
930 if (mti->modify_geometry_set) {
931 /* Prepare mesh with vertices at the given positions. */
933 if (mesh) {
935 }
936 else {
938 }
939 Mesh *mesh_to_deform = geometry.get_mesh_for_write();
940 mesh_to_deform->vert_positions_for_write().copy_from(positions);
941 mesh_to_deform->tag_positions_changed();
942
943 /* Remember the topology of the mesh before passing it to the modifier. */
944 const MeshTopologyState old_topology{*mesh_to_deform};
945
946 /* Call the modifier and "hope" that it just deforms the mesh. */
947 mti->modify_geometry_set(md, ctx, &geometry);
948
949 /* Extract the deformed vertex positions if the topology has not changed. */
950 if (const Mesh *deformed_mesh = geometry.get_mesh()) {
951 if (old_topology.same_topology_as(*deformed_mesh)) {
952 positions.copy_from(deformed_mesh->vert_positions());
953 if (mesh) {
954 mesh->tag_positions_changed();
955 }
956 return true;
957 }
958 }
959 }
960 return false;
961}
962
964 const ModifierEvalContext *ctx,
965 const BMEditMesh *em,
966 Mesh *mesh,
968{
970 if (mesh && mti->depends_on_normals && mti->depends_on_normals(md)) {
972 }
973 mti->deform_verts_EM(md, ctx, em, mesh, positions);
974}
975
976/* end modifier callback wrappers */
977
979{
980 if (!DEG_object_geometry_is_evaluated(*ob_eval)) {
981 return nullptr;
982 }
983
984 Mesh *mesh = nullptr;
985
986 if ((ob_eval->type == OB_MESH) && (ob_eval->mode & OB_MODE_EDIT)) {
987 /* In EditMode, evaluated mesh is stored in BMEditMesh, not the object... */
989 /* 'em' might not exist yet in some cases, just after loading a .blend file, see #57878. */
990 if (em != nullptr) {
991 mesh = const_cast<Mesh *>(BKE_object_get_editmesh_eval_final(ob_eval));
992 if (mesh != nullptr) {
994 }
995 }
996 }
997 if (mesh == nullptr) {
999 }
1000
1001 return mesh;
1002}
1003
1005{
1006 const Object *object_orig = DEG_get_original((Object *)object);
1007 return BKE_modifiers_findby_persistent_uid(object_orig, md->persistent_uid);
1008}
1009
1011{
1012 Object *object_eval = DEG_get_evaluated(depsgraph, object);
1013 if (object_eval == object) {
1014 return md;
1015 }
1016 return BKE_modifiers_findby_persistent_uid(object_eval, md->persistent_uid);
1017}
1018
1020{
1022 if (ID_IS_LINKED(&object)) {
1024 blender::StringRef(object.id.lib->runtime->filepath_abs));
1025 }
1026 if (ID_IS_OVERRIDE_LIBRARY_REAL(&object)) {
1027 BLI_assert(ID_IS_LINKED(object.id.override_library->reference));
1029 hash,
1030 blender::StringRef(object.id.override_library->reference->lib->runtime->filepath_abs));
1031 }
1032 blender::RandomNumberGenerator rng{uint32_t(hash)};
1033 while (true) {
1034 const int new_uid = rng.get_int32();
1035 if (new_uid <= 0) {
1036 continue;
1037 }
1038 if (BKE_modifiers_findby_persistent_uid(&object, new_uid) != nullptr) {
1039 continue;
1040 }
1041 md.persistent_uid = new_uid;
1042 break;
1043 }
1044}
1045
1047{
1048 blender::Set<int> uids;
1049 int modifiers_num = 0;
1050 LISTBASE_FOREACH (const ModifierData *, md, &object.modifiers) {
1051 if (md->persistent_uid <= 0) {
1052 return false;
1053 }
1054 uids.add(md->persistent_uid);
1055 modifiers_num++;
1056 }
1057 if (uids.size() != modifiers_num) {
1058 return false;
1059 }
1060 return true;
1061}
1062
1063void BKE_modifier_blend_write(BlendWriter *writer, const ID *id_owner, ListBase *modbase)
1064{
1065 if (modbase == nullptr) {
1066 return;
1067 }
1068
1069 LISTBASE_FOREACH (ModifierData *, md, modbase) {
1070 const ModifierTypeInfo *mti = BKE_modifier_get_info(ModifierType(md->type));
1071 if (mti == nullptr) {
1072 continue;
1073 }
1074
1075 /* If the blend_write callback is defined, it should handle the whole writing process. */
1076 if (mti->blend_write != nullptr) {
1077 mti->blend_write(writer, id_owner, md);
1078 continue;
1079 }
1080
1081 BLO_write_struct_by_name(writer, mti->struct_name, md);
1082
1083 if (md->type == eModifierType_Cloth) {
1085
1089 BKE_ptcache_blend_write(writer, &clmd->ptcaches);
1090 }
1091 else if (md->type == eModifierType_Fluid) {
1093
1094 if (fmd->type & MOD_FLUID_TYPE_DOMAIN) {
1096
1097 if (fmd->domain) {
1098 BKE_ptcache_blend_write(writer, &(fmd->domain->ptcaches[0]));
1099
1100 /* create fake pointcache so that old blender versions can read it */
1101 fmd->domain->point_cache[1] = BKE_ptcache_add(&fmd->domain->ptcaches[1]);
1103 fmd->domain->point_cache[1]->step = 1;
1104
1105 BKE_ptcache_blend_write(writer, &(fmd->domain->ptcaches[1]));
1106
1107 if (fmd->domain->coba) {
1108 BLO_write_struct(writer, ColorBand, fmd->domain->coba);
1109 }
1110
1111 /* cleanup the fake pointcache */
1113 fmd->domain->point_cache[1] = nullptr;
1114
1116 }
1117 }
1118 else if (fmd->type & MOD_FLUID_TYPE_FLOW) {
1120 }
1121 else if (fmd->type & MOD_FLUID_TYPE_EFFEC) {
1123 }
1124 }
1125 else if (md->type == eModifierType_Fluidsim) {
1126 BLI_assert_unreachable(); /* Deprecated data, should never be written. */
1127 }
1128 else if (md->type == eModifierType_DynamicPaint) {
1130
1131 if (pmd->canvas) {
1133
1134 /* write surfaces */
1136 BLO_write_struct(writer, DynamicPaintSurface, surface);
1137 }
1138 /* write caches and effector weights */
1140 BKE_ptcache_blend_write(writer, &(surface->ptcaches));
1141
1142 BLO_write_struct(writer, EffectorWeights, surface->effector_weights);
1143 }
1144 }
1145 if (pmd->brush) {
1148 BLO_write_struct(writer, ColorBand, pmd->brush->vel_ramp);
1149 }
1150 }
1151 else if (md->type == eModifierType_Collision) {
1152
1153#if 0
1155 /* TODO: CollisionModifier should use pointcache
1156 * + have proper reset events before enabling this. */
1157 writestruct(wd, DATA, float[3], collmd->numverts, collmd->x);
1158 writestruct(wd, DATA, float[3], collmd->numverts, collmd->xnew);
1159 writestruct(wd, DATA, MFace, collmd->numfaces, collmd->mfaces);
1160#endif
1161 }
1162 }
1163}
1164
1165/* TODO(sergey): Find a better place for this.
1166 *
1167 * Unfortunately, this can not be done as a regular do_versions() since the modifier type is
1168 * set to NONE, so the do_versions code wouldn't know where the modifier came from.
1169 *
1170 * The best approach seems to have the functionality in `versioning_280.cc` but still call the
1171 * function from #BKE_modifier_blend_read_data().
1172 */
1173
1174/* Domain, inflow, ... */
1175static void modifier_ensure_type(FluidModifierData *fluid_modifier_data, int type)
1176{
1177 fluid_modifier_data->type = type;
1178 BKE_fluid_modifier_free(fluid_modifier_data);
1179 BKE_fluid_modifier_create_type_data(fluid_modifier_data);
1180}
1181
1188 Object *object,
1189 ListBase *modifiers,
1190 ModifierData *old_modifier_data)
1191{
1193 FluidModifierData *fluid_modifier_data = (FluidModifierData *)new_modifier_data;
1194
1195 if (old_modifier_data->type == eModifierType_Fluidsim) {
1196 FluidsimModifierData *old_fluidsim_modifier_data = (FluidsimModifierData *)old_modifier_data;
1197 /* Only get access to the data, do not mark it as used, otherwise there will be memory leak
1198 * since readfile code won't free it. */
1199 FluidsimSettings *old_fluidsim_settings = static_cast<FluidsimSettings *>(
1201 reader, old_fluidsim_modifier_data->fss, sizeof(FluidsimSettings)));
1202 switch (old_fluidsim_settings->type) {
1203 case OB_FLUIDSIM_ENABLE:
1204 modifier_ensure_type(fluid_modifier_data, 0);
1205 break;
1206 case OB_FLUIDSIM_DOMAIN:
1207 modifier_ensure_type(fluid_modifier_data, MOD_FLUID_TYPE_DOMAIN);
1208 BKE_fluid_domain_type_set(object, fluid_modifier_data->domain, FLUID_DOMAIN_TYPE_LIQUID);
1209 break;
1210 case OB_FLUIDSIM_FLUID:
1211 modifier_ensure_type(fluid_modifier_data, MOD_FLUID_TYPE_FLOW);
1212 BKE_fluid_flow_type_set(object, fluid_modifier_data->flow, FLUID_FLOW_TYPE_LIQUID);
1213 /* No need to emit liquid far away from surface. */
1214 fluid_modifier_data->flow->surface_distance = 0.0f;
1215 break;
1217 modifier_ensure_type(fluid_modifier_data, MOD_FLUID_TYPE_EFFEC);
1219 object, fluid_modifier_data->effector, FLUID_EFFECTOR_TYPE_COLLISION);
1220 break;
1221 case OB_FLUIDSIM_INFLOW:
1222 modifier_ensure_type(fluid_modifier_data, MOD_FLUID_TYPE_FLOW);
1223 BKE_fluid_flow_type_set(object, fluid_modifier_data->flow, FLUID_FLOW_TYPE_LIQUID);
1224 BKE_fluid_flow_behavior_set(object, fluid_modifier_data->flow, FLUID_FLOW_BEHAVIOR_INFLOW);
1225 /* No need to emit liquid far away from surface. */
1226 fluid_modifier_data->flow->surface_distance = 0.0f;
1227 break;
1229 modifier_ensure_type(fluid_modifier_data, MOD_FLUID_TYPE_FLOW);
1230 BKE_fluid_flow_type_set(object, fluid_modifier_data->flow, FLUID_FLOW_TYPE_LIQUID);
1232 object, fluid_modifier_data->flow, FLUID_FLOW_BEHAVIOR_OUTFLOW);
1233 break;
1235 /* "Particle" type objects not being used by Mantaflow fluid simulations.
1236 * Skip this object, secondary particles can only be enabled through the domain object. */
1237 break;
1239 /* "Control" type objects not being used by Mantaflow fluid simulations.
1240 * Use guiding type instead which is similar. */
1241 modifier_ensure_type(fluid_modifier_data, MOD_FLUID_TYPE_EFFEC);
1243 object, fluid_modifier_data->effector, FLUID_EFFECTOR_TYPE_GUIDE);
1244 break;
1245 }
1246 }
1247 else if (old_modifier_data->type == eModifierType_Smoke) {
1248 SmokeModifierData *old_smoke_modifier_data = (SmokeModifierData *)old_modifier_data;
1249 modifier_ensure_type(fluid_modifier_data, old_smoke_modifier_data->type);
1250 if (fluid_modifier_data->type == MOD_FLUID_TYPE_DOMAIN) {
1251 BKE_fluid_domain_type_set(object, fluid_modifier_data->domain, FLUID_DOMAIN_TYPE_GAS);
1252 }
1253 else if (fluid_modifier_data->type == MOD_FLUID_TYPE_FLOW) {
1254 BKE_fluid_flow_type_set(object, fluid_modifier_data->flow, FLUID_FLOW_TYPE_SMOKE);
1255 }
1256 else if (fluid_modifier_data->type == MOD_FLUID_TYPE_EFFEC) {
1258 object, fluid_modifier_data->effector, FLUID_EFFECTOR_TYPE_COLLISION);
1259 }
1260 }
1261
1262 /* Replace modifier data in the stack. */
1263 new_modifier_data->next = old_modifier_data->next;
1264 new_modifier_data->prev = old_modifier_data->prev;
1265 if (new_modifier_data->prev != nullptr) {
1266 new_modifier_data->prev->next = new_modifier_data;
1267 }
1268 if (new_modifier_data->next != nullptr) {
1269 new_modifier_data->next->prev = new_modifier_data;
1270 }
1271 if (modifiers->first == old_modifier_data) {
1272 modifiers->first = new_modifier_data;
1273 }
1274 if (modifiers->last == old_modifier_data) {
1275 modifiers->last = new_modifier_data;
1276 }
1277
1278 /* Free old modifier data. */
1279 MEM_freeN(old_modifier_data);
1280
1281 return new_modifier_data;
1282}
1283
1284static size_t modifier_struct_size(const ModifierType type)
1285{
1286 switch (type) {
1288 return sizeof(FluidsimModifierData);
1289 case eModifierType_Smoke:
1290 return sizeof(SmokeModifierData);
1291 default: {
1292 const ModifierTypeInfo *mti = BKE_modifier_get_info(type);
1293 return mti ? size_t(mti->struct_size) : sizeof(ModifierData);
1294 }
1295 }
1296}
1297
1299{
1302 });
1303
1304 LISTBASE_FOREACH (ModifierData *, md, lb) {
1305 md->error = nullptr;
1306 md->runtime = nullptr;
1307
1308 /* If linking from a library, clear 'local' library override flag. */
1309 if (ID_IS_LINKED(ob)) {
1311 }
1312
1313 /* Modifier data has been allocated as a part of data migration process and
1314 * no reading of nested fields from file is needed. */
1315 bool is_allocated = false;
1316
1317 if (md->type == eModifierType_Fluidsim) {
1319 BLO_read_data_reports(reader),
1321 RPT_("Possible data loss when saving this file! %s modifier is deprecated (Object: %s)"),
1322 md->name,
1323 ob->id.name + 2);
1324 md = modifier_replace_with_fluid(reader, ob, lb, md);
1325 is_allocated = true;
1326 }
1327 else if (md->type == eModifierType_Smoke) {
1329 BLO_read_data_reports(reader),
1331 RPT_("Possible data loss when saving this file! %s modifier is deprecated (Object: %s)"),
1332 md->name,
1333 ob->id.name + 2);
1334 md = modifier_replace_with_fluid(reader, ob, lb, md);
1335 is_allocated = true;
1336 }
1337
1339
1340 /* if modifiers disappear, or for upward compatibility */
1341 if (mti == nullptr) {
1343 }
1344
1345 if (is_allocated) {
1346 /* All the fields has been properly allocated. */
1347 }
1348 else if (md->type == eModifierType_Cloth) {
1350
1351 clmd->clothObject = nullptr;
1352 clmd->hairdata = nullptr;
1353
1356
1357 BKE_ptcache_blend_read_data(reader, &clmd->ptcaches, &clmd->point_cache, 0);
1358
1359 if (clmd->sim_parms) {
1360 if (clmd->sim_parms->presets > 10) {
1361 clmd->sim_parms->presets = 0;
1362 }
1363
1364 clmd->sim_parms->reset = 0;
1365
1367
1368 if (!clmd->sim_parms->effector_weights) {
1370 }
1371 }
1372
1373 clmd->solver_result = nullptr;
1374 }
1375 else if (md->type == eModifierType_Fluid) {
1376
1378
1379 if (fmd->type == MOD_FLUID_TYPE_DOMAIN) {
1380 fmd->flow = nullptr;
1381 fmd->effector = nullptr;
1383 fmd->domain->fmd = fmd;
1384
1385 fmd->domain->fluid = nullptr;
1387 fmd->domain->tex_density = nullptr;
1388 fmd->domain->tex_color = nullptr;
1389 fmd->domain->tex_shadow = nullptr;
1390 fmd->domain->tex_flame = nullptr;
1391 fmd->domain->tex_flame_coba = nullptr;
1392 fmd->domain->tex_coba = nullptr;
1393 fmd->domain->tex_field = nullptr;
1394 fmd->domain->tex_velocity_x = nullptr;
1395 fmd->domain->tex_velocity_y = nullptr;
1396 fmd->domain->tex_velocity_z = nullptr;
1397 fmd->domain->tex_wt = nullptr;
1398 BLO_read_struct(reader, ColorBand, &fmd->domain->coba);
1399
1401 if (!fmd->domain->effector_weights) {
1403 }
1404
1406 reader, &(fmd->domain->ptcaches[0]), &(fmd->domain->point_cache[0]), 1);
1407
1408 /* Manta sim uses only one cache from now on, so store pointer convert */
1409 if (fmd->domain->ptcaches[1].first || fmd->domain->point_cache[1]) {
1410 if (fmd->domain->point_cache[1]) {
1412 reader, fmd->domain->point_cache[1], sizeof(PointCache)));
1413 if (cache->flag & PTCACHE_FAKE_SMOKE) {
1414 /* Manta-sim/smoke was already saved in "new format" and this cache is a fake one. */
1415 }
1416 else {
1417 printf(
1418 "High resolution manta cache not available due to pointcache update. Please "
1419 "reset the simulation.\n");
1420 }
1421 }
1423 fmd->domain->point_cache[1] = nullptr;
1424 }
1425
1426 /* Flag for refreshing the simulation after loading */
1428 }
1429 else if (fmd->type == MOD_FLUID_TYPE_FLOW) {
1430 fmd->domain = nullptr;
1431 fmd->effector = nullptr;
1432 BLO_read_struct(reader, FluidFlowSettings, &fmd->flow);
1433 fmd->flow->fmd = fmd;
1434 fmd->flow->mesh = nullptr;
1435 fmd->flow->verts_old = nullptr;
1436 fmd->flow->numverts = 0;
1437 BLO_read_struct(reader, ParticleSystem, &fmd->flow->psys);
1438
1440 }
1441 else if (fmd->type == MOD_FLUID_TYPE_EFFEC) {
1442 fmd->flow = nullptr;
1443 fmd->domain = nullptr;
1445 if (fmd->effector) {
1446 fmd->effector->fmd = fmd;
1447 fmd->effector->verts_old = nullptr;
1448 fmd->effector->numverts = 0;
1449 fmd->effector->mesh = nullptr;
1450
1452 }
1453 else {
1454 fmd->type = 0;
1455 fmd->flow = nullptr;
1456 fmd->domain = nullptr;
1457 fmd->effector = nullptr;
1458 }
1459 }
1460 }
1461 else if (md->type == eModifierType_DynamicPaint) {
1463
1464 if (pmd->canvas) {
1466 pmd->canvas->pmd = pmd;
1467 pmd->canvas->flags &= ~MOD_DPAINT_BAKING; /* just in case */
1468
1469 if (pmd->canvas->surfaces.first) {
1471
1473 surface->canvas = pmd->canvas;
1474 surface->data = nullptr;
1475 BKE_ptcache_blend_read_data(reader, &(surface->ptcaches), &(surface->pointcache), 1);
1476
1477 BLO_read_struct(reader, EffectorWeights, &surface->effector_weights);
1478 if (surface->effector_weights == nullptr) {
1479 surface->effector_weights = BKE_effector_add_weights(nullptr);
1480 }
1481 }
1482 }
1483 }
1484 if (pmd->brush) {
1486 pmd->brush->pmd = pmd;
1487 BLO_read_struct(reader, ParticleSystem, &pmd->brush->psys);
1488 BLO_read_struct(reader, ColorBand, &pmd->brush->paint_ramp);
1489 BLO_read_struct(reader, ColorBand, &pmd->brush->vel_ramp);
1490 }
1491 }
1492
1493 if ((mti != nullptr) && (mti->blend_read != nullptr)) {
1494 mti->blend_read(reader, md);
1495 }
1496 }
1497}
1498
1499namespace blender::bke {
1500
1501using Clock = std::chrono::high_resolution_clock;
1502
1504{
1505 return std::chrono::duration<double, std::chrono::seconds::period>(
1506 Clock::now().time_since_epoch())
1507 .count();
1508}
1509
1514
1516{
1517 const double end_time = get_current_time_in_seconds();
1518 const double duration = end_time - start_time_;
1519 md_.execution_time = duration;
1520}
1521
1522} // namespace blender::bke
void CustomData_MeshMasks_update(CustomData_MeshMasks *mask_dst, const CustomData_MeshMasks *mask_src)
Definition customdata.cc:94
BMEditMesh * BKE_editmesh_from_object(Object *ob)
Return the BMEditMesh for a given object.
Definition editmesh.cc:61
blender::Span< blender::float3 > BKE_editmesh_cache_ensure_vert_normals(BMEditMesh &em, blender::bke::EditMeshData &emd)
struct EffectorWeights * BKE_effector_add_weights(struct Collection *collection)
Definition effect.cc:58
void BKE_fluid_flow_behavior_set(struct Object *object, struct FluidFlowSettings *settings, int behavior)
Definition fluid.cc:4571
void BKE_fluid_effector_type_set(struct Object *object, struct FluidEffectorSettings *settings, int type)
Definition fluid.cc:4591
void BKE_fluid_domain_type_set(struct Object *object, struct FluidDomainSettings *settings, int type)
Definition fluid.cc:4544
void BKE_fluid_modifier_create_type_data(struct FluidModifierData *fmd)
Definition fluid.cc:4761
void BKE_fluid_flow_type_set(struct Object *object, struct FluidFlowSettings *settings, int type)
Definition fluid.cc:4576
void BKE_fluid_modifier_free(struct FluidModifierData *fmd)
Definition fluid.cc:4750
#define G_MAIN
Key * BKE_key_from_object(Object *ob)
Definition key.cc:1824
void id_us_plus(ID *id)
Definition lib_id.cc:353
void id_us_min(ID *id)
Definition lib_id.cc:361
@ LIB_ID_CREATE_NO_USER_REFCOUNT
LibraryForeachIDCallbackFlag
@ IDWALK_CB_USER
const char * BKE_main_blendfile_path_from_global()
Definition main.cc:882
Mesh * BKE_mesh_new_nomain(int verts_num, int edges_num, int faces_num, int corners_num)
@ ME_WRAPPER_TYPE_MDATA
@ ME_WRAPPER_TYPE_SUBD
@ ME_WRAPPER_TYPE_BMESH
void BKE_mesh_wrapper_ensure_mdata(Mesh *mesh)
Mesh * BKE_mesh_wrapper_ensure_subdivision(Mesh *mesh)
bool BKE_modifier_depends_ontime(Scene *scene, ModifierData *md)
void BKE_modifier_panel_expand(ModifierData *md)
bool BKE_modifier_is_non_geometrical(ModifierData *md)
#define MODIFIER_TYPE_PANEL_PREFIX
Object * BKE_modifiers_is_deformed_by_curve(Object *ob)
void BKE_modifier_path_init(char *path, int path_maxncpy, const char *name)
void BKE_modifiers_clear_errors(Object *ob)
void BKE_modifier_blend_write(BlendWriter *writer, const ID *id_owner, ListBase *modbase)
void(*)(void *user_data, Object *ob, ID **idpoin, LibraryForeachIDCallbackFlag cb_flag) IDWalkFunc
Mesh * BKE_modifier_get_evaluated_mesh_from_evaluated_object(Object *ob_eval)
bool BKE_modifier_is_enabled(const Scene *scene, ModifierData *md, int required_mode)
int BKE_modifiers_get_cage_index(const Scene *scene, Object *ob, int *r_lastPossibleCageIndex, bool is_virtual)
void BKE_modifier_copydata_ex(const ModifierData *md, ModifierData *target, int flag)
ModifierData * BKE_modifiers_findby_type(const Object *ob, ModifierType type)
bool BKE_modifiers_uses_multires(Object *ob)
const ModifierTypeInfo * BKE_modifier_get_info(ModifierType type)
CDMaskLink * BKE_modifier_calc_data_masks(const Scene *scene, ModifierData *md, CustomData_MeshMasks *final_datamask, int required_mode)
void BKE_modifiers_persistent_uid_init(const Object &object, ModifierData &md)
Object * BKE_modifiers_is_deformed_by_lattice(Object *ob)
void BKE_modifier_copydata_generic(const ModifierData *md, ModifierData *md_dst, int flag)
@ eModifierTypeFlag_AcceptsBMesh
@ eModifierTypeFlag_SupportsMapping
@ eModifierTypeFlag_EnableInEditmode
@ eModifierTypeFlag_SupportsEditmode
void BKE_modifier_blend_read_data(BlendDataReader *reader, ListBase *lb, Object *ob)
const char * BKE_modifier_path_relbase_from_global(Object *ob)
bool BKE_modifiers_uses_armature(Object *ob, bArmature *arm)
void void void BKE_modifiers_foreach_ID_link(Object *ob, IDWalkFunc walk, void *user_data)
ModifierData * BKE_modifier_get_original(const Object *object, ModifierData *md)
bool BKE_modifier_supports_mapping(ModifierData *md)
ModifierData * BKE_modifiers_findby_name(const Object *ob, const char *name)
bool BKE_modifier_supports_cage(Scene *scene, ModifierData *md)
void BKE_modifier_init()
const char * BKE_modifier_path_relbase(Main *bmain, Object *ob)
void BKE_modifier_free_temporary_data(ModifierData *md)
ModifierData * BKE_modifier_copy_ex(const ModifierData *md, int flag)
bool BKE_modifier_is_same_topology(ModifierData *md)
void BKE_modifier_unique_name(ListBase *modifiers, ModifierData *md)
Mesh * BKE_modifier_modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh)
void BKE_modifier_free(ModifierData *md)
bool BKE_modifier_is_nonlocal_in_liboverride(const Object *ob, const ModifierData *md)
void BKE_modifiers_test_object(Object *ob)
void BKE_modifier_set_error(const Object *ob, ModifierData *md, const char *format,...) ATTR_PRINTF_FORMAT(3
Object * BKE_modifiers_is_deformed_by_meshdeform(Object *ob)
void BKE_modifier_remove_from_list(Object *ob, ModifierData *md)
void(*)(void *user_data, Object *ob, ModifierData *md, const PointerRNA *ptr, PropertyRNA *texture_prop) TexWalkFunc
bool BKE_modifiers_persistent_uids_are_valid(const Object &object)
void BKE_modifier_free_ex(ModifierData *md, int flag)
bool BKE_modifier_deform_verts(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh, blender::MutableSpan< blender::float3 > positions)
void BKE_modifier_deform_vertsEM(ModifierData *md, const ModifierEvalContext *ctx, const BMEditMesh *em, Mesh *mesh, blender::MutableSpan< blender::float3 > positions)
bool BKE_modifier_is_correctable_deformed(ModifierData *md)
ModifierData * BKE_modifier_get_evaluated(Depsgraph *depsgraph, Object *object, ModifierData *md)
ModifierData * BKE_modifiers_get_virtual_modifierlist(const Object *ob, VirtualModifierData *data)
bool BKE_modifiers_is_correctable_deformed(const Scene *scene, Object *ob)
void BKE_modifier_type_panel_id(ModifierType type, char *r_idname)
ModifierData * BKE_modifier_new(int type)
bool BKE_modifier_couldbe_cage(Scene *scene, ModifierData *md)
Object * BKE_modifiers_is_deformed_by_armature(Object *ob)
ModifierData * BKE_modifiers_findby_persistent_uid(const Object *ob, int persistent_uid)
void void BKE_modifier_set_warning(const Object *ob, ModifierData *md, const char *format,...) ATTR_PRINTF_FORMAT(3
void BKE_modifier_copydata(const ModifierData *md, ModifierData *target)
void BKE_modifiers_foreach_tex_link(Object *ob, TexWalkFunc walk, void *user_data)
void multiresModifier_set_levels_from_disps(MultiresModifierData *mmd, Object *ob)
Definition multires.cc:503
General operations, lookup, etc. for blender objects.
void BKE_object_modifier_set_active(Object *ob, ModifierData *md)
Mesh * BKE_object_get_evaluated_mesh(const Object *object_eval)
const Mesh * BKE_object_get_editmesh_eval_final(const Object *object)
struct PointCache * BKE_ptcache_add(struct ListBase *ptcaches)
void BKE_ptcache_blend_read_data(struct BlendDataReader *reader, struct ListBase *ptcaches, struct PointCache **ocache, int force_disk)
void BKE_ptcache_free_list(struct ListBase *ptcaches)
void BKE_ptcache_blend_write(struct BlendWriter *writer, struct ListBase *ptcaches)
#define BLI_assert_unreachable()
Definition BLI_assert.h:93
#define BLI_assert(a)
Definition BLI_assert.h:46
int BLI_findindex(const ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:586
#define LISTBASE_FOREACH(type, var, list)
BLI_INLINE void BLI_listbase_clear(ListBase *lb)
void * BLI_findstring(const ListBase *listbase, const char *id, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:608
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:131
#define BLI_path_join(...)
char * BLI_strdup(const char *str) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1) ATTR_MALLOC
Definition string.cc:41
char * STRNCPY(char(&dst)[N], const char *src)
Definition BLI_string.h:688
#define STRNCPY_UTF8(dst, src)
void BLI_uniquename(const struct ListBase *list, void *vlink, const char *defname, char delim, int name_offset, size_t name_maxncpy) ATTR_NONNULL(1
#define BLI_string_join(...)
ThreadRWMutex * BLI_rw_mutex_alloc(void)
Definition threads.cc:487
#define UNUSED_VARS_NDEBUG(...)
#define ELEM(...)
void * BLO_read_get_new_data_address_no_us(BlendDataReader *reader, const void *old_address, size_t expected_size)
Definition readfile.cc:5540
BlendFileReadReport * BLO_read_data_reports(BlendDataReader *reader)
Definition readfile.cc:5932
void BLO_write_struct_by_name(BlendWriter *writer, const char *struct_name, const void *data_ptr)
#define BLO_write_struct(writer, struct_name, data_ptr)
void BLO_read_struct_list_with_type_size(BlendDataReader *reader, size_t base_size, ListBase *list, blender::FunctionRef< size_t(const void *data)> type_size_fn)
Definition readfile.cc:5647
#define BLO_read_struct_list(reader, struct_name, list)
#define BLO_read_struct(reader, struct_name, ptr_p)
void BLO_reportf_wrap(BlendFileReadReport *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
#define RPT_(msgid)
#define DATA_(msgid)
#define CLOG_WARN(clg_ref,...)
Definition CLG_log.h:181
bool DEG_object_geometry_is_evaluated(const Object &object)
T * DEG_get_original(T *id)
T * DEG_get_evaluated(const Depsgraph *depsgraph, T *id)
@ MOD_DPAINT_BAKING
@ FLUID_EFFECTOR_NEEDS_UPDATE
@ FLUID_FLOW_TYPE_LIQUID
@ FLUID_FLOW_TYPE_SMOKE
@ FLUID_FLOW_NEEDS_UPDATE
@ FLUID_EFFECTOR_TYPE_GUIDE
@ FLUID_EFFECTOR_TYPE_COLLISION
@ FLUID_FLOW_BEHAVIOR_OUTFLOW
@ FLUID_FLOW_BEHAVIOR_INFLOW
@ FLUID_DOMAIN_FILE_LOAD
@ FLUID_DOMAIN_TYPE_GAS
@ FLUID_DOMAIN_TYPE_LIQUID
@ eModifierFlag_OverrideLibrary_Local
@ eModifierFlag_Active
@ MOD_FLUID_TYPE_EFFEC
@ MOD_FLUID_TYPE_DOMAIN
@ MOD_FLUID_TYPE_FLOW
@ eModifierMode_Virtual
@ eModifierMode_Render
@ eModifierMode_Editmode
@ eModifierMode_DisableTemporary
@ eModifierMode_Realtime
@ eModifierMode_OnCage
@ eModifierType_MeshDeform
@ eModifierType_Fluidsim
@ eModifierType_Curve
@ eModifierType_Lattice
@ eModifierType_GreasePencilArmature
@ eModifierType_Cloth
@ eModifierType_Fluid
@ NUM_MODIFIER_TYPES
@ eModifierType_ShapeKey
@ eModifierType_Armature
@ eModifierType_Collision
@ eModifierType_DynamicPaint
@ eModifierType_None
@ eModifierType_Multires
@ OB_MODE_EDIT
Object is a sort of wrapper for general info.
@ OB_LATTICE
@ OB_GREASE_PENCIL
@ OB_ARMATURE
@ OB_MESH
@ OB_CURVES_LEGACY
@ PARSKEL
@ OB_SHAPE_EDIT_MODE
@ PTCACHE_FAKE_SMOKE
@ PTCACHE_DISK_CACHE
#define BASE_SELECTED(v3d, base)
@ UI_PANEL_DATA_EXPAND_ROOT
Read Guarded memory(de)allocation.
void modifier_type_init(ModifierTypeInfo *types[])
Definition MOD_util.cc:202
static void modifier_ensure_type(FluidModifierData *fluid_modifier_data, int type)
static ModifierTypeInfo * modifier_types[NUM_MODIFIER_TYPES]
static void modifier_copy_data_id_us_cb(void *, Object *, ID **idpoin, const LibraryForeachIDCallbackFlag cb_flag)
static size_t modifier_struct_size(const ModifierType type)
static ModifierData * modifier_allocate_and_init(ModifierType type)
static ModifierData * modifier_replace_with_fluid(BlendDataReader *reader, Object *object, ListBase *modifiers, ModifierData *old_modifier_data)
static VirtualModifierData virtualModifierCommonData
static void ensure_non_lazy_normals(Mesh *mesh)
void BM_mesh_normals_update(BMesh *bm)
unsigned long long int uint64_t
constexpr int64_t size() const
Definition BLI_span.hh:493
constexpr void copy_from(Span< T > values) const
Definition BLI_span.hh:739
int64_t size() const
Definition BLI_set.hh:587
bool add(const Key &key)
Definition BLI_set.hh:248
bool same_topology_as(const Mesh &mesh) const
#define offsetof(t, d)
#define DATA(_y, _x)
static void modifier_free_data_id_us_cb(void *, Object *, ID **idpoin, const LibraryForeachIDCallbackFlag cb_flag)
#define printf(...)
#define CD_MASK_ORCO
#define ID_IS_OVERRIDE_LIBRARY_REAL(_id)
#define MEM_SAFE_FREE(v)
#define ID_IS_LINKED(_id)
#define ID_BLEND_PATH(_bmain, _id)
#define ID_IS_OVERRIDE_LIBRARY(_id)
format
#define LOG(severity)
Definition log.h:32
void * MEM_callocN(size_t len, const char *str)
Definition mallocn.cc:118
void MEM_freeN(void *vmemh)
Definition mallocn.cc:113
static double get_current_time_in_seconds()
std::chrono::high_resolution_clock Clock
uint64_t get_default_hash(const T &v, const Args &...args)
Definition BLI_hash.hh:233
#define hash
Definition noise_c.cc:154
struct ListBase ptcaches
struct ClothSolverResult * solver_result
struct ClothHairData * hairdata
struct Cloth * clothObject
struct PointCache * point_cache
struct ClothSimSettings * sim_parms
struct ClothCollSettings * coll_parms
struct EffectorWeights * effector_weights
struct Object * object
struct DynamicPaintModifierData * pmd
struct DynamicPaintModifierData * pmd
struct DynamicPaintCanvasSettings * canvas
struct DynamicPaintBrushSettings * brush
struct ListBase ptcaches[2]
struct FluidModifierData * fmd
struct GPUTexture * tex_density
struct GPUTexture * tex_velocity_x
struct GPUTexture * tex_color
struct GPUTexture * tex_wt
struct GPUTexture * tex_velocity_y
struct GPUTexture * tex_field
struct GPUTexture * tex_velocity_z
struct PointCache * point_cache[2]
struct GPUTexture * tex_shadow
struct ColorBand * coba
struct GPUTexture * tex_coba
struct GPUTexture * tex_flame
struct EffectorWeights * effector_weights
struct GPUTexture * tex_flame_coba
struct FluidModifierData * fmd
struct FluidModifierData * fmd
struct ParticleSystem * psys
struct FluidDomainSettings * domain
struct FluidEffectorSettings * effector
struct FluidFlowSettings * flow
struct FluidsimSettings * fss
static GeometrySet from_mesh(Mesh *mesh, GeometryOwnershipType ownership=GeometryOwnershipType::Owned)
Definition DNA_ID.h:404
char name[66]
Definition DNA_ID.h:415
void * last
void * first
char filepath[1024]
Definition BKE_main.hh:155
MeshRuntimeHandle * runtime
struct ModifierData * next
struct ModifierData * prev
void(*) deform_matrices_EM(ModifierData *md, const ModifierEvalContext *ctx, const BMEditMesh *em, Mesh *mesh, blender::MutableSpan< blender::float3 > positions, blender::MutableSpan< blender::float3x3 > matrices)
bool(*) depends_on_normals(ModifierData *md)
void(*) foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
bool(*) depends_on_time(Scene *scene, ModifierData *md)
void(*) copy_data(const ModifierData *md, ModifierData *target, int flag)
void(*) modify_geometry_set(ModifierData *md, const ModifierEvalContext *ctx, blender::bke::GeometrySet *geometry_set)
bool(*) is_disabled(const Scene *scene, ModifierData *md, bool use_render_params)
void(*) deform_verts(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh, blender::MutableSpan< blender::float3 > positions)
ModifierTypeFlag flags
ModifierTypeType type
void(*) free_data(ModifierData *md)
void(*) blend_write(BlendWriter *writer, const ID *id_owner, const ModifierData *md)
Mesh *(*) modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh)
void(*) blend_read(BlendDataReader *reader, ModifierData *md)
void(*) foreach_tex_link(ModifierData *md, Object *ob, TexWalkFunc walk, void *user_data)
void(*) required_data_mask(ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
void(*) deform_verts_EM(ModifierData *md, const ModifierEvalContext *ctx, const BMEditMesh *em, Mesh *mesh, blender::MutableSpan< blender::float3 > positions)
void(*) init_data(ModifierData *md)
short base_flag
ListBase modifiers
struct Object * parent
short trackflag
char idname[BKE_ST_MAXNAME]
ArmatureModifierData amd
CurveModifierData cmd
LatticeModifierData lmd
ShapeKeyModifierData smd
void * BKE_tempdir_session
Definition stubs.c:38
i
Definition text_draw.cc:230
static DynamicLibrary lib
#define writestruct(wd, filecode, struct_id, nr, adr)
Definition writefile.cc:923