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