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