1 /*
2 * This program is free software; you can redistribute it and/or
3 * modify it under the terms of the GNU General Public License
4 * as published by the Free Software Foundation; either version 2
5 * of the License, or (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software Foundation,
14 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15 *
16 * The Original Code is Copyright (C) 2005 by the Blender Foundation.
17 * All rights reserved.
18 * Modifier stack implementation.
19 *
20 * BKE_modifier.h contains the function prototypes for this file.
21 */
22
23 /** \file
24 * \ingroup bke
25 */
26
27 #include <float.h>
28 #include <math.h>
29 #include <stdarg.h>
30 #include <stddef.h>
31 #include <stdlib.h>
32 #include <string.h>
33
34 #include "MEM_guardedalloc.h"
35
36 #include "DNA_armature_types.h"
37 #include "DNA_gpencil_modifier_types.h"
38 #include "DNA_mesh_types.h"
39 #include "DNA_object_types.h"
40 #include "DNA_scene_types.h"
41
42 #include "BLI_linklist.h"
43 #include "BLI_listbase.h"
44 #include "BLI_path_util.h"
45 #include "BLI_session_uuid.h"
46 #include "BLI_string.h"
47 #include "BLI_string_utils.h"
48 #include "BLI_utildefines.h"
49
50 #include "BLT_translation.h"
51
52 #include "BKE_DerivedMesh.h"
53 #include "BKE_appdir.h"
54 #include "BKE_editmesh.h"
55 #include "BKE_editmesh_cache.h"
56 #include "BKE_global.h"
57 #include "BKE_gpencil_modifier.h"
58 #include "BKE_idtype.h"
59 #include "BKE_key.h"
60 #include "BKE_lib_id.h"
61 #include "BKE_lib_query.h"
62 #include "BKE_mesh.h"
63 #include "BKE_mesh_wrapper.h"
64 #include "BKE_multires.h"
65 #include "BKE_object.h"
66
67 /* may move these, only for BKE_modifier_path_relbase */
68 #include "BKE_main.h"
69 /* end */
70
71 #include "DEG_depsgraph.h"
72 #include "DEG_depsgraph_query.h"
73
74 #include "MOD_modifiertypes.h"
75
76 #include "CLG_log.h"
77
78 static CLG_LogRef LOG = {"bke.modifier"};
79 static ModifierTypeInfo *modifier_types[NUM_MODIFIER_TYPES] = {NULL};
80 static VirtualModifierData virtualModifierCommonData;
81
BKE_modifier_init(void)82 void BKE_modifier_init(void)
83 {
84 ModifierData *md;
85
86 /* Initialize modifier types */
87 modifier_type_init(modifier_types); /* MOD_utils.c */
88
89 /* Initialize global cmmon storage used for virtual modifier list */
90 md = BKE_modifier_new(eModifierType_Armature);
91 virtualModifierCommonData.amd = *((ArmatureModifierData *)md);
92 BKE_modifier_free(md);
93
94 md = BKE_modifier_new(eModifierType_Curve);
95 virtualModifierCommonData.cmd = *((CurveModifierData *)md);
96 BKE_modifier_free(md);
97
98 md = BKE_modifier_new(eModifierType_Lattice);
99 virtualModifierCommonData.lmd = *((LatticeModifierData *)md);
100 BKE_modifier_free(md);
101
102 md = BKE_modifier_new(eModifierType_ShapeKey);
103 virtualModifierCommonData.smd = *((ShapeKeyModifierData *)md);
104 BKE_modifier_free(md);
105
106 virtualModifierCommonData.amd.modifier.mode |= eModifierMode_Virtual;
107 virtualModifierCommonData.cmd.modifier.mode |= eModifierMode_Virtual;
108 virtualModifierCommonData.lmd.modifier.mode |= eModifierMode_Virtual;
109 virtualModifierCommonData.smd.modifier.mode |= eModifierMode_Virtual;
110 }
111
BKE_modifier_get_info(ModifierType type)112 const ModifierTypeInfo *BKE_modifier_get_info(ModifierType type)
113 {
114 /* type unsigned, no need to check < 0 */
115 if (type < NUM_MODIFIER_TYPES && modifier_types[type] && modifier_types[type]->name[0] != '\0') {
116 return modifier_types[type];
117 }
118
119 return NULL;
120 }
121
122 /**
123 * Get the idname of the modifier type's panel, which was defined in the #panelRegister callback.
124 */
BKE_modifier_type_panel_id(ModifierType type,char * r_idname)125 void BKE_modifier_type_panel_id(ModifierType type, char *r_idname)
126 {
127 const ModifierTypeInfo *mti = BKE_modifier_get_info(type);
128
129 strcpy(r_idname, MODIFIER_TYPE_PANEL_PREFIX);
130 strcat(r_idname, mti->name);
131 }
132
133 /***/
134
BKE_modifier_new(int type)135 ModifierData *BKE_modifier_new(int type)
136 {
137 const ModifierTypeInfo *mti = BKE_modifier_get_info(type);
138 ModifierData *md = MEM_callocN(mti->structSize, mti->structName);
139
140 /* note, this name must be made unique later */
141 BLI_strncpy(md->name, DATA_(mti->name), sizeof(md->name));
142
143 md->type = type;
144 md->mode = eModifierMode_Realtime | eModifierMode_Render;
145 md->flag = eModifierFlag_OverrideLibrary_Local;
146 md->ui_expand_flag = 1; /* Only open the main panel at the beginning, not the sub-panels. */
147
148 if (mti->flags & eModifierTypeFlag_EnableInEditmode) {
149 md->mode |= eModifierMode_Editmode;
150 }
151
152 if (mti->initData) {
153 mti->initData(md);
154 }
155
156 BKE_modifier_session_uuid_generate(md);
157
158 return md;
159 }
160
modifier_free_data_id_us_cb(void * UNUSED (userData),Object * UNUSED (ob),ID ** idpoin,int cb_flag)161 static void modifier_free_data_id_us_cb(void *UNUSED(userData),
162 Object *UNUSED(ob),
163 ID **idpoin,
164 int cb_flag)
165 {
166 ID *id = *idpoin;
167 if (id != NULL && (cb_flag & IDWALK_CB_USER) != 0) {
168 id_us_min(id);
169 }
170 }
171
BKE_modifier_free_ex(ModifierData * md,const int flag)172 void BKE_modifier_free_ex(ModifierData *md, const int flag)
173 {
174 const ModifierTypeInfo *mti = BKE_modifier_get_info(md->type);
175
176 if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
177 if (mti->foreachIDLink) {
178 mti->foreachIDLink(md, NULL, modifier_free_data_id_us_cb, NULL);
179 }
180 }
181
182 if (mti->freeData) {
183 mti->freeData(md);
184 }
185 if (md->error) {
186 MEM_freeN(md->error);
187 }
188
189 MEM_freeN(md);
190 }
191
BKE_modifier_free(ModifierData * md)192 void BKE_modifier_free(ModifierData *md)
193 {
194 BKE_modifier_free_ex(md, 0);
195 }
196
BKE_modifier_session_uuid_generate(ModifierData * md)197 void BKE_modifier_session_uuid_generate(ModifierData *md)
198 {
199 md->session_uuid = BLI_session_uuid_generate();
200 }
201
BKE_modifier_unique_name(ListBase * modifiers,ModifierData * md)202 bool BKE_modifier_unique_name(ListBase *modifiers, ModifierData *md)
203 {
204 if (modifiers && md) {
205 const ModifierTypeInfo *mti = BKE_modifier_get_info(md->type);
206
207 return BLI_uniquename(
208 modifiers, md, DATA_(mti->name), '.', offsetof(ModifierData, name), sizeof(md->name));
209 }
210 return false;
211 }
212
BKE_modifier_depends_ontime(ModifierData * md)213 bool BKE_modifier_depends_ontime(ModifierData *md)
214 {
215 const ModifierTypeInfo *mti = BKE_modifier_get_info(md->type);
216
217 return mti->dependsOnTime && mti->dependsOnTime(md);
218 }
219
BKE_modifier_supports_mapping(ModifierData * md)220 bool BKE_modifier_supports_mapping(ModifierData *md)
221 {
222 const ModifierTypeInfo *mti = BKE_modifier_get_info(md->type);
223
224 return (mti->type == eModifierTypeType_OnlyDeform ||
225 (mti->flags & eModifierTypeFlag_SupportsMapping));
226 }
227
BKE_modifier_is_preview(ModifierData * md)228 bool BKE_modifier_is_preview(ModifierData *md)
229 {
230 const ModifierTypeInfo *mti = BKE_modifier_get_info(md->type);
231
232 /* Constructive modifiers are highly likely to also modify data like vgroups or vcol! */
233 if (!((mti->flags & eModifierTypeFlag_UsesPreview) ||
234 (mti->type == eModifierTypeType_Constructive))) {
235 return false;
236 }
237
238 if (md->mode & eModifierMode_Realtime) {
239 return true;
240 }
241
242 return false;
243 }
244
BKE_modifiers_findby_type(Object * ob,ModifierType type)245 ModifierData *BKE_modifiers_findby_type(Object *ob, ModifierType type)
246 {
247 LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
248 if (md->type == type) {
249 return md;
250 }
251 }
252 return NULL;
253 }
254
BKE_modifiers_findby_name(Object * ob,const char * name)255 ModifierData *BKE_modifiers_findby_name(Object *ob, const char *name)
256 {
257 return BLI_findstring(&(ob->modifiers), name, offsetof(ModifierData, name));
258 }
259
BKE_modifiers_clear_errors(Object * ob)260 void BKE_modifiers_clear_errors(Object *ob)
261 {
262 LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
263 if (md->error) {
264 MEM_freeN(md->error);
265 md->error = NULL;
266 }
267 }
268 }
269
BKE_modifiers_foreach_ID_link(Object * ob,IDWalkFunc walk,void * userData)270 void BKE_modifiers_foreach_ID_link(Object *ob, IDWalkFunc walk, void *userData)
271 {
272 LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
273 const ModifierTypeInfo *mti = BKE_modifier_get_info(md->type);
274
275 if (mti->foreachIDLink) {
276 mti->foreachIDLink(md, ob, walk, userData);
277 }
278 }
279 }
280
BKE_modifiers_foreach_tex_link(Object * ob,TexWalkFunc walk,void * userData)281 void BKE_modifiers_foreach_tex_link(Object *ob, TexWalkFunc walk, void *userData)
282 {
283 LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
284 const ModifierTypeInfo *mti = BKE_modifier_get_info(md->type);
285
286 if (mti->foreachTexLink) {
287 mti->foreachTexLink(md, ob, walk, userData);
288 }
289 }
290 }
291
292 /* callback's can use this
293 * to avoid copying every member.
294 */
BKE_modifier_copydata_generic(const ModifierData * md_src,ModifierData * md_dst,const int UNUSED (flag))295 void BKE_modifier_copydata_generic(const ModifierData *md_src,
296 ModifierData *md_dst,
297 const int UNUSED(flag))
298 {
299 const ModifierTypeInfo *mti = BKE_modifier_get_info(md_src->type);
300
301 /* md_dst may have already be fully initialized with some extra allocated data,
302 * we need to free it now to avoid memleak. */
303 if (mti->freeData) {
304 mti->freeData(md_dst);
305 }
306
307 const size_t data_size = sizeof(ModifierData);
308 const char *md_src_data = ((const char *)md_src) + data_size;
309 char *md_dst_data = ((char *)md_dst) + data_size;
310 BLI_assert(data_size <= (size_t)mti->structSize);
311 memcpy(md_dst_data, md_src_data, (size_t)mti->structSize - data_size);
312
313 /* Runtime fields are never to be preserved. */
314 md_dst->runtime = NULL;
315 }
316
modifier_copy_data_id_us_cb(void * UNUSED (userData),Object * UNUSED (ob),ID ** idpoin,int cb_flag)317 static void modifier_copy_data_id_us_cb(void *UNUSED(userData),
318 Object *UNUSED(ob),
319 ID **idpoin,
320 int cb_flag)
321 {
322 ID *id = *idpoin;
323 if (id != NULL && (cb_flag & IDWALK_CB_USER) != 0) {
324 id_us_plus(id);
325 }
326 }
327
BKE_modifier_copydata_ex(ModifierData * md,ModifierData * target,const int flag)328 void BKE_modifier_copydata_ex(ModifierData *md, ModifierData *target, const int flag)
329 {
330 const ModifierTypeInfo *mti = BKE_modifier_get_info(md->type);
331
332 target->mode = md->mode;
333 target->flag = md->flag;
334 target->ui_expand_flag = md->ui_expand_flag;
335
336 if (mti->copyData) {
337 mti->copyData(md, target, flag);
338 }
339
340 if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
341 if (mti->foreachIDLink) {
342 mti->foreachIDLink(target, NULL, modifier_copy_data_id_us_cb, NULL);
343 }
344 }
345
346 if (flag & LIB_ID_CREATE_NO_MAIN) {
347 /* Make sure UUID is the same between the source and the target.
348 * This is needed in the cases when UUID is to be preserved and when there is no copyData
349 * callback, or the copyData does not do full byte copy of the modifier data. */
350 target->session_uuid = md->session_uuid;
351 }
352 else {
353 /* In the case copyData made full byte copy force UUID to be re-generated. */
354 BKE_modifier_session_uuid_generate(md);
355 }
356 }
357
BKE_modifier_copydata(ModifierData * md,ModifierData * target)358 void BKE_modifier_copydata(ModifierData *md, ModifierData *target)
359 {
360 BKE_modifier_copydata_ex(md, target, 0);
361 }
362
BKE_modifier_supports_cage(struct Scene * scene,ModifierData * md)363 bool BKE_modifier_supports_cage(struct Scene *scene, ModifierData *md)
364 {
365 const ModifierTypeInfo *mti = BKE_modifier_get_info(md->type);
366
367 return ((!mti->isDisabled || !mti->isDisabled(scene, md, 0)) &&
368 (mti->flags & eModifierTypeFlag_SupportsEditmode) && BKE_modifier_supports_mapping(md));
369 }
370
BKE_modifier_couldbe_cage(struct Scene * scene,ModifierData * md)371 bool BKE_modifier_couldbe_cage(struct Scene *scene, ModifierData *md)
372 {
373 const ModifierTypeInfo *mti = BKE_modifier_get_info(md->type);
374
375 return ((md->mode & eModifierMode_Realtime) && (md->mode & eModifierMode_Editmode) &&
376 (!mti->isDisabled || !mti->isDisabled(scene, md, 0)) &&
377 BKE_modifier_supports_mapping(md));
378 }
379
BKE_modifier_is_same_topology(ModifierData * md)380 bool BKE_modifier_is_same_topology(ModifierData *md)
381 {
382 const ModifierTypeInfo *mti = BKE_modifier_get_info(md->type);
383 return ELEM(mti->type, eModifierTypeType_OnlyDeform, eModifierTypeType_NonGeometrical);
384 }
385
BKE_modifier_is_non_geometrical(ModifierData * md)386 bool BKE_modifier_is_non_geometrical(ModifierData *md)
387 {
388 const ModifierTypeInfo *mti = BKE_modifier_get_info(md->type);
389 return (mti->type == eModifierTypeType_NonGeometrical);
390 }
391
BKE_modifier_set_error(ModifierData * md,const char * _format,...)392 void BKE_modifier_set_error(ModifierData *md, const char *_format, ...)
393 {
394 char buffer[512];
395 va_list ap;
396 const char *format = TIP_(_format);
397
398 va_start(ap, _format);
399 vsnprintf(buffer, sizeof(buffer), format, ap);
400 va_end(ap);
401 buffer[sizeof(buffer) - 1] = '\0';
402
403 if (md->error) {
404 MEM_freeN(md->error);
405 }
406
407 md->error = BLI_strdup(buffer);
408
409 CLOG_STR_ERROR(&LOG, md->error);
410 }
411
412 /* used for buttons, to find out if the 'draw deformed in editmode' option is
413 * there
414 *
415 * also used in transform_conversion.c, to detect CrazySpace [tm] (2nd arg
416 * then is NULL)
417 * also used for some mesh tools to give warnings
418 */
BKE_modifiers_get_cage_index(struct Scene * scene,Object * ob,int * r_lastPossibleCageIndex,bool is_virtual)419 int BKE_modifiers_get_cage_index(struct Scene *scene,
420 Object *ob,
421 int *r_lastPossibleCageIndex,
422 bool is_virtual)
423 {
424 VirtualModifierData virtualModifierData;
425 ModifierData *md = (is_virtual) ?
426 BKE_modifiers_get_virtual_modifierlist(ob, &virtualModifierData) :
427 ob->modifiers.first;
428
429 if (r_lastPossibleCageIndex) {
430 /* ensure the value is initialized */
431 *r_lastPossibleCageIndex = -1;
432 }
433
434 /* Find the last modifier acting on the cage. */
435 int cageIndex = -1;
436 for (int i = 0; md; i++, md = md->next) {
437 const ModifierTypeInfo *mti = BKE_modifier_get_info(md->type);
438 bool supports_mapping;
439
440 if (mti->isDisabled && mti->isDisabled(scene, md, 0)) {
441 continue;
442 }
443 if (!(mti->flags & eModifierTypeFlag_SupportsEditmode)) {
444 continue;
445 }
446 if (md->mode & eModifierMode_DisableTemporary) {
447 continue;
448 }
449
450 supports_mapping = BKE_modifier_supports_mapping(md);
451 if (r_lastPossibleCageIndex && supports_mapping) {
452 *r_lastPossibleCageIndex = i;
453 }
454
455 if (!(md->mode & eModifierMode_Realtime)) {
456 continue;
457 }
458 if (!(md->mode & eModifierMode_Editmode)) {
459 continue;
460 }
461
462 if (!supports_mapping) {
463 break;
464 }
465
466 if (md->mode & eModifierMode_OnCage) {
467 cageIndex = i;
468 }
469 }
470
471 return cageIndex;
472 }
473
BKE_modifiers_is_softbody_enabled(Object * ob)474 bool BKE_modifiers_is_softbody_enabled(Object *ob)
475 {
476 ModifierData *md = BKE_modifiers_findby_type(ob, eModifierType_Softbody);
477
478 return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
479 }
480
BKE_modifiers_is_cloth_enabled(Object * ob)481 bool BKE_modifiers_is_cloth_enabled(Object *ob)
482 {
483 ModifierData *md = BKE_modifiers_findby_type(ob, eModifierType_Cloth);
484
485 return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
486 }
487
BKE_modifiers_is_modifier_enabled(Object * ob,int modifierType)488 bool BKE_modifiers_is_modifier_enabled(Object *ob, int modifierType)
489 {
490 ModifierData *md = BKE_modifiers_findby_type(ob, modifierType);
491
492 return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
493 }
494
BKE_modifiers_is_particle_enabled(Object * ob)495 bool BKE_modifiers_is_particle_enabled(Object *ob)
496 {
497 ModifierData *md = BKE_modifiers_findby_type(ob, eModifierType_ParticleSystem);
498
499 return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
500 }
501
502 /**
503 * Check whether is enabled.
504 *
505 * \param scene: Current scene, may be NULL,
506 * in which case isDisabled callback of the modifier is never called.
507 */
BKE_modifier_is_enabled(const struct Scene * scene,ModifierData * md,int required_mode)508 bool BKE_modifier_is_enabled(const struct Scene *scene, ModifierData *md, int required_mode)
509 {
510 const ModifierTypeInfo *mti = BKE_modifier_get_info(md->type);
511
512 if ((md->mode & required_mode) != required_mode) {
513 return false;
514 }
515 if (scene != NULL && mti->isDisabled &&
516 mti->isDisabled(scene, md, required_mode == eModifierMode_Render)) {
517 return false;
518 }
519 if (md->mode & eModifierMode_DisableTemporary) {
520 return false;
521 }
522 if ((required_mode & eModifierMode_Editmode) &&
523 !(mti->flags & eModifierTypeFlag_SupportsEditmode)) {
524 return false;
525 }
526
527 return true;
528 }
529
BKE_modifier_calc_data_masks(struct Scene * scene,Object * ob,ModifierData * md,CustomData_MeshMasks * final_datamask,int required_mode,ModifierData * previewmd,const CustomData_MeshMasks * previewmask)530 CDMaskLink *BKE_modifier_calc_data_masks(struct Scene *scene,
531 Object *ob,
532 ModifierData *md,
533 CustomData_MeshMasks *final_datamask,
534 int required_mode,
535 ModifierData *previewmd,
536 const CustomData_MeshMasks *previewmask)
537 {
538 CDMaskLink *dataMasks = NULL;
539 CDMaskLink *curr, *prev;
540 bool have_deform_modifier = false;
541
542 /* build a list of modifier data requirements in reverse order */
543 for (; md; md = md->next) {
544 const ModifierTypeInfo *mti = BKE_modifier_get_info(md->type);
545
546 curr = MEM_callocN(sizeof(CDMaskLink), "CDMaskLink");
547
548 if (BKE_modifier_is_enabled(scene, md, required_mode)) {
549 if (mti->type == eModifierTypeType_OnlyDeform) {
550 have_deform_modifier = true;
551 }
552
553 if (mti->requiredDataMask) {
554 mti->requiredDataMask(ob, md, &curr->mask);
555 }
556
557 if (previewmd == md && previewmask != NULL) {
558 CustomData_MeshMasks_update(&curr->mask, previewmask);
559 }
560 }
561
562 if (!have_deform_modifier) {
563 /* Don't create orco layer when there is no deformation, we fall
564 * back to regular vertex coordinates */
565 curr->mask.vmask &= ~CD_MASK_ORCO;
566 }
567
568 /* prepend new datamask */
569 curr->next = dataMasks;
570 dataMasks = curr;
571 }
572
573 if (!have_deform_modifier) {
574 final_datamask->vmask &= ~CD_MASK_ORCO;
575 }
576
577 /* build the list of required data masks - each mask in the list must
578 * include all elements of the masks that follow it
579 *
580 * note the list is currently in reverse order, so "masks that follow it"
581 * actually means "masks that precede it" at the moment
582 */
583 for (curr = dataMasks, prev = NULL; curr; prev = curr, curr = curr->next) {
584 if (prev) {
585 CustomData_MeshMasks_update(&curr->mask, &prev->mask);
586 }
587 else {
588 CustomData_MeshMasks_update(&curr->mask, final_datamask);
589 }
590 }
591
592 /* reverse the list so it's in the correct order */
593 BLI_linklist_reverse((LinkNode **)&dataMasks);
594
595 return dataMasks;
596 }
597
BKE_modifier_get_last_preview(struct Scene * scene,ModifierData * md,int required_mode)598 ModifierData *BKE_modifier_get_last_preview(struct Scene *scene,
599 ModifierData *md,
600 int required_mode)
601 {
602 ModifierData *tmp_md = NULL;
603
604 if ((required_mode & ~eModifierMode_Editmode) != eModifierMode_Realtime) {
605 return tmp_md;
606 }
607
608 /* Find the latest modifier in stack generating preview. */
609 for (; md; md = md->next) {
610 if (BKE_modifier_is_enabled(scene, md, required_mode) && BKE_modifier_is_preview(md)) {
611 tmp_md = md;
612 }
613 }
614 return tmp_md;
615 }
616
617 /* This is to include things that are not modifiers in the evaluation of the modifier stack, for
618 * example parenting to an armature. */
BKE_modifiers_get_virtual_modifierlist(const Object * ob,VirtualModifierData * virtualModifierData)619 ModifierData *BKE_modifiers_get_virtual_modifierlist(const Object *ob,
620 VirtualModifierData *virtualModifierData)
621 {
622 ModifierData *md = ob->modifiers.first;
623
624 *virtualModifierData = virtualModifierCommonData;
625
626 if (ob->parent) {
627 if (ob->parent->type == OB_ARMATURE && ob->partype == PARSKEL) {
628 virtualModifierData->amd.object = ob->parent;
629 virtualModifierData->amd.modifier.next = md;
630 virtualModifierData->amd.deformflag = ((bArmature *)(ob->parent->data))->deformflag;
631 md = &virtualModifierData->amd.modifier;
632 }
633 else if (ob->parent->type == OB_CURVE && ob->partype == PARSKEL) {
634 virtualModifierData->cmd.object = ob->parent;
635 virtualModifierData->cmd.defaxis = ob->trackflag + 1;
636 virtualModifierData->cmd.modifier.next = md;
637 md = &virtualModifierData->cmd.modifier;
638 }
639 else if (ob->parent->type == OB_LATTICE && ob->partype == PARSKEL) {
640 virtualModifierData->lmd.object = ob->parent;
641 virtualModifierData->lmd.modifier.next = md;
642 md = &virtualModifierData->lmd.modifier;
643 }
644 }
645
646 /* shape key modifier, not yet for curves */
647 if (ELEM(ob->type, OB_MESH, OB_LATTICE) && BKE_key_from_object(ob)) {
648 if (ob->type == OB_MESH && (ob->shapeflag & OB_SHAPE_EDIT_MODE)) {
649 virtualModifierData->smd.modifier.mode |= eModifierMode_Editmode | eModifierMode_OnCage;
650 }
651 else {
652 virtualModifierData->smd.modifier.mode &= ~eModifierMode_Editmode | eModifierMode_OnCage;
653 }
654
655 virtualModifierData->smd.modifier.next = md;
656 md = &virtualModifierData->smd.modifier;
657 }
658
659 return md;
660 }
661
662 /* Takes an object and returns its first selected armature, else just its armature
663 * This should work for multiple armatures per object
664 */
BKE_modifiers_is_deformed_by_armature(Object * ob)665 Object *BKE_modifiers_is_deformed_by_armature(Object *ob)
666 {
667 if (ob->type == OB_GPENCIL) {
668 GpencilVirtualModifierData gpencilvirtualModifierData;
669 ArmatureGpencilModifierData *agmd = NULL;
670 GpencilModifierData *gmd = BKE_gpencil_modifiers_get_virtual_modifierlist(
671 ob, &gpencilvirtualModifierData);
672 gmd = ob->greasepencil_modifiers.first;
673
674 /* return the first selected armature, this lets us use multiple armatures */
675 for (; gmd; gmd = gmd->next) {
676 if (gmd->type == eGpencilModifierType_Armature) {
677 agmd = (ArmatureGpencilModifierData *)gmd;
678 if (agmd->object && (agmd->object->base_flag & BASE_SELECTED)) {
679 return agmd->object;
680 }
681 }
682 }
683 /* If we're still here then return the last armature. */
684 if (agmd) {
685 return agmd->object;
686 }
687 }
688 else {
689 VirtualModifierData virtualModifierData;
690 ArmatureModifierData *amd = NULL;
691 ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtualModifierData);
692 md = ob->modifiers.first;
693
694 /* return the first selected armature, this lets us use multiple armatures */
695 for (; md; md = md->next) {
696 if (md->type == eModifierType_Armature) {
697 amd = (ArmatureModifierData *)md;
698 if (amd->object && (amd->object->base_flag & BASE_SELECTED)) {
699 return amd->object;
700 }
701 }
702 }
703 /* If we're still here then return the last armature. */
704 if (amd) {
705 return amd->object;
706 }
707 }
708
709 return NULL;
710 }
711
BKE_modifiers_is_deformed_by_meshdeform(Object * ob)712 Object *BKE_modifiers_is_deformed_by_meshdeform(Object *ob)
713 {
714 VirtualModifierData virtualModifierData;
715 ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtualModifierData);
716 MeshDeformModifierData *mdmd = NULL;
717
718 /* return the first selected armature, this lets us use multiple armatures */
719 for (; md; md = md->next) {
720 if (md->type == eModifierType_MeshDeform) {
721 mdmd = (MeshDeformModifierData *)md;
722 if (mdmd->object && (mdmd->object->base_flag & BASE_SELECTED)) {
723 return mdmd->object;
724 }
725 }
726 }
727
728 if (mdmd) { /* if we're still here then return the last armature */
729 return mdmd->object;
730 }
731
732 return NULL;
733 }
734
735 /* Takes an object and returns its first selected lattice, else just its lattice
736 * This should work for multiple lattices per object
737 */
BKE_modifiers_is_deformed_by_lattice(Object * ob)738 Object *BKE_modifiers_is_deformed_by_lattice(Object *ob)
739 {
740 VirtualModifierData virtualModifierData;
741 ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtualModifierData);
742 LatticeModifierData *lmd = NULL;
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 = (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 NULL;
759 }
760
761 /* Takes an object and returns its first selected curve, else just its curve
762 * This should work for multiple curves per object
763 */
BKE_modifiers_is_deformed_by_curve(Object * ob)764 Object *BKE_modifiers_is_deformed_by_curve(Object *ob)
765 {
766 VirtualModifierData virtualModifierData;
767 ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtualModifierData);
768 CurveModifierData *cmd = NULL;
769
770 /* return the first selected curve, this lets us use multiple curves */
771 for (; md; md = md->next) {
772 if (md->type == eModifierType_Curve) {
773 cmd = (CurveModifierData *)md;
774 if (cmd->object && (cmd->object->base_flag & BASE_SELECTED)) {
775 return cmd->object;
776 }
777 }
778 }
779
780 if (cmd) { /* if we're still here then return the last curve */
781 return cmd->object;
782 }
783
784 return NULL;
785 }
786
BKE_modifiers_uses_multires(Object * ob)787 bool BKE_modifiers_uses_multires(Object *ob)
788 {
789 VirtualModifierData virtualModifierData;
790 ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtualModifierData);
791 MultiresModifierData *mmd = NULL;
792
793 for (; md; md = md->next) {
794 if (md->type == eModifierType_Multires) {
795 mmd = (MultiresModifierData *)md;
796 if (mmd->totlvl != 0) {
797 return true;
798 }
799 }
800 }
801 return false;
802 }
803
BKE_modifiers_uses_armature(Object * ob,bArmature * arm)804 bool BKE_modifiers_uses_armature(Object *ob, bArmature *arm)
805 {
806 VirtualModifierData virtualModifierData;
807 ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtualModifierData);
808
809 for (; md; md = md->next) {
810 if (md->type == eModifierType_Armature) {
811 ArmatureModifierData *amd = (ArmatureModifierData *)md;
812 if (amd->object && amd->object->data == arm) {
813 return true;
814 }
815 }
816 }
817
818 return false;
819 }
820
BKE_modifiers_uses_subsurf_facedots(struct Scene * scene,Object * ob)821 bool BKE_modifiers_uses_subsurf_facedots(struct Scene *scene, Object *ob)
822 {
823 /* Search (backward) in the modifier stack to find if we have a subsurf modifier (enabled) before
824 * the last modifier displayed on cage (or if the subsurf is the last). */
825 VirtualModifierData virtualModifierData;
826 ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtualModifierData);
827 int cage_index = BKE_modifiers_get_cage_index(scene, ob, NULL, 1);
828 if (cage_index == -1) {
829 return false;
830 }
831 /* Find first modifier enabled on cage. */
832 for (int i = 0; md && i < cage_index; i++) {
833 md = md->next;
834 }
835 /* Now from this point, search for subsurf modifier. */
836 for (; md; md = md->prev) {
837 const ModifierTypeInfo *mti = BKE_modifier_get_info(md->type);
838 if (md->type == eModifierType_Subsurf) {
839 ModifierMode mode = eModifierMode_Realtime | eModifierMode_Editmode;
840 if (BKE_modifier_is_enabled(scene, md, mode)) {
841 return true;
842 }
843 }
844 else if (mti->type == eModifierTypeType_OnlyDeform) {
845 /* These modifiers do not reset the subdiv flag nor change the topology.
846 * We can still search for a subsurf modifier. */
847 }
848 else {
849 /* Other modifiers may reset the subdiv facedot flag or create. */
850 return false;
851 }
852 }
853 return false;
854 }
855
BKE_modifier_is_correctable_deformed(ModifierData * md)856 bool BKE_modifier_is_correctable_deformed(ModifierData *md)
857 {
858 const ModifierTypeInfo *mti = BKE_modifier_get_info(md->type);
859 return mti->deformMatricesEM != NULL;
860 }
861
BKE_modifiers_is_correctable_deformed(struct Scene * scene,Object * ob)862 bool BKE_modifiers_is_correctable_deformed(struct Scene *scene, Object *ob)
863 {
864 VirtualModifierData virtualModifierData;
865 ModifierData *md = BKE_modifiers_get_virtual_modifierlist(ob, &virtualModifierData);
866 int required_mode = eModifierMode_Realtime;
867
868 if (ob->mode == OB_MODE_EDIT) {
869 required_mode |= eModifierMode_Editmode;
870 }
871 for (; md; md = md->next) {
872 if (!BKE_modifier_is_enabled(scene, md, required_mode)) {
873 /* pass */
874 }
875 else if (BKE_modifier_is_correctable_deformed(md)) {
876 return true;
877 }
878 }
879 return false;
880 }
881
BKE_modifier_free_temporary_data(ModifierData * md)882 void BKE_modifier_free_temporary_data(ModifierData *md)
883 {
884 if (md->type == eModifierType_Armature) {
885 ArmatureModifierData *amd = (ArmatureModifierData *)md;
886
887 MEM_SAFE_FREE(amd->vert_coords_prev);
888 }
889 }
890
891 /* ensure modifier correctness when changing ob->data */
BKE_modifiers_test_object(Object * ob)892 void BKE_modifiers_test_object(Object *ob)
893 {
894 ModifierData *md;
895
896 /* just multires checked for now, since only multires
897 * modifies mesh data */
898
899 if (ob->type != OB_MESH) {
900 return;
901 }
902
903 for (md = ob->modifiers.first; md; md = md->next) {
904 if (md->type == eModifierType_Multires) {
905 MultiresModifierData *mmd = (MultiresModifierData *)md;
906
907 multiresModifier_set_levels_from_disps(mmd, ob);
908 }
909 }
910 }
911
912 /* where should this go?, it doesn't fit well anywhere :S - campbell */
913
914 /* elubie: changed this to default to the same dir as the render output
915 * to prevent saving to C:\ on Windows */
916
917 /* campbell: logic behind this...
918 *
919 * - if the ID is from a library, return library path
920 * - else if the file has been saved return the blend file path.
921 * - else if the file isn't saved and the ID isn't from a library, return the temp dir.
922 */
BKE_modifier_path_relbase(Main * bmain,Object * ob)923 const char *BKE_modifier_path_relbase(Main *bmain, Object *ob)
924 {
925 if (G.relbase_valid || ID_IS_LINKED(ob)) {
926 return ID_BLEND_PATH(bmain, &ob->id);
927 }
928
929 /* last resort, better than using "" which resolves to the current
930 * working directory */
931 return BKE_tempdir_session();
932 }
933
BKE_modifier_path_relbase_from_global(Object * ob)934 const char *BKE_modifier_path_relbase_from_global(Object *ob)
935 {
936 if (G.relbase_valid || ID_IS_LINKED(ob)) {
937 return ID_BLEND_PATH_FROM_GLOBAL(&ob->id);
938 }
939
940 /* last resort, better than using "" which resolves to the current
941 * working directory */
942 return BKE_tempdir_session();
943 }
944
945 /* initializes the path with either */
BKE_modifier_path_init(char * path,int path_maxlen,const char * name)946 void BKE_modifier_path_init(char *path, int path_maxlen, const char *name)
947 {
948 /* elubie: changed this to default to the same dir as the render output
949 * to prevent saving to C:\ on Windows */
950 BLI_join_dirfile(path, path_maxlen, G.relbase_valid ? "//" : BKE_tempdir_session(), name);
951 }
952
953 /**
954 * Call when #ModifierTypeInfo.dependsOnNormals callback requests normals.
955 */
modwrap_dependsOnNormals(Mesh * me)956 static void modwrap_dependsOnNormals(Mesh *me)
957 {
958 switch ((eMeshWrapperType)me->runtime.wrapper_type) {
959 case ME_WRAPPER_TYPE_BMESH: {
960 EditMeshData *edit_data = me->runtime.edit_data;
961 if (edit_data->vertexCos) {
962 /* Note that 'ensure' is acceptable here since these values aren't modified in-place.
963 * If that changes we'll need to recalculate. */
964 BKE_editmesh_cache_ensure_vert_normals(me->edit_mesh, edit_data);
965 }
966 else {
967 BM_mesh_normals_update(me->edit_mesh->bm);
968 }
969 break;
970 }
971 case ME_WRAPPER_TYPE_MDATA:
972 BKE_mesh_calc_normals(me);
973 break;
974 }
975 }
976
977 /* wrapper around ModifierTypeInfo.modifyMesh that ensures valid normals */
978
BKE_modifier_modify_mesh(ModifierData * md,const ModifierEvalContext * ctx,struct Mesh * me)979 struct Mesh *BKE_modifier_modify_mesh(ModifierData *md,
980 const ModifierEvalContext *ctx,
981 struct Mesh *me)
982 {
983 const ModifierTypeInfo *mti = BKE_modifier_get_info(md->type);
984 BLI_assert(CustomData_has_layer(&me->pdata, CD_NORMAL) == false);
985
986 if (me->runtime.wrapper_type == ME_WRAPPER_TYPE_BMESH) {
987 if ((mti->flags & eModifierTypeFlag_AcceptsBMesh) == 0) {
988 BKE_mesh_wrapper_ensure_mdata(me);
989 }
990 }
991
992 if (mti->dependsOnNormals && mti->dependsOnNormals(md)) {
993 modwrap_dependsOnNormals(me);
994 }
995 return mti->modifyMesh(md, ctx, me);
996 }
997
BKE_modifier_deform_verts(ModifierData * md,const ModifierEvalContext * ctx,Mesh * me,float (* vertexCos)[3],int numVerts)998 void BKE_modifier_deform_verts(ModifierData *md,
999 const ModifierEvalContext *ctx,
1000 Mesh *me,
1001 float (*vertexCos)[3],
1002 int numVerts)
1003 {
1004 const ModifierTypeInfo *mti = BKE_modifier_get_info(md->type);
1005 BLI_assert(!me || CustomData_has_layer(&me->pdata, CD_NORMAL) == false);
1006
1007 if (me && mti->dependsOnNormals && mti->dependsOnNormals(md)) {
1008 modwrap_dependsOnNormals(me);
1009 }
1010 mti->deformVerts(md, ctx, me, vertexCos, numVerts);
1011 }
1012
BKE_modifier_deform_vertsEM(ModifierData * md,const ModifierEvalContext * ctx,struct BMEditMesh * em,Mesh * me,float (* vertexCos)[3],int numVerts)1013 void BKE_modifier_deform_vertsEM(ModifierData *md,
1014 const ModifierEvalContext *ctx,
1015 struct BMEditMesh *em,
1016 Mesh *me,
1017 float (*vertexCos)[3],
1018 int numVerts)
1019 {
1020 const ModifierTypeInfo *mti = BKE_modifier_get_info(md->type);
1021 BLI_assert(!me || CustomData_has_layer(&me->pdata, CD_NORMAL) == false);
1022
1023 if (me && mti->dependsOnNormals && mti->dependsOnNormals(md)) {
1024 BKE_mesh_calc_normals(me);
1025 }
1026 mti->deformVertsEM(md, ctx, em, me, vertexCos, numVerts);
1027 }
1028
1029 /* end modifier callback wrappers */
1030
1031 /**
1032 * Get evaluated mesh for other evaluated object, which is used as an operand for the modifier,
1033 * e.g. second operand for boolean modifier.
1034 * Note that modifiers in stack always get fully evaluated COW ID pointers,
1035 * never original ones. Makes things simpler.
1036 *
1037 * \param get_cage_mesh: Return evaluated mesh with only deforming modifiers applied
1038 * (i.e. mesh topology remains the same as original one, a.k.a. 'cage' mesh).
1039 */
BKE_modifier_get_evaluated_mesh_from_evaluated_object(Object * ob_eval,const bool get_cage_mesh)1040 Mesh *BKE_modifier_get_evaluated_mesh_from_evaluated_object(Object *ob_eval,
1041 const bool get_cage_mesh)
1042 {
1043 Mesh *me = NULL;
1044
1045 if ((ob_eval->type == OB_MESH) && (ob_eval->mode & OB_MODE_EDIT)) {
1046 /* In EditMode, evaluated mesh is stored in BMEditMesh, not the object... */
1047 BMEditMesh *em = BKE_editmesh_from_object(ob_eval);
1048 /* 'em' might not exist yet in some cases, just after loading a .blend file, see T57878. */
1049 if (em != NULL) {
1050 me = (get_cage_mesh && em->mesh_eval_cage != NULL) ? em->mesh_eval_cage :
1051 em->mesh_eval_final;
1052 }
1053 }
1054 if (me == NULL) {
1055 me = (get_cage_mesh && ob_eval->runtime.mesh_deform_eval != NULL) ?
1056 ob_eval->runtime.mesh_deform_eval :
1057 BKE_object_get_evaluated_mesh(ob_eval);
1058 }
1059
1060 return me;
1061 }
1062
BKE_modifier_get_original(ModifierData * md)1063 ModifierData *BKE_modifier_get_original(ModifierData *md)
1064 {
1065 if (md->orig_modifier_data == NULL) {
1066 return md;
1067 }
1068 return md->orig_modifier_data;
1069 }
1070
BKE_modifier_get_evaluated(Depsgraph * depsgraph,Object * object,ModifierData * md)1071 struct ModifierData *BKE_modifier_get_evaluated(Depsgraph *depsgraph,
1072 Object *object,
1073 ModifierData *md)
1074 {
1075 Object *object_eval = DEG_get_evaluated_object(depsgraph, object);
1076 if (object_eval == object) {
1077 return md;
1078 }
1079 return BKE_modifiers_findby_name(object_eval, md->name);
1080 }
1081
BKE_modifier_check_uuids_unique_and_report(const Object * object)1082 void BKE_modifier_check_uuids_unique_and_report(const Object *object)
1083 {
1084 struct GSet *used_uuids = BLI_gset_new(
1085 BLI_session_uuid_ghash_hash, BLI_session_uuid_ghash_compare, "modifier used uuids");
1086
1087 LISTBASE_FOREACH (ModifierData *, md, &object->modifiers) {
1088 const SessionUUID *session_uuid = &md->session_uuid;
1089 if (!BLI_session_uuid_is_generated(session_uuid)) {
1090 printf("Modifier %s -> %s does not have UUID generated.\n", object->id.name + 2, md->name);
1091 continue;
1092 }
1093
1094 if (BLI_gset_lookup(used_uuids, session_uuid) != NULL) {
1095 printf("Modifier %s -> %s has duplicate UUID generated.\n", object->id.name + 2, md->name);
1096 continue;
1097 }
1098
1099 BLI_gset_insert(used_uuids, (void *)session_uuid);
1100 }
1101
1102 BLI_gset_free(used_uuids, NULL);
1103 }
1104