GPencil: Fix unreported unable to deselect when masking is OFF
[blender.git] / source / blender / editors / mesh / meshtools.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) 2004 by Blender Foundation
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup edmesh
22  *
23  * meshtools.c: no editmode (violated already :), mirror & join),
24  * tools operating on meshes
25  */
26
27 #include "MEM_guardedalloc.h"
28
29 #include "DNA_key_types.h"
30 #include "DNA_material_types.h"
31 #include "DNA_mesh_types.h"
32 #include "DNA_meshdata_types.h"
33 #include "DNA_modifier_types.h"
34 #include "DNA_object_types.h"
35 #include "DNA_scene_types.h"
36 #include "DNA_screen_types.h"
37 #include "DNA_view3d_types.h"
38 #include "DNA_workspace_types.h"
39
40 #include "BLI_math.h"
41 #include "BLI_blenlib.h"
42
43 #include "BKE_context.h"
44 #include "BKE_deform.h"
45 #include "BKE_editmesh.h"
46 #include "BKE_key.h"
47 #include "BKE_layer.h"
48 #include "BKE_library.h"
49 #include "BKE_main.h"
50 #include "BKE_material.h"
51 #include "BKE_mesh.h"
52 #include "BKE_mesh_iterators.h"
53 #include "BKE_mesh_runtime.h"
54 #include "BKE_multires.h"
55 #include "BKE_object.h"
56 #include "BKE_object_deform.h"
57 #include "BKE_report.h"
58
59 #include "DEG_depsgraph.h"
60 #include "DEG_depsgraph_build.h"
61 #include "DEG_depsgraph_query.h"
62
63 #include "DRW_select_buffer.h"
64
65 #include "ED_mesh.h"
66 #include "ED_object.h"
67 #include "ED_view3d.h"
68
69 #include "WM_api.h"
70 #include "WM_types.h"
71
72 /* * ********************** no editmode!!! *********** */
73
74 /*********************** JOIN ***************************/
75
76 /* join selected meshes into the active mesh, context sensitive
77  * return 0 if no join is made (error) and 1 if the join is done */
78
79 static void join_mesh_single(Depsgraph *depsgraph,
80                              Main *bmain,
81                              Scene *scene,
82                              Object *ob_dst,
83                              Object *ob_src,
84                              float imat[4][4],
85                              MVert **mvert_pp,
86                              MEdge **medge_pp,
87                              MLoop **mloop_pp,
88                              MPoly **mpoly_pp,
89                              CustomData *vdata,
90                              CustomData *edata,
91                              CustomData *ldata,
92                              CustomData *pdata,
93                              int totvert,
94                              int totedge,
95                              int totloop,
96                              int totpoly,
97                              Key *key,
98                              Key *nkey,
99                              Material **matar,
100                              int *matmap,
101                              int totcol,
102                              int *vertofs,
103                              int *edgeofs,
104                              int *loopofs,
105                              int *polyofs)
106 {
107   int a, b;
108
109   Mesh *me = ob_src->data;
110   MVert *mvert = *mvert_pp;
111   MEdge *medge = *medge_pp;
112   MLoop *mloop = *mloop_pp;
113   MPoly *mpoly = *mpoly_pp;
114
115   if (me->totvert) {
116     /* merge customdata flag */
117     ((Mesh *)ob_dst->data)->cd_flag |= me->cd_flag;
118
119     /* standard data */
120     CustomData_merge(&me->vdata, vdata, CD_MASK_MESH.vmask, CD_DEFAULT, totvert);
121     CustomData_copy_data_named(&me->vdata, vdata, 0, *vertofs, me->totvert);
122
123     /* vertex groups */
124     MDeformVert *dvert = CustomData_get(vdata, *vertofs, CD_MDEFORMVERT);
125     MDeformVert *dvert_src = CustomData_get(&me->vdata, 0, CD_MDEFORMVERT);
126
127     /* Remap to correct new vgroup indices, if needed. */
128     if (dvert_src) {
129       BLI_assert(dvert != NULL);
130
131       /* Build src to merged mapping of vgroup indices. */
132       int *vgroup_index_map;
133       int vgroup_index_map_len;
134       vgroup_index_map = BKE_object_defgroup_index_map_create(
135           ob_src, ob_dst, &vgroup_index_map_len);
136       BKE_object_defgroup_index_map_apply(
137           dvert, me->totvert, vgroup_index_map, vgroup_index_map_len);
138       if (vgroup_index_map != NULL) {
139         MEM_freeN(vgroup_index_map);
140       }
141     }
142
143     /* if this is the object we're merging into, no need to do anything */
144     if (ob_src != ob_dst) {
145       float cmat[4][4];
146
147       /* watch this: switch matmul order really goes wrong */
148       mul_m4_m4m4(cmat, imat, ob_src->obmat);
149
150       /* transform vertex coordinates into new space */
151       for (a = 0, mvert = *mvert_pp; a < me->totvert; a++, mvert++) {
152         mul_m4_v3(cmat, mvert->co);
153       }
154
155       /* For each shapekey in destination mesh:
156        * - if there's a matching one, copy it across
157        *   (will need to transform vertices into new space...).
158        * - otherwise, just copy own coordinates of mesh
159        *   (no need to transform vertex coordinates into new space).
160        */
161       if (key) {
162         /* if this mesh has any shapekeys, check first, otherwise just copy coordinates */
163         for (KeyBlock *kb = key->block.first; kb; kb = kb->next) {
164           /* get pointer to where to write data for this mesh in shapekey's data array */
165           float(*cos)[3] = ((float(*)[3])kb->data) + *vertofs;
166
167           /* check if this mesh has such a shapekey */
168           KeyBlock *okb = me->key ? BKE_keyblock_find_name(me->key, kb->name) : NULL;
169           if (okb) {
170             /* copy this mesh's shapekey to the destination shapekey
171              * (need to transform first) */
172             float(*ocos)[3] = okb->data;
173             for (a = 0; a < me->totvert; a++, cos++, ocos++) {
174               copy_v3_v3(*cos, *ocos);
175               mul_m4_v3(cmat, *cos);
176             }
177           }
178           else {
179             /* copy this mesh's vertex coordinates to the destination shapekey */
180             for (a = 0, mvert = *mvert_pp; a < me->totvert; a++, cos++, mvert++) {
181               copy_v3_v3(*cos, mvert->co);
182             }
183           }
184         }
185       }
186     }
187     else {
188       /* for each shapekey in destination mesh:
189        * - if it was an 'original', copy the appropriate data from nkey
190        * - otherwise, copy across plain coordinates (no need to transform coordinates)
191        */
192       if (key) {
193         for (KeyBlock *kb = key->block.first; kb; kb = kb->next) {
194           /* get pointer to where to write data for this mesh in shapekey's data array */
195           float(*cos)[3] = ((float(*)[3])kb->data) + *vertofs;
196
197           /* check if this was one of the original shapekeys */
198           KeyBlock *okb = nkey ? BKE_keyblock_find_name(nkey, kb->name) : NULL;
199           if (okb) {
200             /* copy this mesh's shapekey to the destination shapekey */
201             float(*ocos)[3] = okb->data;
202             for (a = 0; a < me->totvert; a++, cos++, ocos++) {
203               copy_v3_v3(*cos, *ocos);
204             }
205           }
206           else {
207             /* copy base-coordinates to the destination shapekey */
208             for (a = 0, mvert = *mvert_pp; a < me->totvert; a++, cos++, mvert++) {
209               copy_v3_v3(*cos, mvert->co);
210             }
211           }
212         }
213       }
214     }
215   }
216
217   if (me->totedge) {
218     CustomData_merge(&me->edata, edata, CD_MASK_MESH.emask, CD_DEFAULT, totedge);
219     CustomData_copy_data_named(&me->edata, edata, 0, *edgeofs, me->totedge);
220
221     for (a = 0; a < me->totedge; a++, medge++) {
222       medge->v1 += *vertofs;
223       medge->v2 += *vertofs;
224     }
225   }
226
227   if (me->totloop) {
228     if (ob_src != ob_dst) {
229       MultiresModifierData *mmd;
230
231       multiresModifier_prepare_join(depsgraph, scene, ob_src, ob_dst);
232
233       if ((mmd = get_multires_modifier(scene, ob_src, true))) {
234         ED_object_iter_other(
235             bmain, ob_src, true, ED_object_multires_update_totlevels_cb, &mmd->totlvl);
236       }
237     }
238
239     CustomData_merge(&me->ldata, ldata, CD_MASK_MESH.lmask, CD_DEFAULT, totloop);
240     CustomData_copy_data_named(&me->ldata, ldata, 0, *loopofs, me->totloop);
241
242     for (a = 0; a < me->totloop; a++, mloop++) {
243       mloop->v += *vertofs;
244       mloop->e += *edgeofs;
245     }
246   }
247
248   if (me->totpoly) {
249     if (matmap) {
250       /* make mapping for materials */
251       for (a = 1; a <= ob_src->totcol; a++) {
252         Material *ma = give_current_material(ob_src, a);
253
254         for (b = 0; b < totcol; b++) {
255           if (ma == matar[b]) {
256             matmap[a - 1] = b;
257             break;
258           }
259         }
260       }
261     }
262
263     CustomData_merge(&me->pdata, pdata, CD_MASK_MESH.pmask, CD_DEFAULT, totpoly);
264     CustomData_copy_data_named(&me->pdata, pdata, 0, *polyofs, me->totpoly);
265
266     for (a = 0; a < me->totpoly; a++, mpoly++) {
267       mpoly->loopstart += *loopofs;
268       mpoly->mat_nr = matmap ? matmap[mpoly->mat_nr] : 0;
269     }
270   }
271
272   /* these are used for relinking (cannot be set earlier, or else reattaching goes wrong) */
273   *vertofs += me->totvert;
274   *mvert_pp += me->totvert;
275   *edgeofs += me->totedge;
276   *medge_pp += me->totedge;
277   *loopofs += me->totloop;
278   *mloop_pp += me->totloop;
279   *polyofs += me->totpoly;
280   *mpoly_pp += me->totpoly;
281 }
282
283 int join_mesh_exec(bContext *C, wmOperator *op)
284 {
285   Main *bmain = CTX_data_main(C);
286   Scene *scene = CTX_data_scene(C);
287   Object *ob = CTX_data_active_object(C);
288   Material **matar = NULL, *ma;
289   Mesh *me;
290   MVert *mvert = NULL;
291   MEdge *medge = NULL;
292   MPoly *mpoly = NULL;
293   MLoop *mloop = NULL;
294   Key *key, *nkey = NULL;
295   KeyBlock *kb, *kbn;
296   float imat[4][4];
297   int a, b, totcol, totmat = 0, totedge = 0, totvert = 0;
298   int totloop = 0, totpoly = 0, vertofs, *matmap = NULL;
299   int i, haskey = 0, edgeofs, loopofs, polyofs;
300   bool ok = false;
301   bDeformGroup *dg, *odg;
302   CustomData vdata, edata, fdata, ldata, pdata;
303
304   if (ob->mode & OB_MODE_EDIT) {
305     BKE_report(op->reports, RPT_WARNING, "Cannot join while in edit mode");
306     return OPERATOR_CANCELLED;
307   }
308
309   /* ob is the object we are adding geometry to */
310   if (!ob || ob->type != OB_MESH) {
311     BKE_report(op->reports, RPT_WARNING, "Active object is not a mesh");
312     return OPERATOR_CANCELLED;
313   }
314
315   Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
316
317   /* count & check */
318   CTX_DATA_BEGIN (C, Object *, ob_iter, selected_editable_objects) {
319     if (ob_iter->type == OB_MESH) {
320       me = ob_iter->data;
321
322       totvert += me->totvert;
323       totedge += me->totedge;
324       totloop += me->totloop;
325       totpoly += me->totpoly;
326       totmat += ob_iter->totcol;
327
328       if (ob_iter == ob) {
329         ok = true;
330       }
331
332       /* check for shapekeys */
333       if (me->key) {
334         haskey++;
335       }
336     }
337   }
338   CTX_DATA_END;
339
340   /* that way the active object is always selected */
341   if (ok == false) {
342     BKE_report(op->reports, RPT_WARNING, "Active object is not a selected mesh");
343     return OPERATOR_CANCELLED;
344   }
345
346   /* Only join meshes if there are verts to join,
347    * there aren't too many, and we only had one mesh selected. */
348   me = (Mesh *)ob->data;
349   key = me->key;
350
351   if (totvert == 0 || totvert == me->totvert) {
352     BKE_report(op->reports, RPT_WARNING, "No mesh data to join");
353     return OPERATOR_CANCELLED;
354   }
355
356   if (totvert > MESH_MAX_VERTS) {
357     BKE_reportf(op->reports,
358                 RPT_WARNING,
359                 "Joining results in %d vertices, limit is %ld",
360                 totvert,
361                 MESH_MAX_VERTS);
362     return OPERATOR_CANCELLED;
363   }
364
365   /* remove tessface to ensure we don't hold references to invalid faces */
366   BKE_mesh_tessface_clear(me);
367
368   /* new material indices and material array */
369   if (totmat) {
370     matar = MEM_callocN(sizeof(*matar) * totmat, "join_mesh matar");
371     matmap = MEM_callocN(sizeof(*matmap) * totmat, "join_mesh matmap");
372   }
373   totcol = ob->totcol;
374
375   /* obact materials in new main array, is nicer start! */
376   for (a = 0; a < ob->totcol; a++) {
377     matar[a] = give_current_material(ob, a + 1);
378     id_us_plus((ID *)matar[a]);
379     /* increase id->us : will be lowered later */
380   }
381
382   /* - if destination mesh had shapekeys, move them somewhere safe, and set up placeholders
383    *   with arrays that are large enough to hold shapekey data for all meshes
384    * - if destination mesh didn't have shapekeys, but we encountered some in the meshes we're
385    *   joining, set up a new keyblock and assign to the mesh
386    */
387   if (key) {
388     /* make a duplicate copy that will only be used here... (must remember to free it!) */
389     nkey = BKE_key_copy(bmain, key);
390
391     /* for all keys in old block, clear data-arrays */
392     for (kb = key->block.first; kb; kb = kb->next) {
393       if (kb->data) {
394         MEM_freeN(kb->data);
395       }
396       kb->data = MEM_callocN(sizeof(float) * 3 * totvert, "join_shapekey");
397       kb->totelem = totvert;
398     }
399   }
400   else if (haskey) {
401     /* add a new key-block and add to the mesh */
402     key = me->key = BKE_key_add(bmain, (ID *)me);
403     key->type = KEY_RELATIVE;
404   }
405
406   /* first pass over objects - copying materials and vertexgroups across */
407   CTX_DATA_BEGIN (C, Object *, ob_iter, selected_editable_objects) {
408     /* only act if a mesh, and not the one we're joining to */
409     if ((ob != ob_iter) && (ob_iter->type == OB_MESH)) {
410       me = ob_iter->data;
411
412       /* Join this object's vertex groups to the base one's */
413       for (dg = ob_iter->defbase.first; dg; dg = dg->next) {
414         /* See if this group exists in the object (if it doesn't, add it to the end) */
415         if (!defgroup_find_name(ob, dg->name)) {
416           odg = MEM_callocN(sizeof(bDeformGroup), "join deformGroup");
417           memcpy(odg, dg, sizeof(bDeformGroup));
418           BLI_addtail(&ob->defbase, odg);
419         }
420       }
421       if (ob->defbase.first && ob->actdef == 0) {
422         ob->actdef = 1;
423       }
424
425       if (me->totvert) {
426         /* Add this object's materials to the base one's if they don't exist already
427          * (but only if limits not exceeded yet) */
428         if (totcol < MAXMAT) {
429           for (a = 1; a <= ob_iter->totcol; a++) {
430             ma = give_current_material(ob_iter, a);
431
432             for (b = 0; b < totcol; b++) {
433               if (ma == matar[b]) {
434                 break;
435               }
436             }
437             if (b == totcol) {
438               matar[b] = ma;
439               if (ma) {
440                 id_us_plus(&ma->id);
441               }
442               totcol++;
443             }
444             if (totcol >= MAXMAT) {
445               break;
446             }
447           }
448         }
449
450         /* if this mesh has shapekeys,
451          * check if destination mesh already has matching entries too */
452         if (me->key && key) {
453           /* for remapping KeyBlock.relative */
454           int *index_map = MEM_mallocN(sizeof(int) * me->key->totkey, __func__);
455           KeyBlock **kb_map = MEM_mallocN(sizeof(KeyBlock *) * me->key->totkey, __func__);
456
457           for (kb = me->key->block.first, i = 0; kb; kb = kb->next, i++) {
458             BLI_assert(i < me->key->totkey);
459
460             kbn = BKE_keyblock_find_name(key, kb->name);
461             /* if key doesn't exist in destination mesh, add it */
462             if (kbn) {
463               index_map[i] = BLI_findindex(&key->block, kbn);
464             }
465             else {
466               index_map[i] = key->totkey;
467
468               kbn = BKE_keyblock_add(key, kb->name);
469
470               BKE_keyblock_copy_settings(kbn, kb);
471
472               /* adjust settings to fit (allocate a new data-array) */
473               kbn->data = MEM_callocN(sizeof(float) * 3 * totvert, "joined_shapekey");
474               kbn->totelem = totvert;
475             }
476
477             kb_map[i] = kbn;
478           }
479
480           /* remap relative index values */
481           for (kb = me->key->block.first, i = 0; kb; kb = kb->next, i++) {
482             /* sanity check, should always be true */
483             if (LIKELY(kb->relative < me->key->totkey)) {
484               kb_map[i]->relative = index_map[kb->relative];
485             }
486           }
487
488           MEM_freeN(index_map);
489           MEM_freeN(kb_map);
490         }
491       }
492     }
493   }
494   CTX_DATA_END;
495
496   /* setup new data for destination mesh */
497   CustomData_reset(&vdata);
498   CustomData_reset(&edata);
499   CustomData_reset(&fdata);
500   CustomData_reset(&ldata);
501   CustomData_reset(&pdata);
502
503   mvert = CustomData_add_layer(&vdata, CD_MVERT, CD_CALLOC, NULL, totvert);
504   medge = CustomData_add_layer(&edata, CD_MEDGE, CD_CALLOC, NULL, totedge);
505   mloop = CustomData_add_layer(&ldata, CD_MLOOP, CD_CALLOC, NULL, totloop);
506   mpoly = CustomData_add_layer(&pdata, CD_MPOLY, CD_CALLOC, NULL, totpoly);
507
508   vertofs = 0;
509   edgeofs = 0;
510   loopofs = 0;
511   polyofs = 0;
512
513   /* inverse transform for all selected meshes in this object */
514   invert_m4_m4(imat, ob->obmat);
515
516   /* Add back active mesh first.
517    * This allows to keep things similar as they were, as much as possible
518    * (i.e. data from active mesh will remain first ones in new result of the merge,
519    * in same order for CD layers, etc). See also T50084.
520    */
521   join_mesh_single(depsgraph,
522                    bmain,
523                    scene,
524                    ob,
525                    ob,
526                    imat,
527                    &mvert,
528                    &medge,
529                    &mloop,
530                    &mpoly,
531                    &vdata,
532                    &edata,
533                    &ldata,
534                    &pdata,
535                    totvert,
536                    totedge,
537                    totloop,
538                    totpoly,
539                    key,
540                    nkey,
541                    matar,
542                    matmap,
543                    totcol,
544                    &vertofs,
545                    &edgeofs,
546                    &loopofs,
547                    &polyofs);
548
549   CTX_DATA_BEGIN (C, Object *, ob_iter, selected_editable_objects) {
550     if (ob_iter == ob) {
551       continue;
552     }
553     /* only join if this is a mesh */
554     if (ob_iter->type == OB_MESH) {
555       join_mesh_single(depsgraph,
556                        bmain,
557                        scene,
558                        ob,
559                        ob_iter,
560                        imat,
561                        &mvert,
562                        &medge,
563                        &mloop,
564                        &mpoly,
565                        &vdata,
566                        &edata,
567                        &ldata,
568                        &pdata,
569                        totvert,
570                        totedge,
571                        totloop,
572                        totpoly,
573                        key,
574                        nkey,
575                        matar,
576                        matmap,
577                        totcol,
578                        &vertofs,
579                        &edgeofs,
580                        &loopofs,
581                        &polyofs);
582
583       /* free base, now that data is merged */
584       if (ob_iter != ob) {
585         ED_object_base_free_and_unlink(bmain, scene, ob_iter);
586       }
587     }
588   }
589   CTX_DATA_END;
590
591   /* return to mesh we're merging to */
592   me = ob->data;
593
594   CustomData_free(&me->vdata, me->totvert);
595   CustomData_free(&me->edata, me->totedge);
596   CustomData_free(&me->ldata, me->totloop);
597   CustomData_free(&me->pdata, me->totpoly);
598
599   me->totvert = totvert;
600   me->totedge = totedge;
601   me->totloop = totloop;
602   me->totpoly = totpoly;
603
604   me->vdata = vdata;
605   me->edata = edata;
606   me->ldata = ldata;
607   me->pdata = pdata;
608
609   /* tessface data removed above, no need to update */
610   BKE_mesh_update_customdata_pointers(me, false);
611
612   /* update normals in case objects with non-uniform scale are joined */
613   BKE_mesh_calc_normals(me);
614
615   /* old material array */
616   for (a = 1; a <= ob->totcol; a++) {
617     ma = ob->mat[a - 1];
618     if (ma) {
619       id_us_min(&ma->id);
620     }
621   }
622   for (a = 1; a <= me->totcol; a++) {
623     ma = me->mat[a - 1];
624     if (ma) {
625       id_us_min(&ma->id);
626     }
627   }
628   MEM_SAFE_FREE(ob->mat);
629   MEM_SAFE_FREE(ob->matbits);
630   MEM_SAFE_FREE(me->mat);
631
632   if (totcol) {
633     me->mat = matar;
634     ob->mat = MEM_callocN(sizeof(*ob->mat) * totcol, "join obmatar");
635     ob->matbits = MEM_callocN(sizeof(*ob->matbits) * totcol, "join obmatbits");
636     MEM_freeN(matmap);
637   }
638
639   ob->totcol = me->totcol = totcol;
640
641   /* other mesh users */
642   test_all_objects_materials(bmain, (ID *)me);
643
644   /* free temp copy of destination shapekeys (if applicable) */
645   if (nkey) {
646     /* We can assume nobody is using that ID currently. */
647     BKE_id_free_ex(bmain, nkey, LIB_ID_FREE_NO_UI_USER, false);
648   }
649
650   /* ensure newly inserted keys are time sorted */
651   if (key && (key->type != KEY_RELATIVE)) {
652     BKE_key_sort(key);
653   }
654
655   /* Due to dependnecy cycle some other object might access old derived data. */
656   BKE_object_free_derived_caches(ob);
657
658   DEG_relations_tag_update(bmain); /* removed objects, need to rebuild dag */
659
660   DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
661
662   DEG_id_tag_update(&scene->id, ID_RECALC_SELECT);
663   WM_event_add_notifier(C, NC_SCENE | ND_OB_ACTIVE, scene);
664
665   return OPERATOR_FINISHED;
666 }
667
668 /*********************** JOIN AS SHAPES ***************************/
669
670 /* Append selected meshes vertex locations as shapes of the active mesh,
671  * return 0 if no join is made (error) and 1 of the join is done */
672
673 int join_mesh_shapes_exec(bContext *C, wmOperator *op)
674 {
675   Main *bmain = CTX_data_main(C);
676   Scene *scene = CTX_data_scene(C);
677   Object *ob_active = CTX_data_active_object(C);
678   Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
679   Mesh *me = (Mesh *)ob_active->data;
680   Mesh *selme = NULL;
681   Mesh *me_deformed = NULL;
682   Key *key = me->key;
683   KeyBlock *kb;
684   bool ok = false, nonequal_verts = false;
685
686   CTX_DATA_BEGIN (C, Object *, ob_iter, selected_editable_objects) {
687     if (ob_iter == ob_active) {
688       continue;
689     }
690
691     if (ob_iter->type == OB_MESH) {
692       selme = (Mesh *)ob_iter->data;
693
694       if (selme->totvert == me->totvert) {
695         ok = true;
696       }
697       else {
698         nonequal_verts = 1;
699       }
700     }
701   }
702   CTX_DATA_END;
703
704   if (!ok) {
705     if (nonequal_verts) {
706       BKE_report(op->reports, RPT_WARNING, "Selected meshes must have equal numbers of vertices");
707     }
708     else {
709       BKE_report(op->reports,
710                  RPT_WARNING,
711                  "No additional selected meshes with equal vertex count to join");
712     }
713     return OPERATOR_CANCELLED;
714   }
715
716   if (key == NULL) {
717     key = me->key = BKE_key_add(bmain, (ID *)me);
718     key->type = KEY_RELATIVE;
719
720     /* first key added, so it was the basis. initialize it with the existing mesh */
721     kb = BKE_keyblock_add(key, NULL);
722     BKE_keyblock_convert_from_mesh(me, key, kb);
723   }
724
725   /* now ready to add new keys from selected meshes */
726   CTX_DATA_BEGIN (C, Object *, ob_iter, selected_editable_objects) {
727     if (ob_iter == ob_active) {
728       continue;
729     }
730
731     if (ob_iter->type == OB_MESH) {
732       selme = (Mesh *)ob_iter->data;
733
734       if (selme->totvert == me->totvert) {
735         Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
736         Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob_iter);
737
738         me_deformed = mesh_get_eval_deform(depsgraph, scene_eval, ob_eval, &CD_MASK_BAREMESH);
739
740         if (!me_deformed) {
741           continue;
742         }
743
744         kb = BKE_keyblock_add(key, ob_iter->id.name + 2);
745
746         BKE_mesh_runtime_eval_to_meshkey(me_deformed, me, kb);
747       }
748     }
749   }
750   CTX_DATA_END;
751
752   DEG_id_tag_update(&scene->id, ID_RECALC_SELECT);
753   WM_event_add_notifier(C, NC_SCENE | ND_OB_ACTIVE, scene);
754
755   return OPERATOR_FINISHED;
756 }
757
758 /* -------------------------------------------------------------------- */
759 /* Mesh Mirror (Topology) */
760
761 /** \name Mesh Topology Mirror API
762  * \{ */
763
764 static MirrTopoStore_t mesh_topo_store = {NULL, -1. - 1, -1};
765
766 /** mode is 's' start, or 'e' end, or 'u' use
767  * if end, ob can be NULL.
768  * \note, is supposed return -1 on error,
769  * which callers are currently checking for, but is not used so far. */
770 int ED_mesh_mirror_topo_table(Object *ob, Mesh *me_eval, char mode)
771 {
772   if (mode == 'u') { /* use table */
773     if (ED_mesh_mirrtopo_recalc_check(ob->data, me_eval, &mesh_topo_store)) {
774       ED_mesh_mirror_topo_table(ob, me_eval, 's');
775     }
776   }
777   else if (mode == 's') { /* start table */
778     ED_mesh_mirrtopo_init(ob->data, me_eval, &mesh_topo_store, false);
779   }
780   else if (mode == 'e') { /* end table */
781     ED_mesh_mirrtopo_free(&mesh_topo_store);
782   }
783   else {
784     BLI_assert(0);
785   }
786
787   return 0;
788 }
789
790 /** \} */
791
792 static int mesh_get_x_mirror_vert_spatial(Object *ob, Mesh *mesh, int index)
793 {
794   Mesh *me = ob->data;
795   MVert *mvert = mesh ? mesh->mvert : me->mvert;
796   float vec[3];
797
798   mvert = &mvert[index];
799   vec[0] = -mvert->co[0];
800   vec[1] = mvert->co[1];
801   vec[2] = mvert->co[2];
802
803   return ED_mesh_mirror_spatial_table(ob, NULL, mesh, vec, 'u');
804 }
805
806 static int mesh_get_x_mirror_vert_topo(Object *ob, Mesh *mesh, int index)
807 {
808   if (ED_mesh_mirror_topo_table(ob, mesh, 'u') == -1) {
809     return -1;
810   }
811
812   return mesh_topo_store.index_lookup[index];
813 }
814
815 int mesh_get_x_mirror_vert(Object *ob, Mesh *me_eval, int index, const bool use_topology)
816 {
817   if (use_topology) {
818     return mesh_get_x_mirror_vert_topo(ob, me_eval, index);
819   }
820   else {
821     return mesh_get_x_mirror_vert_spatial(ob, me_eval, index);
822   }
823 }
824
825 static BMVert *editbmesh_get_x_mirror_vert_spatial(Object *ob, BMEditMesh *em, const float co[3])
826 {
827   float vec[3];
828   int i;
829
830   /* ignore nan verts */
831   if ((isfinite(co[0]) == false) || (isfinite(co[1]) == false) || (isfinite(co[2]) == false)) {
832     return NULL;
833   }
834
835   vec[0] = -co[0];
836   vec[1] = co[1];
837   vec[2] = co[2];
838
839   i = ED_mesh_mirror_spatial_table(ob, em, NULL, vec, 'u');
840   if (i != -1) {
841     return BM_vert_at_index(em->bm, i);
842   }
843   return NULL;
844 }
845
846 static BMVert *editbmesh_get_x_mirror_vert_topo(Object *ob,
847                                                 struct BMEditMesh *em,
848                                                 BMVert *eve,
849                                                 int index)
850 {
851   intptr_t poinval;
852   if (ED_mesh_mirror_topo_table(ob, NULL, 'u') == -1) {
853     return NULL;
854   }
855
856   if (index == -1) {
857     BMIter iter;
858     BMVert *v;
859
860     index = 0;
861     BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
862       if (v == eve) {
863         break;
864       }
865       index++;
866     }
867
868     if (index == em->bm->totvert) {
869       return NULL;
870     }
871   }
872
873   poinval = mesh_topo_store.index_lookup[index];
874
875   if (poinval != -1) {
876     return (BMVert *)(poinval);
877   }
878   return NULL;
879 }
880
881 BMVert *editbmesh_get_x_mirror_vert(Object *ob,
882                                     struct BMEditMesh *em,
883                                     BMVert *eve,
884                                     const float co[3],
885                                     int index,
886                                     const bool use_topology)
887 {
888   if (use_topology) {
889     return editbmesh_get_x_mirror_vert_topo(ob, em, eve, index);
890   }
891   else {
892     return editbmesh_get_x_mirror_vert_spatial(ob, em, co);
893   }
894 }
895
896 /**
897  * Wrapper for objectmode/editmode.
898  *
899  * call #BM_mesh_elem_table_ensure first for editmesh.
900  */
901 int ED_mesh_mirror_get_vert(Object *ob, int index)
902 {
903   Mesh *me = ob->data;
904   BMEditMesh *em = me->edit_mesh;
905   bool use_topology = (me->editflag & ME_EDIT_MIRROR_TOPO) != 0;
906   int index_mirr;
907
908   if (em) {
909     BMVert *eve, *eve_mirr;
910     eve = BM_vert_at_index(em->bm, index);
911     eve_mirr = editbmesh_get_x_mirror_vert(ob, em, eve, eve->co, index, use_topology);
912     index_mirr = eve_mirr ? BM_elem_index_get(eve_mirr) : -1;
913   }
914   else {
915     index_mirr = mesh_get_x_mirror_vert(ob, NULL, index, use_topology);
916   }
917
918   return index_mirr;
919 }
920
921 #if 0
922
923 static float *editmesh_get_mirror_uv(
924     BMEditMesh *em, int axis, float *uv, float *mirrCent, float *face_cent)
925 {
926   float vec[2];
927   float cent_vec[2];
928   float cent[2];
929
930   /* ignore nan verts */
931   if (isnan(uv[0]) || !isfinite(uv[0]) || isnan(uv[1]) || !isfinite(uv[1])) {
932     return NULL;
933   }
934
935   if (axis) {
936     vec[0] = uv[0];
937     vec[1] = -((uv[1]) - mirrCent[1]) + mirrCent[1];
938
939     cent_vec[0] = face_cent[0];
940     cent_vec[1] = -((face_cent[1]) - mirrCent[1]) + mirrCent[1];
941   }
942   else {
943     vec[0] = -((uv[0]) - mirrCent[0]) + mirrCent[0];
944     vec[1] = uv[1];
945
946     cent_vec[0] = -((face_cent[0]) - mirrCent[0]) + mirrCent[0];
947     cent_vec[1] = face_cent[1];
948   }
949
950   /* TODO - Optimize */
951   {
952     BMIter iter;
953     BMFace *efa;
954
955     BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
956       uv_poly_center(efa, cent, cd_loop_uv_offset);
957
958       if ((fabsf(cent[0] - cent_vec[0]) < 0.001f) && (fabsf(cent[1] - cent_vec[1]) < 0.001f)) {
959         BMIter liter;
960         BMLoop *l;
961
962         BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
963           MLoopUV *luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
964           if ((fabsf(luv->uv[0] - vec[0]) < 0.001f) && (fabsf(luv->uv[1] - vec[1]) < 0.001f)) {
965             return luv->uv;
966           }
967         }
968       }
969     }
970   }
971
972   return NULL;
973 }
974
975 #endif
976
977 static unsigned int mirror_facehash(const void *ptr)
978 {
979   const MFace *mf = ptr;
980   unsigned int v0, v1;
981
982   if (mf->v4) {
983     v0 = MIN4(mf->v1, mf->v2, mf->v3, mf->v4);
984     v1 = MAX4(mf->v1, mf->v2, mf->v3, mf->v4);
985   }
986   else {
987     v0 = MIN3(mf->v1, mf->v2, mf->v3);
988     v1 = MAX3(mf->v1, mf->v2, mf->v3);
989   }
990
991   return ((v0 * 39) ^ (v1 * 31));
992 }
993
994 static int mirror_facerotation(MFace *a, MFace *b)
995 {
996   if (b->v4) {
997     if (a->v1 == b->v1 && a->v2 == b->v2 && a->v3 == b->v3 && a->v4 == b->v4) {
998       return 0;
999     }
1000     else if (a->v4 == b->v1 && a->v1 == b->v2 && a->v2 == b->v3 && a->v3 == b->v4) {
1001       return 1;
1002     }
1003     else if (a->v3 == b->v1 && a->v4 == b->v2 && a->v1 == b->v3 && a->v2 == b->v4) {
1004       return 2;
1005     }
1006     else if (a->v2 == b->v1 && a->v3 == b->v2 && a->v4 == b->v3 && a->v1 == b->v4) {
1007       return 3;
1008     }
1009   }
1010   else {
1011     if (a->v1 == b->v1 && a->v2 == b->v2 && a->v3 == b->v3) {
1012       return 0;
1013     }
1014     else if (a->v3 == b->v1 && a->v1 == b->v2 && a->v2 == b->v3) {
1015       return 1;
1016     }
1017     else if (a->v2 == b->v1 && a->v3 == b->v2 && a->v1 == b->v3) {
1018       return 2;
1019     }
1020   }
1021
1022   return -1;
1023 }
1024
1025 static bool mirror_facecmp(const void *a, const void *b)
1026 {
1027   return (mirror_facerotation((MFace *)a, (MFace *)b) == -1);
1028 }
1029
1030 /* This is a Mesh-based copy of mesh_get_x_mirror_faces() */
1031 int *mesh_get_x_mirror_faces(Object *ob, BMEditMesh *em, Mesh *me_eval)
1032 {
1033   Mesh *me = ob->data;
1034   MVert *mv, *mvert;
1035   MFace mirrormf, *mf, *hashmf, *mface;
1036   GHash *fhash;
1037   int *mirrorverts, *mirrorfaces;
1038
1039   BLI_assert(em == NULL); /* Does not work otherwise, currently... */
1040
1041   const bool use_topology = (me->editflag & ME_EDIT_MIRROR_TOPO) != 0;
1042   const int totvert = me_eval ? me_eval->totvert : me->totvert;
1043   const int totface = me_eval ? me_eval->totface : me->totface;
1044   int a;
1045
1046   mirrorverts = MEM_callocN(sizeof(int) * totvert, "MirrorVerts");
1047   mirrorfaces = MEM_callocN(sizeof(int) * 2 * totface, "MirrorFaces");
1048
1049   mvert = me_eval ? me_eval->mvert : me->mvert;
1050   mface = me_eval ? me_eval->mface : me->mface;
1051
1052   ED_mesh_mirror_spatial_table(ob, em, me_eval, NULL, 's');
1053
1054   for (a = 0, mv = mvert; a < totvert; a++, mv++) {
1055     mirrorverts[a] = mesh_get_x_mirror_vert(ob, me_eval, a, use_topology);
1056   }
1057
1058   ED_mesh_mirror_spatial_table(ob, em, me_eval, NULL, 'e');
1059
1060   fhash = BLI_ghash_new_ex(mirror_facehash, mirror_facecmp, "mirror_facehash gh", me->totface);
1061   for (a = 0, mf = mface; a < totface; a++, mf++) {
1062     BLI_ghash_insert(fhash, mf, mf);
1063   }
1064
1065   for (a = 0, mf = mface; a < totface; a++, mf++) {
1066     mirrormf.v1 = mirrorverts[mf->v3];
1067     mirrormf.v2 = mirrorverts[mf->v2];
1068     mirrormf.v3 = mirrorverts[mf->v1];
1069     mirrormf.v4 = (mf->v4) ? mirrorverts[mf->v4] : 0;
1070
1071     /* make sure v4 is not 0 if a quad */
1072     if (mf->v4 && mirrormf.v4 == 0) {
1073       SWAP(unsigned int, mirrormf.v1, mirrormf.v3);
1074       SWAP(unsigned int, mirrormf.v2, mirrormf.v4);
1075     }
1076
1077     hashmf = BLI_ghash_lookup(fhash, &mirrormf);
1078     if (hashmf) {
1079       mirrorfaces[a * 2] = hashmf - mface;
1080       mirrorfaces[a * 2 + 1] = mirror_facerotation(&mirrormf, hashmf);
1081     }
1082     else {
1083       mirrorfaces[a * 2] = -1;
1084     }
1085   }
1086
1087   BLI_ghash_free(fhash, NULL, NULL);
1088   MEM_freeN(mirrorverts);
1089
1090   return mirrorfaces;
1091 }
1092
1093 /* selection, vertex and face */
1094 /* returns 0 if not found, otherwise 1 */
1095
1096 /**
1097  * Face selection in object mode,
1098  * currently only weight-paint and vertex-paint use this.
1099  *
1100  * \return boolean true == Found
1101  */
1102 bool ED_mesh_pick_face(bContext *C, Object *ob, const int mval[2], uint dist_px, uint *r_index)
1103 {
1104   ViewContext vc;
1105   Mesh *me = ob->data;
1106
1107   BLI_assert(me && GS(me->id.name) == ID_ME);
1108
1109   if (!me || me->totpoly == 0) {
1110     return false;
1111   }
1112
1113   ED_view3d_viewcontext_init(C, &vc);
1114   ED_view3d_select_id_validate(&vc);
1115
1116   if (dist_px) {
1117     /* sample rect to increase chances of selecting, so that when clicking
1118      * on an edge in the backbuf, we can still select a face */
1119     *r_index = DRW_select_buffer_find_nearest_to_point(
1120         vc.depsgraph, vc.ar, vc.v3d, mval, 1, me->totpoly + 1, &dist_px);
1121   }
1122   else {
1123     /* sample only on the exact position */
1124     *r_index = DRW_select_buffer_sample_point(vc.depsgraph, vc.ar, vc.v3d, mval);
1125   }
1126
1127   if ((*r_index) == 0 || (*r_index) > (unsigned int)me->totpoly) {
1128     return false;
1129   }
1130
1131   (*r_index)--;
1132
1133   return true;
1134 }
1135
1136 static void ed_mesh_pick_face_vert__mpoly_find(
1137     /* context */
1138     struct ARegion *ar,
1139     const float mval[2],
1140     /* mesh data (evaluated) */
1141     const MPoly *mp,
1142     const MVert *mvert,
1143     const MLoop *mloop,
1144     /* return values */
1145     float *r_len_best,
1146     int *r_v_idx_best)
1147 {
1148   const MLoop *ml;
1149   int j = mp->totloop;
1150   for (ml = &mloop[mp->loopstart]; j--; ml++) {
1151     float sco[2];
1152     const int v_idx = ml->v;
1153     const float *co = mvert[v_idx].co;
1154     if (ED_view3d_project_float_object(ar, co, sco, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK) {
1155       const float len_test = len_manhattan_v2v2(mval, sco);
1156       if (len_test < *r_len_best) {
1157         *r_len_best = len_test;
1158         *r_v_idx_best = v_idx;
1159       }
1160     }
1161   }
1162 }
1163 /**
1164  * Use when the back buffer stores face index values. but we want a vert.
1165  * This gets the face then finds the closest vertex to mval.
1166  */
1167 bool ED_mesh_pick_face_vert(
1168     bContext *C, Object *ob, const int mval[2], uint dist_px, uint *r_index)
1169 {
1170   Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
1171   unsigned int poly_index;
1172   Mesh *me = ob->data;
1173
1174   BLI_assert(me && GS(me->id.name) == ID_ME);
1175
1176   if (ED_mesh_pick_face(C, ob, mval, dist_px, &poly_index)) {
1177     Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
1178     Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
1179     struct ARegion *ar = CTX_wm_region(C);
1180
1181     /* derived mesh to find deformed locations */
1182     Mesh *me_eval = mesh_get_eval_final(
1183         depsgraph, scene_eval, ob_eval, &CD_MASK_BAREMESH_ORIGINDEX);
1184
1185     int v_idx_best = ORIGINDEX_NONE;
1186
1187     /* find the vert closest to 'mval' */
1188     const float mval_f[2] = {UNPACK2(mval)};
1189     float len_best = FLT_MAX;
1190
1191     MPoly *me_eval_mpoly;
1192     MLoop *me_eval_mloop;
1193     MVert *me_eval_mvert;
1194     unsigned int me_eval_mpoly_len;
1195     const int *index_mp_to_orig;
1196
1197     me_eval_mpoly = me_eval->mpoly;
1198     me_eval_mloop = me_eval->mloop;
1199     me_eval_mvert = me_eval->mvert;
1200
1201     me_eval_mpoly_len = me_eval->totpoly;
1202
1203     index_mp_to_orig = CustomData_get_layer(&me_eval->pdata, CD_ORIGINDEX);
1204
1205     /* tag all verts using this face */
1206     if (index_mp_to_orig) {
1207       unsigned int i;
1208
1209       for (i = 0; i < me_eval_mpoly_len; i++) {
1210         if (index_mp_to_orig[i] == poly_index) {
1211           ed_mesh_pick_face_vert__mpoly_find(
1212               ar, mval_f, &me_eval_mpoly[i], me_eval_mvert, me_eval_mloop, &len_best, &v_idx_best);
1213         }
1214       }
1215     }
1216     else {
1217       if (poly_index < me_eval_mpoly_len) {
1218         ed_mesh_pick_face_vert__mpoly_find(ar,
1219                                            mval_f,
1220                                            &me_eval_mpoly[poly_index],
1221                                            me_eval_mvert,
1222                                            me_eval_mloop,
1223                                            &len_best,
1224                                            &v_idx_best);
1225       }
1226     }
1227
1228     /* map 'dm -> me' r_index if possible */
1229     if (v_idx_best != ORIGINDEX_NONE) {
1230       const int *index_mv_to_orig;
1231       index_mv_to_orig = CustomData_get_layer(&me_eval->vdata, CD_ORIGINDEX);
1232       if (index_mv_to_orig) {
1233         v_idx_best = index_mv_to_orig[v_idx_best];
1234       }
1235     }
1236
1237     if ((v_idx_best != ORIGINDEX_NONE) && (v_idx_best < me->totvert)) {
1238       *r_index = v_idx_best;
1239       return true;
1240     }
1241   }
1242
1243   return false;
1244 }
1245
1246 /**
1247  * Vertex selection in object mode,
1248  * currently only weight paint uses this.
1249  *
1250  * \return boolean true == Found
1251  */
1252 typedef struct VertPickData {
1253   const MVert *mvert;
1254   const float *mval_f; /* [2] */
1255   ARegion *ar;
1256
1257   /* runtime */
1258   float len_best;
1259   int v_idx_best;
1260 } VertPickData;
1261
1262 static void ed_mesh_pick_vert__mapFunc(void *userData,
1263                                        int index,
1264                                        const float co[3],
1265                                        const float UNUSED(no_f[3]),
1266                                        const short UNUSED(no_s[3]))
1267 {
1268   VertPickData *data = userData;
1269   if ((data->mvert[index].flag & ME_HIDE) == 0) {
1270     float sco[2];
1271
1272     if (ED_view3d_project_float_object(data->ar, co, sco, V3D_PROJ_TEST_CLIP_DEFAULT) ==
1273         V3D_PROJ_RET_OK) {
1274       const float len = len_manhattan_v2v2(data->mval_f, sco);
1275       if (len < data->len_best) {
1276         data->len_best = len;
1277         data->v_idx_best = index;
1278       }
1279     }
1280   }
1281 }
1282 bool ED_mesh_pick_vert(
1283     bContext *C, Object *ob, const int mval[2], uint dist_px, bool use_zbuf, uint *r_index)
1284 {
1285   ViewContext vc;
1286   Mesh *me = ob->data;
1287
1288   BLI_assert(me && GS(me->id.name) == ID_ME);
1289
1290   if (!me || me->totvert == 0) {
1291     return false;
1292   }
1293
1294   ED_view3d_viewcontext_init(C, &vc);
1295   ED_view3d_select_id_validate(&vc);
1296
1297   if (use_zbuf) {
1298     if (dist_px > 0) {
1299       /* sample rect to increase chances of selecting, so that when clicking
1300        * on an face in the backbuf, we can still select a vert */
1301       *r_index = DRW_select_buffer_find_nearest_to_point(
1302           vc.depsgraph, vc.ar, vc.v3d, mval, 1, me->totvert + 1, &dist_px);
1303     }
1304     else {
1305       /* sample only on the exact position */
1306       *r_index = DRW_select_buffer_sample_point(vc.depsgraph, vc.ar, vc.v3d, mval);
1307     }
1308
1309     if ((*r_index) == 0 || (*r_index) > (uint)me->totvert) {
1310       return false;
1311     }
1312
1313     (*r_index)--;
1314   }
1315   else {
1316     Scene *scene_eval = DEG_get_evaluated_scene(vc.depsgraph);
1317     Object *ob_eval = DEG_get_evaluated_object(vc.depsgraph, ob);
1318
1319     /* derived mesh to find deformed locations */
1320     Mesh *me_eval = mesh_get_eval_final(vc.depsgraph, scene_eval, ob_eval, &CD_MASK_BAREMESH);
1321     ARegion *ar = vc.ar;
1322     RegionView3D *rv3d = ar->regiondata;
1323
1324     /* find the vert closest to 'mval' */
1325     const float mval_f[2] = {(float)mval[0], (float)mval[1]};
1326
1327     VertPickData data = {NULL};
1328
1329     ED_view3d_init_mats_rv3d(ob, rv3d);
1330
1331     if (me_eval == NULL) {
1332       return false;
1333     }
1334
1335     /* setup data */
1336     data.mvert = me->mvert;
1337     data.ar = ar;
1338     data.mval_f = mval_f;
1339     data.len_best = FLT_MAX;
1340     data.v_idx_best = -1;
1341
1342     BKE_mesh_foreach_mapped_vert(me_eval, ed_mesh_pick_vert__mapFunc, &data, MESH_FOREACH_NOP);
1343
1344     if (data.v_idx_best == -1) {
1345       return false;
1346     }
1347
1348     *r_index = data.v_idx_best;
1349   }
1350
1351   return true;
1352 }
1353
1354 MDeformVert *ED_mesh_active_dvert_get_em(Object *ob, BMVert **r_eve)
1355 {
1356   if (ob->mode & OB_MODE_EDIT && ob->type == OB_MESH && ob->defbase.first) {
1357     Mesh *me = ob->data;
1358     BMesh *bm = me->edit_mesh->bm;
1359     const int cd_dvert_offset = CustomData_get_offset(&bm->vdata, CD_MDEFORMVERT);
1360
1361     if (cd_dvert_offset != -1) {
1362       BMVert *eve = BM_mesh_active_vert_get(bm);
1363
1364       if (eve) {
1365         if (r_eve) {
1366           *r_eve = eve;
1367         }
1368         return BM_ELEM_CD_GET_VOID_P(eve, cd_dvert_offset);
1369       }
1370     }
1371   }
1372
1373   if (r_eve) {
1374     *r_eve = NULL;
1375   }
1376   return NULL;
1377 }
1378
1379 MDeformVert *ED_mesh_active_dvert_get_ob(Object *ob, int *r_index)
1380 {
1381   Mesh *me = ob->data;
1382   int index = BKE_mesh_mselect_active_get(me, ME_VSEL);
1383   if (r_index) {
1384     *r_index = index;
1385   }
1386   if (index == -1 || me->dvert == NULL) {
1387     return NULL;
1388   }
1389   else {
1390     return me->dvert + index;
1391   }
1392 }
1393
1394 MDeformVert *ED_mesh_active_dvert_get_only(Object *ob)
1395 {
1396   if (ob->type == OB_MESH) {
1397     if (ob->mode & OB_MODE_EDIT) {
1398       return ED_mesh_active_dvert_get_em(ob, NULL);
1399     }
1400     else {
1401       return ED_mesh_active_dvert_get_ob(ob, NULL);
1402     }
1403   }
1404   else {
1405     return NULL;
1406   }
1407 }
1408
1409 void EDBM_mesh_stats_multi(struct Object **objects,
1410                            const uint objects_len,
1411                            int totelem[3],
1412                            int totelem_sel[3])
1413 {
1414   if (totelem) {
1415     totelem[0] = 0;
1416     totelem[1] = 0;
1417     totelem[2] = 0;
1418   }
1419   if (totelem_sel) {
1420     totelem_sel[0] = 0;
1421     totelem_sel[1] = 0;
1422     totelem_sel[2] = 0;
1423   }
1424
1425   for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
1426     Object *obedit = objects[ob_index];
1427     BMEditMesh *em = BKE_editmesh_from_object(obedit);
1428     BMesh *bm = em->bm;
1429     if (totelem) {
1430       totelem[0] += bm->totvert;
1431       totelem[1] += bm->totedge;
1432       totelem[2] += bm->totface;
1433     }
1434     if (totelem_sel) {
1435       totelem_sel[0] += bm->totvertsel;
1436       totelem_sel[1] += bm->totedgesel;
1437       totelem_sel[2] += bm->totfacesel;
1438     }
1439   }
1440 }
1441
1442 void EDBM_mesh_elem_index_ensure_multi(Object **objects, const uint objects_len, const char htype)
1443 {
1444   int elem_offset[4] = {0, 0, 0, 0};
1445   for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
1446     Object *obedit = objects[ob_index];
1447     BMEditMesh *em = BKE_editmesh_from_object(obedit);
1448     BMesh *bm = em->bm;
1449     BM_mesh_elem_index_ensure_ex(bm, htype, elem_offset);
1450   }
1451 }