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