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