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