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