Fix T53291: Deleting objects do not delete them from the blend file
[blender.git] / source / blender / blenkernel / intern / object.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/blenkernel/intern/object.c
29  *  \ingroup bke
30  */
31
32
33 #include <string.h>
34 #include <math.h>
35 #include <stdio.h>
36
37 #include "MEM_guardedalloc.h"
38
39 #include "DNA_anim_types.h"
40 #include "DNA_armature_types.h"
41 #include "DNA_camera_types.h"
42 #include "DNA_constraint_types.h"
43 #include "DNA_gpencil_types.h"
44 #include "DNA_group_types.h"
45 #include "DNA_key_types.h"
46 #include "DNA_lamp_types.h"
47 #include "DNA_lattice_types.h"
48 #include "DNA_material_types.h"
49 #include "DNA_meta_types.h"
50 #include "DNA_mesh_types.h"
51 #include "DNA_meshdata_types.h"
52 #include "DNA_movieclip_types.h"
53 #include "DNA_scene_types.h"
54 #include "DNA_screen_types.h"
55 #include "DNA_sequence_types.h"
56 #include "DNA_smoke_types.h"
57 #include "DNA_space_types.h"
58 #include "DNA_view3d_types.h"
59 #include "DNA_world_types.h"
60 #include "DNA_object_types.h"
61 #include "DNA_lightprobe_types.h"
62 #include "DNA_property_types.h"
63 #include "DNA_rigidbody_types.h"
64
65 #include "BLI_blenlib.h"
66 #include "BLI_math.h"
67 #include "BLI_threads.h"
68 #include "BLI_utildefines.h"
69 #include "BLI_linklist.h"
70 #include "BLI_kdtree.h"
71
72 #include "BLT_translation.h"
73
74 #include "BKE_pbvh.h"
75 #include "BKE_main.h"
76 #include "BKE_global.h"
77 #include "BKE_idprop.h"
78 #include "BKE_armature.h"
79 #include "BKE_action.h"
80 #include "BKE_bullet.h"
81 #include "BKE_deform.h"
82 #include "BKE_DerivedMesh.h"
83 #include "BKE_animsys.h"
84 #include "BKE_anim.h"
85 #include "BKE_constraint.h"
86 #include "BKE_curve.h"
87 #include "BKE_displist.h"
88 #include "BKE_effect.h"
89 #include "BKE_fcurve.h"
90 #include "BKE_group.h"
91 #include "BKE_icons.h"
92 #include "BKE_key.h"
93 #include "BKE_lamp.h"
94 #include "BKE_layer.h"
95 #include "BKE_lattice.h"
96 #include "BKE_library.h"
97 #include "BKE_library_query.h"
98 #include "BKE_library_remap.h"
99 #include "BKE_linestyle.h"
100 #include "BKE_mesh.h"
101 #include "BKE_editmesh.h"
102 #include "BKE_mball.h"
103 #include "BKE_modifier.h"
104 #include "BKE_multires.h"
105 #include "BKE_node.h"
106 #include "BKE_object.h"
107 #include "BKE_object_facemap.h"
108 #include "BKE_paint.h"
109 #include "BKE_particle.h"
110 #include "BKE_pointcache.h"
111 #include "BKE_lightprobe.h"
112 #include "BKE_property.h"
113 #include "BKE_rigidbody.h"
114 #include "BKE_sca.h"
115 #include "BKE_scene.h"
116 #include "BKE_sequencer.h"
117 #include "BKE_speaker.h"
118 #include "BKE_softbody.h"
119 #include "BKE_subsurf.h"
120 #include "BKE_material.h"
121 #include "BKE_camera.h"
122 #include "BKE_image.h"
123
124 #include "DEG_depsgraph.h"
125
126 #include "DRW_engine.h"
127
128 #ifdef WITH_MOD_FLUID
129 #include "LBM_fluidsim.h"
130 #endif
131
132 #ifdef WITH_PYTHON
133 #include "BPY_extern.h"
134 #endif
135
136 #include "CCGSubSurf.h"
137 #include "atomic_ops.h"
138
139 #include "GPU_lamp.h"
140
141 /* Vertex parent modifies original BMesh which is not safe for threading.
142  * Ideally such a modification should be handled as a separate DAG update
143  * callback for mesh datablock, but for until it is actually supported use
144  * simpler solution with a mutex lock.
145  *                                               - sergey -
146  */
147 #define VPARENT_THREADING_HACK
148
149 #ifdef VPARENT_THREADING_HACK
150 static ThreadMutex vparent_lock = BLI_MUTEX_INITIALIZER;
151 #endif
152
153 void BKE_object_workob_clear(Object *workob)
154 {
155         memset(workob, 0, sizeof(Object));
156         
157         workob->size[0] = workob->size[1] = workob->size[2] = 1.0f;
158         workob->dscale[0] = workob->dscale[1] = workob->dscale[2] = 1.0f;
159         workob->rotmode = ROT_MODE_EUL;
160 }
161
162 void BKE_object_free_particlesystems(Object *ob)
163 {
164         ParticleSystem *psys;
165
166         while ((psys = BLI_pophead(&ob->particlesystem))) {
167                 psys_free(ob, psys);
168         }
169 }
170
171 void BKE_object_free_softbody(Object *ob)
172 {
173         if (ob->soft) {
174                 sbFree(ob->soft);
175                 ob->soft = NULL;
176         }
177 }
178
179 void BKE_object_free_bulletsoftbody(Object *ob)
180 {
181         if (ob->bsoft) {
182                 bsbFree(ob->bsoft);
183                 ob->bsoft = NULL;
184         }
185 }
186
187 void BKE_object_free_curve_cache(Object *ob)
188 {
189         if (ob->curve_cache) {
190                 BKE_displist_free(&ob->curve_cache->disp);
191                 BKE_curve_bevelList_free(&ob->curve_cache->bev);
192                 if (ob->curve_cache->path) {
193                         free_path(ob->curve_cache->path);
194                 }
195                 BKE_nurbList_free(&ob->curve_cache->deformed_nurbs);
196                 MEM_freeN(ob->curve_cache);
197                 ob->curve_cache = NULL;
198         }
199 }
200
201 void BKE_object_free_modifiers(Object *ob)
202 {
203         ModifierData *md;
204
205         while ((md = BLI_pophead(&ob->modifiers))) {
206                 modifier_free(md);
207         }
208
209         /* particle modifiers were freed, so free the particlesystems as well */
210         BKE_object_free_particlesystems(ob);
211
212         /* same for softbody */
213         BKE_object_free_softbody(ob);
214
215         /* modifiers may have stored data in the DM cache */
216         BKE_object_free_derived_caches(ob);
217 }
218
219 void BKE_object_modifier_hook_reset(Object *ob, HookModifierData *hmd)
220 {
221         /* reset functionality */
222         if (hmd->object) {
223                 bPoseChannel *pchan = BKE_pose_channel_find_name(hmd->object->pose, hmd->subtarget);
224
225                 if (hmd->subtarget[0] && pchan) {
226                         float imat[4][4], mat[4][4];
227
228                         /* calculate the world-space matrix for the pose-channel target first, then carry on as usual */
229                         mul_m4_m4m4(mat, hmd->object->obmat, pchan->pose_mat);
230
231                         invert_m4_m4(imat, mat);
232                         mul_m4_m4m4(hmd->parentinv, imat, ob->obmat);
233                 }
234                 else {
235                         invert_m4_m4(hmd->object->imat, hmd->object->obmat);
236                         mul_m4_m4m4(hmd->parentinv, hmd->object->imat, ob->obmat);
237                 }
238         }
239 }
240
241 bool BKE_object_support_modifier_type_check(Object *ob, int modifier_type)
242 {
243         const ModifierTypeInfo *mti;
244
245         mti = modifierType_getInfo(modifier_type);
246
247         /* only geometry objects should be able to get modifiers [#25291] */
248         if (!ELEM(ob->type, OB_MESH, OB_CURVE, OB_SURF, OB_FONT, OB_LATTICE)) {
249                 return false;
250         }
251
252         if (ob->type == OB_LATTICE && (mti->flags & eModifierTypeFlag_AcceptsLattice) == 0) {
253                 return false;
254         }
255
256         if (!((mti->flags & eModifierTypeFlag_AcceptsCVs) ||
257               (ob->type == OB_MESH && (mti->flags & eModifierTypeFlag_AcceptsMesh))))
258         {
259                 return false;
260         }
261
262         return true;
263 }
264
265 void BKE_object_link_modifiers(struct Object *ob_dst, const struct Object *ob_src)
266 {
267         ModifierData *md;
268         BKE_object_free_modifiers(ob_dst);
269
270         if (!ELEM(ob_dst->type, OB_MESH, OB_CURVE, OB_SURF, OB_FONT, OB_LATTICE)) {
271                 /* only objects listed above can have modifiers and linking them to objects
272                  * which doesn't have modifiers stack is quite silly */
273                 return;
274         }
275
276         for (md = ob_src->modifiers.first; md; md = md->next) {
277                 ModifierData *nmd = NULL;
278
279                 if (ELEM(md->type,
280                          eModifierType_Hook,
281                          eModifierType_Collision))
282                 {
283                         continue;
284                 }
285
286                 if (!BKE_object_support_modifier_type_check(ob_dst, md->type))
287                         continue;
288
289                 switch (md->type) {
290                         case eModifierType_Softbody:
291                                 BKE_object_copy_softbody(ob_dst, ob_src);
292                                 break;
293                         case eModifierType_Skin:
294                                 /* ensure skin-node customdata exists */
295                                 BKE_mesh_ensure_skin_customdata(ob_dst->data);
296                                 break;
297                 }
298
299                 nmd = modifier_new(md->type);
300                 BLI_strncpy(nmd->name, md->name, sizeof(nmd->name));
301
302                 if (md->type == eModifierType_Multires) {
303                         /* Has to be done after mod creation, but *before* we actually copy its settings! */
304                         multiresModifier_sync_levels_ex(ob_dst, (MultiresModifierData *)md, (MultiresModifierData *)nmd);
305                 }
306
307                 modifier_copyData(md, nmd);
308                 BLI_addtail(&ob_dst->modifiers, nmd);
309                 modifier_unique_name(&ob_dst->modifiers, nmd);
310         }
311
312         BKE_object_copy_particlesystems(ob_dst, ob_src, 0);
313
314         /* TODO: smoke?, cloth? */
315 }
316
317 /* free data derived from mesh, called when mesh changes or is freed */
318 void BKE_object_free_derived_caches(Object *ob)
319 {
320         /* Also serves as signal to remake texspace.
321          *
322          * NOTE: This function can be called from threads on different objects
323          * sharing same data datablock. So we need to ensure atomic nature of
324          * data modification here.
325          */
326         if (ob->type == OB_MESH) {
327                 Mesh *me = ob->data;
328
329                 if (me && me->bb) {
330                         atomic_fetch_and_or_int32(&me->bb->flag, BOUNDBOX_DIRTY);
331                 }
332         }
333         else if (ELEM(ob->type, OB_SURF, OB_CURVE, OB_FONT)) {
334                 Curve *cu = ob->data;
335
336                 if (cu && cu->bb) {
337                         atomic_fetch_and_or_int32(&cu->bb->flag, BOUNDBOX_DIRTY);
338                 }
339         }
340
341         if (ob->bb) {
342                 MEM_freeN(ob->bb);
343                 ob->bb = NULL;
344         }
345
346         if (ob->derivedFinal) {
347                 ob->derivedFinal->needsFree = 1;
348                 ob->derivedFinal->release(ob->derivedFinal);
349                 ob->derivedFinal = NULL;
350         }
351         if (ob->derivedDeform) {
352                 ob->derivedDeform->needsFree = 1;
353                 ob->derivedDeform->release(ob->derivedDeform);
354                 ob->derivedDeform = NULL;
355         }
356
357         if (ob->mesh_evaluated != NULL) {
358                 /* Restore initial pointer. */
359                 ob->data = ob->mesh_evaluated->id.newid;
360                 /* Evaluated mesh points to edit mesh, but does not own it. */
361                 ob->mesh_evaluated->edit_btmesh = NULL;
362                 BKE_mesh_free(ob->mesh_evaluated);
363                 BKE_libblock_free_data(&ob->mesh_evaluated->id, false);
364                 MEM_freeN(ob->mesh_evaluated);
365                 ob->mesh_evaluated = NULL;
366         }
367
368         BKE_object_free_curve_cache(ob);
369 }
370
371 void BKE_object_free_caches(Object *object)
372 {
373         ModifierData *md;
374         short update_flag = 0;
375
376         /* Free particle system caches holding paths. */
377         if (object->particlesystem.first) {
378                 ParticleSystem *psys;
379                 for (psys = object->particlesystem.first;
380                      psys != NULL;
381                      psys = psys->next)
382                 {
383                         psys_free_path_cache(psys, psys->edit);
384                         update_flag |= PSYS_RECALC_REDO;
385                 }
386         }
387
388         /* Free memory used by cached derived meshes in the particle system modifiers. */
389         for (md = object->modifiers.first; md != NULL; md = md->next) {
390                 if (md->type == eModifierType_ParticleSystem) {
391                         ParticleSystemModifierData *psmd = (ParticleSystemModifierData *) md;
392                         if (psmd->dm_final != NULL) {
393                                 psmd->dm_final->needsFree = 1;
394                                 psmd->dm_final->release(psmd->dm_final);
395                                 psmd->dm_final = NULL;
396                                 if (psmd->dm_deformed != NULL) {
397                                         psmd->dm_deformed->needsFree = 1;
398                                         psmd->dm_deformed->release(psmd->dm_deformed);
399                                         psmd->dm_deformed = NULL;
400                                 }
401                                 psmd->flag |= eParticleSystemFlag_file_loaded;
402                                 update_flag |= OB_RECALC_DATA;
403                         }
404                 }
405         }
406
407         /* Tag object for update, so once memory critical operation is over and
408          * scene update routines are back to it's business the object will be
409          * guaranteed to be in a known state.
410          */
411         if (update_flag != 0) {
412                 DEG_id_tag_update(&object->id, update_flag);
413         }
414 }
415
416 /** Free (or release) any data used by this object (does not free the object itself). */
417 void BKE_object_free(Object *ob)
418 {
419         BKE_animdata_free((ID *)ob, false);
420
421         BKE_object_free_modifiers(ob);
422
423         MEM_SAFE_FREE(ob->mat);
424         MEM_SAFE_FREE(ob->matbits);
425         MEM_SAFE_FREE(ob->iuser);
426         MEM_SAFE_FREE(ob->bb);
427
428         BLI_freelistN(&ob->defbase);
429         BLI_freelistN(&ob->fmaps);
430         if (ob->pose) {
431                 BKE_pose_free_ex(ob->pose, false);
432                 ob->pose = NULL;
433         }
434         if (ob->mpath) {
435                 animviz_free_motionpath(ob->mpath);
436                 ob->mpath = NULL;
437         }
438         BKE_bproperty_free_list(&ob->prop);
439
440         free_sensors(&ob->sensors);
441         free_controllers(&ob->controllers);
442         free_actuators(&ob->actuators);
443         
444         BKE_constraints_free_ex(&ob->constraints, false);
445         
446         free_partdeflect(ob->pd);
447         BKE_rigidbody_free_object(ob);
448         BKE_rigidbody_free_constraint(ob);
449
450         if (ob->soft) {
451                 sbFree(ob->soft);
452                 ob->soft = NULL;
453         }
454         if (ob->bsoft) {
455                 bsbFree(ob->bsoft);
456                 ob->bsoft = NULL;
457         }
458         GPU_lamp_free(ob);
459
460         for (ObjectEngineData *oed = ob->drawdata.first; oed; oed = oed->next) {
461                 if (oed->storage) {
462                         if (oed->free) {
463                                 oed->free(oed->storage);
464                         }
465                         MEM_freeN(oed->storage);
466                 }
467         }
468         BLI_freelistN(&ob->drawdata);
469
470         ob->deg_update_flag = 0;
471
472         BKE_sculptsession_free(ob);
473
474         BLI_freelistN(&ob->pc_ids);
475
476         BLI_freelistN(&ob->lodlevels);
477
478         /* Free runtime curves data. */
479         if (ob->curve_cache) {
480                 BKE_curve_bevelList_free(&ob->curve_cache->bev);
481                 if (ob->curve_cache->path)
482                         free_path(ob->curve_cache->path);
483                 MEM_freeN(ob->curve_cache);
484                 ob->curve_cache = NULL;
485         }
486
487         BKE_previewimg_free(&ob->preview);
488
489         /* don't free, let the base free it */
490         ob->base_collection_properties = NULL;
491 }
492
493 /* actual check for internal data, not context or flags */
494 bool BKE_object_is_in_editmode(Object *ob)
495 {
496         if (ob->data == NULL)
497                 return false;
498         
499         if (ob->type == OB_MESH) {
500                 Mesh *me = ob->data;
501                 if (me->edit_btmesh)
502                         return true;
503         }
504         else if (ob->type == OB_ARMATURE) {
505                 bArmature *arm = ob->data;
506                 
507                 if (arm->edbo)
508                         return true;
509         }
510         else if (ob->type == OB_FONT) {
511                 Curve *cu = ob->data;
512                 
513                 if (cu->editfont)
514                         return true;
515         }
516         else if (ob->type == OB_MBALL) {
517                 MetaBall *mb = ob->data;
518                 
519                 if (mb->editelems)
520                         return true;
521         }
522         else if (ob->type == OB_LATTICE) {
523                 Lattice *lt = ob->data;
524                 
525                 if (lt->editlatt)
526                         return true;
527         }
528         else if (ob->type == OB_SURF || ob->type == OB_CURVE) {
529                 Curve *cu = ob->data;
530
531                 if (cu->editnurb)
532                         return true;
533         }
534         return false;
535 }
536
537 bool BKE_object_is_in_editmode_vgroup(Object *ob)
538 {
539         return (OB_TYPE_SUPPORT_VGROUP(ob->type) &&
540                 BKE_object_is_in_editmode(ob));
541 }
542
543 bool BKE_object_is_in_wpaint_select_vert(Object *ob)
544 {
545         if (ob->type == OB_MESH) {
546                 Mesh *me = ob->data;
547                 return ((ob->mode & OB_MODE_WEIGHT_PAINT) &&
548                         (me->edit_btmesh == NULL) &&
549                         (ME_EDIT_PAINT_SEL_MODE(me) == SCE_SELECT_VERTEX));
550         }
551
552         return false;
553 }
554
555 /**
556  * Return if the object is visible, as evaluated by depsgraph
557  * Keep in sync with rna_object.c (object.is_visible).
558  */
559 bool BKE_object_is_visible(Object *ob)
560 {
561         return (ob->base_flag & BASE_VISIBLED) != 0;
562 }
563
564 bool BKE_object_exists_check(Object *obtest)
565 {
566         Object *ob;
567         
568         if (obtest == NULL) return false;
569         
570         ob = G.main->object.first;
571         while (ob) {
572                 if (ob == obtest) return true;
573                 ob = ob->id.next;
574         }
575         return false;
576 }
577
578 /* *************************************************** */
579
580 static const char *get_obdata_defname(int type)
581 {
582         switch (type) {
583                 case OB_MESH: return DATA_("Mesh");
584                 case OB_CURVE: return DATA_("Curve");
585                 case OB_SURF: return DATA_("Surf");
586                 case OB_FONT: return DATA_("Text");
587                 case OB_MBALL: return DATA_("Mball");
588                 case OB_CAMERA: return DATA_("Camera");
589                 case OB_LAMP: return DATA_("Lamp");
590                 case OB_LATTICE: return DATA_("Lattice");
591                 case OB_ARMATURE: return DATA_("Armature");
592                 case OB_SPEAKER: return DATA_("Speaker");
593                 case OB_EMPTY: return DATA_("Empty");
594                 default:
595                         printf("get_obdata_defname: Internal error, bad type: %d\n", type);
596                         return DATA_("Empty");
597         }
598 }
599
600 void *BKE_object_obdata_add_from_type(Main *bmain, int type, const char *name)
601 {
602         if (name == NULL) {
603                 name = get_obdata_defname(type);
604         }
605
606         switch (type) {
607                 case OB_MESH:      return BKE_mesh_add(bmain, name);
608                 case OB_CURVE:     return BKE_curve_add(bmain, name, OB_CURVE);
609                 case OB_SURF:      return BKE_curve_add(bmain, name, OB_SURF);
610                 case OB_FONT:      return BKE_curve_add(bmain, name, OB_FONT);
611                 case OB_MBALL:     return BKE_mball_add(bmain, name);
612                 case OB_CAMERA:    return BKE_camera_add(bmain, name);
613                 case OB_LAMP:      return BKE_lamp_add(bmain, name);
614                 case OB_LATTICE:   return BKE_lattice_add(bmain, name);
615                 case OB_ARMATURE:  return BKE_armature_add(bmain, name);
616                 case OB_SPEAKER:   return BKE_speaker_add(bmain, name);
617                 case OB_LIGHTPROBE:return BKE_lightprobe_add(bmain, name);
618                 case OB_EMPTY:     return NULL;
619                 default:
620                         printf("%s: Internal error, bad type: %d\n", __func__, type);
621                         return NULL;
622         }
623 }
624
625 void BKE_object_init(Object *ob)
626 {
627         /* BLI_assert(MEMCMP_STRUCT_OFS_IS_ZERO(ob, id)); */  /* ob->type is already initialized... */
628
629         ob->col[0] = ob->col[1] = ob->col[2] = 1.0;
630         ob->col[3] = 1.0;
631         
632         ob->size[0] = ob->size[1] = ob->size[2] = 1.0;
633         ob->dscale[0] = ob->dscale[1] = ob->dscale[2] = 1.0;
634         
635         /* objects should default to having Euler XYZ rotations, 
636          * but rotations default to quaternions 
637          */
638         ob->rotmode = ROT_MODE_EUL;
639
640         unit_axis_angle(ob->rotAxis, &ob->rotAngle);
641         unit_axis_angle(ob->drotAxis, &ob->drotAngle);
642
643         unit_qt(ob->quat);
644         unit_qt(ob->dquat);
645
646         /* rotation locks should be 4D for 4 component rotations by default... */
647         ob->protectflag = OB_LOCK_ROT4D;
648         
649         unit_m4(ob->constinv);
650         unit_m4(ob->parentinv);
651         unit_m4(ob->obmat);
652         ob->dt = OB_TEXTURE;
653         ob->empty_drawtype = OB_PLAINAXES;
654         ob->empty_drawsize = 1.0;
655
656         if (ELEM(ob->type, OB_LAMP, OB_CAMERA, OB_SPEAKER)) {
657                 ob->trackflag = OB_NEGZ;
658                 ob->upflag = OB_POSY;
659         }
660         else {
661                 ob->trackflag = OB_POSY;
662                 ob->upflag = OB_POSZ;
663         }
664         
665         ob->dupon = 1; ob->dupoff = 0;
666         ob->dupsta = 1; ob->dupend = 100;
667         ob->dupfacesca = 1.0;
668
669         /* Game engine defaults*/
670         ob->mass = ob->inertia = 1.0f;
671         ob->formfactor = 0.4f;
672         ob->damping = 0.04f;
673         ob->rdamping = 0.1f;
674         ob->anisotropicFriction[0] = 1.0f;
675         ob->anisotropicFriction[1] = 1.0f;
676         ob->anisotropicFriction[2] = 1.0f;
677         ob->gameflag = OB_PROP | OB_COLLISION;
678         ob->margin = 0.04f;
679         ob->init_state = 1;
680         ob->state = 1;
681         ob->obstacleRad = 1.0f;
682         ob->step_height = 0.15f;
683         ob->jump_speed = 10.0f;
684         ob->fall_speed = 55.0f;
685         ob->max_jumps = 1;
686         ob->col_group = 0x01;
687         ob->col_mask = 0xffff;
688         ob->preview = NULL;
689
690         /* NT fluid sim defaults */
691         ob->fluidsimSettings = NULL;
692
693         BLI_listbase_clear(&ob->pc_ids);
694         
695         /* Animation Visualization defaults */
696         animviz_settings_init(&ob->avs);
697 }
698
699 /* more general add: creates minimum required data, but without vertices etc. */
700 Object *BKE_object_add_only_object(Main *bmain, int type, const char *name)
701 {
702         Object *ob;
703
704         if (!name)
705                 name = get_obdata_defname(type);
706
707         ob = BKE_libblock_alloc(bmain, ID_OB, name, 0);
708
709         /* We increase object user count when linking to SceneCollections. */
710         id_us_min(&ob->id);
711
712         /* default object vars */
713         ob->type = type;
714
715         BKE_object_init(ob);
716
717         return ob;
718 }
719
720
721 static Object *object_add_common(Main *bmain, ViewLayer *view_layer, int type, const char *name)
722 {
723         Object *ob;
724
725         ob = BKE_object_add_only_object(bmain, type, name);
726         ob->data = BKE_object_obdata_add_from_type(bmain, type, name);
727         BKE_view_layer_base_deselect_all(view_layer);
728
729         DEG_id_tag_update_ex(bmain, &ob->id, OB_RECALC_OB | OB_RECALC_DATA | OB_RECALC_TIME);
730         return ob;
731 }
732
733 /**
734  * General add: to scene, with layer from area and default name
735  *
736  * Object is added to the active SceneCollection.
737  * If there is no linked collection to the active ViewLayer we create a new one.
738  */
739 /* creates minimum required data, but without vertices etc. */
740 Object *BKE_object_add(
741         Main *bmain, Scene *scene, ViewLayer *view_layer,
742         int type, const char *name)
743 {
744         Object *ob;
745         Base *base;
746         LayerCollection *layer_collection;
747
748         ob = object_add_common(bmain, view_layer, type, name);
749
750         layer_collection = BKE_layer_collection_get_active_ensure(scene, view_layer);
751         BKE_collection_object_add(scene, layer_collection->scene_collection, ob);
752
753         base = BKE_view_layer_base_find(view_layer, ob);
754         BKE_view_layer_base_select(view_layer, base);
755
756         return ob;
757 }
758
759 /**
760  * Add a new object, using another one as a reference
761  *
762  * /param ob_src object to use to determine the collections of the new object.
763  */
764 Object *BKE_object_add_from(
765         Main *bmain, Scene *scene, ViewLayer *view_layer,
766         int type, const char *name, Object *ob_src)
767 {
768         Object *ob;
769         Base *base;
770
771         ob = object_add_common(bmain, view_layer, type, name);
772         BKE_collection_object_add_from(scene, ob_src, ob);
773
774         base = BKE_view_layer_base_find(view_layer, ob);
775         BKE_view_layer_base_select(view_layer, base);
776
777         return ob;
778 }
779
780 #ifdef WITH_GAMEENGINE
781
782 void BKE_object_lod_add(Object *ob)
783 {
784         LodLevel *lod = MEM_callocN(sizeof(LodLevel), "LoD Level");
785         LodLevel *last = ob->lodlevels.last;
786
787         /* If the lod list is empty, initialize it with the base lod level */
788         if (!last) {
789                 LodLevel *base = MEM_callocN(sizeof(LodLevel), "Base LoD Level");
790                 BLI_addtail(&ob->lodlevels, base);
791                 base->flags = OB_LOD_USE_MESH | OB_LOD_USE_MAT;
792                 base->source = ob;
793                 base->obhysteresis = 10;
794                 last = ob->currentlod = base;
795         }
796         
797         lod->distance = last->distance + 25.0f;
798         lod->obhysteresis = 10;
799         lod->flags = OB_LOD_USE_MESH | OB_LOD_USE_MAT;
800
801         BLI_addtail(&ob->lodlevels, lod);
802 }
803
804 static int lod_cmp(const void *a, const void *b)
805 {
806         const LodLevel *loda = a;
807         const LodLevel *lodb = b;
808
809         if (loda->distance < lodb->distance) return -1;
810         return loda->distance > lodb->distance;
811 }
812
813 void BKE_object_lod_sort(Object *ob)
814 {
815         BLI_listbase_sort(&ob->lodlevels, lod_cmp);
816 }
817
818 bool BKE_object_lod_remove(Object *ob, int level)
819 {
820         LodLevel *rem;
821
822         if (level < 1 || level > BLI_listbase_count(&ob->lodlevels) - 1)
823                 return false;
824
825         rem = BLI_findlink(&ob->lodlevels, level);
826
827         if (rem == ob->currentlod) {
828                 ob->currentlod = rem->prev;
829         }
830
831         BLI_remlink(&ob->lodlevels, rem);
832         MEM_freeN(rem);
833
834         /* If there are no user defined lods, remove the base lod as well */
835         if (BLI_listbase_is_single(&ob->lodlevels)) {
836                 LodLevel *base = ob->lodlevels.first;
837                 BLI_remlink(&ob->lodlevels, base);
838                 MEM_freeN(base);
839                 ob->currentlod = NULL;
840         }
841
842         return true;
843 }
844
845 static LodLevel *lod_level_select(Object *ob, const float camera_position[3])
846 {
847         LodLevel *current = ob->currentlod;
848         float dist_sq;
849
850         if (!current) return NULL;
851
852         dist_sq = len_squared_v3v3(ob->obmat[3], camera_position);
853
854         if (dist_sq < SQUARE(current->distance)) {
855                 /* check for higher LoD */
856                 while (current->prev && dist_sq < SQUARE(current->distance)) {
857                         current = current->prev;
858                 }
859         }
860         else {
861                 /* check for lower LoD */
862                 while (current->next && dist_sq > SQUARE(current->next->distance)) {
863                         current = current->next;
864                 }
865         }
866
867         return current;
868 }
869
870 bool BKE_object_lod_is_usable(Object *ob, ViewLayer *view_layer)
871 {
872         bool active = (view_layer) ? ob == OBACT(view_layer) : false;
873         return (ob->mode == OB_MODE_OBJECT || !active);
874 }
875
876 void BKE_object_lod_update(Object *ob, const float camera_position[3])
877 {
878         LodLevel *cur_level = ob->currentlod;
879         LodLevel *new_level = lod_level_select(ob, camera_position);
880
881         if (new_level != cur_level) {
882                 ob->currentlod = new_level;
883         }
884 }
885
886 static Object *lod_ob_get(Object *ob, ViewLayer *view_layer, int flag)
887 {
888         LodLevel *current = ob->currentlod;
889
890         if (!current || !BKE_object_lod_is_usable(ob, view_layer))
891                 return ob;
892
893         while (current->prev && (!(current->flags & flag) || !current->source || current->source->type != OB_MESH)) {
894                 current = current->prev;
895         }
896
897         return current->source;
898 }
899
900 struct Object *BKE_object_lod_meshob_get(Object *ob, ViewLayer *view_layer)
901 {
902         return lod_ob_get(ob, view_layer, OB_LOD_USE_MESH);
903 }
904
905 struct Object *BKE_object_lod_matob_get(Object *ob, ViewLayer *view_layer)
906 {
907         return lod_ob_get(ob, view_layer, OB_LOD_USE_MAT);
908 }
909
910 #endif  /* WITH_GAMEENGINE */
911
912
913 SoftBody *copy_softbody(const SoftBody *sb, const int flag)
914 {
915         SoftBody *sbn;
916         
917         if (sb == NULL) return(NULL);
918         
919         sbn = MEM_dupallocN(sb);
920
921         if ((flag & LIB_ID_COPY_CACHES) == 0) {
922                 sbn->totspring = sbn->totpoint = 0;
923                 sbn->bpoint = NULL;
924                 sbn->bspring = NULL;
925         }
926         else {
927                 sbn->totspring = sb->totspring;
928                 sbn->totpoint = sb->totpoint;
929
930                 if (sbn->bpoint) {
931                         int i;
932
933                         sbn->bpoint = MEM_dupallocN(sbn->bpoint);
934
935                         for (i = 0; i < sbn->totpoint; i++) {
936                                 if (sbn->bpoint[i].springs)
937                                         sbn->bpoint[i].springs = MEM_dupallocN(sbn->bpoint[i].springs);
938                         }
939                 }
940
941                 if (sb->bspring)
942                         sbn->bspring = MEM_dupallocN(sb->bspring);
943         }
944         
945         sbn->keys = NULL;
946         sbn->totkey = sbn->totpointkey = 0;
947         
948         sbn->scratch = NULL;
949
950         sbn->pointcache = BKE_ptcache_copy_list(&sbn->ptcaches, &sb->ptcaches, flag);
951
952         if (sb->effector_weights)
953                 sbn->effector_weights = MEM_dupallocN(sb->effector_weights);
954
955         return sbn;
956 }
957
958 BulletSoftBody *copy_bulletsoftbody(const BulletSoftBody *bsb, const int UNUSED(flag))
959 {
960         BulletSoftBody *bsbn;
961
962         if (bsb == NULL)
963                 return NULL;
964         bsbn = MEM_dupallocN(bsb);
965         /* no pointer in this structure yet */
966         return bsbn;
967 }
968
969 ParticleSystem *BKE_object_copy_particlesystem(ParticleSystem *psys, const int flag)
970 {
971         ParticleSystem *psysn;
972         ParticleData *pa;
973         int p;
974
975         psysn = MEM_dupallocN(psys);
976         psysn->particles = MEM_dupallocN(psys->particles);
977         psysn->child = MEM_dupallocN(psys->child);
978
979         if (psys->part->type == PART_HAIR) {
980                 for (p = 0, pa = psysn->particles; p < psysn->totpart; p++, pa++)
981                         pa->hair = MEM_dupallocN(pa->hair);
982         }
983
984         if (psysn->particles && (psysn->particles->keys || psysn->particles->boid)) {
985                 ParticleKey *key = psysn->particles->keys;
986                 BoidParticle *boid = psysn->particles->boid;
987
988                 if (key)
989                         key = MEM_dupallocN(key);
990                 
991                 if (boid)
992                         boid = MEM_dupallocN(boid);
993                 
994                 for (p = 0, pa = psysn->particles; p < psysn->totpart; p++, pa++) {
995                         if (boid)
996                                 pa->boid = boid++;
997                         if (key) {
998                                 pa->keys = key;
999                                 key += pa->totkey;
1000                         }
1001                 }
1002         }
1003
1004         if (psys->clmd) {
1005                 psysn->clmd = (ClothModifierData *)modifier_new(eModifierType_Cloth);
1006                 modifier_copyData_ex((ModifierData *)psys->clmd, (ModifierData *)psysn->clmd, flag);
1007                 psys->hair_in_dm = psys->hair_out_dm = NULL;
1008         }
1009
1010         BLI_duplicatelist(&psysn->targets, &psys->targets);
1011
1012         psysn->pathcache = NULL;
1013         psysn->childcache = NULL;
1014         psysn->edit = NULL;
1015         psysn->pdd = NULL;
1016         psysn->effectors = NULL;
1017         psysn->tree = NULL;
1018         psysn->bvhtree = NULL;
1019         psysn->batch_cache = NULL;
1020         
1021         BLI_listbase_clear(&psysn->pathcachebufs);
1022         BLI_listbase_clear(&psysn->childcachebufs);
1023         psysn->renderdata = NULL;
1024         
1025         /* XXX Never copy caches here? */
1026         psysn->pointcache = BKE_ptcache_copy_list(&psysn->ptcaches, &psys->ptcaches, flag & ~LIB_ID_COPY_CACHES);
1027
1028         /* XXX - from reading existing code this seems correct but intended usage of
1029          * pointcache should /w cloth should be added in 'ParticleSystem' - campbell */
1030         if (psysn->clmd) {
1031                 psysn->clmd->point_cache = psysn->pointcache;
1032         }
1033
1034         if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
1035                 id_us_plus((ID *)psysn->part);
1036         }
1037
1038         return psysn;
1039 }
1040
1041 void BKE_object_copy_particlesystems(Object *ob_dst, const Object *ob_src, const int flag)
1042 {
1043         ParticleSystem *psys, *npsys;
1044         ModifierData *md;
1045
1046         if (ob_dst->type != OB_MESH) {
1047                 /* currently only mesh objects can have soft body */
1048                 return;
1049         }
1050
1051         BLI_listbase_clear(&ob_dst->particlesystem);
1052         for (psys = ob_src->particlesystem.first; psys; psys = psys->next) {
1053                 npsys = BKE_object_copy_particlesystem(psys, flag);
1054
1055                 BLI_addtail(&ob_dst->particlesystem, npsys);
1056
1057                 /* need to update particle modifiers too */
1058                 for (md = ob_dst->modifiers.first; md; md = md->next) {
1059                         if (md->type == eModifierType_ParticleSystem) {
1060                                 ParticleSystemModifierData *psmd = (ParticleSystemModifierData *)md;
1061                                 if (psmd->psys == psys)
1062                                         psmd->psys = npsys;
1063                         }
1064                         else if (md->type == eModifierType_DynamicPaint) {
1065                                 DynamicPaintModifierData *pmd = (DynamicPaintModifierData *)md;
1066                                 if (pmd->brush) {
1067                                         if (pmd->brush->psys == psys) {
1068                                                 pmd->brush->psys = npsys;
1069                                         }
1070                                 }
1071                         }
1072                         else if (md->type == eModifierType_Smoke) {
1073                                 SmokeModifierData *smd = (SmokeModifierData *) md;
1074                                 
1075                                 if (smd->type == MOD_SMOKE_TYPE_FLOW) {
1076                                         if (smd->flow) {
1077                                                 if (smd->flow->psys == psys)
1078                                                         smd->flow->psys = npsys;
1079                                         }
1080                                 }
1081                         }
1082                 }
1083         }
1084 }
1085
1086 void BKE_object_copy_softbody(Object *ob_dst, const Object *ob_src)
1087 {
1088         if (ob_src->soft) {
1089                 ob_dst->softflag = ob_src->softflag;
1090                 ob_dst->soft = copy_softbody(ob_src->soft, 0);
1091         }
1092 }
1093
1094 static void copy_object_pose(Object *obn, const Object *ob, const int flag)
1095 {
1096         bPoseChannel *chan;
1097         
1098         /* note: need to clear obn->pose pointer first, so that BKE_pose_copy_data works (otherwise there's a crash) */
1099         obn->pose = NULL;
1100         BKE_pose_copy_data_ex(&obn->pose, ob->pose, flag, true);  /* true = copy constraints */
1101
1102         for (chan = obn->pose->chanbase.first; chan; chan = chan->next) {
1103                 bConstraint *con;
1104                 
1105                 chan->flag &= ~(POSE_LOC | POSE_ROT | POSE_SIZE);
1106                 
1107                 /* XXX Remapping object pointing onto itself should be handled by generic BKE_library_remap stuff, but...
1108                  *     the flush_constraint_targets callback am not sure about, so will delay that for now. */
1109                 for (con = chan->constraints.first; con; con = con->next) {
1110                         const bConstraintTypeInfo *cti = BKE_constraint_typeinfo_get(con);
1111                         ListBase targets = {NULL, NULL};
1112                         bConstraintTarget *ct;
1113                         
1114                         if (cti && cti->get_constraint_targets) {
1115                                 cti->get_constraint_targets(con, &targets);
1116                                 
1117                                 for (ct = targets.first; ct; ct = ct->next) {
1118                                         if (ct->tar == ob)
1119                                                 ct->tar = obn;
1120                                 }
1121                                 
1122                                 if (cti->flush_constraint_targets)
1123                                         cti->flush_constraint_targets(con, &targets, 0);
1124                         }
1125                 }
1126         }
1127 }
1128
1129 static void copy_object_lod(Object *obn, const Object *ob, const int UNUSED(flag))
1130 {
1131         BLI_duplicatelist(&obn->lodlevels, &ob->lodlevels);
1132
1133         obn->currentlod = (LodLevel *)obn->lodlevels.first;
1134 }
1135
1136 bool BKE_object_pose_context_check(Object *ob)
1137 {
1138         if ((ob) &&
1139             (ob->type == OB_ARMATURE) &&
1140             (ob->pose) &&
1141             (ob->mode & OB_MODE_POSE))
1142         {
1143                 return true;
1144         }
1145         else {
1146                 return false;
1147         }
1148 }
1149
1150 Object *BKE_object_pose_armature_get(Object *ob)
1151 {
1152         if (ob == NULL)
1153                 return NULL;
1154
1155         if (BKE_object_pose_context_check(ob))
1156                 return ob;
1157
1158         ob = modifiers_isDeformedByArmature(ob);
1159
1160         if (BKE_object_pose_context_check(ob))
1161                 return ob;
1162
1163         return NULL;
1164 }
1165
1166 void BKE_object_transform_copy(Object *ob_tar, const Object *ob_src)
1167 {
1168         copy_v3_v3(ob_tar->loc, ob_src->loc);
1169         copy_v3_v3(ob_tar->rot, ob_src->rot);
1170         copy_v3_v3(ob_tar->quat, ob_src->quat);
1171         copy_v3_v3(ob_tar->rotAxis, ob_src->rotAxis);
1172         ob_tar->rotAngle = ob_src->rotAngle;
1173         ob_tar->rotmode = ob_src->rotmode;
1174         copy_v3_v3(ob_tar->size, ob_src->size);
1175 }
1176
1177 /**
1178  * Only copy internal data of Object ID from source to already allocated/initialized destination.
1179  * You probably nerver want to use that directly, use id_copy or BKE_id_copy_ex for typical needs.
1180  *
1181  * WARNING! This function will not handle ID user count!
1182  *
1183  * \param flag  Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
1184  */
1185 void BKE_object_copy_data(Main *UNUSED(bmain), Object *ob_dst, const Object *ob_src, const int flag)
1186 {
1187         ModifierData *md;
1188
1189         /* We never handle usercount here for own data. */
1190         const int flag_subdata = flag | LIB_ID_CREATE_NO_USER_REFCOUNT;
1191
1192         if (ob_src->totcol) {
1193                 ob_dst->mat = MEM_dupallocN(ob_src->mat);
1194                 ob_dst->matbits = MEM_dupallocN(ob_src->matbits);
1195                 ob_dst->totcol = ob_src->totcol;
1196         }
1197
1198         if (ob_src->iuser) ob_dst->iuser = MEM_dupallocN(ob_src->iuser);
1199         
1200         if (ob_src->bb) ob_dst->bb = MEM_dupallocN(ob_src->bb);
1201         ob_dst->flag &= ~OB_FROMGROUP;
1202         
1203         BLI_listbase_clear(&ob_dst->modifiers);
1204         
1205         for (md = ob_src->modifiers.first; md; md = md->next) {
1206                 ModifierData *nmd = modifier_new(md->type);
1207                 BLI_strncpy(nmd->name, md->name, sizeof(nmd->name));
1208                 modifier_copyData_ex(md, nmd, flag_subdata);
1209                 BLI_addtail(&ob_dst->modifiers, nmd);
1210         }
1211
1212         BLI_listbase_clear(&ob_dst->prop);
1213         BKE_bproperty_copy_list(&ob_dst->prop, &ob_src->prop);
1214
1215         BKE_sca_logic_copy(ob_dst, ob_src, flag_subdata);
1216
1217         if (ob_src->pose) {
1218                 copy_object_pose(ob_dst, ob_src, flag_subdata);
1219                 /* backwards compat... non-armatures can get poses in older files? */
1220                 if (ob_src->type == OB_ARMATURE)
1221                         BKE_pose_rebuild(ob_dst, ob_dst->data);
1222         }
1223         defgroup_copy_list(&ob_dst->defbase, &ob_src->defbase);
1224         BKE_object_facemap_copy_list(&ob_dst->fmaps, &ob_src->fmaps);
1225         BKE_constraints_copy_ex(&ob_dst->constraints, &ob_src->constraints, flag_subdata, true);
1226
1227         ob_dst->mode = OB_MODE_OBJECT;
1228         ob_dst->sculpt = NULL;
1229
1230         if (ob_src->pd) {
1231                 ob_dst->pd = MEM_dupallocN(ob_src->pd);
1232                 if (ob_dst->pd->rng) {
1233                         ob_dst->pd->rng = MEM_dupallocN(ob_src->pd->rng);
1234                 }
1235         }
1236         ob_dst->soft = copy_softbody(ob_src->soft, flag_subdata);
1237         ob_dst->bsoft = copy_bulletsoftbody(ob_src->bsoft, flag_subdata);
1238         ob_dst->rigidbody_object = BKE_rigidbody_copy_object(ob_src, flag_subdata);
1239         ob_dst->rigidbody_constraint = BKE_rigidbody_copy_constraint(ob_src, flag_subdata);
1240
1241         BKE_object_copy_particlesystems(ob_dst, ob_src, flag_subdata);
1242         
1243         ob_dst->derivedDeform = NULL;
1244         ob_dst->derivedFinal = NULL;
1245
1246         BLI_listbase_clear(&ob_dst->gpulamp);
1247         BLI_listbase_clear(&ob_dst->drawdata);
1248         BLI_listbase_clear(&ob_dst->pc_ids);
1249
1250         ob_dst->mpath = NULL;
1251
1252         copy_object_lod(ob_dst, ob_src, flag_subdata);
1253         
1254         /* Do not copy runtime curve data. */
1255         ob_dst->curve_cache = NULL;
1256
1257         /* Do not copy object's preview (mostly due to the fact renderers create temp copy of objects). */
1258         if ((flag & LIB_ID_COPY_NO_PREVIEW) == 0 && false) {  /* XXX TODO temp hack */
1259                 BKE_previewimg_id_copy(&ob_dst->id, &ob_src->id);
1260         }
1261         else {
1262                 ob_dst->preview = NULL;
1263         }
1264 }
1265
1266 /* copy objects, will re-initialize cached simulation data */
1267 Object *BKE_object_copy(Main *bmain, const Object *ob)
1268 {
1269         Object *ob_copy;
1270         BKE_id_copy_ex(bmain, &ob->id, (ID **)&ob_copy, 0, false);
1271         return ob_copy;
1272 }
1273
1274 void BKE_object_make_local_ex(Main *bmain, Object *ob, const bool lib_local, const bool clear_proxy)
1275 {
1276         bool is_local = false, is_lib = false;
1277
1278         /* - only lib users: do nothing (unless force_local is set)
1279          * - only local users: set flag
1280          * - mixed: make copy
1281          * In case we make a whole lib's content local, we always want to localize, and we skip remapping (done later).
1282          */
1283
1284         if (!ID_IS_LINKED(ob)) {
1285                 return;
1286         }
1287
1288         BKE_library_ID_test_usages(bmain, ob, &is_local, &is_lib);
1289
1290         if (lib_local || is_local) {
1291                 if (!is_lib) {
1292                         id_clear_lib_data(bmain, &ob->id);
1293                         BKE_id_expand_local(bmain, &ob->id);
1294                         if (clear_proxy) {
1295                                 if (ob->proxy_from != NULL) {
1296                                         ob->proxy_from->proxy = NULL;
1297                                         ob->proxy_from->proxy_group = NULL;
1298                                 }
1299                                 ob->proxy = ob->proxy_from = ob->proxy_group = NULL;
1300                         }
1301                 }
1302                 else {
1303                         Object *ob_new = BKE_object_copy(bmain, ob);
1304
1305                         ob_new->id.us = 0;
1306                         ob_new->proxy = ob_new->proxy_from = ob_new->proxy_group = NULL;
1307
1308                         /* setting newid is mandatory for complex make_lib_local logic... */
1309                         ID_NEW_SET(ob, ob_new);
1310
1311                         if (!lib_local) {
1312                                 BKE_libblock_remap(bmain, ob, ob_new, ID_REMAP_SKIP_INDIRECT_USAGE);
1313                         }
1314                 }
1315         }
1316 }
1317
1318 void BKE_object_make_local(Main *bmain, Object *ob, const bool lib_local)
1319 {
1320         BKE_object_make_local_ex(bmain, ob, lib_local, true);
1321 }
1322
1323 /* Returns true if the Object is from an external blend file (libdata) */
1324 bool BKE_object_is_libdata(Object *ob)
1325 {
1326         return (ob && ID_IS_LINKED(ob));
1327 }
1328
1329 /* Returns true if the Object data is from an external blend file (libdata) */
1330 bool BKE_object_obdata_is_libdata(Object *ob)
1331 {
1332         /* Linked objects with local obdata are forbidden! */
1333         BLI_assert(!ob || !ob->data || (ID_IS_LINKED(ob) ? ID_IS_LINKED(ob->data) : true));
1334         return (ob && ob->data && ID_IS_LINKED(ob->data));
1335 }
1336
1337 /* *************** PROXY **************** */
1338
1339 /* when you make proxy, ensure the exposed layers are extern */
1340 static void armature_set_id_extern(Object *ob)
1341 {
1342         bArmature *arm = ob->data;
1343         bPoseChannel *pchan;
1344         unsigned int lay = arm->layer_protected;
1345         
1346         for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
1347                 if (!(pchan->bone->layer & lay))
1348                         id_lib_extern((ID *)pchan->custom);
1349         }
1350                         
1351 }
1352
1353 void BKE_object_copy_proxy_drivers(Object *ob, Object *target)
1354 {
1355         if ((target->adt) && (target->adt->drivers.first)) {
1356                 FCurve *fcu;
1357                 
1358                 /* add new animdata block */
1359                 if (!ob->adt)
1360                         ob->adt = BKE_animdata_add_id(&ob->id);
1361                 
1362                 /* make a copy of all the drivers (for now), then correct any links that need fixing */
1363                 free_fcurves(&ob->adt->drivers);
1364                 copy_fcurves(&ob->adt->drivers, &target->adt->drivers);
1365                 
1366                 for (fcu = ob->adt->drivers.first; fcu; fcu = fcu->next) {
1367                         ChannelDriver *driver = fcu->driver;
1368                         DriverVar *dvar;
1369                         
1370                         for (dvar = driver->variables.first; dvar; dvar = dvar->next) {
1371                                 /* all drivers */
1372                                 DRIVER_TARGETS_LOOPER(dvar) 
1373                                 {
1374                                         if (dtar->id) {
1375                                                 if ((Object *)dtar->id == target)
1376                                                         dtar->id = (ID *)ob;
1377                                                 else {
1378                                                         /* only on local objects because this causes indirect links
1379                                                          * 'a -> b -> c', blend to point directly to a.blend
1380                                                          * when a.blend has a proxy thats linked into c.blend  */
1381                                                         if (!ID_IS_LINKED(ob))
1382                                                                 id_lib_extern((ID *)dtar->id);
1383                                                 }
1384                                         }
1385                                 }
1386                                 DRIVER_TARGETS_LOOPER_END
1387                         }
1388                 }
1389         }
1390 }
1391
1392 /* proxy rule: lib_object->proxy_from == the one we borrow from, set temporally while object_update */
1393 /*             local_object->proxy == pointer to library object, saved in files and read */
1394 /*             local_object->proxy_group == pointer to group dupli-object, saved in files and read */
1395
1396 void BKE_object_make_proxy(Object *ob, Object *target, Object *gob)
1397 {
1398         /* paranoia checks */
1399         if (ID_IS_LINKED(ob) || !ID_IS_LINKED(target)) {
1400                 printf("cannot make proxy\n");
1401                 return;
1402         }
1403         
1404         ob->proxy = target;
1405         ob->proxy_group = gob;
1406         id_lib_extern(&target->id);
1407         
1408         DEG_id_tag_update(&ob->id, OB_RECALC_OB | OB_RECALC_DATA | OB_RECALC_TIME);
1409         DEG_id_tag_update(&target->id, OB_RECALC_OB | OB_RECALC_DATA | OB_RECALC_TIME);
1410         
1411         /* copy transform
1412          * - gob means this proxy comes from a group, just apply the matrix
1413          *   so the object wont move from its dupli-transform.
1414          *
1415          * - no gob means this is being made from a linked object,
1416          *   this is closer to making a copy of the object - in-place. */
1417         if (gob) {
1418                 ob->rotmode = target->rotmode;
1419                 mul_m4_m4m4(ob->obmat, gob->obmat, target->obmat);
1420                 if (gob->dup_group) { /* should always be true */
1421                         float tvec[3];
1422                         mul_v3_mat3_m4v3(tvec, ob->obmat, gob->dup_group->dupli_ofs);
1423                         sub_v3_v3(ob->obmat[3], tvec);
1424                 }
1425                 BKE_object_apply_mat4(ob, ob->obmat, false, true);
1426         }
1427         else {
1428                 BKE_object_transform_copy(ob, target);
1429                 ob->parent = target->parent; /* libdata */
1430                 copy_m4_m4(ob->parentinv, target->parentinv);
1431         }
1432         
1433         /* copy animdata stuff - drivers only for now... */
1434         BKE_object_copy_proxy_drivers(ob, target);
1435
1436         /* skip constraints? */
1437         /* FIXME: this is considered by many as a bug */
1438         
1439         /* set object type and link to data */
1440         ob->type = target->type;
1441         ob->data = target->data;
1442         id_us_plus((ID *)ob->data);     /* ensures lib data becomes LIB_TAG_EXTERN */
1443
1444         /* copy vertex groups */
1445         defgroup_copy_list(&ob->defbase, &target->defbase);
1446
1447         /* copy material and index information */
1448         ob->actcol = ob->totcol = 0;
1449         if (ob->mat) MEM_freeN(ob->mat);
1450         if (ob->matbits) MEM_freeN(ob->matbits);
1451         ob->mat = NULL;
1452         ob->matbits = NULL;
1453         if ((target->totcol) && (target->mat) && OB_TYPE_SUPPORT_MATERIAL(ob->type)) {
1454                 int i;
1455                 
1456                 ob->actcol = target->actcol;
1457                 ob->totcol = target->totcol;
1458                 
1459                 ob->mat = MEM_dupallocN(target->mat);
1460                 ob->matbits = MEM_dupallocN(target->matbits);
1461                 for (i = 0; i < target->totcol; i++) {
1462                         /* don't need to run test_object_materials since we know this object is new and not used elsewhere */
1463                         id_us_plus((ID *)ob->mat[i]); 
1464                 }
1465         }
1466         
1467         /* type conversions */
1468         if (target->type == OB_ARMATURE) {
1469                 copy_object_pose(ob, target, 0);   /* data copy, object pointers in constraints */
1470                 BKE_pose_rest(ob->pose);            /* clear all transforms in channels */
1471                 BKE_pose_rebuild(ob, ob->data); /* set all internal links */
1472                 
1473                 armature_set_id_extern(ob);
1474         }
1475         else if (target->type == OB_EMPTY) {
1476                 ob->empty_drawtype = target->empty_drawtype;
1477                 ob->empty_drawsize = target->empty_drawsize;
1478         }
1479
1480         /* copy IDProperties */
1481         if (ob->id.properties) {
1482                 IDP_FreeProperty(ob->id.properties);
1483                 MEM_freeN(ob->id.properties);
1484                 ob->id.properties = NULL;
1485         }
1486         if (target->id.properties) {
1487                 ob->id.properties = IDP_CopyProperty(target->id.properties);
1488         }
1489
1490         /* copy drawtype info */
1491         ob->dt = target->dt;
1492 }
1493
1494 /**
1495  * Use with newly created objects to set their size
1496  * (used to apply scene-scale).
1497  */
1498 void BKE_object_obdata_size_init(struct Object *ob, const float size)
1499 {
1500         /* apply radius as a scale to types that support it */
1501         switch (ob->type) {
1502                 case OB_EMPTY:
1503                 {
1504                         ob->empty_drawsize *= size;
1505                         break;
1506                 }
1507                 case OB_FONT:
1508                 {
1509                         Curve *cu = ob->data;
1510                         cu->fsize *= size;
1511                         break;
1512                 }
1513                 case OB_CAMERA:
1514                 {
1515                         Camera *cam = ob->data;
1516                         cam->drawsize *= size;
1517                         break;
1518                 }
1519                 case OB_LAMP:
1520                 {
1521                         Lamp *lamp = ob->data;
1522                         lamp->dist *= size;
1523                         lamp->area_size  *= size;
1524                         lamp->area_sizey *= size;
1525                         lamp->area_sizez *= size;
1526                         break;
1527                 }
1528                 /* Only lattice (not mesh, curve, mball...),
1529                  * because its got data when newly added */
1530                 case OB_LATTICE:
1531                 {
1532                         struct Lattice *lt = ob->data;
1533                         float mat[4][4];
1534
1535                         unit_m4(mat);
1536                         scale_m4_fl(mat, size);
1537
1538                         BKE_lattice_transform(lt, (float (*)[4])mat, false);
1539                         break;
1540                 }
1541         }
1542 }
1543
1544 /* *************** CALC ****************** */
1545
1546 void BKE_object_scale_to_mat3(Object *ob, float mat[3][3])
1547 {
1548         float vec[3];
1549         mul_v3_v3v3(vec, ob->size, ob->dscale);
1550         size_to_mat3(mat, vec);
1551 }
1552
1553 void BKE_object_rot_to_mat3(Object *ob, float mat[3][3], bool use_drot)
1554 {
1555         float rmat[3][3], dmat[3][3];
1556         
1557         /* 'dmat' is the delta-rotation matrix, which will get (pre)multiplied
1558          * with the rotation matrix to yield the appropriate rotation
1559          */
1560
1561         /* rotations may either be quats, eulers (with various rotation orders), or axis-angle */
1562         if (ob->rotmode > 0) {
1563                 /* euler rotations (will cause gimble lock, but this can be alleviated a bit with rotation orders) */
1564                 eulO_to_mat3(rmat, ob->rot, ob->rotmode);
1565                 eulO_to_mat3(dmat, ob->drot, ob->rotmode);
1566         }
1567         else if (ob->rotmode == ROT_MODE_AXISANGLE) {
1568                 /* axis-angle - not really that great for 3D-changing orientations */
1569                 axis_angle_to_mat3(rmat, ob->rotAxis, ob->rotAngle);
1570                 axis_angle_to_mat3(dmat, ob->drotAxis, ob->drotAngle);
1571         }
1572         else {
1573                 /* quats are normalized before use to eliminate scaling issues */
1574                 float tquat[4];
1575                 
1576                 normalize_qt_qt(tquat, ob->quat);
1577                 quat_to_mat3(rmat, tquat);
1578                 
1579                 normalize_qt_qt(tquat, ob->dquat);
1580                 quat_to_mat3(dmat, tquat);
1581         }
1582         
1583         /* combine these rotations */
1584         if (use_drot)
1585                 mul_m3_m3m3(mat, dmat, rmat);
1586         else
1587                 copy_m3_m3(mat, rmat);
1588 }
1589
1590 void BKE_object_mat3_to_rot(Object *ob, float mat[3][3], bool use_compat)
1591 {
1592         BLI_ASSERT_UNIT_M3(mat);
1593
1594         switch (ob->rotmode) {
1595                 case ROT_MODE_QUAT:
1596                 {
1597                         float dquat[4];
1598                         mat3_normalized_to_quat(ob->quat, mat);
1599                         normalize_qt_qt(dquat, ob->dquat);
1600                         invert_qt_normalized(dquat);
1601                         mul_qt_qtqt(ob->quat, dquat, ob->quat);
1602                         break;
1603                 }
1604                 case ROT_MODE_AXISANGLE:
1605                 {
1606                         float quat[4];
1607                         float dquat[4];
1608
1609                         /* without drot we could apply 'mat' directly */
1610                         mat3_normalized_to_quat(quat, mat);
1611                         axis_angle_to_quat(dquat, ob->drotAxis, ob->drotAngle);
1612                         invert_qt_normalized(dquat);
1613                         mul_qt_qtqt(quat, dquat, quat);
1614                         quat_to_axis_angle(ob->rotAxis, &ob->rotAngle, quat);
1615                         break;
1616                 }
1617                 default: /* euler */
1618                 {
1619                         float quat[4];
1620                         float dquat[4];
1621
1622                         /* without drot we could apply 'mat' directly */
1623                         mat3_normalized_to_quat(quat, mat);
1624                         eulO_to_quat(dquat, ob->drot, ob->rotmode);
1625                         invert_qt_normalized(dquat);
1626                         mul_qt_qtqt(quat, dquat, quat);
1627                         /* end drot correction */
1628
1629                         if (use_compat) quat_to_compatible_eulO(ob->rot, ob->rot, ob->rotmode, quat);
1630                         else            quat_to_eulO(ob->rot, ob->rotmode, quat);
1631                         break;
1632                 }
1633         }
1634 }
1635
1636 void BKE_object_tfm_protected_backup(const Object *ob,
1637                                      ObjectTfmProtectedChannels *obtfm)
1638 {
1639
1640 #define TFMCPY(_v) (obtfm->_v = ob->_v)
1641 #define TFMCPY3D(_v) copy_v3_v3(obtfm->_v, ob->_v)
1642 #define TFMCPY4D(_v) copy_v4_v4(obtfm->_v, ob->_v)
1643
1644         TFMCPY3D(loc);
1645         TFMCPY3D(dloc);
1646         TFMCPY3D(size);
1647         TFMCPY3D(dscale);
1648         TFMCPY3D(rot);
1649         TFMCPY3D(drot);
1650         TFMCPY4D(quat);
1651         TFMCPY4D(dquat);
1652         TFMCPY3D(rotAxis);
1653         TFMCPY3D(drotAxis);
1654         TFMCPY(rotAngle);
1655         TFMCPY(drotAngle);
1656
1657 #undef TFMCPY
1658 #undef TFMCPY3D
1659 #undef TFMCPY4D
1660
1661 }
1662
1663 void BKE_object_tfm_protected_restore(Object *ob,
1664                                       const ObjectTfmProtectedChannels *obtfm,
1665                                       const short protectflag)
1666 {
1667         unsigned int i;
1668
1669         for (i = 0; i < 3; i++) {
1670                 if (protectflag & (OB_LOCK_LOCX << i)) {
1671                         ob->loc[i] =  obtfm->loc[i];
1672                         ob->dloc[i] = obtfm->dloc[i];
1673                 }
1674
1675                 if (protectflag & (OB_LOCK_SCALEX << i)) {
1676                         ob->size[i] =  obtfm->size[i];
1677                         ob->dscale[i] = obtfm->dscale[i];
1678                 }
1679
1680                 if (protectflag & (OB_LOCK_ROTX << i)) {
1681                         ob->rot[i] =  obtfm->rot[i];
1682                         ob->drot[i] = obtfm->drot[i];
1683
1684                         ob->quat[i + 1] =  obtfm->quat[i + 1];
1685                         ob->dquat[i + 1] = obtfm->dquat[i + 1];
1686
1687                         ob->rotAxis[i] =  obtfm->rotAxis[i];
1688                         ob->drotAxis[i] = obtfm->drotAxis[i];
1689                 }
1690         }
1691
1692         if ((protectflag & OB_LOCK_ROT4D) && (protectflag & OB_LOCK_ROTW)) {
1693                 ob->quat[0] =  obtfm->quat[0];
1694                 ob->dquat[0] = obtfm->dquat[0];
1695
1696                 ob->rotAngle =  obtfm->rotAngle;
1697                 ob->drotAngle = obtfm->drotAngle;
1698         }
1699 }
1700
1701 void BKE_object_to_mat3(Object *ob, float mat[3][3]) /* no parent */
1702 {
1703         float smat[3][3];
1704         float rmat[3][3];
1705         /*float q1[4];*/
1706         
1707         /* size */
1708         BKE_object_scale_to_mat3(ob, smat);
1709
1710         /* rot */
1711         BKE_object_rot_to_mat3(ob, rmat, true);
1712         mul_m3_m3m3(mat, rmat, smat);
1713 }
1714
1715 void BKE_object_to_mat4(Object *ob, float mat[4][4])
1716 {
1717         float tmat[3][3];
1718         
1719         BKE_object_to_mat3(ob, tmat);
1720         
1721         copy_m4_m3(mat, tmat);
1722
1723         add_v3_v3v3(mat[3], ob->loc, ob->dloc);
1724 }
1725
1726 void BKE_object_matrix_local_get(struct Object *ob, float mat[4][4])
1727 {
1728         if (ob->parent) {
1729                 float par_imat[4][4];
1730
1731                 BKE_object_get_parent_matrix(NULL, ob, ob->parent, par_imat);
1732                 invert_m4(par_imat);
1733                 mul_m4_m4m4(mat, par_imat, ob->obmat);
1734         }
1735         else {
1736                 copy_m4_m4(mat, ob->obmat);
1737         }
1738 }
1739
1740 /* extern */
1741 int enable_cu_speed = 1;
1742
1743 /**
1744  * \param scene: Used when curve cache needs to be calculated, or for dupli-frame time.
1745  * \return success if \a mat is set.
1746  */
1747 static bool ob_parcurve(Scene *scene, Object *ob, Object *par, float mat[4][4])
1748 {
1749         Curve *cu = par->data;
1750         float vec[4], dir[3], quat[4], radius, ctime;
1751
1752         /* TODO: Make sure this doesn't crash. */
1753 #if 0
1754         /* only happens on reload file, but violates depsgraph still... fix! */
1755         if (par->curve_cache == NULL) {
1756                 if (scene == NULL) {
1757                         return false;
1758                 }
1759                 BKE_displist_make_curveTypes(eval_ctx, scene, par, 0);
1760         }
1761 #endif
1762
1763         if (par->curve_cache->path == NULL) {
1764                 return false;
1765         }
1766
1767         /* catch exceptions: curve paths used as a duplicator */
1768         if (enable_cu_speed) {
1769                 /* ctime is now a proper var setting of Curve which gets set by Animato like any other var that's animated,
1770                  * but this will only work if it actually is animated... 
1771                  *
1772                  * we divide the curvetime calculated in the previous step by the length of the path, to get a time
1773                  * factor, which then gets clamped to lie within 0.0 - 1.0 range
1774                  */
1775                 if (cu->pathlen) {
1776                         ctime = cu->ctime / cu->pathlen;
1777                 }
1778                 else {
1779                         ctime = cu->ctime;
1780                 }
1781
1782                 CLAMP(ctime, 0.0f, 1.0f);
1783         }
1784         else {
1785                 /* For dupli-frames only */
1786                 if (scene == NULL) {
1787                         return false;
1788                 }
1789
1790                 ctime = BKE_scene_frame_get(scene);
1791                 if (cu->pathlen) {
1792                         ctime /= cu->pathlen;
1793                 }
1794                 
1795                 CLAMP(ctime, 0.0f, 1.0f);
1796         }
1797         
1798         unit_m4(mat);
1799
1800         /* vec: 4 items! */
1801         if (where_on_path(par, ctime, vec, dir, (cu->flag & CU_FOLLOW) ? quat : NULL, &radius, NULL)) {
1802
1803                 if (cu->flag & CU_FOLLOW) {
1804 #if 0
1805                         float si, q[4];
1806                         vec_to_quat(quat, dir, ob->trackflag, ob->upflag);
1807                         
1808                         /* the tilt */
1809                         normalize_v3(dir);
1810                         q[0] = cosf(0.5 * vec[3]);
1811                         si = sinf(0.5 * vec[3]);
1812                         q[1] = -si * dir[0];
1813                         q[2] = -si * dir[1];
1814                         q[3] = -si * dir[2];
1815                         mul_qt_qtqt(quat, q, quat);
1816 #else
1817                         quat_apply_track(quat, ob->trackflag, ob->upflag);
1818 #endif
1819                         normalize_qt(quat);
1820                         quat_to_mat4(mat, quat);
1821                 }
1822                 
1823                 if (cu->flag & CU_PATH_RADIUS) {
1824                         float tmat[4][4], rmat[4][4];
1825                         scale_m4_fl(tmat, radius);
1826                         mul_m4_m4m4(rmat, tmat, mat);
1827                         copy_m4_m4(mat, rmat);
1828                 }
1829
1830                 copy_v3_v3(mat[3], vec);
1831                 
1832         }
1833
1834         return true;
1835 }
1836
1837 static void ob_parbone(Object *ob, Object *par, float mat[4][4])
1838 {       
1839         bPoseChannel *pchan;
1840         float vec[3];
1841         
1842         if (par->type != OB_ARMATURE) {
1843                 unit_m4(mat);
1844                 return;
1845         }
1846         
1847         /* Make sure the bone is still valid */
1848         pchan = BKE_pose_channel_find_name(par->pose, ob->parsubstr);
1849         if (!pchan || !pchan->bone) {
1850                 printf("Object %s with Bone parent: bone %s doesn't exist\n", ob->id.name + 2, ob->parsubstr);
1851                 unit_m4(mat);
1852                 return;
1853         }
1854
1855         /* get bone transform */
1856         if (pchan->bone->flag & BONE_RELATIVE_PARENTING) {
1857                 /* the new option uses the root - expected bahaviour, but differs from old... */
1858                 /* XXX check on version patching? */
1859                 copy_m4_m4(mat, pchan->chan_mat);
1860         }
1861         else {
1862                 copy_m4_m4(mat, pchan->pose_mat);
1863
1864                 /* but for backwards compatibility, the child has to move to the tail */
1865                 copy_v3_v3(vec, mat[1]);
1866                 mul_v3_fl(vec, pchan->bone->length);
1867                 add_v3_v3(mat[3], vec);
1868         }
1869 }
1870
1871 static void give_parvert(Object *par, int nr, float vec[3])
1872 {
1873         zero_v3(vec);
1874         
1875         if (par->type == OB_MESH) {
1876                 Mesh *me = par->data;
1877                 BMEditMesh *em = me->edit_btmesh;
1878                 DerivedMesh *dm;
1879
1880                 dm = (em) ? em->derivedFinal : par->derivedFinal;
1881                         
1882                 if (dm) {
1883                         int count = 0;
1884                         int numVerts = dm->getNumVerts(dm);
1885
1886                         if (nr < numVerts) {
1887                                 bool use_special_ss_case = false;
1888
1889                                 if (dm->type == DM_TYPE_CCGDM) {
1890                                         ModifierData *md;
1891                                         VirtualModifierData virtualModifierData;
1892                                         use_special_ss_case = true;
1893                                         for (md = modifiers_getVirtualModifierList(par, &virtualModifierData);
1894                                              md != NULL;
1895                                              md = md->next)
1896                                         {
1897                                                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1898                                                 /* TODO(sergey): Check for disabled modifiers. */
1899                                                 if (mti->type != eModifierTypeType_OnlyDeform && md->next != NULL) {
1900                                                         use_special_ss_case = false;
1901                                                         break;
1902                                                 }
1903                                         }
1904                                 }
1905
1906                                 if (!use_special_ss_case) {
1907                                         /* avoid dm->getVertDataArray() since it allocates arrays in the dm (not thread safe) */
1908                                         if (em && dm->type == DM_TYPE_EDITBMESH) {
1909                                                 if (em->bm->elem_table_dirty & BM_VERT) {
1910 #ifdef VPARENT_THREADING_HACK
1911                                                         BLI_mutex_lock(&vparent_lock);
1912                                                         if (em->bm->elem_table_dirty & BM_VERT) {
1913                                                                 BM_mesh_elem_table_ensure(em->bm, BM_VERT);
1914                                                         }
1915                                                         BLI_mutex_unlock(&vparent_lock);
1916 #else
1917                                                         BLI_assert(!"Not safe for threading");
1918                                                         BM_mesh_elem_table_ensure(em->bm, BM_VERT);
1919 #endif
1920                                                 }
1921                                         }
1922                                 }
1923
1924                                 if (use_special_ss_case) {
1925                                         /* Special case if the last modifier is SS and no constructive modifier are in front of it. */
1926                                         CCGDerivedMesh *ccgdm = (CCGDerivedMesh *)dm;
1927                                         CCGVert *ccg_vert = ccgSubSurf_getVert(ccgdm->ss, SET_INT_IN_POINTER(nr));
1928                                         /* In case we deleted some verts, nr may refer to inexistent one now, see T42557. */
1929                                         if (ccg_vert) {
1930                                                 float *co = ccgSubSurf_getVertData(ccgdm->ss, ccg_vert);
1931                                                 add_v3_v3(vec, co);
1932                                                 count++;
1933                                         }
1934                                 }
1935                                 else if (CustomData_has_layer(&dm->vertData, CD_ORIGINDEX) &&
1936                                          !(em && dm->type == DM_TYPE_EDITBMESH))
1937                                 {
1938                                         int i;
1939
1940                                         /* Get the average of all verts with (original index == nr). */
1941                                         for (i = 0; i < numVerts; i++) {
1942                                                 const int *index = dm->getVertData(dm, i, CD_ORIGINDEX);
1943                                                 if (*index == nr) {
1944                                                         float co[3];
1945                                                         dm->getVertCo(dm, i, co);
1946                                                         add_v3_v3(vec, co);
1947                                                         count++;
1948                                                 }
1949                                         }
1950                                 }
1951                                 else {
1952                                         if (nr < numVerts) {
1953                                                 float co[3];
1954                                                 dm->getVertCo(dm, nr, co);
1955                                                 add_v3_v3(vec, co);
1956                                                 count++;
1957                                         }
1958                                 }
1959                         }
1960
1961                         if (count == 0) {
1962                                 /* keep as 0, 0, 0 */
1963                         }
1964                         else if (count > 0) {
1965                                 mul_v3_fl(vec, 1.0f / count);
1966                         }
1967                         else {
1968                                 /* use first index if its out of range */
1969                                 dm->getVertCo(dm, 0, vec);
1970                         }
1971                 }
1972                 else {
1973                         fprintf(stderr,
1974                                 "%s: DerivedMesh is needed to solve parenting, "
1975                                 "object position can be wrong now\n", __func__);
1976                 }
1977         }
1978         else if (ELEM(par->type, OB_CURVE, OB_SURF)) {
1979                 ListBase *nurb;
1980
1981                 /* Unless there's some weird depsgraph failure the cache should exist. */
1982                 BLI_assert(par->curve_cache != NULL);
1983
1984                 if (par->curve_cache->deformed_nurbs.first != NULL) {
1985                         nurb = &par->curve_cache->deformed_nurbs;
1986                 }
1987                 else {
1988                         Curve *cu = par->data;
1989                         nurb = BKE_curve_nurbs_get(cu);
1990                 }
1991
1992                 BKE_nurbList_index_get_co(nurb, nr, vec);
1993         }
1994         else if (par->type == OB_LATTICE) {
1995                 Lattice *latt  = par->data;
1996                 DispList *dl   = par->curve_cache ? BKE_displist_find(&par->curve_cache->disp, DL_VERTS) : NULL;
1997                 float (*co)[3] = dl ? (float (*)[3])dl->verts : NULL;
1998                 int tot;
1999
2000                 if (latt->editlatt) latt = latt->editlatt->latt;
2001
2002                 tot = latt->pntsu * latt->pntsv * latt->pntsw;
2003
2004                 /* ensure dl is correct size */
2005                 BLI_assert(dl == NULL || dl->nr == tot);
2006
2007                 if (nr < tot) {
2008                         if (co) {
2009                                 copy_v3_v3(vec, co[nr]);
2010                         }
2011                         else {
2012                                 copy_v3_v3(vec, latt->def[nr].vec);
2013                         }
2014                 }
2015         }
2016 }
2017
2018 static void ob_parvert3(Object *ob, Object *par, float mat[4][4])
2019 {
2020
2021         /* in local ob space */
2022         if (OB_TYPE_SUPPORT_PARVERT(par->type)) {
2023                 float cmat[3][3], v1[3], v2[3], v3[3], q[4];
2024
2025                 give_parvert(par, ob->par1, v1);
2026                 give_parvert(par, ob->par2, v2);
2027                 give_parvert(par, ob->par3, v3);
2028
2029                 tri_to_quat(q, v1, v2, v3);
2030                 quat_to_mat3(cmat, q);
2031                 copy_m4_m3(mat, cmat);
2032
2033                 mid_v3_v3v3v3(mat[3], v1, v2, v3);
2034         }
2035         else {
2036                 unit_m4(mat);
2037         }
2038 }
2039
2040
2041 void BKE_object_get_parent_matrix(Scene *scene, Object *ob, Object *par, float parentmat[4][4])
2042 {
2043         float tmat[4][4];
2044         float vec[3];
2045         bool ok;
2046
2047         switch (ob->partype & PARTYPE) {
2048                 case PAROBJECT:
2049                         ok = 0;
2050                         if (par->type == OB_CURVE) {
2051                                 if ((((Curve *)par->data)->flag & CU_PATH) &&
2052                                     (ob_parcurve(scene, ob, par, tmat)))
2053                                 {
2054                                         ok = 1;
2055                                 }
2056                         }
2057                         
2058                         if (ok) mul_m4_m4m4(parentmat, par->obmat, tmat);
2059                         else copy_m4_m4(parentmat, par->obmat);
2060                         
2061                         break;
2062                 case PARBONE:
2063                         ob_parbone(ob, par, tmat);
2064                         mul_m4_m4m4(parentmat, par->obmat, tmat);
2065                         break;
2066                 
2067                 case PARVERT1:
2068                         unit_m4(parentmat);
2069                         give_parvert(par, ob->par1, vec);
2070                         mul_v3_m4v3(parentmat[3], par->obmat, vec);
2071                         break;
2072                 case PARVERT3:
2073                         ob_parvert3(ob, par, tmat);
2074                         
2075                         mul_m4_m4m4(parentmat, par->obmat, tmat);
2076                         break;
2077                 
2078                 case PARSKEL:
2079                         copy_m4_m4(parentmat, par->obmat);
2080                         break;
2081         }
2082
2083 }
2084
2085 /**
2086  * \param r_originmat  Optional matrix that stores the space the object is in (without its own matrix applied)
2087  */
2088 static void solve_parenting(Scene *scene, Object *ob, Object *par, float obmat[4][4], float slowmat[4][4],
2089                             float r_originmat[3][3], const bool set_origin)
2090 {
2091         float totmat[4][4];
2092         float tmat[4][4];
2093         float locmat[4][4];
2094         
2095         BKE_object_to_mat4(ob, locmat);
2096         
2097         if (ob->partype & PARSLOW) copy_m4_m4(slowmat, obmat);
2098
2099         BKE_object_get_parent_matrix(scene, ob, par, totmat);
2100         
2101         /* total */
2102         mul_m4_m4m4(tmat, totmat, ob->parentinv);
2103         mul_m4_m4m4(obmat, tmat, locmat);
2104         
2105         if (r_originmat) {
2106                 /* usable originmat */
2107                 copy_m3_m4(r_originmat, tmat);
2108         }
2109         
2110         /* origin, for help line */
2111         if (set_origin) {
2112                 if ((ob->partype & PARTYPE) == PARSKEL) {
2113                         copy_v3_v3(ob->orig, par->obmat[3]);
2114                 }
2115                 else {
2116                         copy_v3_v3(ob->orig, totmat[3]);
2117                 }
2118         }
2119 }
2120
2121 static bool where_is_object_parslow(Object *ob, float obmat[4][4], float slowmat[4][4])
2122 {
2123         float *fp1, *fp2;
2124         float fac1, fac2;
2125         int a;
2126
2127         /* include framerate */
2128         fac1 = (1.0f / (1.0f + fabsf(ob->sf)));
2129         if (fac1 >= 1.0f) return false;
2130         fac2 = 1.0f - fac1;
2131
2132         fp1 = obmat[0];
2133         fp2 = slowmat[0];
2134         for (a = 0; a < 16; a++, fp1++, fp2++) {
2135                 fp1[0] = fac1 * fp1[0] + fac2 * fp2[0];
2136         }
2137
2138         return true;
2139 }
2140
2141 /* note, scene is the active scene while actual_scene is the scene the object resides in */
2142 void BKE_object_where_is_calc_time_ex(
2143         const EvaluationContext *eval_ctx, Scene *scene, Object *ob, float ctime,
2144         RigidBodyWorld *rbw, float r_originmat[3][3])
2145 {
2146         if (ob == NULL) return;
2147         
2148         /* execute drivers only, as animation has already been done */
2149         BKE_animsys_evaluate_animdata(scene, &ob->id, ob->adt, ctime, ADT_RECALC_DRIVERS);
2150         
2151         if (ob->parent) {
2152                 Object *par = ob->parent;
2153                 float slowmat[4][4];
2154                 
2155                 /* calculate parent matrix */
2156                 solve_parenting(scene, ob, par, ob->obmat, slowmat, r_originmat, true);
2157                 
2158                 /* "slow parent" is definitely not threadsafe, and may also give bad results jumping around 
2159                  * An old-fashioned hack which probably doesn't really cut it anymore
2160                  */
2161                 if (ob->partype & PARSLOW) {
2162                         if (!where_is_object_parslow(ob, ob->obmat, slowmat))
2163                                 return;
2164                 }
2165         }
2166         else {
2167                 BKE_object_to_mat4(ob, ob->obmat);
2168         }
2169
2170         /* try to fall back to the scene rigid body world if none given */
2171         rbw = rbw ? rbw : scene->rigidbody_world;
2172         /* read values pushed into RBO from sim/cache... */
2173         BKE_rigidbody_sync_transforms(rbw, ob, ctime);
2174         
2175         /* solve constraints */
2176         if (ob->constraints.first && !(ob->transflag & OB_NO_CONSTRAINTS)) {
2177                 bConstraintOb *cob;
2178                 cob = BKE_constraints_make_evalob(scene, ob, NULL, CONSTRAINT_OBTYPE_OBJECT);
2179                 BKE_constraints_solve(eval_ctx, &ob->constraints, cob, ctime);
2180                 BKE_constraints_clear_evalob(cob);
2181         }
2182         
2183         /* set negative scale flag in object */
2184         if (is_negative_m4(ob->obmat)) ob->transflag |= OB_NEG_SCALE;
2185         else ob->transflag &= ~OB_NEG_SCALE;
2186 }
2187
2188 void BKE_object_where_is_calc_time(const EvaluationContext *eval_ctx, Scene *scene, Object *ob, float ctime)
2189 {
2190         BKE_object_where_is_calc_time_ex(eval_ctx, scene, ob, ctime, NULL, NULL);
2191 }
2192
2193 /* get object transformation matrix without recalculating dependencies and
2194  * constraints -- assume dependencies are already solved by depsgraph.
2195  * no changes to object and it's parent would be done.
2196  * used for bundles orientation in 3d space relative to parented blender camera */
2197 void BKE_object_where_is_calc_mat4(Scene *scene, Object *ob, float obmat[4][4])
2198 {
2199
2200         if (ob->parent) {
2201                 float slowmat[4][4];
2202
2203                 Object *par = ob->parent;
2204                 
2205                 solve_parenting(scene, ob, par, obmat, slowmat, NULL, false);
2206                 
2207                 if (ob->partype & PARSLOW)
2208                         where_is_object_parslow(ob, obmat, slowmat);
2209         }
2210         else {
2211                 BKE_object_to_mat4(ob, obmat);
2212         }
2213 }
2214
2215 void BKE_object_where_is_calc_ex(const EvaluationContext *eval_ctx, Scene *scene, RigidBodyWorld *rbw, Object *ob, float r_originmat[3][3])
2216 {
2217         BKE_object_where_is_calc_time_ex(eval_ctx, scene, ob, BKE_scene_frame_get(scene), rbw, r_originmat);
2218 }
2219 void BKE_object_where_is_calc(const EvaluationContext *eval_ctx, Scene *scene, Object *ob)
2220 {
2221         BKE_object_where_is_calc_time_ex(eval_ctx, scene, ob, BKE_scene_frame_get(scene), NULL, NULL);
2222 }
2223
2224 /* for calculation of the inverse parent transform, only used for editor */
2225 void BKE_object_workob_calc_parent(const EvaluationContext *eval_ctx, Scene *scene, Object *ob, Object *workob)
2226 {
2227         BKE_object_workob_clear(workob);
2228         
2229         unit_m4(workob->obmat);
2230         unit_m4(workob->parentinv);
2231         unit_m4(workob->constinv);
2232         workob->parent = ob->parent;
2233
2234         workob->trackflag = ob->trackflag;
2235         workob->upflag = ob->upflag;
2236         
2237         workob->partype = ob->partype;
2238         workob->par1 = ob->par1;
2239         workob->par2 = ob->par2;
2240         workob->par3 = ob->par3;
2241
2242         workob->constraints.first = ob->constraints.first;
2243         workob->constraints.last = ob->constraints.last;
2244
2245         BLI_strncpy(workob->parsubstr, ob->parsubstr, sizeof(workob->parsubstr));
2246
2247         BKE_object_where_is_calc(eval_ctx, scene, workob);
2248 }
2249
2250 /* see BKE_pchan_apply_mat4() for the equivalent 'pchan' function */
2251 void BKE_object_apply_mat4(Object *ob, float mat[4][4], const bool use_compat, const bool use_parent)
2252 {
2253         float rot[3][3];
2254
2255         if (use_parent && ob->parent) {
2256                 float rmat[4][4], diff_mat[4][4], imat[4][4], parent_mat[4][4];
2257
2258                 BKE_object_get_parent_matrix(NULL, ob, ob->parent, parent_mat);
2259
2260                 mul_m4_m4m4(diff_mat, parent_mat, ob->parentinv);
2261                 invert_m4_m4(imat, diff_mat);
2262                 mul_m4_m4m4(rmat, imat, mat); /* get the parent relative matrix */
2263
2264                 /* same as below, use rmat rather than mat */
2265                 mat4_to_loc_rot_size(ob->loc, rot, ob->size, rmat);
2266         }
2267         else {
2268                 mat4_to_loc_rot_size(ob->loc, rot, ob->size, mat);
2269         }
2270
2271         BKE_object_mat3_to_rot(ob, rot, use_compat);
2272
2273         sub_v3_v3(ob->loc, ob->dloc);
2274
2275         if (ob->dscale[0] != 0.0f) ob->size[0] /= ob->dscale[0];
2276         if (ob->dscale[1] != 0.0f) ob->size[1] /= ob->dscale[1];
2277         if (ob->dscale[2] != 0.0f) ob->size[2] /= ob->dscale[2];
2278
2279         /* BKE_object_mat3_to_rot handles delta rotations */
2280 }
2281
2282 BoundBox *BKE_boundbox_alloc_unit(void)
2283 {
2284         BoundBox *bb;
2285         const float min[3] = {-1.0f, -1.0f, -1.0f}, max[3] = {-1.0f, -1.0f, -1.0f};
2286
2287         bb = MEM_callocN(sizeof(BoundBox), "OB-BoundBox");
2288         BKE_boundbox_init_from_minmax(bb, min, max);
2289         
2290         return bb;
2291 }
2292
2293 void BKE_boundbox_init_from_minmax(BoundBox *bb, const float min[3], const float max[3])
2294 {
2295         bb->vec[0][0] = bb->vec[1][0] = bb->vec[2][0] = bb->vec[3][0] = min[0];
2296         bb->vec[4][0] = bb->vec[5][0] = bb->vec[6][0] = bb->vec[7][0] = max[0];
2297         
2298         bb->vec[0][1] = bb->vec[1][1] = bb->vec[4][1] = bb->vec[5][1] = min[1];
2299         bb->vec[2][1] = bb->vec[3][1] = bb->vec[6][1] = bb->vec[7][1] = max[1];
2300
2301         bb->vec[0][2] = bb->vec[3][2] = bb->vec[4][2] = bb->vec[7][2] = min[2];
2302         bb->vec[1][2] = bb->vec[2][2] = bb->vec[5][2] = bb->vec[6][2] = max[2];
2303 }
2304
2305 void BKE_boundbox_calc_center_aabb(const BoundBox *bb, float r_cent[3])
2306 {
2307         r_cent[0] = 0.5f * (bb->vec[0][0] + bb->vec[4][0]);
2308         r_cent[1] = 0.5f * (bb->vec[0][1] + bb->vec[2][1]);
2309         r_cent[2] = 0.5f * (bb->vec[0][2] + bb->vec[1][2]);
2310 }
2311
2312 void BKE_boundbox_calc_size_aabb(const BoundBox *bb, float r_size[3])
2313 {
2314         r_size[0] = 0.5f * fabsf(bb->vec[0][0] - bb->vec[4][0]);
2315         r_size[1] = 0.5f * fabsf(bb->vec[0][1] - bb->vec[2][1]);
2316         r_size[2] = 0.5f * fabsf(bb->vec[0][2] - bb->vec[1][2]);
2317 }
2318
2319 void BKE_boundbox_minmax(const BoundBox *bb, float obmat[4][4], float r_min[3], float r_max[3])
2320 {
2321         int i;
2322         for (i = 0; i < 8; i++) {
2323                 float vec[3];
2324                 mul_v3_m4v3(vec, obmat, bb->vec[i]);
2325                 minmax_v3v3_v3(r_min, r_max, vec);
2326         }
2327 }
2328
2329 BoundBox *BKE_object_boundbox_get(Object *ob)
2330 {
2331         BoundBox *bb = NULL;
2332         
2333         if (ob->type == OB_MESH) {
2334                 bb = BKE_mesh_boundbox_get(ob);
2335         }
2336         else if (ELEM(ob->type, OB_CURVE, OB_SURF, OB_FONT)) {
2337                 bb = BKE_curve_boundbox_get(ob);
2338         }
2339         else if (ob->type == OB_MBALL) {
2340                 bb = ob->bb;
2341         }
2342         else if (ob->type == OB_LATTICE) {
2343                 bb = BKE_lattice_boundbox_get(ob);
2344         }
2345         else if (ob->type == OB_ARMATURE) {
2346                 bb = BKE_armature_boundbox_get(ob);
2347         }
2348         return bb;
2349 }
2350
2351 /* used to temporally disable/enable boundbox */
2352 void BKE_object_boundbox_flag(Object *ob, int flag, const bool set)
2353 {
2354         BoundBox *bb = BKE_object_boundbox_get(ob);
2355         if (bb) {
2356                 if (set) bb->flag |= flag;
2357                 else bb->flag &= ~flag;
2358         }
2359 }
2360
2361 void BKE_object_dimensions_get(Object *ob, float vec[3])
2362 {
2363         BoundBox *bb = NULL;
2364         
2365         bb = BKE_object_boundbox_get(ob);
2366         if (bb) {
2367                 float scale[3];
2368                 
2369                 mat4_to_size(scale, ob->obmat);
2370                 
2371                 vec[0] = fabsf(scale[0]) * (bb->vec[4][0] - bb->vec[0][0]);
2372                 vec[1] = fabsf(scale[1]) * (bb->vec[2][1] - bb->vec[0][1]);
2373                 vec[2] = fabsf(scale[2]) * (bb->vec[1][2] - bb->vec[0][2]);
2374         }
2375         else {
2376                 zero_v3(vec);
2377         }
2378 }
2379
2380 void BKE_object_dimensions_set(Object *ob, const float value[3])
2381 {
2382         BoundBox *bb = NULL;
2383         
2384         bb = BKE_object_boundbox_get(ob);
2385         if (bb) {
2386                 float scale[3], len[3];
2387                 
2388                 mat4_to_size(scale, ob->obmat);
2389                 
2390                 len[0] = bb->vec[4][0] - bb->vec[0][0];
2391                 len[1] = bb->vec[2][1] - bb->vec[0][1];
2392                 len[2] = bb->vec[1][2] - bb->vec[0][2];
2393                 
2394                 if (len[0] > 0.f) ob->size[0] = value[0] / len[0];
2395                 if (len[1] > 0.f) ob->size[1] = value[1] / len[1];
2396                 if (len[2] > 0.f) ob->size[2] = value[2] / len[2];
2397         }
2398 }
2399
2400 void BKE_object_minmax(Object *ob, float min_r[3], float max_r[3], const bool use_hidden)
2401 {
2402         BoundBox bb;
2403         float vec[3];
2404         bool changed = false;
2405         
2406         switch (ob->type) {
2407                 case OB_CURVE:
2408                 case OB_FONT:
2409                 case OB_SURF:
2410                 {
2411                         bb = *BKE_curve_boundbox_get(ob);
2412                         BKE_boundbox_minmax(&bb, ob->obmat, min_r, max_r);
2413                         changed = true;
2414                         break;
2415                 }
2416                 case OB_LATTICE:
2417                 {
2418                         Lattice *lt = ob->data;
2419                         BPoint *bp = lt->def;
2420                         int u, v, w;
2421
2422                         for (w = 0; w < lt->pntsw; w++) {
2423                                 for (v = 0; v < lt->pntsv; v++) {
2424                                         for (u = 0; u < lt->pntsu; u++, bp++) {
2425                                                 mul_v3_m4v3(vec, ob->obmat, bp->vec);
2426                                                 minmax_v3v3_v3(min_r, max_r, vec);
2427                                         }
2428                                 }
2429                         }
2430                         changed = true;
2431                         break;
2432                 }
2433                 case OB_ARMATURE:
2434                 {
2435                         changed = BKE_pose_minmax(ob, min_r, max_r, use_hidden, false);
2436                         break;
2437                 }
2438                 case OB_MESH:
2439                 {
2440                         Mesh *me = BKE_mesh_from_object(ob);
2441
2442                         if (me) {
2443                                 bb = *BKE_mesh_boundbox_get(ob);
2444                                 BKE_boundbox_minmax(&bb, ob->obmat, min_r, max_r);
2445                                 changed = true;
2446                         }
2447                         break;
2448                 }
2449                 case OB_MBALL:
2450                 {
2451                         float ob_min[3], ob_max[3];
2452
2453                         changed = BKE_mball_minmax_ex(ob->data, ob_min, ob_max, ob->obmat, 0);
2454                         if (changed) {
2455                                 minmax_v3v3_v3(min_r, max_r, ob_min);
2456                                 minmax_v3v3_v3(min_r, max_r, ob_max);
2457                         }
2458                         break;
2459                 }
2460         }
2461
2462         if (changed == false) {
2463                 float size[3];
2464
2465                 copy_v3_v3(size, ob->size);
2466                 if (ob->type == OB_EMPTY) {
2467                         mul_v3_fl(size, ob->empty_drawsize);
2468                 }
2469
2470                 minmax_v3v3_v3(min_r, max_r, ob->obmat[3]);
2471
2472                 copy_v3_v3(vec, ob->obmat[3]);
2473                 add_v3_v3(vec, size);
2474                 minmax_v3v3_v3(min_r, max_r, vec);
2475
2476                 copy_v3_v3(vec, ob->obmat[3]);
2477                 sub_v3_v3(vec, size);
2478                 minmax_v3v3_v3(min_r, max_r, vec);
2479         }
2480 }
2481
2482 void BKE_object_empty_draw_type_set(Object *ob, const int value)
2483 {
2484         ob->empty_drawtype = value;
2485
2486         if (ob->type == OB_EMPTY && ob->empty_drawtype == OB_EMPTY_IMAGE) {
2487                 if (!ob->iuser) {
2488                         ob->iuser = MEM_callocN(sizeof(ImageUser), "image user");
2489                         ob->iuser->ok = 1;
2490                         ob->iuser->frames = 100;
2491                         ob->iuser->sfra = 1;
2492                         ob->iuser->fie_ima = 2;
2493                 }
2494         }
2495         else {
2496                 if (ob->iuser) {
2497                         MEM_freeN(ob->iuser);
2498                         ob->iuser = NULL;
2499                 }
2500         }
2501 }
2502
2503 bool BKE_object_minmax_dupli(Scene *scene, Object *ob, float r_min[3], float r_max[3], const bool use_hidden)
2504 {
2505         bool ok = false;
2506         if ((ob->transflag & OB_DUPLI) == 0) {
2507                 return ok;
2508         }
2509         else {
2510                 ListBase *lb;
2511                 DupliObject *dob;
2512                 lb = object_duplilist(G.main->eval_ctx, scene, ob);
2513                 for (dob = lb->first; dob; dob = dob->next) {
2514                         if ((use_hidden == false) && (dob->no_draw != 0)) {
2515                                 /* pass */
2516                         }
2517                         else {
2518                                 BoundBox *bb = BKE_object_boundbox_get(dob->ob);
2519
2520                                 if (bb) {
2521                                         int i;
2522                                         for (i = 0; i < 8; i++) {
2523                                                 float vec[3];
2524                                                 mul_v3_m4v3(vec, dob->mat, bb->vec[i]);
2525                                                 minmax_v3v3_v3(r_min, r_max, vec);
2526                                         }
2527
2528                                         ok = true;
2529                                 }
2530                         }
2531                 }
2532                 free_object_duplilist(lb);  /* does restore */
2533         }
2534
2535         return ok;
2536 }
2537
2538 void BKE_object_foreach_display_point(
2539         Object *ob, float obmat[4][4],
2540         void (*func_cb)(const float[3], void *), void *user_data)
2541 {
2542         float co[3];
2543
2544         if (ob->derivedFinal) {
2545                 DerivedMesh *dm = ob->derivedFinal;
2546                 MVert *mv = dm->getVertArray(dm);
2547                 int totvert = dm->getNumVerts(dm);
2548                 int i;
2549
2550                 for (i = 0; i < totvert; i++, mv++) {
2551                         mul_v3_m4v3(co, obmat, mv->co);
2552                         func_cb(co, user_data);
2553                 }
2554         }
2555         else if (ob->curve_cache && ob->curve_cache->disp.first) {
2556                 DispList *dl;
2557
2558                 for (dl = ob->curve_cache->disp.first; dl; dl = dl->next) {
2559                         const float *v3 = dl->verts;
2560                         int totvert = dl->nr;
2561                         int i;
2562
2563                         for (i = 0; i < totvert; i++, v3 += 3) {
2564                                 mul_v3_m4v3(co, obmat, v3);
2565                                 func_cb(co, user_data);
2566                         }
2567                 }
2568         }
2569 }
2570
2571 void BKE_scene_foreach_display_point(
2572         Scene *scene, ViewLayer *view_layer,
2573         void (*func_cb)(const float[3], void *), void *user_data)
2574 {
2575         Base *base;
2576         Object *ob;
2577
2578         for (base = FIRSTBASE(view_layer); base; base = base->next) {
2579                 if (((base->flag & BASE_VISIBLED) != 0) && ((base->flag & BASE_SELECTED) != 0)) {
2580                         ob = base->object;
2581
2582                         if ((ob->transflag & OB_DUPLI) == 0) {
2583                                 BKE_object_foreach_display_point(ob, ob->obmat, func_cb, user_data);
2584                         }
2585                         else {
2586                                 ListBase *lb;
2587                                 DupliObject *dob;
2588
2589                                 lb = object_duplilist(G.main->eval_ctx, scene, ob);
2590                                 for (dob = lb->first; dob; dob = dob->next) {
2591                                         if (dob->no_draw == 0) {
2592                                                 BKE_object_foreach_display_point(dob->ob, dob->mat, func_cb, user_data);
2593                                         }
2594                                 }
2595                                 free_object_duplilist(lb);  /* does restore */
2596                         }
2597                 }
2598         }
2599 }
2600
2601 /* copied from DNA_object_types.h */
2602 typedef struct ObTfmBack {
2603         float loc[3], dloc[3], orig[3];
2604         float size[3], dscale[3];   /* scale and delta scale */
2605         float rot[3], drot[3];      /* euler rotation */
2606         float quat[4], dquat[4];    /* quaternion rotation */
2607         float rotAxis[3], drotAxis[3];  /* axis angle rotation - axis part */
2608         float rotAngle, drotAngle;  /* axis angle rotation - angle part */
2609         float obmat[4][4];      /* final worldspace matrix with constraints & animsys applied */
2610         float parentinv[4][4]; /* inverse result of parent, so that object doesn't 'stick' to parent */
2611         float constinv[4][4]; /* inverse result of constraints. doesn't include effect of parent or object local transform */
2612         float imat[4][4];   /* inverse matrix of 'obmat' for during render, old game engine, temporally: ipokeys of transform  */
2613 } ObTfmBack;
2614
2615 void *BKE_object_tfm_backup(Object *ob)
2616 {
2617         ObTfmBack *obtfm = MEM_mallocN(sizeof(ObTfmBack), "ObTfmBack");
2618         copy_v3_v3(obtfm->loc, ob->loc);
2619         copy_v3_v3(obtfm->dloc, ob->dloc);
2620         copy_v3_v3(obtfm->orig, ob->orig);
2621         copy_v3_v3(obtfm->size, ob->size);
2622         copy_v3_v3(obtfm->dscale, ob->dscale);
2623         copy_v3_v3(obtfm->rot, ob->rot);
2624         copy_v3_v3(obtfm->drot, ob->drot);
2625         copy_qt_qt(obtfm->quat, ob->quat);
2626         copy_qt_qt(obtfm->dquat, ob->dquat);
2627         copy_v3_v3(obtfm->rotAxis, ob->rotAxis);
2628         copy_v3_v3(obtfm->drotAxis, ob->drotAxis);
2629         obtfm->rotAngle = ob->rotAngle;
2630         obtfm->drotAngle = ob->drotAngle;
2631         copy_m4_m4(obtfm->obmat, ob->obmat);
2632         copy_m4_m4(obtfm->parentinv, ob->parentinv);
2633         copy_m4_m4(obtfm->constinv, ob->constinv);
2634         copy_m4_m4(obtfm->imat, ob->imat);
2635
2636         return (void *)obtfm;
2637 }
2638
2639 void BKE_object_tfm_restore(Object *ob, void *obtfm_pt)
2640 {
2641         ObTfmBack *obtfm = (ObTfmBack *)obtfm_pt;
2642         copy_v3_v3(ob->loc, obtfm->loc);
2643         copy_v3_v3(ob->dloc, obtfm->dloc);
2644         copy_v3_v3(ob->orig, obtfm->orig);
2645         copy_v3_v3(ob->size, obtfm->size);
2646         copy_v3_v3(ob->dscale, obtfm->dscale);
2647         copy_v3_v3(ob->rot, obtfm->rot);
2648         copy_v3_v3(ob->drot, obtfm->drot);
2649         copy_qt_qt(ob->quat, obtfm->quat);
2650         copy_qt_qt(ob->dquat, obtfm->dquat);
2651         copy_v3_v3(ob->rotAxis, obtfm->rotAxis);
2652         copy_v3_v3(ob->drotAxis, obtfm->drotAxis);
2653         ob->rotAngle = obtfm->rotAngle;
2654         ob->drotAngle = obtfm->drotAngle;
2655         copy_m4_m4(ob->obmat, obtfm->obmat);
2656         copy_m4_m4(ob->parentinv, obtfm->parentinv);
2657         copy_m4_m4(ob->constinv, obtfm->constinv);
2658         copy_m4_m4(ob->imat, obtfm->imat);
2659 }
2660
2661 bool BKE_object_parent_loop_check(const Object *par, const Object *ob)
2662 {
2663         /* test if 'ob' is a parent somewhere in par's parents */
2664         if (par == NULL) return false;
2665         if (ob == par) return true;
2666         return BKE_object_parent_loop_check(par->parent, ob);
2667 }
2668
2669 /* proxy rule: lib_object->proxy_from == the one we borrow from, only set temporal and cleared here */
2670 /*           local_object->proxy      == pointer to library object, saved in files and read */
2671
2672 /* function below is polluted with proxy exceptions, cleanup will follow! */
2673
2674 /* the main object update call, for object matrix, constraints, keys and displist (modifiers) */
2675 /* requires flags to be set! */
2676 /* Ideally we shouldn't have to pass the rigid body world, but need bigger restructuring to avoid id */
2677 void BKE_object_handle_update_ex(const EvaluationContext *eval_ctx,
2678                                  Scene *scene, Object *ob,
2679                                  RigidBodyWorld *rbw,
2680                                  const bool do_proxy_update)
2681 {
2682         if (ob->recalc & OB_RECALC_ALL) {
2683                 /* speed optimization for animation lookups */
2684                 if (ob->pose) {
2685                         BKE_pose_channels_hash_make(ob->pose);
2686                         if (ob->pose->flag & POSE_CONSTRAINTS_NEED_UPDATE_FLAGS) {
2687                                 BKE_pose_update_constraint_flags(ob->pose);
2688                         }
2689                 }
2690
2691                 if (ob->recalc & OB_RECALC_DATA) {
2692                         if (ob->type == OB_ARMATURE) {
2693                                 /* this happens for reading old files and to match library armatures
2694                                  * with poses we do it ahead of BKE_object_where_is_calc to ensure animation
2695                                  * is evaluated on the rebuilt pose, otherwise we get incorrect poses
2696                                  * on file load */
2697                                 if (ob->pose == NULL || (ob->pose->flag & POSE_RECALC))
2698                                         BKE_pose_rebuild(ob, ob->data);
2699                         }
2700                 }
2701
2702                 /* XXX new animsys warning: depsgraph tag OB_RECALC_DATA should not skip drivers, 
2703                  * which is only in BKE_object_where_is_calc now */
2704                 /* XXX: should this case be OB_RECALC_OB instead? */
2705                 if (ob->recalc & OB_RECALC_ALL) {
2706                         
2707                         if (G.debug & G_DEBUG_DEPSGRAPH)
2708                                 printf("recalcob %s\n", ob->id.name + 2);
2709                         
2710                         /* handle proxy copy for target */
2711                         if (ID_IS_LINKED(ob) && ob->proxy_from) {
2712                                 // printf("ob proxy copy, lib ob %s proxy %s\n", ob->id.name, ob->proxy_from->id.name);
2713                                 if (ob->proxy_from->proxy_group) { /* transform proxy into group space */
2714                                         Object *obg = ob->proxy_from->proxy_group;
2715                                         float imat[4][4];
2716                                         invert_m4_m4(imat, obg->obmat);
2717                                         mul_m4_m4m4(ob->obmat, imat, ob->proxy_from->obmat);
2718                                         if (obg->dup_group) { /* should always be true */
2719                                                 add_v3_v3(ob->obmat[3], obg->dup_group->dupli_ofs);
2720                                         }
2721                                 }
2722                                 else
2723                                         copy_m4_m4(ob->obmat, ob->proxy_from->obmat);
2724                         }
2725                         else
2726                                 BKE_object_where_is_calc_ex(eval_ctx, scene, rbw, ob, NULL);
2727                 }
2728                 
2729                 if (ob->recalc & OB_RECALC_DATA) {
2730                         BKE_object_handle_data_update(eval_ctx, scene, ob);
2731                 }
2732
2733                 ob->recalc &= ~OB_RECALC_ALL;
2734         }
2735
2736         /* the case when this is a group proxy, object_update is called in group.c */
2737         if (ob->proxy) {
2738                 /* set pointer in library proxy target, for copying, but restore it */
2739                 ob->proxy->proxy_from = ob;
2740                 // printf("set proxy pointer for later group stuff %s\n", ob->id.name);
2741
2742                 /* the no-group proxy case, we call update */
2743                 if (ob->proxy_group == NULL) {
2744                         if (do_proxy_update) {
2745                                 // printf("call update, lib ob %s proxy %s\n", ob->proxy->id.name, ob->id.name);
2746                                 BKE_object_handle_update(eval_ctx, scene, ob->proxy);
2747                         }
2748                 }
2749         }
2750 }
2751 /* WARNING: "scene" here may not be the scene object actually resides in. 
2752  * When dealing with background-sets, "scene" is actually the active scene.
2753  * e.g. "scene" <-- set 1 <-- set 2 ("ob" lives here) <-- set 3 <-- ... <-- set n
2754  * rigid bodies depend on their world so use BKE_object_handle_update_ex() to also pass along the corrent rigid body world
2755  */
2756 void BKE_object_handle_update(const EvaluationContext *eval_ctx, Scene *scene, Object *ob)
2757 {
2758         BKE_object_handle_update_ex(eval_ctx, scene, ob, NULL, true);
2759 }
2760
2761 void BKE_object_sculpt_modifiers_changed(Object *ob)
2762 {
2763         SculptSession *ss = ob->sculpt;
2764
2765         if (ss && ss->building_vp_handle == false) {
2766                 if (!ss->cache) {
2767                         /* we free pbvh on changes, except during sculpt since it can't deal with
2768                          * changing PVBH node organization, we hope topology does not change in
2769                          * the meantime .. weak */
2770                         if (ss->pbvh) {
2771                                 BKE_pbvh_free(ss->pbvh);
2772                                 ss->pbvh = NULL;
2773                         }
2774
2775                         BKE_sculptsession_free_deformMats(ob->sculpt);
2776
2777                         /* In vertex/weight paint, force maps to be rebuilt. */
2778                         BKE_sculptsession_free_vwpaint_data(ob->sculpt);
2779                 }
2780                 else {
2781                         PBVHNode **nodes;
2782                         int n, totnode;
2783
2784                         BKE_pbvh_search_gather(ss->pbvh, NULL, NULL, &nodes, &totnode);
2785
2786                         for (n = 0; n < totnode; n++)
2787                                 BKE_pbvh_node_mark_update(nodes[n]);
2788
2789                         MEM_freeN(nodes);
2790                 }
2791         }
2792 }
2793
2794 int BKE_object_obdata_texspace_get(Object *ob, short **r_texflag, float **r_loc, float **r_size, float **r_rot)
2795 {
2796         
2797         if (ob->data == NULL)
2798                 return 0;
2799         
2800         switch (GS(((ID *)ob->data)->name)) {
2801                 case ID_ME:
2802                 {
2803                         BKE_mesh_texspace_get_reference((Mesh *)ob->data, r_texflag, r_loc, r_rot, r_size);
2804                         break;
2805                 }
2806                 case ID_CU:
2807                 {
2808                         Curve *cu = ob->data;
2809                         if (cu->bb == NULL || (cu->bb->flag & BOUNDBOX_DIRTY)) {
2810                                 BKE_curve_texspace_calc(cu);
2811                         }
2812                         if (r_texflag) *r_texflag = &cu->texflag;
2813                         if (r_loc) *r_loc = cu->loc;
2814                         if (r_size) *r_size = cu->size;
2815                         if (r_rot) *r_rot = cu->rot;
2816                         break;
2817                 }
2818                 case ID_MB:
2819                 {
2820                         MetaBall *mb = ob->data;
2821                         if (r_texflag) *r_texflag = &mb->texflag;
2822                         if (r_loc) *r_loc = mb->loc;
2823                         if (r_size) *r_size = mb->size;
2824                         if (r_rot) *r_rot = mb->rot;
2825                         break;
2826                 }
2827                 default:
2828                         return 0;
2829         }
2830         return 1;
2831 }
2832
2833 static int pc_cmp(const void *a, const void *b)
2834 {
2835         const LinkData *ad = a, *bd = b;
2836         if (GET_INT_FROM_POINTER(ad->data) > GET_INT_FROM_POINTER(bd->data))
2837                 return 1;
2838         else return 0;
2839 }
2840
2841 int BKE_object_insert_ptcache(Object *ob) 
2842 {
2843         LinkData *link = NULL;
2844         int i = 0;
2845
2846         BLI_listbase_sort(&ob->pc_ids, pc_cmp);
2847
2848         for (link = ob->pc_ids.first, i = 0; link; link = link->next, i++) {
2849                 int index = GET_INT_FROM_POINTER(link->data);
2850
2851                 if (i < index)
2852                         break;
2853         }
2854
2855         link = MEM_callocN(sizeof(LinkData), "PCLink");
2856         link->data = SET_INT_IN_POINTER(i);
2857         BLI_addtail(&ob->pc_ids, link);
2858
2859         return i;
2860 }
2861
2862 static int pc_findindex(ListBase *listbase, int index)
2863 {
2864         LinkData *link = NULL;
2865         int number = 0;
2866         
2867         if (listbase == NULL) return -1;
2868         
2869         link = listbase->first;
2870         while (link) {
2871                 if (GET_INT_FROM_POINTER(link->data) == index)
2872                         return number;
2873                 
2874                 number++;
2875                 link = link->next;
2876         }
2877         
2878         return -1;
2879 }
2880
2881 void BKE_object_delete_ptcache(Object *ob, int index)
2882 {
2883         int list_index = pc_findindex(&ob->pc_ids, index);
2884         LinkData *link = BLI_findlink(&ob->pc_ids, list_index);
2885         BLI_freelinkN(&ob->pc_ids, link);
2886 }
2887
2888 /* shape key utility function */
2889
2890 /************************* Mesh ************************/
2891 static KeyBlock *insert_meshkey(Object *ob, const char *name, const bool from_mix)
2892 {
2893         Mesh *me = ob->data;
2894         Key *key = me->key;
2895         KeyBlock *kb;
2896         int newkey = 0;
2897
2898         if (key == NULL) {
2899                 key = me->key = BKE_key_add((ID *)me);
2900                 key->type = KEY_RELATIVE;
2901                 newkey = 1;
2902         }
2903
2904         if (newkey || from_mix == false) {
2905                 /* create from mesh */
2906                 kb = BKE_keyblock_add_ctime(key, name, false);
2907                 BKE_keyblock_convert_from_mesh(me, kb);
2908         }
2909         else {
2910                 /* copy from current values */
2911                 int totelem;
2912                 float *data = BKE_key_evaluate_object(ob, &totelem);
2913
2914                 /* create new block with prepared data */
2915                 kb = BKE_keyblock_add_ctime(key, name, false);
2916                 kb->data = data;
2917                 kb->totelem = totelem;
2918         }
2919
2920         return kb;
2921 }
2922 /************************* Lattice ************************/
2923 static KeyBlock *insert_lattkey(Object *ob, const char *name, const bool from_mix)
2924 {
2925         Lattice *lt = ob->data;
2926         Key *key = lt->key;
2927         KeyBlock *kb;
2928         int newkey = 0;
2929
2930         if (key == NULL) {
2931                 key = lt->key = BKE_key_add((ID *)lt);
2932                 key->type = KEY_RELATIVE;
2933                 newkey = 1;
2934         }
2935
2936         if (newkey || from_mix == false) {
2937                 kb = BKE_keyblock_add_ctime(key, name, false);
2938                 if (!newkey) {
2939                         KeyBlock *basekb = (KeyBlock *)key->block.first;
2940                         kb->data = MEM_dupallocN(basekb->data);
2941                         kb->totelem = basekb->totelem;
2942                 }
2943                 else {
2944                         BKE_keyblock_convert_from_lattice(lt, kb);
2945                 }
2946         }
2947         else {
2948                 /* copy from current values */
2949                 int totelem;
2950                 float *data = BKE_key_evaluate_object(ob, &totelem);
2951
2952                 /* create new block with prepared data */
2953                 kb = BKE_keyblock_add_ctime(key, name, false);
2954                 kb->totelem = totelem;
2955                 kb->data = data;
2956         }
2957
2958         return kb;
2959 }
2960 /************************* Curve ************************/
2961 static KeyBlock *insert_curvekey(Object *ob, const char *name, const bool from_mix)
2962 {
2963         Curve *cu = ob->data;
2964         Key *key = cu->key;
2965         KeyBlock *kb;
2966         ListBase *lb = BKE_curve_nurbs_get(cu);
2967         int newkey = 0;
2968
2969         if (key == NULL) {
2970                 key = cu->key = BKE_key_add((ID *)cu);
2971                 key->type = KEY_RELATIVE;
2972                 newkey = 1;
2973         }
2974
2975         if (newkey || from_mix == false) {
2976                 /* create from curve */
2977                 kb = BKE_keyblock_add_ctime(key, name, false);
2978                 if (!newkey) {
2979                         KeyBlock *basekb = (KeyBlock *)key->block.first;
2980                         kb->data = MEM_dupallocN(basekb->data);
2981                         kb->totelem = basekb->totelem;
2982                 }
2983                 else {
2984                         BKE_keyblock_convert_from_curve(cu, kb, lb);
2985                 }
2986         }
2987         else {
2988                 /* copy from current values */
2989                 int totelem;
2990                 float *data = BKE_key_evaluate_object(ob, &totelem);
2991
2992                 /* create new block with prepared data */
2993                 kb = BKE_keyblock_add_ctime(key, name, false);
2994                 kb->totelem = totelem;
2995                 kb->data = data;
2996         }
2997
2998         return kb;
2999 }
3000
3001 KeyBlock *BKE_object_shapekey_insert(Object *ob, const char *name, const bool from_mix)
3002 {       
3003         switch (ob->type) {
3004                 case OB_MESH:
3005                         return insert_meshkey(ob, name, from_mix);
3006                 case OB_CURVE:
3007                 case OB_SURF:
3008                         return insert_curvekey(ob, name, from_mix);
3009                 case OB_LATTICE:
3010                         return insert_lattkey(ob, name, from_mix);
3011                 default:
3012                         return NULL;
3013         }
3014
3015 }
3016
3017 bool BKE_object_shapekey_free(Main *bmain, Object *ob)
3018 {
3019         Key **key_p, *key;
3020
3021         key_p = BKE_key_from_object_p(ob);
3022         if (ELEM(NULL, key_p, *key_p)) {
3023                 return false;
3024         }
3025
3026         key = *key_p;
3027         *key_p = NULL;
3028
3029         BKE_libblock_free_us(bmain, key);
3030
3031         return false;
3032 }
3033
3034 bool BKE_object_shapekey_remove(Main *bmain, Object *ob, KeyBlock *kb)
3035 {
3036         KeyBlock *rkb;
3037         Key *key = BKE_key_from_object(ob);
3038         short kb_index;
3039
3040         if (key == NULL) {
3041                 return false;
3042         }
3043
3044         kb_index = BLI_findindex(&key->block, kb);
3045         BLI_assert(kb_index != -1);
3046
3047         for (rkb = key->block.first; rkb; rkb = rkb->next) {
3048                 if (rkb->relative == kb_index) {
3049                         /* remap to the 'Basis' */
3050                         rkb->relative = 0;
3051                 }
3052                 else if (rkb->relative >= kb_index) {
3053                         /* Fix positional shift of the keys when kb is deleted from the list */
3054                         rkb->relative -= 1;
3055                 }
3056         }
3057
3058         BLI_remlink(&key->block, kb);
3059         key->totkey--;
3060         if (key->refkey == kb) {
3061                 key->refkey = key->block.first;
3062
3063                 if (key->refkey) {
3064                         /* apply new basis key on original data */
3065                         switch (ob->type) {
3066                                 case OB_MESH:
3067                                         BKE_keyblock_convert_to_mesh(key->refkey, ob->data);
3068                                         break;
3069                                 case OB_CURVE:
3070                                 case OB_SURF:
3071                                         BKE_keyblock_convert_to_curve(key->refkey, ob->data, BKE_curve_nurbs_get(ob->data));
3072                                         break;
3073                                 case OB_LATTICE:
3074                                         BKE_keyblock_convert_to_lattice(key->refkey, ob->data);
3075                                         break;
3076                         }
3077                 }
3078         }
3079
3080         if (kb->data) {
3081                 MEM_freeN(kb->data);
3082         }
3083         MEM_freeN(kb);
3084
3085         if (ob->shapenr > 1) {
3086                 ob->shapenr--;
3087         }
3088
3089         if (key->totkey == 0) {
3090                 BKE_object_shapekey_free(bmain, ob);
3091         }
3092
3093         return true;
3094 }
3095
3096 bool BKE_object_flag_test_recursive(const Object *ob, short flag)
3097 {
3098         if (ob->flag & flag) {
3099                 return true;
3100         }
3101         else if (ob->parent) {
3102                 return BKE_object_flag_test_recursive(ob->parent, flag);
3103         }
3104         else {
3105                 return false;
3106         }
3107 }
3108
3109 bool BKE_object_is_child_recursive(Object *ob_parent, Object *ob_child)
3110 {
3111         for (ob_child = ob_child->parent; ob_child; ob_child = ob_child->parent) {
3112                 if (ob_child == ob_parent) {
3113                         return true;
3114                 }
3115         }
3116         return false;
3117 }
3118
3119 /* most important if this is modified it should _always_ return True, in certain
3120  * cases false positives are hard to avoid (shape keys for example) */
3121 int BKE_object_is_modified(Scene *scene, Object *ob)
3122 {
3123         int flag = 0;
3124
3125         if (BKE_key_from_object(ob)) {
3126                 flag |= eModifierMode_Render | eModifierMode_Realtime;
3127         }
3128         else {
3129                 ModifierData *md;
3130                 VirtualModifierData virtualModifierData;
3131                 /* cloth */
3132                 for (md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
3133                      md && (flag != (eModifierMode_Render | eModifierMode_Realtime));
3134                      md = md->next)
3135                 {
3136                         if ((flag & eModifierMode_Render) == 0 && modifier_isEnabled(scene, md, eModifierMode_Render))
3137                                 flag |= eModifierMode_Render;
3138
3139                         if ((flag & eModifierMode_Realtime) == 0 && modifier_isEnabled(scene, md, eModifierMode_Realtime))
3140                                 flag |= eModifierMode_Realtime;
3141                 }
3142         }
3143
3144         return flag;
3145 }
3146
3147 /* Check of objects moves in time. */
3148 /* NOTE: This function is currently optimized for usage in combination
3149  * with mti->canDeform, so modifiers can quickly check if their target
3150  * objects moves (causing deformation motion blur) or not.
3151  *
3152  * This makes it possible to give some degree of false-positives here,
3153  * but it's currently an acceptable tradeoff between complexity and check
3154  * speed. In combination with checks of modifier stack and real life usage
3155  * percentage of false-positives shouldn't be that hight.
3156  */
3157 static bool object_moves_in_time(Object *object)
3158 {
3159         AnimData *adt = object->adt;
3160         if (adt != NULL) {
3161                 /* If object has any sort of animation data assume it is moving. */
3162                 if (adt->action != NULL ||
3163                     !BLI_listbase_is_empty(&adt->nla_tracks) ||
3164                     !BLI_listbase_is_empty(&adt->drivers) ||
3165                     !BLI_listbase_is_empty(&adt->overrides))
3166                 {
3167                         return true;
3168                 }
3169         }
3170         if (!BLI_listbase_is_empty(&object->constraints)) {
3171                 return true;
3172         }
3173         if (object->parent != NULL) {
3174                 /* TODO(sergey): Do recursive check here? */
3175                 return true;
3176         }
3177         return false;
3178 }
3179
3180 static bool object_deforms_in_time(Object *object)
3181 {
3182         if (BKE_key_from_object(object) != NULL) {
3183                 return true;
3184         }
3185         if (!BLI_listbase_is_empty(&object->modifiers)) {
3186                 return true;
3187         }
3188         return object_moves_in_time(object);
3189 }
3190
3191 static bool constructive_modifier_is_deform_modified(ModifierData *md)
3192 {
3193         /* TODO(sergey): Consider generalizing this a bit so all modifier logic
3194          * is concentrated in MOD_{modifier}.c file,
3195          */
3196         if (md->type == eModifierType_Array) {
3197                 ArrayModifierData *amd = (ArrayModifierData *)md;
3198                 /* TODO(sergey): Check if curve is deformed. */
3199                 return (amd->start_cap != NULL && object_moves_in_time(amd->start_cap)) ||
3200                        (amd->end_cap != NULL && object_moves_in_time(amd->end_cap)) ||
3201                        (amd->curve_ob != NULL && object_moves_in_time(amd->curve_ob)) ||
3202                        (amd->offset_ob != NULL && object_moves_in_time(amd->offset_ob));
3203         }
3204         else if (md->type == eModifierType_Mirror) {
3205                 MirrorModifierData *mmd = (MirrorModifierData *)md;
3206                 return mmd->mirror_ob != NULL && object_moves_in_time(mmd->mirror_ob);
3207         }
3208         else if (md->type == eModifierType_Screw) {
3209                 ScrewModifierData *smd = (ScrewModifierData *)md;
3210                 return smd->ob_axis != NULL && object_moves_in_time(smd->ob_axis);
3211         }
3212         else if (md->type == eModifierType_MeshSequenceCache) {
3213                 /* NOTE: Not ideal because it's unknown whether topology changes or not.
3214                  * This will be detected later, so by assuming it's only deformation
3215                  * going on here we allow to bake deform-only mesh to Alembic and have
3216                  * proper motion blur after that.
3217                  */
3218                 return true;
3219         }
3220         return false;
3221 }
3222
3223 static bool modifiers_has_animation_check(Object *ob)
3224 {
3225         /* TODO(sergey): This is a bit code duplication with depsgraph, but
3226          * would be nicer to solve this as a part of new dependency graph
3227          * work, so we avoid conflicts and so.
3228          */
3229         if (ob->adt != NULL) {
3230                 AnimData *adt = ob->adt;
3231                 FCurve *fcu;
3232                 if (adt->action != NULL) {
3233                         for (fcu = adt->action->curves.first; fcu; fcu = fcu->next) {
3234                                 if (fcu->rna_path && strstr(fcu->rna_path, "modifiers[")) {
3235                                         return true;
3236                                 }
3237                         }
3238                 }
3239                 for (fcu = adt->drivers.first; fcu; fcu = fcu->next) {
3240                         if (fcu->rna_path && strstr(fcu->rna_path, "modifiers[")) {
3241                                 return true;
3242                         }
3243                 }
3244         }
3245         return false;
3246 }
3247
3248 /* test if object is affected by deforming modifiers (for motion blur). again
3249  * most important is to avoid false positives, this is to skip computations
3250  * and we can still if there was actual deformation afterwards */
3251 int BKE_object_is_deform_modified(Scene *scene, Object *ob)
3252 {
3253         ModifierData *md;
3254         VirtualModifierData virtualModifierData;
3255         int flag = 0;
3256         const bool is_modifier_animated = modifiers_has_animation_check(ob);