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