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