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