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