Merge branch 'master' into blender2.8
[blender.git] / source / blender / blenkernel / intern / mesh.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * Contributor(s): Blender Foundation
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  */
25
26 /** \file blender/blenkernel/intern/mesh.c
27  *  \ingroup bke
28  */
29
30 #include "MEM_guardedalloc.h"
31
32 #include "DNA_object_types.h"
33 #include "DNA_key_types.h"
34 #include "DNA_mesh_types.h"
35
36 #include "BLI_utildefines.h"
37 #include "BLI_math.h"
38 #include "BLI_linklist.h"
39 #include "BLI_memarena.h"
40 #include "BLI_edgehash.h"
41 #include "BLI_string.h"
42
43 #include "BKE_animsys.h"
44 #include "BKE_idcode.h"
45 #include "BKE_main.h"
46 #include "BKE_DerivedMesh.h"
47 #include "BKE_global.h"
48 #include "BKE_mesh.h"
49 #include "BKE_library.h"
50 #include "BKE_material.h"
51 #include "BKE_modifier.h"
52 #include "BKE_multires.h"
53 #include "BKE_object.h"
54 #include "BKE_editmesh.h"
55
56 #include "DEG_depsgraph.h"
57
58 /* Define for cases when you want extra validation of mesh
59  * after certain modifications.
60  */
61 // #undef VALIDATE_MESH
62
63 enum {
64         MESHCMP_DVERT_WEIGHTMISMATCH = 1,
65         MESHCMP_DVERT_GROUPMISMATCH,
66         MESHCMP_DVERT_TOTGROUPMISMATCH,
67         MESHCMP_LOOPCOLMISMATCH,
68         MESHCMP_LOOPUVMISMATCH,
69         MESHCMP_LOOPMISMATCH,
70         MESHCMP_POLYVERTMISMATCH,
71         MESHCMP_POLYMISMATCH,
72         MESHCMP_EDGEUNKNOWN,
73         MESHCMP_VERTCOMISMATCH,
74         MESHCMP_CDLAYERS_MISMATCH
75 };
76
77 static const char *cmpcode_to_str(int code)
78 {
79         switch (code) {
80                 case MESHCMP_DVERT_WEIGHTMISMATCH:
81                         return "Vertex Weight Mismatch";
82                 case MESHCMP_DVERT_GROUPMISMATCH:
83                         return "Vertex Group Mismatch";
84                 case MESHCMP_DVERT_TOTGROUPMISMATCH:
85                         return "Vertex Doesn't Belong To Same Number Of Groups";
86                 case MESHCMP_LOOPCOLMISMATCH:
87                         return "Vertex Color Mismatch";
88                 case MESHCMP_LOOPUVMISMATCH:
89                         return "UV Mismatch";
90                 case MESHCMP_LOOPMISMATCH:
91                         return "Loop Mismatch";
92                 case MESHCMP_POLYVERTMISMATCH:
93                         return "Loop Vert Mismatch In Poly Test";
94                 case MESHCMP_POLYMISMATCH:
95                         return "Loop Vert Mismatch";
96                 case MESHCMP_EDGEUNKNOWN:
97                         return "Edge Mismatch";
98                 case MESHCMP_VERTCOMISMATCH:
99                         return "Vertex Coordinate Mismatch";
100                 case MESHCMP_CDLAYERS_MISMATCH:
101                         return "CustomData Layer Count Mismatch";
102                 default:
103                         return "Mesh Comparison Code Unknown";
104         }
105 }
106
107 /* thresh is threshold for comparing vertices, uvs, vertex colors,
108  * weights, etc.*/
109 static int customdata_compare(CustomData *c1, CustomData *c2, Mesh *m1, Mesh *m2, const float thresh)
110 {
111         const float thresh_sq = thresh * thresh;
112         CustomDataLayer *l1, *l2;
113         int i, i1 = 0, i2 = 0, tot, j;
114         
115         for (i = 0; i < c1->totlayer; i++) {
116                 if (ELEM(c1->layers[i].type, CD_MVERT, CD_MEDGE, CD_MPOLY,
117                          CD_MLOOPUV, CD_MLOOPCOL, CD_MDEFORMVERT))
118                 {
119                         i1++;
120                 }
121         }
122
123         for (i = 0; i < c2->totlayer; i++) {
124                 if (ELEM(c2->layers[i].type, CD_MVERT, CD_MEDGE, CD_MPOLY,
125                          CD_MLOOPUV, CD_MLOOPCOL, CD_MDEFORMVERT))
126                 {
127                         i2++;
128                 }
129         }
130
131         if (i1 != i2)
132                 return MESHCMP_CDLAYERS_MISMATCH;
133         
134         l1 = c1->layers; l2 = c2->layers;
135         tot = i1;
136         i1 = 0; i2 = 0;
137         for (i = 0; i < tot; i++) {
138                 while (i1 < c1->totlayer && !ELEM(l1->type, CD_MVERT, CD_MEDGE, CD_MPOLY,
139                                                   CD_MLOOPUV, CD_MLOOPCOL, CD_MDEFORMVERT))
140                 {
141                         i1++;
142                         l1++;
143                 }
144
145                 while (i2 < c2->totlayer && !ELEM(l2->type, CD_MVERT, CD_MEDGE, CD_MPOLY,
146                                                   CD_MLOOPUV, CD_MLOOPCOL, CD_MDEFORMVERT))
147                 {
148                         i2++;
149                         l2++;
150                 }
151                 
152                 if (l1->type == CD_MVERT) {
153                         MVert *v1 = l1->data;
154                         MVert *v2 = l2->data;
155                         int vtot = m1->totvert;
156                         
157                         for (j = 0; j < vtot; j++, v1++, v2++) {
158                                 if (len_squared_v3v3(v1->co, v2->co) > thresh_sq)
159                                         return MESHCMP_VERTCOMISMATCH;
160                                 /* I don't care about normals, let's just do coodinates */
161                         }
162                 }
163                 
164                 /*we're order-agnostic for edges here*/
165                 if (l1->type == CD_MEDGE) {
166                         MEdge *e1 = l1->data;
167                         MEdge *e2 = l2->data;
168                         int etot = m1->totedge;
169                         EdgeHash *eh = BLI_edgehash_new_ex(__func__, etot);
170                 
171                         for (j = 0; j < etot; j++, e1++) {
172                                 BLI_edgehash_insert(eh, e1->v1, e1->v2, e1);
173                         }
174                         
175                         for (j = 0; j < etot; j++, e2++) {
176                                 if (!BLI_edgehash_lookup(eh, e2->v1, e2->v2))
177                                         return MESHCMP_EDGEUNKNOWN;
178                         }
179                         BLI_edgehash_free(eh, NULL);
180                 }
181                 
182                 if (l1->type == CD_MPOLY) {
183                         MPoly *p1 = l1->data;
184                         MPoly *p2 = l2->data;
185                         int ptot = m1->totpoly;
186                 
187                         for (j = 0; j < ptot; j++, p1++, p2++) {
188                                 MLoop *lp1, *lp2;
189                                 int k;
190                                 
191                                 if (p1->totloop != p2->totloop)
192                                         return MESHCMP_POLYMISMATCH;
193                                 
194                                 lp1 = m1->mloop + p1->loopstart;
195                                 lp2 = m2->mloop + p2->loopstart;
196                                 
197                                 for (k = 0; k < p1->totloop; k++, lp1++, lp2++) {
198                                         if (lp1->v != lp2->v)
199                                                 return MESHCMP_POLYVERTMISMATCH;
200                                 }
201                         }
202                 }
203                 if (l1->type == CD_MLOOP) {
204                         MLoop *lp1 = l1->data;
205                         MLoop *lp2 = l2->data;
206                         int ltot = m1->totloop;
207                 
208                         for (j = 0; j < ltot; j++, lp1++, lp2++) {
209                                 if (lp1->v != lp2->v)
210                                         return MESHCMP_LOOPMISMATCH;
211                         }
212                 }
213                 if (l1->type == CD_MLOOPUV) {
214                         MLoopUV *lp1 = l1->data;
215                         MLoopUV *lp2 = l2->data;
216                         int ltot = m1->totloop;
217                 
218                         for (j = 0; j < ltot; j++, lp1++, lp2++) {
219                                 if (len_squared_v2v2(lp1->uv, lp2->uv) > thresh_sq)
220                                         return MESHCMP_LOOPUVMISMATCH;
221                         }
222                 }
223                 
224                 if (l1->type == CD_MLOOPCOL) {
225                         MLoopCol *lp1 = l1->data;
226                         MLoopCol *lp2 = l2->data;
227                         int ltot = m1->totloop;
228                 
229                         for (j = 0; j < ltot; j++, lp1++, lp2++) {
230                                 if (ABS(lp1->r - lp2->r) > thresh || 
231                                     ABS(lp1->g - lp2->g) > thresh || 
232                                     ABS(lp1->b - lp2->b) > thresh || 
233                                     ABS(lp1->a - lp2->a) > thresh)
234                                 {
235                                         return MESHCMP_LOOPCOLMISMATCH;
236                                 }
237                         }
238                 }
239
240                 if (l1->type == CD_MDEFORMVERT) {
241                         MDeformVert *dv1 = l1->data;
242                         MDeformVert *dv2 = l2->data;
243                         int dvtot = m1->totvert;
244                 
245                         for (j = 0; j < dvtot; j++, dv1++, dv2++) {
246                                 int k;
247                                 MDeformWeight *dw1 = dv1->dw, *dw2 = dv2->dw;
248                                 
249                                 if (dv1->totweight != dv2->totweight)
250                                         return MESHCMP_DVERT_TOTGROUPMISMATCH;
251                                 
252                                 for (k = 0; k < dv1->totweight; k++, dw1++, dw2++) {
253                                         if (dw1->def_nr != dw2->def_nr)
254                                                 return MESHCMP_DVERT_GROUPMISMATCH;
255                                         if (fabsf(dw1->weight - dw2->weight) > thresh)
256                                                 return MESHCMP_DVERT_WEIGHTMISMATCH;
257                                 }
258                         }
259                 }
260         }
261         
262         return 0;
263 }
264
265 /**
266  * Used for unit testing; compares two meshes, checking only
267  * differences we care about.  should be usable with leaf's
268  * testing framework I get RNA work done, will use hackish
269  * testing code for now.
270  */
271 const char *BKE_mesh_cmp(Mesh *me1, Mesh *me2, float thresh)
272 {
273         int c;
274         
275         if (!me1 || !me2)
276                 return "Requires two input meshes";
277         
278         if (me1->totvert != me2->totvert) 
279                 return "Number of verts don't match";
280         
281         if (me1->totedge != me2->totedge)
282                 return "Number of edges don't match";
283         
284         if (me1->totpoly != me2->totpoly)
285                 return "Number of faces don't match";
286                                 
287         if (me1->totloop != me2->totloop)
288                 return "Number of loops don't match";
289         
290         if ((c = customdata_compare(&me1->vdata, &me2->vdata, me1, me2, thresh)))
291                 return cmpcode_to_str(c);
292
293         if ((c = customdata_compare(&me1->edata, &me2->edata, me1, me2, thresh)))
294                 return cmpcode_to_str(c);
295
296         if ((c = customdata_compare(&me1->ldata, &me2->ldata, me1, me2, thresh)))
297                 return cmpcode_to_str(c);
298
299         if ((c = customdata_compare(&me1->pdata, &me2->pdata, me1, me2, thresh)))
300                 return cmpcode_to_str(c);
301         
302         return NULL;
303 }
304
305 static void mesh_ensure_tessellation_customdata(Mesh *me)
306 {
307         if (UNLIKELY((me->totface != 0) && (me->totpoly == 0))) {
308                 /* Pass, otherwise this function  clears 'mface' before
309                  * versioning 'mface -> mpoly' code kicks in [#30583]
310                  *
311                  * Callers could also check but safer to do here - campbell */
312         }
313         else {
314                 const int tottex_original = CustomData_number_of_layers(&me->ldata, CD_MLOOPUV);
315                 const int totcol_original = CustomData_number_of_layers(&me->ldata, CD_MLOOPCOL);
316
317                 const int tottex_tessface = CustomData_number_of_layers(&me->fdata, CD_MTFACE);
318                 const int totcol_tessface = CustomData_number_of_layers(&me->fdata, CD_MCOL);
319
320                 if (tottex_tessface != tottex_original ||
321                     totcol_tessface != totcol_original)
322                 {
323                         BKE_mesh_tessface_clear(me);
324
325                         CustomData_from_bmeshpoly(&me->fdata, &me->ldata, me->totface);
326
327                         /* TODO - add some --debug-mesh option */
328                         if (G.debug & G_DEBUG) {
329                                 /* note: this warning may be un-called for if we are initializing the mesh for the
330                                  * first time from bmesh, rather then giving a warning about this we could be smarter
331                                  * and check if there was any data to begin with, for now just print the warning with
332                                  * some info to help troubleshoot whats going on - campbell */
333                                 printf("%s: warning! Tessellation uvs or vcol data got out of sync, "
334                                        "had to reset!\n    CD_MTFACE: %d != CD_MLOOPUV: %d || CD_MCOL: %d != CD_MLOOPCOL: %d\n",
335                                        __func__, tottex_tessface, tottex_original, totcol_tessface, totcol_original);
336                         }
337                 }
338         }
339 }
340
341 void BKE_mesh_ensure_skin_customdata(Mesh *me)
342 {
343         BMesh *bm = me->edit_btmesh ? me->edit_btmesh->bm : NULL;
344         MVertSkin *vs;
345
346         if (bm) {
347                 if (!CustomData_has_layer(&bm->vdata, CD_MVERT_SKIN)) {
348                         BMVert *v;
349                         BMIter iter;
350
351                         BM_data_layer_add(bm, &bm->vdata, CD_MVERT_SKIN);
352
353                         /* Mark an arbitrary vertex as root */
354                         BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
355                                 vs = CustomData_bmesh_get(&bm->vdata, v->head.data,
356                                                           CD_MVERT_SKIN);
357                                 vs->flag |= MVERT_SKIN_ROOT;
358                                 break;
359                         }
360                 }
361         }
362         else {
363                 if (!CustomData_has_layer(&me->vdata, CD_MVERT_SKIN)) {
364                         vs = CustomData_add_layer(&me->vdata,
365                                                   CD_MVERT_SKIN,
366                                                   CD_DEFAULT,
367                                                   NULL,
368                                                   me->totvert);
369
370                         /* Mark an arbitrary vertex as root */
371                         if (vs) {
372                                 vs->flag |= MVERT_SKIN_ROOT;
373                         }
374                 }
375         }
376 }
377
378 bool BKE_mesh_ensure_edit_data(struct Mesh *me)
379 {
380         if (me->runtime.edit_data != NULL) {
381                 return false;
382         }
383
384         me->runtime.edit_data = MEM_callocN(sizeof(EditMeshData), "EditMeshData");
385         return true;
386 }
387
388 bool BKE_mesh_clear_edit_data(struct Mesh *me)
389 {
390         if (me->runtime.edit_data == NULL) {
391                 return false;
392         }
393
394         if (me->runtime.edit_data->polyCos != NULL)
395                 MEM_freeN((void *)me->runtime.edit_data->polyCos);
396         if (me->runtime.edit_data->polyNos != NULL)
397                 MEM_freeN((void *)me->runtime.edit_data->polyNos);
398         if (me->runtime.edit_data->vertexCos != NULL)
399                 MEM_freeN((void *)me->runtime.edit_data->vertexCos);
400         if (me->runtime.edit_data->vertexNos != NULL)
401                 MEM_freeN((void *)me->runtime.edit_data->vertexNos);
402
403         MEM_SAFE_FREE(me->runtime.edit_data);
404         return true;
405 }
406
407
408 bool BKE_mesh_ensure_facemap_customdata(struct Mesh *me)
409 {
410         BMesh *bm = me->edit_btmesh ? me->edit_btmesh->bm : NULL;
411         bool changed = false;
412         if (bm) {
413                 if (!CustomData_has_layer(&bm->pdata, CD_FACEMAP)) {
414                         BM_data_layer_add(bm, &bm->pdata, CD_FACEMAP);
415                         changed = true;
416                 }
417         }
418         else {
419                 if (!CustomData_has_layer(&me->pdata, CD_FACEMAP)) {
420                         CustomData_add_layer(&me->pdata,
421                                                   CD_FACEMAP,
422                                                   CD_DEFAULT,
423                                                   NULL,
424                                                   me->totpoly);
425                         changed = true;
426                 }
427         }
428         return changed;
429 }
430
431 bool BKE_mesh_clear_facemap_customdata(struct Mesh *me)
432 {
433         BMesh *bm = me->edit_btmesh ? me->edit_btmesh->bm : NULL;
434         bool changed = false;
435         if (bm) {
436                 if (CustomData_has_layer(&bm->pdata, CD_FACEMAP)) {
437                         BM_data_layer_free(bm, &bm->pdata, CD_FACEMAP);
438                         changed = true;
439                 }
440         }
441         else {
442                 if (CustomData_has_layer(&me->pdata, CD_FACEMAP)) {
443                         CustomData_free_layers(&me->pdata, CD_FACEMAP, me->totpoly);
444                         changed = true;
445                 }
446         }
447         return changed;
448 }
449
450 /* this ensures grouped customdata (e.g. mtexpoly and mloopuv and mtface, or
451  * mloopcol and mcol) have the same relative active/render/clone/mask indices.
452  *
453  * note that for undo mesh data we want to skip 'ensure_tess_cd' call since
454  * we don't want to store memory for tessface when its only used for older
455  * versions of the mesh. - campbell*/
456 static void mesh_update_linked_customdata(Mesh *me, const bool do_ensure_tess_cd)
457 {
458         if (do_ensure_tess_cd) {
459                 mesh_ensure_tessellation_customdata(me);
460         }
461
462         CustomData_bmesh_update_active_layers(&me->fdata, &me->ldata);
463 }
464
465 void BKE_mesh_update_customdata_pointers(Mesh *me, const bool do_ensure_tess_cd)
466 {
467         mesh_update_linked_customdata(me, do_ensure_tess_cd);
468
469         me->mvert = CustomData_get_layer(&me->vdata, CD_MVERT);
470         me->dvert = CustomData_get_layer(&me->vdata, CD_MDEFORMVERT);
471
472         me->medge = CustomData_get_layer(&me->edata, CD_MEDGE);
473
474         me->mface = CustomData_get_layer(&me->fdata, CD_MFACE);
475         me->mcol = CustomData_get_layer(&me->fdata, CD_MCOL);
476         me->mtface = CustomData_get_layer(&me->fdata, CD_MTFACE);
477         
478         me->mpoly = CustomData_get_layer(&me->pdata, CD_MPOLY);
479         me->mloop = CustomData_get_layer(&me->ldata, CD_MLOOP);
480
481         me->mloopcol = CustomData_get_layer(&me->ldata, CD_MLOOPCOL);
482         me->mloopuv = CustomData_get_layer(&me->ldata, CD_MLOOPUV);
483 }
484
485 bool BKE_mesh_has_custom_loop_normals(Mesh *me)
486 {
487         if (me->edit_btmesh) {
488                 return CustomData_has_layer(&me->edit_btmesh->bm->ldata, CD_CUSTOMLOOPNORMAL);
489         }
490         else {
491                 return CustomData_has_layer(&me->ldata, CD_CUSTOMLOOPNORMAL);
492         }
493 }
494
495 /** Free (or release) any data used by this mesh (does not free the mesh itself). */
496 void BKE_mesh_free(Mesh *me)
497 {
498         BKE_animdata_free(&me->id, false);
499
500         BKE_mesh_batch_cache_free(me);
501         BKE_mesh_clear_edit_data(me);
502
503         CustomData_free(&me->vdata, me->totvert);
504         CustomData_free(&me->edata, me->totedge);
505         CustomData_free(&me->fdata, me->totface);
506         CustomData_free(&me->ldata, me->totloop);
507         CustomData_free(&me->pdata, me->totpoly);
508
509         MEM_SAFE_FREE(me->mat);
510         MEM_SAFE_FREE(me->bb);
511         MEM_SAFE_FREE(me->mselect);
512         MEM_SAFE_FREE(me->edit_btmesh);
513 }
514
515 static void mesh_tessface_clear_intern(Mesh *mesh, int free_customdata)
516 {
517         if (free_customdata) {
518                 CustomData_free(&mesh->fdata, mesh->totface);
519         }
520         else {
521                 CustomData_reset(&mesh->fdata);
522         }
523
524         mesh->mface = NULL;
525         mesh->mtface = NULL;
526         mesh->mcol = NULL;
527         mesh->totface = 0;
528 }
529
530 void BKE_mesh_init(Mesh *me)
531 {
532         BLI_assert(MEMCMP_STRUCT_OFS_IS_ZERO(me, id));
533
534         me->size[0] = me->size[1] = me->size[2] = 1.0;
535         me->smoothresh = DEG2RADF(30);
536         me->texflag = ME_AUTOSPACE;
537
538         /* disable because its slow on many GPU's, see [#37518] */
539 #if 0
540         me->flag = ME_TWOSIDED;
541 #endif
542         me->drawflag = ME_DRAWEDGES | ME_DRAWFACES | ME_DRAWCREASES;
543
544         CustomData_reset(&me->vdata);
545         CustomData_reset(&me->edata);
546         CustomData_reset(&me->fdata);
547         CustomData_reset(&me->pdata);
548         CustomData_reset(&me->ldata);
549 }
550
551 Mesh *BKE_mesh_add(Main *bmain, const char *name)
552 {
553         Mesh *me;
554
555         me = BKE_libblock_alloc(bmain, ID_ME, name, 0);
556
557         BKE_mesh_init(me);
558
559         return me;
560 }
561
562 /**
563  * Only copy internal data of Mesh ID from source to already allocated/initialized destination.
564  * You probably nerver want to use that directly, use id_copy or BKE_id_copy_ex for typical needs.
565  *
566  * WARNING! This function will not handle ID user count!
567  *
568  * \param flag  Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
569  */
570 void BKE_mesh_copy_data(Main *bmain, Mesh *me_dst, const Mesh *me_src, const int flag)
571 {
572         const bool do_tessface = ((me_src->totface != 0) && (me_src->totpoly == 0)); /* only do tessface if we have no polys */
573
574         me_dst->mat = MEM_dupallocN(me_src->mat);
575
576         CustomData_copy(&me_src->vdata, &me_dst->vdata, CD_MASK_MESH, CD_DUPLICATE, me_dst->totvert);
577         CustomData_copy(&me_src->edata, &me_dst->edata, CD_MASK_MESH, CD_DUPLICATE, me_dst->totedge);
578         CustomData_copy(&me_src->ldata, &me_dst->ldata, CD_MASK_MESH, CD_DUPLICATE, me_dst->totloop);
579         CustomData_copy(&me_src->pdata, &me_dst->pdata, CD_MASK_MESH, CD_DUPLICATE, me_dst->totpoly);
580         if (do_tessface) {
581                 CustomData_copy(&me_src->fdata, &me_dst->fdata, CD_MASK_MESH, CD_DUPLICATE, me_dst->totface);
582         }
583         else {
584                 mesh_tessface_clear_intern(me_dst, false);
585         }
586
587         BKE_mesh_update_customdata_pointers(me_dst, do_tessface);
588
589         me_dst->edit_btmesh = NULL;
590         me_dst->runtime.batch_cache = NULL;
591
592         me_dst->mselect = MEM_dupallocN(me_dst->mselect);
593         me_dst->bb = MEM_dupallocN(me_dst->bb);
594
595         /* TODO Do we want to add flag to prevent this? */
596         if (me_src->key) {
597                 BKE_id_copy_ex(bmain, &me_src->key->id, (ID **)&me_dst->key, flag, false);
598         }
599 }
600
601 Mesh *BKE_mesh_new_nomain(int verts_len, int edges_len, int tessface_len, int loops_len, int polys_len)
602 {
603         Mesh *mesh = BKE_libblock_alloc(
604                 NULL, ID_ME,
605                 BKE_idcode_to_name(ID_ME),
606                 LIB_ID_CREATE_NO_MAIN |
607                 LIB_ID_CREATE_NO_USER_REFCOUNT |
608                 LIB_ID_CREATE_NO_DEG_TAG);
609         BKE_libblock_init_empty(&mesh->id);
610
611         /* don't use CustomData_reset(...); because we dont want to touch customdata */
612         copy_vn_i(mesh->vdata.typemap, CD_NUMTYPES, -1);
613         copy_vn_i(mesh->edata.typemap, CD_NUMTYPES, -1);
614         copy_vn_i(mesh->fdata.typemap, CD_NUMTYPES, -1);
615         copy_vn_i(mesh->ldata.typemap, CD_NUMTYPES, -1);
616         copy_vn_i(mesh->pdata.typemap, CD_NUMTYPES, -1);
617
618         CustomData_add_layer(&mesh->vdata, CD_ORIGINDEX, CD_CALLOC, NULL, verts_len);
619         CustomData_add_layer(&mesh->edata, CD_ORIGINDEX, CD_CALLOC, NULL, edges_len);
620         CustomData_add_layer(&mesh->fdata, CD_ORIGINDEX, CD_CALLOC, NULL, tessface_len);
621         CustomData_add_layer(&mesh->pdata, CD_ORIGINDEX, CD_CALLOC, NULL, polys_len);
622
623         CustomData_add_layer(&mesh->vdata, CD_MVERT, CD_CALLOC, NULL, verts_len);
624         CustomData_add_layer(&mesh->edata, CD_MEDGE, CD_CALLOC, NULL, edges_len);
625         CustomData_add_layer(&mesh->fdata, CD_MFACE, CD_CALLOC, NULL, tessface_len);
626         CustomData_add_layer(&mesh->ldata, CD_MLOOP, CD_CALLOC, NULL, loops_len);
627         CustomData_add_layer(&mesh->pdata, CD_MPOLY, CD_CALLOC, NULL, polys_len);
628
629         mesh->mvert = CustomData_get_layer(&mesh->vdata, CD_MVERT);
630         mesh->medge = CustomData_get_layer(&mesh->edata, CD_MEDGE);
631         mesh->mface = CustomData_get_layer(&mesh->fdata, CD_MFACE);
632         mesh->mloop = CustomData_get_layer(&mesh->ldata, CD_MLOOP);
633         mesh->mpoly = CustomData_get_layer(&mesh->pdata, CD_MPOLY);
634
635         return mesh;
636 }
637
638 static Mesh *mesh_new_nomain_from_template_ex(
639         const Mesh *me_src,
640         int verts_len, int edges_len, int tessface_len,
641         int loops_len, int polys_len,
642         CustomDataMask mask)
643 {
644         const bool do_tessface = ((me_src->totface != 0) && (me_src->totpoly == 0)); /* only do tessface if we have no polys */
645
646         Mesh *me_dst = BKE_id_new_nomain(ID_ME, NULL);
647
648         me_dst->mat = MEM_dupallocN(me_src->mat);
649         me_dst->mselect = MEM_dupallocN(me_dst->mselect);
650
651         me_dst->totvert = verts_len;
652         me_dst->totedge = edges_len;
653         me_dst->totloop = loops_len;
654         me_dst->totpoly = polys_len;
655
656         CustomData_copy(&me_src->vdata, &me_dst->vdata, mask, CD_CALLOC, verts_len);
657         CustomData_copy(&me_src->edata, &me_dst->edata, mask, CD_CALLOC, edges_len);
658         CustomData_copy(&me_src->ldata, &me_dst->ldata, mask, CD_CALLOC, loops_len);
659         CustomData_copy(&me_src->pdata, &me_dst->pdata, mask, CD_CALLOC, polys_len);
660         if (do_tessface) {
661                 CustomData_copy(&me_src->fdata, &me_dst->fdata, mask, CD_CALLOC, tessface_len);
662         }
663         else {
664                 mesh_tessface_clear_intern(me_dst, false);
665         }
666
667         BKE_mesh_update_customdata_pointers(me_dst, false);
668
669         if (!CustomData_get_layer(&me_dst->vdata, CD_ORIGINDEX))
670                 CustomData_add_layer(&me_dst->vdata, CD_ORIGINDEX, CD_CALLOC, NULL, verts_len);
671         if (!CustomData_get_layer(&me_dst->edata, CD_ORIGINDEX))
672                 CustomData_add_layer(&me_dst->edata, CD_ORIGINDEX, CD_CALLOC, NULL, edges_len);
673         if (!CustomData_get_layer(&me_dst->pdata, CD_ORIGINDEX))
674                 CustomData_add_layer(&me_dst->pdata, CD_ORIGINDEX, CD_CALLOC, NULL, polys_len);
675
676         return me_dst;
677 }
678
679 Mesh * BKE_mesh_new_nomain_from_template(
680         const Mesh *me_src,
681         int verts_len, int edges_len, int tessface_len,
682         int loops_len, int polys_len)
683 {
684         return mesh_new_nomain_from_template_ex(
685                 me_src,
686                 verts_len, edges_len, tessface_len,
687                 loops_len, polys_len,
688                 CD_MASK_EVERYTHING);
689 }
690
691 Mesh *BKE_mesh_copy(Main *bmain, const Mesh *me)
692 {
693         Mesh *me_copy;
694         BKE_id_copy_ex(bmain, &me->id, (ID **)&me_copy, 0, false);
695         return me_copy;
696 }
697
698 BMesh *BKE_mesh_to_bmesh_ex(
699         Mesh *me,
700         const struct BMeshCreateParams *create_params,
701         const struct BMeshFromMeshParams *convert_params)
702 {
703         BMesh *bm;
704         const BMAllocTemplate allocsize = BMALLOC_TEMPLATE_FROM_ME(me);
705
706         bm = BM_mesh_create(&allocsize, create_params);
707         BM_mesh_bm_from_me(bm, me, convert_params);
708
709         return bm;
710 }
711
712 BMesh *BKE_mesh_to_bmesh(
713         Mesh *me, Object *ob,
714         const bool add_key_index, const struct BMeshCreateParams *params)
715 {
716         return BKE_mesh_to_bmesh_ex(
717                 me, params,
718                 &(struct BMeshFromMeshParams){
719                     .calc_face_normal = false,
720                     .add_key_index = add_key_index,
721                     .use_shapekey = true,
722                     .active_shapekey = ob->shapenr,
723                 });
724 }
725
726 Mesh *BKE_bmesh_to_mesh_nomain(BMesh *bm, const struct BMeshToMeshParams *params)
727 {
728         Mesh *mesh = BKE_id_new_nomain(ID_ME, NULL);
729         BM_mesh_bm_to_me(bm, mesh, params);
730         return mesh;
731 }
732
733 void BKE_mesh_make_local(Main *bmain, Mesh *me, const bool lib_local)
734 {
735         BKE_id_make_local_generic(bmain, &me->id, true, lib_local);
736 }
737
738 bool BKE_mesh_uv_cdlayer_rename_index(
739         Mesh *me, const int loop_index, const int face_index,
740         const char *new_name, const bool do_tessface)
741 {
742         CustomData *ldata, *fdata;
743         CustomDataLayer *cdlu, *cdlf;
744
745         if (me->edit_btmesh) {
746                 ldata = &me->edit_btmesh->bm->ldata;
747                 fdata = NULL;  /* No tessellated data in BMesh! */
748         }
749         else {
750                 ldata = &me->ldata;
751                 fdata = &me->fdata;
752         }
753
754         cdlu = &ldata->layers[loop_index];
755         cdlf = (face_index != -1) && fdata && do_tessface ? &fdata->layers[face_index] : NULL;
756
757         if (cdlu->name != new_name) {
758                 /* Mesh validate passes a name from the CD layer as the new name,
759                  * Avoid memcpy from self to self in this case.
760                  */
761                 BLI_strncpy(cdlu->name, new_name, sizeof(cdlu->name));
762                 CustomData_set_layer_unique_name(ldata, loop_index);
763         }
764
765         if (cdlf == NULL) {
766                 return false;
767         }
768
769         BLI_strncpy(cdlf->name, cdlu->name, sizeof(cdlf->name));
770         CustomData_set_layer_unique_name(fdata, face_index);
771
772         return true;
773 }
774
775 bool BKE_mesh_uv_cdlayer_rename(Mesh *me, const char *old_name, const char *new_name, bool do_tessface)
776 {
777         CustomData *ldata, *fdata;
778         if (me->edit_btmesh) {
779                 ldata = &me->edit_btmesh->bm->ldata;
780                 /* No tessellated data in BMesh! */
781                 fdata = NULL;
782                 do_tessface = false;
783         }
784         else {
785                 ldata = &me->ldata;
786                 fdata = &me->fdata;
787                 do_tessface = (do_tessface && fdata->totlayer);
788         }
789
790         {
791                 const int lidx_start = CustomData_get_layer_index(ldata, CD_MLOOPUV);
792                 const int fidx_start = do_tessface ? CustomData_get_layer_index(fdata, CD_MTFACE) : -1;
793                 int lidx = CustomData_get_named_layer(ldata, CD_MLOOPUV, old_name);
794                 int fidx = do_tessface ? CustomData_get_named_layer(fdata, CD_MTFACE, old_name) : -1;
795
796                 /* None of those cases should happen, in theory!
797                  * Note this assume we have the same number of mtexpoly, mloopuv and mtface layers!
798                  */
799                 if (lidx == -1) {
800                         if (fidx == -1) {
801                                 /* No layer found with this name! */
802                                 return false;
803                         }
804                         else {
805                                 lidx = fidx;
806                         }
807                 }
808
809                 /* Go back to absolute indices! */
810                 lidx += lidx_start;
811                 if (fidx != -1)
812                         fidx += fidx_start;
813
814                 return BKE_mesh_uv_cdlayer_rename_index(me, lidx, fidx, new_name, do_tessface);
815         }
816 }
817
818 void BKE_mesh_boundbox_calc(Mesh *me, float r_loc[3], float r_size[3])
819 {
820         BoundBox *bb;
821         float min[3], max[3];
822         float mloc[3], msize[3];
823         
824         if (me->bb == NULL) me->bb = MEM_callocN(sizeof(BoundBox), "boundbox");
825         bb = me->bb;
826
827         if (!r_loc) r_loc = mloc;
828         if (!r_size) r_size = msize;
829         
830         INIT_MINMAX(min, max);
831         if (!BKE_mesh_minmax(me, min, max)) {
832                 min[0] = min[1] = min[2] = -1.0f;
833                 max[0] = max[1] = max[2] = 1.0f;
834         }
835
836         mid_v3_v3v3(r_loc, min, max);
837                 
838         r_size[0] = (max[0] - min[0]) / 2.0f;
839         r_size[1] = (max[1] - min[1]) / 2.0f;
840         r_size[2] = (max[2] - min[2]) / 2.0f;
841         
842         BKE_boundbox_init_from_minmax(bb, min, max);
843
844         bb->flag &= ~BOUNDBOX_DIRTY;
845 }
846
847 void BKE_mesh_texspace_calc(Mesh *me)
848 {
849         float loc[3], size[3];
850         int a;
851
852         BKE_mesh_boundbox_calc(me, loc, size);
853
854         if (me->texflag & ME_AUTOSPACE) {
855                 for (a = 0; a < 3; a++) {
856                         if (size[a] == 0.0f) size[a] = 1.0f;
857                         else if (size[a] > 0.0f && size[a] < 0.00001f) size[a] = 0.00001f;
858                         else if (size[a] < 0.0f && size[a] > -0.00001f) size[a] = -0.00001f;
859                 }
860
861                 copy_v3_v3(me->loc, loc);
862                 copy_v3_v3(me->size, size);
863                 zero_v3(me->rot);
864         }
865 }
866
867 BoundBox *BKE_mesh_boundbox_get(Object *ob)
868 {
869         Mesh *me = ob->data;
870
871         if (ob->bb)
872                 return ob->bb;
873
874         if (me->bb == NULL || (me->bb->flag & BOUNDBOX_DIRTY)) {
875                 BKE_mesh_texspace_calc(me);
876         }
877
878         return me->bb;
879 }
880
881 void BKE_mesh_texspace_get(Mesh *me, float r_loc[3], float r_rot[3], float r_size[3])
882 {
883         if (me->bb == NULL || (me->bb->flag & BOUNDBOX_DIRTY)) {
884                 BKE_mesh_texspace_calc(me);
885         }
886
887         if (r_loc) copy_v3_v3(r_loc,  me->loc);
888         if (r_rot) copy_v3_v3(r_rot,  me->rot);
889         if (r_size) copy_v3_v3(r_size, me->size);
890 }
891
892 void BKE_mesh_texspace_get_reference(Mesh *me, short **r_texflag,  float **r_loc, float **r_rot, float **r_size)
893 {
894         if (me->bb == NULL || (me->bb->flag & BOUNDBOX_DIRTY)) {
895                 BKE_mesh_texspace_calc(me);
896         }
897
898         if (r_texflag != NULL) *r_texflag = &me->texflag;
899         if (r_loc != NULL) *r_loc = me->loc;
900         if (r_rot != NULL) *r_rot = me->rot;
901         if (r_size != NULL) *r_size = me->size;
902 }
903
904 void BKE_mesh_texspace_copy_from_object(Mesh *me, Object *ob)
905 {
906         float *texloc, *texrot, *texsize;
907         short *texflag;
908
909         if (BKE_object_obdata_texspace_get(ob, &texflag, &texloc, &texsize, &texrot)) {
910                 me->texflag = *texflag;
911                 copy_v3_v3(me->loc, texloc);
912                 copy_v3_v3(me->size, texsize);
913                 copy_v3_v3(me->rot, texrot);
914         }
915 }
916
917 float (*BKE_mesh_orco_verts_get(Object *ob))[3]
918 {
919         Mesh *me = ob->data;
920         MVert *mvert = NULL;
921         Mesh *tme = me->texcomesh ? me->texcomesh : me;
922         int a, totvert;
923         float (*vcos)[3] = NULL;
924
925         /* Get appropriate vertex coordinates */
926         vcos = MEM_calloc_arrayN(me->totvert, sizeof(*vcos), "orco mesh");
927         mvert = tme->mvert;
928         totvert = min_ii(tme->totvert, me->totvert);
929
930         for (a = 0; a < totvert; a++, mvert++) {
931                 copy_v3_v3(vcos[a], mvert->co);
932         }
933
934         return vcos;
935 }
936
937 void BKE_mesh_orco_verts_transform(Mesh *me, float (*orco)[3], int totvert, int invert)
938 {
939         float loc[3], size[3];
940         int a;
941
942         BKE_mesh_texspace_get(me->texcomesh ? me->texcomesh : me, loc, NULL, size);
943
944         if (invert) {
945                 for (a = 0; a < totvert; a++) {
946                         float *co = orco[a];
947                         madd_v3_v3v3v3(co, loc, co, size);
948                 }
949         }
950         else {
951                 for (a = 0; a < totvert; a++) {
952                         float *co = orco[a];
953                         co[0] = (co[0] - loc[0]) / size[0];
954                         co[1] = (co[1] - loc[1]) / size[1];
955                         co[2] = (co[2] - loc[2]) / size[2];
956                 }
957         }
958 }
959
960 /* rotates the vertices of a face in case v[2] or v[3] (vertex index) is = 0.
961  * this is necessary to make the if (mface->v4) check for quads work */
962 int test_index_face(MFace *mface, CustomData *fdata, int mfindex, int nr)
963 {
964         /* first test if the face is legal */
965         if ((mface->v3 || nr == 4) && mface->v3 == mface->v4) {
966                 mface->v4 = 0;
967                 nr--;
968         }
969         if ((mface->v2 || mface->v4) && mface->v2 == mface->v3) {
970                 mface->v3 = mface->v4;
971                 mface->v4 = 0;
972                 nr--;
973         }
974         if (mface->v1 == mface->v2) {
975                 mface->v2 = mface->v3;
976                 mface->v3 = mface->v4;
977                 mface->v4 = 0;
978                 nr--;
979         }
980
981         /* check corrupt cases, bow-tie geometry, cant handle these because edge data wont exist so just return 0 */
982         if (nr == 3) {
983                 if (
984                     /* real edges */
985                     mface->v1 == mface->v2 ||
986                     mface->v2 == mface->v3 ||
987                     mface->v3 == mface->v1)
988                 {
989                         return 0;
990                 }
991         }
992         else if (nr == 4) {
993                 if (
994                     /* real edges */
995                     mface->v1 == mface->v2 ||
996                     mface->v2 == mface->v3 ||
997                     mface->v3 == mface->v4 ||
998                     mface->v4 == mface->v1 ||
999                     /* across the face */
1000                     mface->v1 == mface->v3 ||
1001                     mface->v2 == mface->v4)
1002                 {
1003                         return 0;
1004                 }
1005         }
1006
1007         /* prevent a zero at wrong index location */
1008         if (nr == 3) {
1009                 if (mface->v3 == 0) {
1010                         static int corner_indices[4] = {1, 2, 0, 3};
1011
1012                         SWAP(unsigned int, mface->v1, mface->v2);
1013                         SWAP(unsigned int, mface->v2, mface->v3);
1014
1015                         if (fdata)
1016                                 CustomData_swap_corners(fdata, mfindex, corner_indices);
1017                 }
1018         }
1019         else if (nr == 4) {
1020                 if (mface->v3 == 0 || mface->v4 == 0) {
1021                         static int corner_indices[4] = {2, 3, 0, 1};
1022
1023                         SWAP(unsigned int, mface->v1, mface->v3);
1024                         SWAP(unsigned int, mface->v2, mface->v4);
1025
1026                         if (fdata)
1027                                 CustomData_swap_corners(fdata, mfindex, corner_indices);
1028                 }
1029         }
1030
1031         return nr;
1032 }
1033
1034 Mesh *BKE_mesh_from_object(Object *ob)
1035 {
1036         
1037         if (ob == NULL) return NULL;
1038         if (ob->type == OB_MESH) return ob->data;
1039         else return NULL;
1040 }
1041
1042 void BKE_mesh_assign_object(Object *ob, Mesh *me)
1043 {
1044         Mesh *old = NULL;
1045
1046         multires_force_update(ob);
1047         
1048         if (ob == NULL) return;
1049         
1050         if (ob->type == OB_MESH) {
1051                 old = ob->data;
1052                 if (old)
1053                         id_us_min(&old->id);
1054                 ob->data = me;
1055                 id_us_plus((ID *)me);
1056         }
1057         
1058         test_object_materials(ob, (ID *)me);
1059
1060         test_object_modifiers(ob);
1061 }
1062
1063 void BKE_mesh_material_index_remove(Mesh *me, short index)
1064 {
1065         MPoly *mp;
1066         MFace *mf;
1067         int i;
1068
1069         for (mp = me->mpoly, i = 0; i < me->totpoly; i++, mp++) {
1070                 if (mp->mat_nr && mp->mat_nr >= index) {
1071                         mp->mat_nr--;
1072                 }
1073         }
1074
1075         for (mf = me->mface, i = 0; i < me->totface; i++, mf++) {
1076                 if (mf->mat_nr && mf->mat_nr >= index) {
1077                         mf->mat_nr--;
1078                 }
1079         }
1080 }
1081
1082 void BKE_mesh_material_index_clear(Mesh *me)
1083 {
1084         MPoly *mp;
1085         MFace *mf;
1086         int i;
1087
1088         for (mp = me->mpoly, i = 0; i < me->totpoly; i++, mp++) {
1089                 mp->mat_nr = 0;
1090         }
1091
1092         for (mf = me->mface, i = 0; i < me->totface; i++, mf++) {
1093                 mf->mat_nr = 0;
1094         }
1095 }
1096
1097 void BKE_mesh_material_remap(Mesh *me, const unsigned int *remap, unsigned int remap_len)
1098 {
1099         const short remap_len_short = (short)remap_len;
1100
1101 #define MAT_NR_REMAP(n) \
1102         if (n < remap_len_short) { \
1103                 BLI_assert(n >= 0 && remap[n] < remap_len_short); \
1104                 n = remap[n]; \
1105         } ((void)0)
1106
1107         if (me->edit_btmesh) {
1108                 BMEditMesh *em = me->edit_btmesh;
1109                 BMIter iter;
1110                 BMFace *efa;
1111
1112                 BM_ITER_MESH(efa, &iter, em->bm, BM_FACES_OF_MESH) {
1113                         MAT_NR_REMAP(efa->mat_nr);
1114                 }
1115         }
1116         else {
1117                 int i;
1118                 for (i = 0; i < me->totpoly; i++) {
1119                         MAT_NR_REMAP(me->mpoly[i].mat_nr);
1120                 }
1121         }
1122
1123 #undef MAT_NR_REMAP
1124
1125 }
1126
1127 void BKE_mesh_smooth_flag_set(Object *meshOb, int enableSmooth) 
1128 {
1129         Mesh *me = meshOb->data;
1130         int i;
1131
1132         for (i = 0; i < me->totpoly; i++) {
1133                 MPoly *mp = &me->mpoly[i];
1134
1135                 if (enableSmooth) {
1136                         mp->flag |= ME_SMOOTH;
1137                 }
1138                 else {
1139                         mp->flag &= ~ME_SMOOTH;
1140                 }
1141         }
1142         
1143         for (i = 0; i < me->totface; i++) {
1144                 MFace *mf = &me->mface[i];
1145
1146                 if (enableSmooth) {
1147                         mf->flag |= ME_SMOOTH;
1148                 }
1149                 else {
1150                         mf->flag &= ~ME_SMOOTH;
1151                 }
1152         }
1153 }
1154
1155 /**
1156  * Return a newly MEM_malloc'd array of all the mesh vertex locations
1157  * \note \a r_verts_len may be NULL
1158  */
1159 float (*BKE_mesh_vertexCos_get(const Mesh *me, int *r_verts_len))[3]
1160 {
1161         int i, verts_len = me->totvert;
1162         float (*cos)[3] = MEM_malloc_arrayN(verts_len, sizeof(*cos), "vertexcos1");
1163
1164         if (r_verts_len) *r_verts_len = verts_len;
1165         for (i = 0; i < verts_len; i++)
1166                 copy_v3_v3(cos[i], me->mvert[i].co);
1167
1168         return cos;
1169 }
1170
1171 /**
1172  * Find the index of the loop in 'poly' which references vertex,
1173  * returns -1 if not found
1174  */
1175 int poly_find_loop_from_vert(
1176         const MPoly *poly, const MLoop *loopstart,
1177         unsigned vert)
1178 {
1179         int j;
1180         for (j = 0; j < poly->totloop; j++, loopstart++) {
1181                 if (loopstart->v == vert)
1182                         return j;
1183         }
1184         
1185         return -1;
1186 }
1187
1188 /**
1189  * Fill \a r_adj with the loop indices in \a poly adjacent to the
1190  * vertex. Returns the index of the loop matching vertex, or -1 if the
1191  * vertex is not in \a poly
1192  */
1193 int poly_get_adj_loops_from_vert(
1194         const MPoly *poly,
1195         const MLoop *mloop, unsigned int vert,
1196         unsigned int r_adj[2])
1197 {
1198         int corner = poly_find_loop_from_vert(poly,
1199                                               &mloop[poly->loopstart],
1200                                               vert);
1201                 
1202         if (corner != -1) {
1203 #if 0   /* unused - this loop */
1204                 const MLoop *ml = &mloop[poly->loopstart + corner];
1205 #endif
1206
1207                 /* vertex was found */
1208                 r_adj[0] = ME_POLY_LOOP_PREV(mloop, poly, corner)->v;
1209                 r_adj[1] = ME_POLY_LOOP_NEXT(mloop, poly, corner)->v;
1210         }
1211
1212         return corner;
1213 }
1214
1215 /**
1216  * Return the index of the edge vert that is not equal to \a v. If
1217  * neither edge vertex is equal to \a v, returns -1.
1218  */
1219 int BKE_mesh_edge_other_vert(const MEdge *e, int v)
1220 {
1221         if (e->v1 == v)
1222                 return e->v2;
1223         else if (e->v2 == v)
1224                 return e->v1;
1225         else
1226                 return -1;
1227 }
1228
1229 /* basic vertex data functions */
1230 bool BKE_mesh_minmax(const Mesh *me, float r_min[3], float r_max[3])
1231 {
1232         int i = me->totvert;
1233         MVert *mvert;
1234         for (mvert = me->mvert; i--; mvert++) {
1235                 minmax_v3v3_v3(r_min, r_max, mvert->co);
1236         }
1237         
1238         return (me->totvert != 0);
1239 }
1240
1241 void BKE_mesh_transform(Mesh *me, float mat[4][4], bool do_keys)
1242 {
1243         int i;
1244         MVert *mvert = me->mvert;
1245         float (*lnors)[3] = CustomData_get_layer(&me->ldata, CD_NORMAL);
1246
1247         for (i = 0; i < me->totvert; i++, mvert++)
1248                 mul_m4_v3(mat, mvert->co);
1249
1250         if (do_keys && me->key) {
1251                 KeyBlock *kb;
1252                 for (kb = me->key->block.first; kb; kb = kb->next) {
1253                         float *fp = kb->data;
1254                         for (i = kb->totelem; i--; fp += 3) {
1255                                 mul_m4_v3(mat, fp);
1256                         }
1257                 }
1258         }
1259
1260         /* don't update normals, caller can do this explicitly.
1261          * We do update loop normals though, those may not be auto-generated (see e.g. STL import script)! */
1262         if (lnors) {
1263                 float m3[3][3];
1264
1265                 copy_m3_m4(m3, mat);
1266                 normalize_m3(m3);
1267                 for (i = 0; i < me->totloop; i++, lnors++) {
1268                         mul_m3_v3(m3, *lnors);
1269                 }
1270         }
1271 }
1272
1273 void BKE_mesh_translate(Mesh *me, const float offset[3], const bool do_keys)
1274 {
1275         int i = me->totvert;
1276         MVert *mvert;
1277         for (mvert = me->mvert; i--; mvert++) {
1278                 add_v3_v3(mvert->co, offset);
1279         }
1280         
1281         if (do_keys && me->key) {
1282                 KeyBlock *kb;
1283                 for (kb = me->key->block.first; kb; kb = kb->next) {
1284                         float *fp = kb->data;
1285                         for (i = kb->totelem; i--; fp += 3) {
1286                                 add_v3_v3(fp, offset);
1287                         }
1288                 }
1289         }
1290 }
1291
1292 void BKE_mesh_ensure_navmesh(Mesh *me)
1293 {
1294         if (!CustomData_has_layer(&me->pdata, CD_RECAST)) {
1295                 int i;
1296                 int polys_len = me->totpoly;
1297                 int *recastData;
1298                 recastData = (int *)MEM_malloc_arrayN(polys_len, sizeof(int), __func__);
1299                 for (i = 0; i < polys_len; i++) {
1300                         recastData[i] = i + 1;
1301                 }
1302                 CustomData_add_layer_named(&me->pdata, CD_RECAST, CD_ASSIGN, recastData, polys_len, "recastData");
1303         }
1304 }
1305
1306 void BKE_mesh_tessface_calc(Mesh *mesh)
1307 {
1308         mesh->totface = BKE_mesh_recalc_tessellation(&mesh->fdata, &mesh->ldata, &mesh->pdata,
1309                                                      mesh->mvert,
1310                                                      mesh->totface, mesh->totloop, mesh->totpoly,
1311                                                      /* calc normals right after, don't copy from polys here */
1312                                                      false);
1313
1314         BKE_mesh_update_customdata_pointers(mesh, true);
1315 }
1316
1317 void BKE_mesh_tessface_ensure(Mesh *mesh)
1318 {
1319         if (mesh->totpoly && mesh->totface == 0) {
1320                 BKE_mesh_tessface_calc(mesh);
1321         }
1322 }
1323
1324 void BKE_mesh_tessface_clear(Mesh *mesh)
1325 {
1326         mesh_tessface_clear_intern(mesh, true);
1327 }
1328
1329 void BKE_mesh_do_versions_cd_flag_init(Mesh *mesh)
1330 {
1331         if (UNLIKELY(mesh->cd_flag)) {
1332                 return;
1333         }
1334         else {
1335                 MVert *mv;
1336                 MEdge *med;
1337                 int i;
1338
1339                 for (mv = mesh->mvert, i = 0; i < mesh->totvert; mv++, i++) {
1340                         if (mv->bweight != 0) {
1341                                 mesh->cd_flag |= ME_CDFLAG_VERT_BWEIGHT;
1342                                 break;
1343                         }
1344                 }
1345
1346                 for (med = mesh->medge, i = 0; i < mesh->totedge; med++, i++) {
1347                         if (med->bweight != 0) {
1348                                 mesh->cd_flag |= ME_CDFLAG_EDGE_BWEIGHT;
1349                                 if (mesh->cd_flag & ME_CDFLAG_EDGE_CREASE) {
1350                                         break;
1351                                 }
1352                         }
1353                         if (med->crease != 0) {
1354                                 mesh->cd_flag |= ME_CDFLAG_EDGE_CREASE;
1355                                 if (mesh->cd_flag & ME_CDFLAG_EDGE_BWEIGHT) {
1356                                         break;
1357                                 }
1358                         }
1359                 }
1360
1361         }
1362 }
1363
1364
1365 /* -------------------------------------------------------------------- */
1366 /* MSelect functions (currently used in weight paint mode) */
1367
1368 void BKE_mesh_mselect_clear(Mesh *me)
1369 {
1370         if (me->mselect) {
1371                 MEM_freeN(me->mselect);
1372                 me->mselect = NULL;
1373         }
1374         me->totselect = 0;
1375 }
1376
1377 void BKE_mesh_mselect_validate(Mesh *me)
1378 {
1379         MSelect *mselect_src, *mselect_dst;
1380         int i_src, i_dst;
1381
1382         if (me->totselect == 0)
1383                 return;
1384
1385         mselect_src = me->mselect;
1386         mselect_dst = MEM_malloc_arrayN((me->totselect), sizeof(MSelect), "Mesh selection history");
1387
1388         for (i_src = 0, i_dst = 0; i_src < me->totselect; i_src++) {
1389                 int index = mselect_src[i_src].index;
1390                 switch (mselect_src[i_src].type) {
1391                         case ME_VSEL:
1392                         {
1393                                 if (me->mvert[index].flag & SELECT) {
1394                                         mselect_dst[i_dst] = mselect_src[i_src];
1395                                         i_dst++;
1396                                 }
1397                                 break;
1398                         }
1399                         case ME_ESEL:
1400                         {
1401                                 if (me->medge[index].flag & SELECT) {
1402                                         mselect_dst[i_dst] = mselect_src[i_src];
1403                                         i_dst++;
1404                                 }
1405                                 break;
1406                         }
1407                         case ME_FSEL:
1408                         {
1409                                 if (me->mpoly[index].flag & SELECT) {
1410                                         mselect_dst[i_dst] = mselect_src[i_src];
1411                                         i_dst++;
1412                                 }
1413                                 break;
1414                         }
1415                         default:
1416                         {
1417                                 BLI_assert(0);
1418                                 break;
1419                         }
1420                 }
1421         }
1422
1423         MEM_freeN(mselect_src);
1424
1425         if (i_dst == 0) {
1426                 MEM_freeN(mselect_dst);
1427                 mselect_dst = NULL;
1428         }
1429         else if (i_dst != me->totselect) {
1430                 mselect_dst = MEM_reallocN(mselect_dst, sizeof(MSelect) * i_dst);
1431         }
1432
1433         me->totselect = i_dst;
1434         me->mselect = mselect_dst;
1435
1436 }
1437
1438 /**
1439  * Return the index within me->mselect, or -1
1440  */
1441 int BKE_mesh_mselect_find(Mesh *me, int index, int type)
1442 {
1443         int i;
1444
1445         BLI_assert(ELEM(type, ME_VSEL, ME_ESEL, ME_FSEL));
1446
1447         for (i = 0; i < me->totselect; i++) {
1448                 if ((me->mselect[i].index == index) &&
1449                     (me->mselect[i].type == type))
1450                 {
1451                         return i;
1452                 }
1453         }
1454
1455         return -1;
1456 }
1457
1458 /**
1459  * Return The index of the active element.
1460  */
1461 int BKE_mesh_mselect_active_get(Mesh *me, int type)
1462 {
1463         BLI_assert(ELEM(type, ME_VSEL, ME_ESEL, ME_FSEL));
1464
1465         if (me->totselect) {
1466                 if (me->mselect[me->totselect - 1].type == type) {
1467                         return me->mselect[me->totselect - 1].index;
1468                 }
1469         }
1470         return -1;
1471 }
1472
1473 void BKE_mesh_mselect_active_set(Mesh *me, int index, int type)
1474 {
1475         const int msel_index = BKE_mesh_mselect_find(me, index, type);
1476
1477         if (msel_index == -1) {
1478                 /* add to the end */
1479                 me->mselect = MEM_reallocN(me->mselect, sizeof(MSelect) * (me->totselect + 1));
1480                 me->mselect[me->totselect].index = index;
1481                 me->mselect[me->totselect].type  = type;
1482                 me->totselect++;
1483         }
1484         else if (msel_index != me->totselect - 1) {
1485                 /* move to the end */
1486                 SWAP(MSelect, me->mselect[msel_index], me->mselect[me->totselect - 1]);
1487         }
1488
1489         BLI_assert((me->mselect[me->totselect - 1].index == index) &&
1490                    (me->mselect[me->totselect - 1].type  == type));
1491 }
1492
1493
1494 void BKE_mesh_apply_vert_coords(Mesh *mesh, float (*vertCoords)[3])
1495 {
1496         MVert *vert;
1497         int i;
1498
1499         /* this will just return the pointer if it wasn't a referenced layer */
1500         vert = CustomData_duplicate_referenced_layer(&mesh->vdata, CD_MVERT, mesh->totvert);
1501         mesh->mvert = vert;
1502
1503         for (i = 0; i < mesh->totvert; ++i, ++vert)
1504                 copy_v3_v3(vert->co, vertCoords[i]);
1505
1506         mesh->runtime.cd_dirty_vert |= CD_MASK_NORMAL;
1507 }
1508
1509 /**
1510  * Compute 'split' (aka loop, or per face corner's) normals.
1511  *
1512  * \param r_lnors_spacearr Allows to get computed loop normal space array. That data, among other things,
1513  *                         contains 'smooth fan' info, useful e.g. to split geometry along sharp edges...
1514  */
1515 void BKE_mesh_calc_normals_split_ex(Mesh *mesh, MLoopNorSpaceArray *r_lnors_spacearr)
1516 {
1517         float (*r_loopnors)[3];
1518         float (*polynors)[3];
1519         short (*clnors)[2] = NULL;
1520         bool free_polynors = false;
1521
1522         /* Note that we enforce computing clnors when the clnor space array is requested by caller here.
1523          * However, we obviously only use the autosmooth angle threshold only in case autosmooth is enabled. */
1524         const bool use_split_normals = (r_lnors_spacearr != NULL) || ((mesh->flag & ME_AUTOSMOOTH) != 0);
1525         const float split_angle = (mesh->flag & ME_AUTOSMOOTH) != 0 ? mesh->smoothresh : (float)M_PI;
1526
1527         if (CustomData_has_layer(&mesh->ldata, CD_NORMAL)) {
1528                 r_loopnors = CustomData_get_layer(&mesh->ldata, CD_NORMAL);
1529                 memset(r_loopnors, 0, sizeof(float[3]) * mesh->totloop);
1530         }
1531         else {
1532                 r_loopnors = CustomData_add_layer(&mesh->ldata, CD_NORMAL, CD_CALLOC, NULL, mesh->totloop);
1533                 CustomData_set_layer_flag(&mesh->ldata, CD_NORMAL, CD_FLAG_TEMPORARY);
1534         }
1535
1536         /* may be NULL */
1537         clnors = CustomData_get_layer(&mesh->ldata, CD_CUSTOMLOOPNORMAL);
1538
1539         if (CustomData_has_layer(&mesh->pdata, CD_NORMAL)) {
1540                 /* This assume that layer is always up to date, not sure this is the case (esp. in Edit mode?)... */
1541                 polynors = CustomData_get_layer(&mesh->pdata, CD_NORMAL);
1542                 free_polynors = false;
1543         }
1544         else {
1545                 polynors = MEM_malloc_arrayN(mesh->totpoly, sizeof(float[3]), __func__);
1546                 BKE_mesh_calc_normals_poly(
1547                             mesh->mvert, NULL, mesh->totvert,
1548                             mesh->mloop, mesh->mpoly, mesh->totloop, mesh->totpoly, polynors, false);
1549                 free_polynors = true;
1550         }
1551
1552         BKE_mesh_normals_loop_split(
1553                 mesh->mvert, mesh->totvert, mesh->medge, mesh->totedge,
1554                 mesh->mloop, r_loopnors, mesh->totloop, mesh->mpoly, (const float (*)[3])polynors, mesh->totpoly,
1555                 use_split_normals, split_angle, r_lnors_spacearr, clnors, NULL);
1556
1557         if (free_polynors) {
1558                 MEM_freeN(polynors);
1559         }
1560
1561         mesh->runtime.cd_dirty_vert &= ~CD_MASK_NORMAL;
1562 }
1563
1564 void BKE_mesh_calc_normals_split(Mesh *mesh)
1565 {
1566         BKE_mesh_calc_normals_split_ex(mesh, NULL);
1567 }
1568
1569 /* Split faces helper functions. */
1570
1571 typedef struct SplitFaceNewVert {
1572         struct SplitFaceNewVert *next;
1573         int new_index;
1574         int orig_index;
1575         float *vnor;
1576 } SplitFaceNewVert;
1577
1578 typedef struct SplitFaceNewEdge {
1579         struct SplitFaceNewEdge *next;
1580         int new_index;
1581         int orig_index;
1582         int v1;
1583         int v2;
1584 } SplitFaceNewEdge;
1585
1586 /* Detect needed new vertices, and update accordingly loops' vertex indices.
1587  * WARNING! Leaves mesh in invalid state. */
1588 static int split_faces_prepare_new_verts(
1589         const Mesh *mesh, MLoopNorSpaceArray *lnors_spacearr, SplitFaceNewVert **new_verts, MemArena *memarena)
1590 {
1591         /* This is now mandatory, trying to do the job in simple way without that data is doomed to fail, even when only
1592          * dealing with smooth/flat faces one can find cases that no simple algorithm can handle properly. */
1593         BLI_assert(lnors_spacearr != NULL);
1594
1595         const int loops_len = mesh->totloop;
1596         int verts_len = mesh->totvert;
1597         MVert *mvert = mesh->mvert;
1598         MLoop *mloop = mesh->mloop;
1599
1600         BLI_bitmap *verts_used = BLI_BITMAP_NEW(verts_len, __func__);
1601         BLI_bitmap *done_loops = BLI_BITMAP_NEW(loops_len, __func__);
1602
1603         MLoop *ml = mloop;
1604         MLoopNorSpace **lnor_space = lnors_spacearr->lspacearr;
1605
1606         BLI_assert(lnors_spacearr->data_type == MLNOR_SPACEARR_LOOP_INDEX);
1607
1608         for (int loop_idx = 0; loop_idx < loops_len; loop_idx++, ml++, lnor_space++) {
1609                 if (!BLI_BITMAP_TEST(done_loops, loop_idx)) {
1610                         const int vert_idx = ml->v;
1611                         const bool vert_used = BLI_BITMAP_TEST_BOOL(verts_used, vert_idx);
1612                         /* If vert is already used by another smooth fan, we need a new vert for this one. */
1613                         const int new_vert_idx = vert_used ? verts_len++ : vert_idx;
1614
1615                         BLI_assert(*lnor_space);
1616
1617                         if ((*lnor_space)->flags & MLNOR_SPACE_IS_SINGLE) {
1618                                 /* Single loop in this fan... */
1619                                 BLI_assert(GET_INT_FROM_POINTER((*lnor_space)->loops) == loop_idx);
1620                                 BLI_BITMAP_ENABLE(done_loops, loop_idx);
1621                                 if (vert_used) {
1622                                         ml->v = new_vert_idx;
1623                                 }
1624                         }
1625                         else {
1626                                 for (LinkNode *lnode = (*lnor_space)->loops; lnode; lnode = lnode->next) {
1627                                         const int ml_fan_idx = GET_INT_FROM_POINTER(lnode->link);
1628                                         BLI_BITMAP_ENABLE(done_loops, ml_fan_idx);
1629                                         if (vert_used) {
1630                                                 mloop[ml_fan_idx].v = new_vert_idx;
1631                                         }
1632                                 }
1633                         }
1634
1635                         if (!vert_used) {
1636                                 BLI_BITMAP_ENABLE(verts_used, vert_idx);
1637                                 /* We need to update that vertex's normal here, we won't go over it again. */
1638                                 /* This is important! *DO NOT* set vnor to final computed lnor, vnor should always be defined to
1639                                  * 'automatic normal' value computed from its polys, not some custom normal.
1640                                  * Fortunately, that's the loop normal space's 'lnor' reference vector. ;) */
1641                                 normal_float_to_short_v3(mvert[vert_idx].no, (*lnor_space)->vec_lnor);
1642                         }
1643                         else {
1644                                 /* Add new vert to list. */
1645                                 SplitFaceNewVert *new_vert = BLI_memarena_alloc(memarena, sizeof(*new_vert));
1646                                 new_vert->orig_index = vert_idx;
1647                                 new_vert->new_index = new_vert_idx;
1648                                 new_vert->vnor = (*lnor_space)->vec_lnor;  /* See note above. */
1649                                 new_vert->next = *new_verts;
1650                                 *new_verts = new_vert;
1651                         }
1652                 }
1653         }
1654
1655         MEM_freeN(done_loops);
1656         MEM_freeN(verts_used);
1657
1658         return verts_len - mesh->totvert;
1659 }
1660
1661 /* Detect needed new edges, and update accordingly loops' edge indices.
1662  * WARNING! Leaves mesh in invalid state. */
1663 static int split_faces_prepare_new_edges(
1664         const Mesh *mesh, SplitFaceNewEdge **new_edges, MemArena *memarena)
1665 {
1666         const int num_polys = mesh->totpoly;
1667         int num_edges = mesh->totedge;
1668         MEdge *medge = mesh->medge;
1669         MLoop *mloop = mesh->mloop;
1670         const MPoly *mpoly = mesh->mpoly;
1671
1672         BLI_bitmap *edges_used = BLI_BITMAP_NEW(num_edges, __func__);
1673         EdgeHash *edges_hash = BLI_edgehash_new_ex(__func__, num_edges);
1674
1675         const MPoly *mp = mpoly;
1676         for (int poly_idx = 0; poly_idx < num_polys; poly_idx++, mp++) {
1677                 MLoop *ml_prev = &mloop[mp->loopstart + mp->totloop - 1];
1678                 MLoop *ml = &mloop[mp->loopstart];
1679                 for (int loop_idx = 0; loop_idx < mp->totloop; loop_idx++, ml++) {
1680                         void **eval;
1681                         if (!BLI_edgehash_ensure_p(edges_hash, ml_prev->v, ml->v, &eval)) {
1682                                 const int edge_idx = ml_prev->e;
1683
1684                                 /* That edge has not been encountered yet, define it. */
1685                                 if (BLI_BITMAP_TEST(edges_used, edge_idx)) {
1686                                         /* Original edge has already been used, we need to define a new one. */
1687                                         const int new_edge_idx = num_edges++;
1688                                         *eval = SET_INT_IN_POINTER(new_edge_idx);
1689                                         ml_prev->e = new_edge_idx;
1690
1691                                         SplitFaceNewEdge *new_edge = BLI_memarena_alloc(memarena, sizeof(*new_edge));
1692                                         new_edge->orig_index = edge_idx;
1693                                         new_edge->new_index = new_edge_idx;
1694                                         new_edge->v1 = ml_prev->v;
1695                                         new_edge->v2 = ml->v;
1696                                         new_edge->next = *new_edges;
1697                                         *new_edges = new_edge;
1698                                 }
1699                                 else {
1700                                         /* We can re-use original edge. */
1701                                         medge[edge_idx].v1 = ml_prev->v;
1702                                         medge[edge_idx].v2 = ml->v;
1703                                         *eval = SET_INT_IN_POINTER(edge_idx);
1704                                         BLI_BITMAP_ENABLE(edges_used, edge_idx);
1705                                 }
1706                         }
1707                         else {
1708                                 /* Edge already known, just update loop's edge index. */
1709                                 ml_prev->e = GET_INT_FROM_POINTER(*eval);
1710                         }
1711
1712                         ml_prev = ml;
1713                 }
1714         }
1715
1716         MEM_freeN(edges_used);
1717         BLI_edgehash_free(edges_hash, NULL);
1718
1719         return num_edges - mesh->totedge;
1720 }
1721
1722 /* Perform actual split of vertices. */
1723 static void split_faces_split_new_verts(
1724         Mesh *mesh, SplitFaceNewVert *new_verts, const int num_new_verts)
1725 {
1726         const int verts_len = mesh->totvert - num_new_verts;
1727         MVert *mvert = mesh->mvert;
1728
1729         /* Remember new_verts is a single linklist, so its items are in reversed order... */
1730         MVert *new_mv = &mvert[mesh->totvert - 1];
1731         for (int i = mesh->totvert - 1; i >= verts_len ; i--, new_mv--, new_verts = new_verts->next) {
1732                 BLI_assert(new_verts->new_index == i);
1733                 BLI_assert(new_verts->new_index != new_verts->orig_index);
1734                 CustomData_copy_data(&mesh->vdata, &mesh->vdata, new_verts->orig_index, i, 1);
1735                 if (new_verts->vnor) {
1736                         normal_float_to_short_v3(new_mv->no, new_verts->vnor);
1737                 }
1738         }
1739 }
1740
1741 /* Perform actual split of edges. */
1742 static void split_faces_split_new_edges(
1743         Mesh *mesh, SplitFaceNewEdge *new_edges, const int num_new_edges)
1744 {
1745         const int num_edges = mesh->totedge - num_new_edges;
1746         MEdge *medge = mesh->medge;
1747
1748         /* Remember new_edges is a single linklist, so its items are in reversed order... */
1749         MEdge *new_med = &medge[mesh->totedge - 1];
1750         for (int i = mesh->totedge - 1; i >= num_edges ; i--, new_med--, new_edges = new_edges->next) {
1751                 BLI_assert(new_edges->new_index == i);
1752                 BLI_assert(new_edges->new_index != new_edges->orig_index);
1753                 CustomData_copy_data(&mesh->edata, &mesh->edata, new_edges->orig_index, i, 1);
1754                 new_med->v1 = new_edges->v1;
1755                 new_med->v2 = new_edges->v2;
1756         }
1757 }
1758
1759 /* Split faces based on the edge angle and loop normals.
1760  * Matches behavior of face splitting in render engines.
1761  *
1762  * NOTE: Will leave CD_NORMAL loop data layer which is
1763  * used by render engines to set shading up.
1764  */
1765 void BKE_mesh_split_faces(Mesh *mesh, bool free_loop_normals)
1766 {
1767         const int num_polys = mesh->totpoly;
1768
1769         if (num_polys == 0) {
1770                 return;
1771         }
1772         BKE_mesh_tessface_clear(mesh);
1773
1774         MLoopNorSpaceArray lnors_spacearr = {NULL};
1775         /* Compute loop normals and loop normal spaces (a.k.a. smooth fans of faces around vertices). */
1776         BKE_mesh_calc_normals_split_ex(mesh, &lnors_spacearr);
1777         /* Stealing memarena from loop normals space array. */
1778         MemArena *memarena = lnors_spacearr.mem;
1779
1780         SplitFaceNewVert *new_verts = NULL;
1781         SplitFaceNewEdge *new_edges = NULL;
1782
1783         /* Detect loop normal spaces (a.k.a. smooth fans) that will need a new vert. */
1784         const int num_new_verts = split_faces_prepare_new_verts(mesh, &lnors_spacearr, &new_verts, memarena);
1785
1786         if (num_new_verts > 0) {
1787                 /* Reminder: beyond this point, there is no way out, mesh is in invalid state (due to early-reassignment of
1788                  * loops' vertex and edge indices to new, to-be-created split ones). */
1789
1790                 const int num_new_edges = split_faces_prepare_new_edges(mesh, &new_edges, memarena);
1791                 /* We can have to split a vertex without having to add a single new edge... */
1792                 const bool do_edges = (num_new_edges > 0);
1793
1794                 /* Reallocate all vert and edge related data. */
1795                 mesh->totvert += num_new_verts;
1796                 CustomData_realloc(&mesh->vdata, mesh->totvert);
1797                 if (do_edges) {
1798                         mesh->totedge += num_new_edges;
1799                         CustomData_realloc(&mesh->edata, mesh->totedge);
1800                 }
1801                 /* Update pointers to a newly allocated memory. */
1802                 BKE_mesh_update_customdata_pointers(mesh, false);
1803
1804                 /* Perform actual split of vertices and edges. */
1805                 split_faces_split_new_verts(mesh, new_verts, num_new_verts);
1806                 if (do_edges) {
1807                         split_faces_split_new_edges(mesh, new_edges, num_new_edges);
1808                 }
1809         }
1810
1811         /* Note: after this point mesh is expected to be valid again. */
1812
1813         /* CD_NORMAL is expected to be temporary only. */
1814         if (free_loop_normals) {
1815                 CustomData_free_layers(&mesh->ldata, CD_NORMAL, mesh->totloop);
1816         }
1817
1818         /* Also frees new_verts/edges temp data, since we used its memarena to allocate them. */
1819         BKE_lnor_spacearr_free(&lnors_spacearr);
1820
1821 #ifdef VALIDATE_MESH
1822         BKE_mesh_validate(mesh, true, true);
1823 #endif
1824 }
1825
1826 /* **** Depsgraph evaluation **** */
1827
1828 void BKE_mesh_eval_geometry(Depsgraph *depsgraph,
1829                             Mesh *mesh)
1830 {
1831         DEG_debug_print_eval(depsgraph, __func__, mesh->id.name, mesh);
1832         if (mesh->bb == NULL || (mesh->bb->flag & BOUNDBOX_DIRTY)) {
1833                 BKE_mesh_texspace_calc(mesh);
1834         }
1835 }
1836
1837 /* Draw Engine */
1838 void (*BKE_mesh_batch_cache_dirty_cb)(Mesh *me, int mode) = NULL;
1839 void (*BKE_mesh_batch_cache_free_cb)(Mesh *me) = NULL;
1840
1841 void BKE_mesh_batch_cache_dirty(Mesh *me, int mode)
1842 {
1843         if (me->runtime.batch_cache) {
1844                 BKE_mesh_batch_cache_dirty_cb(me, mode);
1845         }
1846 }
1847 void BKE_mesh_batch_cache_free(Mesh *me)
1848 {
1849         if (me->runtime.batch_cache) {
1850                 BKE_mesh_batch_cache_free_cb(me);
1851         }
1852 }