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