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