DRW: Add batch garbage collection
[blender.git] / source / blender / draw / intern / draw_cache_impl_mesh.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) 2017 by Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup draw
22  *
23  * \brief Mesh API for render engines
24  */
25
26 #include "MEM_guardedalloc.h"
27
28 #include "BLI_buffer.h"
29 #include "BLI_utildefines.h"
30 #include "BLI_math_vector.h"
31 #include "BLI_math_bits.h"
32 #include "BLI_string.h"
33 #include "BLI_alloca.h"
34 #include "BLI_edgehash.h"
35
36 #include "DNA_mesh_types.h"
37 #include "DNA_meshdata_types.h"
38 #include "DNA_object_types.h"
39 #include "DNA_scene_types.h"
40
41 #include "BKE_customdata.h"
42 #include "BKE_deform.h"
43 #include "BKE_editmesh.h"
44 #include "BKE_editmesh_cache.h"
45 #include "BKE_editmesh_tangent.h"
46 #include "BKE_mesh.h"
47 #include "BKE_mesh_tangent.h"
48 #include "BKE_mesh_runtime.h"
49 #include "BKE_object_deform.h"
50
51 #include "atomic_ops.h"
52
53 #include "bmesh.h"
54
55 #include "GPU_batch.h"
56 #include "GPU_extensions.h"
57 #include "GPU_material.h"
58
59 #include "DRW_render.h"
60
61 #include "ED_mesh.h"
62 #include "ED_uvedit.h"
63
64 #include "draw_cache_impl.h" /* own include */
65
66 static void mesh_batch_cache_clear(Mesh *me);
67
68 /* Vertex Group Selection and display options */
69 typedef struct DRW_MeshWeightState {
70   int defgroup_active;
71   int defgroup_len;
72
73   short flags;
74   char alert_mode;
75
76   /* Set of all selected bones for Multipaint. */
77   bool *defgroup_sel; /* [defgroup_len] */
78   int defgroup_sel_count;
79 } DRW_MeshWeightState;
80
81 typedef struct DRW_MeshCDMask {
82   uint32_t uv : 8;
83   uint32_t tan : 8;
84   uint32_t vcol : 8;
85   uint32_t orco : 1;
86   uint32_t tan_orco : 1;
87 } DRW_MeshCDMask;
88
89 /* DRW_MeshWeightState.flags */
90 enum {
91   DRW_MESH_WEIGHT_STATE_MULTIPAINT = (1 << 0),
92   DRW_MESH_WEIGHT_STATE_AUTO_NORMALIZE = (1 << 1),
93 };
94
95 /* ---------------------------------------------------------------------- */
96 /** \name BMesh Inline Wrappers
97  * \{ */
98
99 /**
100  * Wrapper for #BM_vert_find_first_loop_visible
101  * since most of the time this can be accessed directly without a function call.
102  */
103 BLI_INLINE BMLoop *bm_vert_find_first_loop_visible_inline(BMVert *v)
104 {
105   if (v->e) {
106     BMLoop *l = v->e->l;
107     if (l && !BM_elem_flag_test(l->f, BM_ELEM_HIDDEN)) {
108       return l->v == v ? l : l->next;
109     }
110     return BM_vert_find_first_loop_visible(v);
111   }
112   return NULL;
113 }
114
115 BLI_INLINE BMLoop *bm_edge_find_first_loop_visible_inline(BMEdge *e)
116 {
117   if (e->l) {
118     BMLoop *l = e->l;
119     if (!BM_elem_flag_test(l->f, BM_ELEM_HIDDEN)) {
120       return l;
121     }
122     return BM_edge_find_first_loop_visible(e);
123   }
124   return NULL;
125 }
126
127 /** \} */
128
129 /* ---------------------------------------------------------------------- */
130 /** \name Mesh/BMesh Interface (direct access to basic data).
131  * \{ */
132
133 static int mesh_render_verts_len_get(Mesh *me)
134 {
135   return me->edit_mesh ? me->edit_mesh->bm->totvert : me->totvert;
136 }
137
138 static int mesh_render_edges_len_get(Mesh *me)
139 {
140   return me->edit_mesh ? me->edit_mesh->bm->totedge : me->totedge;
141 }
142
143 static int mesh_render_looptri_len_get(Mesh *me)
144 {
145   return me->edit_mesh ? me->edit_mesh->tottri : poly_to_tri_count(me->totpoly, me->totloop);
146 }
147
148 static int mesh_render_polys_len_get(Mesh *me)
149 {
150   return me->edit_mesh ? me->edit_mesh->bm->totface : me->totpoly;
151 }
152
153 static int mesh_render_mat_len_get(Mesh *me)
154 {
155   return MAX2(1, me->totcol);
156 }
157
158 static int UNUSED_FUNCTION(mesh_render_loops_len_get)(Mesh *me)
159 {
160   return me->edit_mesh ? me->edit_mesh->bm->totloop : me->totloop;
161 }
162
163 /** \} */
164
165 /* ---------------------------------------------------------------------- */
166 /** \name Mesh/BMesh Interface (indirect, partially cached access to complex data).
167  * \{ */
168
169 typedef struct EdgeAdjacentPolys {
170   int count;
171   int face_index[2];
172 } EdgeAdjacentPolys;
173
174 typedef struct EdgeAdjacentVerts {
175   int vert_index[2]; /* -1 if none */
176 } EdgeAdjacentVerts;
177
178 typedef struct EdgeDrawAttr {
179   uchar v_flag;
180   uchar e_flag;
181   uchar crease;
182   uchar bweight;
183 } EdgeDrawAttr;
184
185 typedef struct MeshRenderData {
186   int types;
187
188   int vert_len;
189   int edge_len;
190   int tri_len;
191   int loop_len;
192   int poly_len;
193   int mat_len;
194   int loose_vert_len;
195   int loose_edge_len;
196
197   /* Support for mapped mesh data. */
198   struct {
199     /* Must be set if we want to get mapped data. */
200     bool use;
201     bool supported;
202
203     Mesh *me_cage;
204
205     int vert_len;
206     int edge_len;
207     int tri_len;
208     int loop_len;
209     int poly_len;
210
211     int *loose_verts;
212     int loose_vert_len;
213
214     int *loose_edges;
215     int loose_edge_len;
216
217     /* origindex layers */
218     int *v_origindex;
219     int *e_origindex;
220     int *l_origindex;
221     int *p_origindex;
222   } mapped;
223
224   BMEditMesh *edit_bmesh;
225   struct EditMeshData *edit_data;
226   const ToolSettings *toolsettings;
227
228   Mesh *me;
229
230   MVert *mvert;
231   const MEdge *medge;
232   const MLoop *mloop;
233   const MPoly *mpoly;
234   float (*orco)[3]; /* vertex coordinates normalized to bounding box */
235   bool is_orco_allocated;
236   MDeformVert *dvert;
237   MLoopUV *mloopuv;
238   MLoopCol *mloopcol;
239   float (*loop_normals)[3];
240
241   /* CustomData 'cd' cache for efficient access. */
242   struct {
243     struct {
244       MLoopUV **uv;
245       int uv_len;
246       int uv_active;
247       int uv_mask_active;
248
249       MLoopCol **vcol;
250       int vcol_len;
251       int vcol_active;
252
253       float (**tangent)[4];
254       int tangent_len;
255       int tangent_active;
256
257       bool *auto_vcol;
258     } layers;
259
260     /* Custom-data offsets (only needed for BMesh access) */
261     struct {
262       int crease;
263       int bweight;
264       int *uv;
265       int *vcol;
266 #ifdef WITH_FREESTYLE
267       int freestyle_edge;
268       int freestyle_face;
269 #endif
270     } offset;
271
272     struct {
273       char (*auto_mix)[32];
274       char (*uv)[32];
275       char (*vcol)[32];
276       char (*tangent)[32];
277     } uuid;
278
279     /* for certain cases we need an output loop-data storage (bmesh tangents) */
280     struct {
281       CustomData ldata;
282       /* grr, special case variable (use in place of 'dm->tangent_mask') */
283       short tangent_mask;
284     } output;
285   } cd;
286
287   BMVert *eve_act;
288   BMEdge *eed_act;
289   BMFace *efa_act;
290   BMFace *efa_act_uv;
291
292   /* Data created on-demand (usually not for bmesh-based data). */
293   EdgeAdjacentPolys *edges_adjacent_polys;
294   MLoopTri *mlooptri;
295   int *loose_edges;
296   int *loose_verts;
297
298   float (*poly_normals)[3];
299   float *vert_weight;
300   char (*vert_color)[3];
301   GPUPackedNormal *poly_normals_pack;
302   GPUPackedNormal *vert_normals_pack;
303   bool *edge_select_bool;
304   bool *edge_visible_bool;
305 } MeshRenderData;
306
307 enum {
308   MR_DATATYPE_VERT = 1 << 0,
309   MR_DATATYPE_EDGE = 1 << 1,
310   MR_DATATYPE_LOOPTRI = 1 << 2,
311   MR_DATATYPE_LOOP = 1 << 3,
312   MR_DATATYPE_POLY = 1 << 4,
313   MR_DATATYPE_OVERLAY = 1 << 5,
314   MR_DATATYPE_SHADING = 1 << 6,
315   MR_DATATYPE_DVERT = 1 << 7,
316   MR_DATATYPE_LOOPCOL = 1 << 8,
317   MR_DATATYPE_LOOPUV = 1 << 9,
318   MR_DATATYPE_LOOSE_VERT = 1 << 10,
319   MR_DATATYPE_LOOSE_EDGE = 1 << 11,
320 };
321
322 /**
323  * These functions look like they would be slow but they will typically return true on the first iteration.
324  * Only false when all attached elements are hidden.
325  */
326 static bool bm_vert_has_visible_edge(const BMVert *v)
327 {
328   const BMEdge *e_iter, *e_first;
329
330   e_iter = e_first = v->e;
331   do {
332     if (!BM_elem_flag_test(e_iter, BM_ELEM_HIDDEN)) {
333       return true;
334     }
335   } while ((e_iter = BM_DISK_EDGE_NEXT(e_iter, v)) != e_first);
336   return false;
337 }
338
339 static bool bm_edge_has_visible_face(const BMEdge *e)
340 {
341   const BMLoop *l_iter, *l_first;
342   l_iter = l_first = e->l;
343   do {
344     if (!BM_elem_flag_test(l_iter->f, BM_ELEM_HIDDEN)) {
345       return true;
346     }
347   } while ((l_iter = l_iter->radial_next) != l_first);
348   return false;
349 }
350
351 BLI_INLINE bool bm_vert_is_loose_and_visible(const BMVert *v)
352 {
353   return (!BM_elem_flag_test(v, BM_ELEM_HIDDEN) && (v->e == NULL || !bm_vert_has_visible_edge(v)));
354 }
355
356 BLI_INLINE bool bm_edge_is_loose_and_visible(const BMEdge *e)
357 {
358   return (!BM_elem_flag_test(e, BM_ELEM_HIDDEN) && (e->l == NULL || !bm_edge_has_visible_face(e)));
359 }
360
361 /* Return true is all layers in _b_ are inside _a_. */
362 BLI_INLINE bool mesh_cd_layers_type_overlap(DRW_MeshCDMask a, DRW_MeshCDMask b)
363 {
364   return (*((uint32_t *)&a) & *((uint32_t *)&b)) == *((uint32_t *)&b);
365 }
366
367 BLI_INLINE bool mesh_cd_layers_type_equal(DRW_MeshCDMask a, DRW_MeshCDMask b)
368 {
369   return *((uint32_t *)&a) == *((uint32_t *)&b);
370 }
371
372 BLI_INLINE void mesh_cd_layers_type_merge(DRW_MeshCDMask *a, DRW_MeshCDMask b)
373 {
374   atomic_fetch_and_or_uint32((uint32_t *)a, *(uint32_t *)&b);
375 }
376
377 BLI_INLINE void mesh_cd_layers_type_clear(DRW_MeshCDMask *a)
378 {
379   *((uint32_t *)a) = 0;
380 }
381
382 static void mesh_cd_calc_active_uv_layer(const Mesh *me, DRW_MeshCDMask *cd_used)
383 {
384   const CustomData *cd_ldata = (me->edit_mesh) ? &me->edit_mesh->bm->ldata : &me->ldata;
385
386   int layer = CustomData_get_active_layer(cd_ldata, CD_MLOOPUV);
387   if (layer != -1) {
388     cd_used->uv |= (1 << layer);
389   }
390 }
391
392 static void mesh_cd_calc_active_mask_uv_layer(const Mesh *me, DRW_MeshCDMask *cd_used)
393 {
394   const CustomData *cd_ldata = (me->edit_mesh) ? &me->edit_mesh->bm->ldata : &me->ldata;
395
396   int layer = CustomData_get_stencil_layer(cd_ldata, CD_MLOOPUV);
397   if (layer != -1) {
398     cd_used->uv |= (1 << layer);
399   }
400 }
401
402 static void mesh_cd_calc_active_vcol_layer(const Mesh *me, DRW_MeshCDMask *cd_used)
403 {
404   const CustomData *cd_ldata = (me->edit_mesh) ? &me->edit_mesh->bm->ldata : &me->ldata;
405
406   int layer = CustomData_get_active_layer(cd_ldata, CD_MLOOPCOL);
407   if (layer != -1) {
408     cd_used->vcol |= (1 << layer);
409   }
410 }
411
412 static DRW_MeshCDMask mesh_cd_calc_used_gpu_layers(const Mesh *me,
413                                                    struct GPUMaterial **gpumat_array,
414                                                    int gpumat_array_len)
415 {
416   const CustomData *cd_ldata = (me->edit_mesh) ? &me->edit_mesh->bm->ldata : &me->ldata;
417
418   /* See: DM_vertex_attributes_from_gpu for similar logic */
419   GPUVertAttrLayers gpu_attrs = {{{0}}};
420   DRW_MeshCDMask cd_used;
421   mesh_cd_layers_type_clear(&cd_used);
422
423   for (int i = 0; i < gpumat_array_len; i++) {
424     GPUMaterial *gpumat = gpumat_array[i];
425     if (gpumat) {
426       GPU_material_vertex_attrs(gpumat, &gpu_attrs);
427       for (int j = 0; j < gpu_attrs.totlayer; j++) {
428         const char *name = gpu_attrs.layer[j].name;
429         int type = gpu_attrs.layer[j].type;
430         int layer = -1;
431
432         if (type == CD_AUTO_FROM_NAME) {
433           /* We need to deduct what exact layer is used.
434            *
435            * We do it based on the specified name.
436            */
437           if (name[0] != '\0') {
438             layer = CustomData_get_named_layer(cd_ldata, CD_MLOOPUV, name);
439             type = CD_MTFACE;
440
441             if (layer == -1) {
442               layer = CustomData_get_named_layer(cd_ldata, CD_MLOOPCOL, name);
443               type = CD_MCOL;
444             }
445 #if 0 /* Tangents are always from UV's - this will never happen. */
446             if (layer == -1) {
447               layer = CustomData_get_named_layer(cd_ldata, CD_TANGENT, name);
448               type = CD_TANGENT;
449             }
450 #endif
451             if (layer == -1) {
452               continue;
453             }
454           }
455           else {
456             /* Fall back to the UV layer, which matches old behavior. */
457             type = CD_MTFACE;
458           }
459         }
460
461         switch (type) {
462           case CD_MTFACE: {
463             if (layer == -1) {
464               layer = (name[0] != '\0') ? CustomData_get_named_layer(cd_ldata, CD_MLOOPUV, name) :
465                                           CustomData_get_active_layer(cd_ldata, CD_MLOOPUV);
466             }
467             if (layer != -1) {
468               cd_used.uv |= (1 << layer);
469             }
470             break;
471           }
472           case CD_TANGENT: {
473             if (layer == -1) {
474               layer = (name[0] != '\0') ? CustomData_get_named_layer(cd_ldata, CD_MLOOPUV, name) :
475                                           CustomData_get_active_layer(cd_ldata, CD_MLOOPUV);
476
477               /* Only fallback to orco (below) when we have no UV layers, see: T56545 */
478               if (layer == -1 && name[0] != '\0') {
479                 layer = CustomData_get_active_layer(cd_ldata, CD_MLOOPUV);
480               }
481             }
482             if (layer != -1) {
483               cd_used.tan |= (1 << layer);
484             }
485             else {
486               /* no UV layers at all => requesting orco */
487               cd_used.tan_orco = 1;
488               cd_used.orco = 1;
489             }
490             break;
491           }
492           case CD_MCOL: {
493             if (layer == -1) {
494               layer = (name[0] != '\0') ? CustomData_get_named_layer(cd_ldata, CD_MLOOPCOL, name) :
495                                           CustomData_get_active_layer(cd_ldata, CD_MLOOPCOL);
496             }
497             if (layer != -1) {
498               cd_used.vcol |= (1 << layer);
499             }
500             break;
501           }
502           case CD_ORCO: {
503             cd_used.orco = 1;
504             break;
505           }
506         }
507       }
508     }
509   }
510   return cd_used;
511 }
512
513 static void mesh_render_calc_normals_loop_and_poly(const Mesh *me,
514                                                    const float split_angle,
515                                                    MeshRenderData *rdata)
516 {
517   BLI_assert((me->flag & ME_AUTOSMOOTH) != 0);
518
519   int totloop = me->totloop;
520   int totpoly = me->totpoly;
521   float(*loop_normals)[3] = MEM_mallocN(sizeof(*loop_normals) * totloop, __func__);
522   float(*poly_normals)[3] = MEM_mallocN(sizeof(*poly_normals) * totpoly, __func__);
523   short(*clnors)[2] = CustomData_get_layer(&me->ldata, CD_CUSTOMLOOPNORMAL);
524
525   BKE_mesh_calc_normals_poly(
526       me->mvert, NULL, me->totvert, me->mloop, me->mpoly, totloop, totpoly, poly_normals, false);
527
528   BKE_mesh_normals_loop_split(me->mvert,
529                               me->totvert,
530                               me->medge,
531                               me->totedge,
532                               me->mloop,
533                               loop_normals,
534                               totloop,
535                               me->mpoly,
536                               poly_normals,
537                               totpoly,
538                               true,
539                               split_angle,
540                               NULL,
541                               clnors,
542                               NULL);
543
544   rdata->loop_len = totloop;
545   rdata->poly_len = totpoly;
546   rdata->loop_normals = loop_normals;
547   rdata->poly_normals = poly_normals;
548 }
549
550 static void mesh_cd_extract_auto_layers_names_and_srgb(Mesh *me,
551                                                        DRW_MeshCDMask cd_used,
552                                                        char **r_auto_layers_names,
553                                                        int **r_auto_layers_srgb,
554                                                        int *r_auto_layers_len)
555 {
556   const CustomData *cd_ldata = (me->edit_mesh) ? &me->edit_mesh->bm->ldata : &me->ldata;
557
558   int uv_len_used = count_bits_i(cd_used.uv);
559   int vcol_len_used = count_bits_i(cd_used.vcol);
560   int uv_len = CustomData_number_of_layers(cd_ldata, CD_MLOOPUV);
561   int vcol_len = CustomData_number_of_layers(cd_ldata, CD_MLOOPCOL);
562
563   uint auto_names_len = 32 * (uv_len_used + vcol_len_used);
564   uint auto_ofs = 0;
565   /* Allocate max, resize later. */
566   char *auto_names = MEM_callocN(sizeof(char) * auto_names_len, __func__);
567   int *auto_is_srgb = MEM_callocN(sizeof(int) * (uv_len_used + vcol_len_used), __func__);
568
569   for (int i = 0; i < uv_len; i++) {
570     if ((cd_used.uv & (1 << i)) != 0) {
571       const char *name = CustomData_get_layer_name(cd_ldata, CD_MLOOPUV, i);
572       uint hash = BLI_ghashutil_strhash_p(name);
573       /* +1 to include '\0' terminator. */
574       auto_ofs += 1 + BLI_snprintf_rlen(
575                           auto_names + auto_ofs, auto_names_len - auto_ofs, "ba%u", hash);
576     }
577   }
578
579   uint auto_is_srgb_ofs = uv_len_used;
580   for (int i = 0; i < vcol_len; i++) {
581     if ((cd_used.vcol & (1 << i)) != 0) {
582       const char *name = CustomData_get_layer_name(cd_ldata, CD_MLOOPCOL, i);
583       /* We only do vcols that are not overridden by a uv layer with same name. */
584       if (CustomData_get_named_layer_index(cd_ldata, CD_MLOOPUV, name) == -1) {
585         uint hash = BLI_ghashutil_strhash_p(name);
586         /* +1 to include '\0' terminator. */
587         auto_ofs += 1 + BLI_snprintf_rlen(
588                             auto_names + auto_ofs, auto_names_len - auto_ofs, "ba%u", hash);
589         auto_is_srgb[auto_is_srgb_ofs] = true;
590         auto_is_srgb_ofs++;
591       }
592     }
593   }
594
595   auto_names = MEM_reallocN(auto_names, sizeof(char) * auto_ofs);
596   auto_is_srgb = MEM_reallocN(auto_is_srgb, sizeof(int) * auto_is_srgb_ofs);
597
598   /* WATCH: May have been referenced somewhere before freeing. */
599   MEM_SAFE_FREE(*r_auto_layers_names);
600   MEM_SAFE_FREE(*r_auto_layers_srgb);
601
602   *r_auto_layers_names = auto_names;
603   *r_auto_layers_srgb = auto_is_srgb;
604   *r_auto_layers_len = auto_is_srgb_ofs;
605 }
606
607 /**
608  * TODO(campbell): 'gpumat_array' may include materials linked to the object.
609  * While not default, object materials should be supported.
610  * Although this only impacts the data that's generated, not the materials that display.
611  */
612 static MeshRenderData *mesh_render_data_create_ex(Mesh *me,
613                                                   const int types,
614                                                   const DRW_MeshCDMask *cd_used,
615                                                   const ToolSettings *ts)
616 {
617   MeshRenderData *rdata = MEM_callocN(sizeof(*rdata), __func__);
618   rdata->types = types;
619   rdata->toolsettings = ts;
620   rdata->mat_len = mesh_render_mat_len_get(me);
621
622   CustomData_reset(&rdata->cd.output.ldata);
623
624   const bool is_auto_smooth = (me->flag & ME_AUTOSMOOTH) != 0;
625   const float split_angle = is_auto_smooth ? me->smoothresh : (float)M_PI;
626
627   if (me->edit_mesh) {
628     BMEditMesh *embm = me->edit_mesh;
629     BMesh *bm = embm->bm;
630
631     rdata->edit_bmesh = embm;
632     rdata->edit_data = me->runtime.edit_data;
633
634     if (embm->mesh_eval_cage && (embm->mesh_eval_cage->runtime.is_original == false)) {
635       Mesh *me_cage = embm->mesh_eval_cage;
636
637       rdata->mapped.me_cage = me_cage;
638       if (types & MR_DATATYPE_VERT) {
639         rdata->mapped.vert_len = me_cage->totvert;
640       }
641       if (types & MR_DATATYPE_EDGE) {
642         rdata->mapped.edge_len = me_cage->totedge;
643       }
644       if (types & MR_DATATYPE_LOOP) {
645         rdata->mapped.loop_len = me_cage->totloop;
646       }
647       if (types & MR_DATATYPE_POLY) {
648         rdata->mapped.poly_len = me_cage->totpoly;
649       }
650       if (types & MR_DATATYPE_LOOPTRI) {
651         rdata->mapped.tri_len = poly_to_tri_count(me_cage->totpoly, me_cage->totloop);
652       }
653       if (types & MR_DATATYPE_LOOPUV) {
654         rdata->mloopuv = CustomData_get_layer(&me_cage->ldata, CD_MLOOPUV);
655       }
656
657       rdata->mapped.v_origindex = CustomData_get_layer(&me_cage->vdata, CD_ORIGINDEX);
658       rdata->mapped.e_origindex = CustomData_get_layer(&me_cage->edata, CD_ORIGINDEX);
659       rdata->mapped.l_origindex = CustomData_get_layer(&me_cage->ldata, CD_ORIGINDEX);
660       rdata->mapped.p_origindex = CustomData_get_layer(&me_cage->pdata, CD_ORIGINDEX);
661       rdata->mapped.supported = (rdata->mapped.v_origindex || rdata->mapped.e_origindex ||
662                                  rdata->mapped.p_origindex);
663     }
664
665     int bm_ensure_types = 0;
666     if (types & MR_DATATYPE_VERT) {
667       rdata->vert_len = bm->totvert;
668       bm_ensure_types |= BM_VERT;
669     }
670     if (types & MR_DATATYPE_EDGE) {
671       rdata->edge_len = bm->totedge;
672       bm_ensure_types |= BM_EDGE;
673     }
674     if (types & MR_DATATYPE_LOOPTRI) {
675       bm_ensure_types |= BM_LOOP;
676     }
677     if (types & MR_DATATYPE_LOOP) {
678       int totloop = bm->totloop;
679       if (is_auto_smooth) {
680         rdata->loop_normals = MEM_mallocN(sizeof(*rdata->loop_normals) * totloop, __func__);
681         int cd_loop_clnors_offset = CustomData_get_offset(&bm->ldata, CD_CUSTOMLOOPNORMAL);
682         BM_loops_calc_normal_vcos(bm,
683                                   NULL,
684                                   NULL,
685                                   NULL,
686                                   true,
687                                   split_angle,
688                                   rdata->loop_normals,
689                                   NULL,
690                                   NULL,
691                                   cd_loop_clnors_offset,
692                                   false);
693       }
694       rdata->loop_len = totloop;
695       bm_ensure_types |= BM_LOOP;
696     }
697     if (types & MR_DATATYPE_POLY) {
698       rdata->poly_len = bm->totface;
699       bm_ensure_types |= BM_FACE;
700     }
701     if (types & MR_DATATYPE_OVERLAY) {
702       rdata->efa_act_uv = EDBM_uv_active_face_get(embm, false, false);
703       rdata->efa_act = BM_mesh_active_face_get(bm, false, true);
704       rdata->eed_act = BM_mesh_active_edge_get(bm);
705       rdata->eve_act = BM_mesh_active_vert_get(bm);
706       rdata->cd.offset.crease = CustomData_get_offset(&bm->edata, CD_CREASE);
707       rdata->cd.offset.bweight = CustomData_get_offset(&bm->edata, CD_BWEIGHT);
708
709 #ifdef WITH_FREESTYLE
710       rdata->cd.offset.freestyle_edge = CustomData_get_offset(&bm->edata, CD_FREESTYLE_EDGE);
711       rdata->cd.offset.freestyle_face = CustomData_get_offset(&bm->pdata, CD_FREESTYLE_FACE);
712 #endif
713     }
714     if (types & (MR_DATATYPE_DVERT)) {
715       bm_ensure_types |= BM_VERT;
716     }
717     if (rdata->edit_data != NULL) {
718       bm_ensure_types |= BM_VERT;
719     }
720
721     BM_mesh_elem_index_ensure(bm, bm_ensure_types);
722     BM_mesh_elem_table_ensure(bm, bm_ensure_types & ~BM_LOOP);
723
724     if (types & MR_DATATYPE_LOOPTRI) {
725       /* Edit mode ensures this is valid, no need to calculate. */
726       BLI_assert((bm->totloop == 0) || (embm->looptris != NULL));
727       int tottri = embm->tottri;
728       MLoopTri *mlooptri = MEM_mallocN(sizeof(*rdata->mlooptri) * embm->tottri, __func__);
729       for (int index = 0; index < tottri; index++) {
730         BMLoop **bmtri = embm->looptris[index];
731         MLoopTri *mtri = &mlooptri[index];
732         mtri->tri[0] = BM_elem_index_get(bmtri[0]);
733         mtri->tri[1] = BM_elem_index_get(bmtri[1]);
734         mtri->tri[2] = BM_elem_index_get(bmtri[2]);
735       }
736       rdata->mlooptri = mlooptri;
737       rdata->tri_len = tottri;
738     }
739
740     if (types & MR_DATATYPE_LOOSE_VERT) {
741       BLI_assert(types & MR_DATATYPE_VERT);
742       rdata->loose_vert_len = 0;
743
744       {
745         int *lverts = MEM_mallocN(rdata->vert_len * sizeof(int), __func__);
746         BLI_assert((bm->elem_table_dirty & BM_VERT) == 0);
747         for (int i = 0; i < bm->totvert; i++) {
748           const BMVert *eve = BM_vert_at_index(bm, i);
749           if (bm_vert_is_loose_and_visible(eve)) {
750             lverts[rdata->loose_vert_len++] = i;
751           }
752         }
753         rdata->loose_verts = MEM_reallocN(lverts, rdata->loose_vert_len * sizeof(int));
754       }
755
756       if (rdata->mapped.supported) {
757         Mesh *me_cage = embm->mesh_eval_cage;
758         rdata->mapped.loose_vert_len = 0;
759
760         if (rdata->loose_vert_len) {
761           int *lverts = MEM_mallocN(me_cage->totvert * sizeof(int), __func__);
762           const int *v_origindex = rdata->mapped.v_origindex;
763           for (int i = 0; i < me_cage->totvert; i++) {
764             const int v_orig = v_origindex[i];
765             if (v_orig != ORIGINDEX_NONE) {
766               BMVert *eve = BM_vert_at_index(bm, v_orig);
767               if (bm_vert_is_loose_and_visible(eve)) {
768                 lverts[rdata->mapped.loose_vert_len++] = i;
769               }
770             }
771           }
772           rdata->mapped.loose_verts = MEM_reallocN(lverts,
773                                                    rdata->mapped.loose_vert_len * sizeof(int));
774         }
775       }
776     }
777
778     if (types & MR_DATATYPE_LOOSE_EDGE) {
779       BLI_assert(types & MR_DATATYPE_EDGE);
780       rdata->loose_edge_len = 0;
781
782       {
783         int *ledges = MEM_mallocN(rdata->edge_len * sizeof(int), __func__);
784         BLI_assert((bm->elem_table_dirty & BM_EDGE) == 0);
785         for (int i = 0; i < bm->totedge; i++) {
786           const BMEdge *eed = BM_edge_at_index(bm, i);
787           if (bm_edge_is_loose_and_visible(eed)) {
788             ledges[rdata->loose_edge_len++] = i;
789           }
790         }
791         rdata->loose_edges = MEM_reallocN(ledges, rdata->loose_edge_len * sizeof(int));
792       }
793
794       if (rdata->mapped.supported) {
795         Mesh *me_cage = embm->mesh_eval_cage;
796         rdata->mapped.loose_edge_len = 0;
797
798         if (rdata->loose_edge_len) {
799           int *ledges = MEM_mallocN(me_cage->totedge * sizeof(int), __func__);
800           const int *e_origindex = rdata->mapped.e_origindex;
801           for (int i = 0; i < me_cage->totedge; i++) {
802             const int e_orig = e_origindex[i];
803             if (e_orig != ORIGINDEX_NONE) {
804               BMEdge *eed = BM_edge_at_index(bm, e_orig);
805               if (bm_edge_is_loose_and_visible(eed)) {
806                 ledges[rdata->mapped.loose_edge_len++] = i;
807               }
808             }
809           }
810           rdata->mapped.loose_edges = MEM_reallocN(ledges,
811                                                    rdata->mapped.loose_edge_len * sizeof(int));
812         }
813       }
814     }
815   }
816   else {
817     rdata->me = me;
818
819     if (types & (MR_DATATYPE_VERT)) {
820       rdata->vert_len = me->totvert;
821       rdata->mvert = CustomData_get_layer(&me->vdata, CD_MVERT);
822     }
823     if (types & (MR_DATATYPE_EDGE)) {
824       rdata->edge_len = me->totedge;
825       rdata->medge = CustomData_get_layer(&me->edata, CD_MEDGE);
826     }
827     if (types & MR_DATATYPE_LOOPTRI) {
828       const int tri_len = rdata->tri_len = poly_to_tri_count(me->totpoly, me->totloop);
829       MLoopTri *mlooptri = MEM_mallocN(sizeof(*mlooptri) * tri_len, __func__);
830       BKE_mesh_recalc_looptri(me->mloop, me->mpoly, me->mvert, me->totloop, me->totpoly, mlooptri);
831       rdata->mlooptri = mlooptri;
832     }
833     if (types & MR_DATATYPE_LOOP) {
834       rdata->loop_len = me->totloop;
835       rdata->mloop = CustomData_get_layer(&me->ldata, CD_MLOOP);
836
837       if (is_auto_smooth) {
838         mesh_render_calc_normals_loop_and_poly(me, split_angle, rdata);
839       }
840     }
841     if (types & MR_DATATYPE_POLY) {
842       rdata->poly_len = me->totpoly;
843       rdata->mpoly = CustomData_get_layer(&me->pdata, CD_MPOLY);
844     }
845     if (types & MR_DATATYPE_DVERT) {
846       rdata->vert_len = me->totvert;
847       rdata->dvert = CustomData_get_layer(&me->vdata, CD_MDEFORMVERT);
848     }
849     if (types & MR_DATATYPE_LOOPCOL) {
850       rdata->loop_len = me->totloop;
851       rdata->mloopcol = CustomData_get_layer(&me->ldata, CD_MLOOPCOL);
852     }
853     if (types & MR_DATATYPE_LOOPUV) {
854       rdata->loop_len = me->totloop;
855       rdata->mloopuv = CustomData_get_layer(&me->ldata, CD_MLOOPUV);
856     }
857   }
858
859   if (types & MR_DATATYPE_SHADING) {
860     CustomData *cd_vdata, *cd_ldata;
861
862     BLI_assert(cd_used != NULL);
863
864     if (me->edit_mesh) {
865       BMesh *bm = me->edit_mesh->bm;
866       cd_vdata = &bm->vdata;
867       cd_ldata = &bm->ldata;
868     }
869     else {
870       cd_vdata = &me->vdata;
871       cd_ldata = &me->ldata;
872     }
873
874     rdata->cd.layers.uv_active = CustomData_get_active_layer(cd_ldata, CD_MLOOPUV);
875     rdata->cd.layers.uv_mask_active = CustomData_get_stencil_layer(cd_ldata, CD_MLOOPUV);
876     rdata->cd.layers.vcol_active = CustomData_get_active_layer(cd_ldata, CD_MLOOPCOL);
877     rdata->cd.layers.tangent_active = rdata->cd.layers.uv_active;
878
879 #define CD_VALIDATE_ACTIVE_LAYER(active_index, used) \
880   if ((active_index != -1) && (used & (1 << active_index)) == 0) { \
881     active_index = -1; \
882   } \
883   ((void)0)
884
885     CD_VALIDATE_ACTIVE_LAYER(rdata->cd.layers.uv_active, cd_used->uv);
886     CD_VALIDATE_ACTIVE_LAYER(rdata->cd.layers.uv_mask_active, cd_used->uv);
887     CD_VALIDATE_ACTIVE_LAYER(rdata->cd.layers.tangent_active, cd_used->tan);
888     CD_VALIDATE_ACTIVE_LAYER(rdata->cd.layers.vcol_active, cd_used->vcol);
889
890 #undef CD_VALIDATE_ACTIVE_LAYER
891
892     rdata->is_orco_allocated = false;
893     if (cd_used->orco != 0) {
894       rdata->orco = CustomData_get_layer(cd_vdata, CD_ORCO);
895       /* If orco is not available compute it ourselves */
896       if (!rdata->orco) {
897         rdata->is_orco_allocated = true;
898         if (me->edit_mesh) {
899           BMesh *bm = me->edit_mesh->bm;
900           rdata->orco = MEM_mallocN(sizeof(*rdata->orco) * rdata->vert_len, "orco mesh");
901           BLI_assert((bm->elem_table_dirty & BM_VERT) == 0);
902           for (int i = 0; i < bm->totvert; i++) {
903             copy_v3_v3(rdata->orco[i], BM_vert_at_index(bm, i)->co);
904           }
905           BKE_mesh_orco_verts_transform(me, rdata->orco, rdata->vert_len, 0);
906         }
907         else {
908           rdata->orco = MEM_mallocN(sizeof(*rdata->orco) * rdata->vert_len, "orco mesh");
909           MVert *mvert = rdata->mvert;
910           for (int a = 0; a < rdata->vert_len; a++, mvert++) {
911             copy_v3_v3(rdata->orco[a], mvert->co);
912           }
913           BKE_mesh_orco_verts_transform(me, rdata->orco, rdata->vert_len, 0);
914         }
915       }
916     }
917     else {
918       rdata->orco = NULL;
919     }
920
921     /* don't access mesh directly, instead use vars taken from BMesh or Mesh */
922 #define me DONT_USE_THIS
923 #ifdef me /* quiet warning */
924 #endif
925     struct {
926       uint uv_len;
927       uint vcol_len;
928     } cd_layers_src = {
929         .uv_len = CustomData_number_of_layers(cd_ldata, CD_MLOOPUV),
930         .vcol_len = CustomData_number_of_layers(cd_ldata, CD_MLOOPCOL),
931     };
932
933     rdata->cd.layers.uv_len = min_ii(cd_layers_src.uv_len, count_bits_i(cd_used->uv));
934     rdata->cd.layers.tangent_len = count_bits_i(cd_used->tan) + cd_used->tan_orco;
935     rdata->cd.layers.vcol_len = min_ii(cd_layers_src.vcol_len, count_bits_i(cd_used->vcol));
936
937     rdata->cd.layers.uv = MEM_mallocN(sizeof(*rdata->cd.layers.uv) * rdata->cd.layers.uv_len,
938                                       __func__);
939     rdata->cd.layers.vcol = MEM_mallocN(sizeof(*rdata->cd.layers.vcol) * rdata->cd.layers.vcol_len,
940                                         __func__);
941     rdata->cd.layers.tangent = MEM_mallocN(
942         sizeof(*rdata->cd.layers.tangent) * rdata->cd.layers.tangent_len, __func__);
943
944     rdata->cd.uuid.uv = MEM_mallocN(sizeof(*rdata->cd.uuid.uv) * rdata->cd.layers.uv_len,
945                                     __func__);
946     rdata->cd.uuid.vcol = MEM_mallocN(sizeof(*rdata->cd.uuid.vcol) * rdata->cd.layers.vcol_len,
947                                       __func__);
948     rdata->cd.uuid.tangent = MEM_mallocN(
949         sizeof(*rdata->cd.uuid.tangent) * rdata->cd.layers.tangent_len, __func__);
950
951     rdata->cd.offset.uv = MEM_mallocN(sizeof(*rdata->cd.offset.uv) * rdata->cd.layers.uv_len,
952                                       __func__);
953     rdata->cd.offset.vcol = MEM_mallocN(sizeof(*rdata->cd.offset.vcol) * rdata->cd.layers.vcol_len,
954                                         __func__);
955
956     /* Allocate max */
957     rdata->cd.layers.auto_vcol = MEM_callocN(
958         sizeof(*rdata->cd.layers.auto_vcol) * rdata->cd.layers.vcol_len, __func__);
959     rdata->cd.uuid.auto_mix = MEM_mallocN(
960         sizeof(*rdata->cd.uuid.auto_mix) * (rdata->cd.layers.vcol_len + rdata->cd.layers.uv_len),
961         __func__);
962
963     /* XXX FIXME XXX */
964     /* We use a hash to identify each data layer based on its name.
965      * Gawain then search for this name in the current shader and bind if it exists.
966      * NOTE : This is prone to hash collision.
967      * One solution to hash collision would be to format the cd layer name
968      * to a safe glsl var name, but without name clash.
969      * NOTE 2 : Replicate changes to code_generate_vertex_new() in gpu_codegen.c */
970     if (rdata->cd.layers.vcol_len != 0) {
971       int act_vcol = rdata->cd.layers.vcol_active;
972       for (int i_src = 0, i_dst = 0; i_src < cd_layers_src.vcol_len; i_src++, i_dst++) {
973         if ((cd_used->vcol & (1 << i_src)) == 0) {
974           /* This is a non-used VCol slot. Skip. */
975           i_dst--;
976           if (rdata->cd.layers.vcol_active >= i_src) {
977             act_vcol--;
978           }
979         }
980         else {
981           const char *name = CustomData_get_layer_name(cd_ldata, CD_MLOOPCOL, i_src);
982           uint hash = BLI_ghashutil_strhash_p(name);
983           BLI_snprintf(rdata->cd.uuid.vcol[i_dst], sizeof(*rdata->cd.uuid.vcol), "c%u", hash);
984           rdata->cd.layers.vcol[i_dst] = CustomData_get_layer_n(cd_ldata, CD_MLOOPCOL, i_src);
985           if (rdata->edit_bmesh) {
986             rdata->cd.offset.vcol[i_dst] = CustomData_get_n_offset(
987                 &rdata->edit_bmesh->bm->ldata, CD_MLOOPCOL, i_src);
988           }
989
990           /* Gather number of auto layers. */
991           /* We only do vcols that are not overridden by uvs */
992           if (CustomData_get_named_layer_index(cd_ldata, CD_MLOOPUV, name) == -1) {
993             BLI_snprintf(rdata->cd.uuid.auto_mix[rdata->cd.layers.uv_len + i_dst],
994                          sizeof(*rdata->cd.uuid.auto_mix),
995                          "a%u",
996                          hash);
997             rdata->cd.layers.auto_vcol[i_dst] = true;
998           }
999         }
1000       }
1001       if (rdata->cd.layers.vcol_active != -1) {
1002         /* Actual active Vcol slot inside vcol layers used for shading. */
1003         rdata->cd.layers.vcol_active = act_vcol;
1004       }
1005     }
1006
1007     /* Start Fresh */
1008     CustomData_free_layers(cd_ldata, CD_TANGENT, rdata->loop_len);
1009     CustomData_free_layers(cd_ldata, CD_MLOOPTANGENT, rdata->loop_len);
1010
1011     if (rdata->cd.layers.uv_len != 0) {
1012       int act_uv = rdata->cd.layers.uv_active;
1013       for (int i_src = 0, i_dst = 0; i_src < cd_layers_src.uv_len; i_src++, i_dst++) {
1014         if ((cd_used->uv & (1 << i_src)) == 0) {
1015           /* This is a non-used UV slot. Skip. */
1016           i_dst--;
1017           if (rdata->cd.layers.uv_active >= i_src) {
1018             act_uv--;
1019           }
1020         }
1021         else {
1022           const char *name = CustomData_get_layer_name(cd_ldata, CD_MLOOPUV, i_src);
1023           uint hash = BLI_ghashutil_strhash_p(name);
1024
1025           BLI_snprintf(rdata->cd.uuid.uv[i_dst], sizeof(*rdata->cd.uuid.uv), "u%u", hash);
1026           rdata->cd.layers.uv[i_dst] = CustomData_get_layer_n(cd_ldata, CD_MLOOPUV, i_src);
1027           if (rdata->edit_bmesh) {
1028             rdata->cd.offset.uv[i_dst] = CustomData_get_n_offset(
1029                 &rdata->edit_bmesh->bm->ldata, CD_MLOOPUV, i_src);
1030           }
1031           BLI_snprintf(
1032               rdata->cd.uuid.auto_mix[i_dst], sizeof(*rdata->cd.uuid.auto_mix), "a%u", hash);
1033         }
1034       }
1035       if (rdata->cd.layers.uv_active != -1) {
1036         /* Actual active UV slot inside uv layers used for shading. */
1037         rdata->cd.layers.uv_active = act_uv;
1038       }
1039     }
1040
1041     if (rdata->cd.layers.tangent_len != 0) {
1042
1043       /* -------------------------------------------------------------------- */
1044       /* Pre-calculate tangents into 'rdata->cd.output.ldata' */
1045
1046       BLI_assert(!CustomData_has_layer(&rdata->cd.output.ldata, CD_TANGENT));
1047
1048       /* Tangent Names */
1049       char tangent_names[MAX_MTFACE][MAX_NAME];
1050       for (int i_src = 0, i_dst = 0; i_src < cd_layers_src.uv_len; i_src++, i_dst++) {
1051         if ((cd_used->tan & (1 << i_src)) == 0) {
1052           i_dst--;
1053         }
1054         else {
1055           BLI_strncpy(tangent_names[i_dst],
1056                       CustomData_get_layer_name(cd_ldata, CD_MLOOPUV, i_src),
1057                       MAX_NAME);
1058         }
1059       }
1060
1061       /* If tangent from orco is requested, decrement tangent_len */
1062       int actual_tangent_len = (cd_used->tan_orco != 0) ? rdata->cd.layers.tangent_len - 1 :
1063                                                           rdata->cd.layers.tangent_len;
1064       if (rdata->edit_bmesh) {
1065         BMEditMesh *em = rdata->edit_bmesh;
1066         BMesh *bm = em->bm;
1067
1068         if (is_auto_smooth && rdata->loop_normals == NULL) {
1069           /* Should we store the previous array of `loop_normals` in somewhere? */
1070           rdata->loop_len = bm->totloop;
1071           rdata->loop_normals = MEM_mallocN(sizeof(*rdata->loop_normals) * rdata->loop_len,
1072                                             __func__);
1073           BM_loops_calc_normal_vcos(
1074               bm, NULL, NULL, NULL, true, split_angle, rdata->loop_normals, NULL, NULL, -1, false);
1075         }
1076
1077         bool calc_active_tangent = false;
1078
1079         BKE_editmesh_loop_tangent_calc(em,
1080                                        calc_active_tangent,
1081                                        tangent_names,
1082                                        actual_tangent_len,
1083                                        rdata->poly_normals,
1084                                        rdata->loop_normals,
1085                                        rdata->orco,
1086                                        &rdata->cd.output.ldata,
1087                                        bm->totloop,
1088                                        &rdata->cd.output.tangent_mask);
1089       }
1090       else {
1091 #undef me
1092
1093         if (is_auto_smooth && rdata->loop_normals == NULL) {
1094           /* Should we store the previous array of `loop_normals` in CustomData? */
1095           mesh_render_calc_normals_loop_and_poly(me, split_angle, rdata);
1096         }
1097
1098         bool calc_active_tangent = false;
1099
1100         BKE_mesh_calc_loop_tangent_ex(me->mvert,
1101                                       me->mpoly,
1102                                       me->totpoly,
1103                                       me->mloop,
1104                                       rdata->mlooptri,
1105                                       rdata->tri_len,
1106                                       cd_ldata,
1107                                       calc_active_tangent,
1108                                       tangent_names,
1109                                       actual_tangent_len,
1110                                       rdata->poly_normals,
1111                                       rdata->loop_normals,
1112                                       rdata->orco,
1113                                       &rdata->cd.output.ldata,
1114                                       me->totloop,
1115                                       &rdata->cd.output.tangent_mask);
1116
1117         /* If we store tangents in the mesh, set temporary. */
1118 #if 0
1119         CustomData_set_layer_flag(cd_ldata, CD_TANGENT, CD_FLAG_TEMPORARY);
1120 #endif
1121
1122 #define me DONT_USE_THIS
1123 #ifdef me /* quiet warning */
1124 #endif
1125       }
1126
1127       /* End tangent calculation */
1128       /* -------------------------------------------------------------------- */
1129
1130       BLI_assert(CustomData_number_of_layers(&rdata->cd.output.ldata, CD_TANGENT) ==
1131                  rdata->cd.layers.tangent_len);
1132
1133       int i_dst = 0;
1134       for (int i_src = 0; i_src < cd_layers_src.uv_len; i_src++, i_dst++) {
1135         if ((cd_used->tan & (1 << i_src)) == 0) {
1136           i_dst--;
1137           if (rdata->cd.layers.tangent_active >= i_src) {
1138             rdata->cd.layers.tangent_active--;
1139           }
1140         }
1141         else {
1142           const char *name = CustomData_get_layer_name(cd_ldata, CD_MLOOPUV, i_src);
1143           uint hash = BLI_ghashutil_strhash_p(name);
1144
1145           BLI_snprintf(
1146               rdata->cd.uuid.tangent[i_dst], sizeof(*rdata->cd.uuid.tangent), "t%u", hash);
1147
1148           /* Done adding tangents. */
1149
1150           /* note: BKE_editmesh_loop_tangent_calc calculates 'CD_TANGENT',
1151            * not 'CD_MLOOPTANGENT' (as done below). It's OK, they're compatible. */
1152
1153           /* note: normally we'd use 'i_src' here, but 'i_dst' is in sync with 'rdata->cd.output' */
1154           rdata->cd.layers.tangent[i_dst] = CustomData_get_layer_n(
1155               &rdata->cd.output.ldata, CD_TANGENT, i_dst);
1156           if (rdata->tri_len != 0) {
1157             BLI_assert(rdata->cd.layers.tangent[i_dst] != NULL);
1158           }
1159         }
1160       }
1161       if (cd_used->tan_orco != 0) {
1162         const char *name = CustomData_get_layer_name(&rdata->cd.output.ldata, CD_TANGENT, i_dst);
1163         uint hash = BLI_ghashutil_strhash_p(name);
1164         BLI_snprintf(rdata->cd.uuid.tangent[i_dst], sizeof(*rdata->cd.uuid.tangent), "t%u", hash);
1165
1166         rdata->cd.layers.tangent[i_dst] = CustomData_get_layer_n(
1167             &rdata->cd.output.ldata, CD_TANGENT, i_dst);
1168       }
1169     }
1170
1171 #undef me
1172   }
1173
1174   return rdata;
1175 }
1176
1177 /* Warning replace mesh pointer. */
1178 #define MBC_GET_FINAL_MESH(me) \
1179   /* Hack to show the final result. */ \
1180   const bool _use_em_final = ((me)->edit_mesh && (me)->edit_mesh->mesh_eval_final && \
1181                               ((me)->edit_mesh->mesh_eval_final->runtime.is_original == false)); \
1182   Mesh _me_fake; \
1183   if (_use_em_final) { \
1184     _me_fake = *(me)->edit_mesh->mesh_eval_final; \
1185     _me_fake.mat = (me)->mat; \
1186     _me_fake.totcol = (me)->totcol; \
1187     (me) = &_me_fake; \
1188   } \
1189   ((void)0)
1190
1191 static void mesh_render_data_free(MeshRenderData *rdata)
1192 {
1193   if (rdata->is_orco_allocated) {
1194     MEM_SAFE_FREE(rdata->orco);
1195   }
1196   MEM_SAFE_FREE(rdata->cd.offset.uv);
1197   MEM_SAFE_FREE(rdata->cd.offset.vcol);
1198   MEM_SAFE_FREE(rdata->cd.uuid.auto_mix);
1199   MEM_SAFE_FREE(rdata->cd.uuid.uv);
1200   MEM_SAFE_FREE(rdata->cd.uuid.vcol);
1201   MEM_SAFE_FREE(rdata->cd.uuid.tangent);
1202   MEM_SAFE_FREE(rdata->cd.layers.uv);
1203   MEM_SAFE_FREE(rdata->cd.layers.vcol);
1204   MEM_SAFE_FREE(rdata->cd.layers.tangent);
1205   MEM_SAFE_FREE(rdata->cd.layers.auto_vcol);
1206   MEM_SAFE_FREE(rdata->loose_verts);
1207   MEM_SAFE_FREE(rdata->loose_edges);
1208   MEM_SAFE_FREE(rdata->edges_adjacent_polys);
1209   MEM_SAFE_FREE(rdata->mlooptri);
1210   MEM_SAFE_FREE(rdata->loop_normals);
1211   MEM_SAFE_FREE(rdata->poly_normals);
1212   MEM_SAFE_FREE(rdata->poly_normals_pack);
1213   MEM_SAFE_FREE(rdata->vert_normals_pack);
1214   MEM_SAFE_FREE(rdata->vert_weight);
1215   MEM_SAFE_FREE(rdata->edge_select_bool);
1216   MEM_SAFE_FREE(rdata->edge_visible_bool);
1217   MEM_SAFE_FREE(rdata->vert_color);
1218
1219   MEM_SAFE_FREE(rdata->mapped.loose_verts);
1220   MEM_SAFE_FREE(rdata->mapped.loose_edges);
1221
1222   CustomData_free(&rdata->cd.output.ldata, rdata->loop_len);
1223
1224   MEM_freeN(rdata);
1225 }
1226
1227 /** \} */
1228
1229 /* ---------------------------------------------------------------------- */
1230 /** \name Accessor Functions
1231  * \{ */
1232
1233 static const char *mesh_render_data_uv_auto_layer_uuid_get(const MeshRenderData *rdata, int layer)
1234 {
1235   BLI_assert(rdata->types & MR_DATATYPE_SHADING);
1236   return rdata->cd.uuid.auto_mix[layer];
1237 }
1238
1239 static const char *mesh_render_data_vcol_auto_layer_uuid_get(const MeshRenderData *rdata,
1240                                                              int layer)
1241 {
1242   BLI_assert(rdata->types & MR_DATATYPE_SHADING);
1243   return rdata->cd.uuid.auto_mix[rdata->cd.layers.uv_len + layer];
1244 }
1245
1246 static const char *mesh_render_data_uv_layer_uuid_get(const MeshRenderData *rdata, int layer)
1247 {
1248   BLI_assert(rdata->types & MR_DATATYPE_SHADING);
1249   return rdata->cd.uuid.uv[layer];
1250 }
1251
1252 static const char *mesh_render_data_vcol_layer_uuid_get(const MeshRenderData *rdata, int layer)
1253 {
1254   BLI_assert(rdata->types & MR_DATATYPE_SHADING);
1255   return rdata->cd.uuid.vcol[layer];
1256 }
1257
1258 static const char *mesh_render_data_tangent_layer_uuid_get(const MeshRenderData *rdata, int layer)
1259 {
1260   BLI_assert(rdata->types & MR_DATATYPE_SHADING);
1261   return rdata->cd.uuid.tangent[layer];
1262 }
1263
1264 static int UNUSED_FUNCTION(mesh_render_data_verts_len_get)(const MeshRenderData *rdata)
1265 {
1266   BLI_assert(rdata->types & MR_DATATYPE_VERT);
1267   return rdata->vert_len;
1268 }
1269 static int mesh_render_data_verts_len_get_maybe_mapped(const MeshRenderData *rdata)
1270 {
1271   BLI_assert(rdata->types & MR_DATATYPE_VERT);
1272   return ((rdata->mapped.use == false) ? rdata->vert_len : rdata->mapped.vert_len);
1273 }
1274
1275 static int UNUSED_FUNCTION(mesh_render_data_loose_verts_len_get)(const MeshRenderData *rdata)
1276 {
1277   BLI_assert(rdata->types & MR_DATATYPE_LOOSE_VERT);
1278   return rdata->loose_vert_len;
1279 }
1280 static int mesh_render_data_loose_verts_len_get_maybe_mapped(const MeshRenderData *rdata)
1281 {
1282   BLI_assert(rdata->types & MR_DATATYPE_LOOSE_VERT);
1283   return ((rdata->mapped.use == false) ? rdata->loose_vert_len : rdata->mapped.loose_vert_len);
1284 }
1285
1286 static int mesh_render_data_edges_len_get(const MeshRenderData *rdata)
1287 {
1288   BLI_assert(rdata->types & MR_DATATYPE_EDGE);
1289   return rdata->edge_len;
1290 }
1291 static int mesh_render_data_edges_len_get_maybe_mapped(const MeshRenderData *rdata)
1292 {
1293   BLI_assert(rdata->types & MR_DATATYPE_EDGE);
1294   return ((rdata->mapped.use == false) ? rdata->edge_len : rdata->mapped.edge_len);
1295 }
1296
1297 static int UNUSED_FUNCTION(mesh_render_data_loose_edges_len_get)(const MeshRenderData *rdata)
1298 {
1299   BLI_assert(rdata->types & MR_DATATYPE_LOOSE_EDGE);
1300   return rdata->loose_edge_len;
1301 }
1302 static int mesh_render_data_loose_edges_len_get_maybe_mapped(const MeshRenderData *rdata)
1303 {
1304   BLI_assert(rdata->types & MR_DATATYPE_LOOSE_EDGE);
1305   return ((rdata->mapped.use == false) ? rdata->loose_edge_len : rdata->mapped.loose_edge_len);
1306 }
1307
1308 static int mesh_render_data_looptri_len_get(const MeshRenderData *rdata)
1309 {
1310   BLI_assert(rdata->types & MR_DATATYPE_LOOPTRI);
1311   return rdata->tri_len;
1312 }
1313 static int mesh_render_data_looptri_len_get_maybe_mapped(const MeshRenderData *rdata)
1314 {
1315   BLI_assert(rdata->types & MR_DATATYPE_LOOPTRI);
1316   return ((rdata->mapped.use == false) ? rdata->tri_len : rdata->mapped.tri_len);
1317 }
1318
1319 static int UNUSED_FUNCTION(mesh_render_data_mat_len_get)(const MeshRenderData *rdata)
1320 {
1321   BLI_assert(rdata->types & MR_DATATYPE_POLY);
1322   return rdata->mat_len;
1323 }
1324
1325 static int mesh_render_data_loops_len_get(const MeshRenderData *rdata)
1326 {
1327   BLI_assert(rdata->types & MR_DATATYPE_LOOP);
1328   return rdata->loop_len;
1329 }
1330
1331 static int mesh_render_data_loops_len_get_maybe_mapped(const MeshRenderData *rdata)
1332 {
1333   BLI_assert(rdata->types & MR_DATATYPE_LOOP);
1334   return ((rdata->mapped.use == false) ? rdata->loop_len : rdata->mapped.loop_len);
1335 }
1336
1337 static int mesh_render_data_polys_len_get(const MeshRenderData *rdata)
1338 {
1339   BLI_assert(rdata->types & MR_DATATYPE_POLY);
1340   return rdata->poly_len;
1341 }
1342 static int mesh_render_data_polys_len_get_maybe_mapped(const MeshRenderData *rdata)
1343 {
1344   BLI_assert(rdata->types & MR_DATATYPE_POLY);
1345   return ((rdata->mapped.use == false) ? rdata->poly_len : rdata->mapped.poly_len);
1346 }
1347
1348 /** \} */
1349
1350 /* ---------------------------------------------------------------------- */
1351
1352 /* TODO remove prototype. */
1353 static void mesh_create_edit_facedots(MeshRenderData *rdata,
1354                                       GPUVertBuf *vbo_facedots_pos_nor_data);
1355
1356 /** \name Internal Cache (Lazy Initialization)
1357  * \{ */
1358
1359 /** Ensure #MeshRenderData.poly_normals_pack */
1360 static void mesh_render_data_ensure_poly_normals_pack(MeshRenderData *rdata)
1361 {
1362   GPUPackedNormal *pnors_pack = rdata->poly_normals_pack;
1363   if (pnors_pack == NULL) {
1364     if (rdata->edit_bmesh) {
1365       BMesh *bm = rdata->edit_bmesh->bm;
1366       BMIter fiter;
1367       BMFace *efa;
1368       int i;
1369
1370       pnors_pack = rdata->poly_normals_pack = MEM_mallocN(sizeof(*pnors_pack) * rdata->poly_len,
1371                                                           __func__);
1372       if (rdata->edit_data && rdata->edit_data->vertexCos != NULL) {
1373         BKE_editmesh_cache_ensure_poly_normals(rdata->edit_bmesh, rdata->edit_data);
1374         const float(*pnors)[3] = rdata->edit_data->polyNos;
1375         for (i = 0; i < bm->totface; i++) {
1376           pnors_pack[i] = GPU_normal_convert_i10_v3(pnors[i]);
1377         }
1378       }
1379       else {
1380         BM_ITER_MESH_INDEX (efa, &fiter, bm, BM_FACES_OF_MESH, i) {
1381           pnors_pack[i] = GPU_normal_convert_i10_v3(efa->no);
1382         }
1383       }
1384     }
1385     else {
1386       float(*pnors)[3] = rdata->poly_normals;
1387
1388       if (!pnors) {
1389         pnors = rdata->poly_normals = MEM_mallocN(sizeof(*pnors) * rdata->poly_len, __func__);
1390         BKE_mesh_calc_normals_poly(rdata->mvert,
1391                                    NULL,
1392                                    rdata->vert_len,
1393                                    rdata->mloop,
1394                                    rdata->mpoly,
1395                                    rdata->loop_len,
1396                                    rdata->poly_len,
1397                                    pnors,
1398                                    true);
1399       }
1400
1401       pnors_pack = rdata->poly_normals_pack = MEM_mallocN(sizeof(*pnors_pack) * rdata->poly_len,
1402                                                           __func__);
1403       for (int i = 0; i < rdata->poly_len; i++) {
1404         pnors_pack[i] = GPU_normal_convert_i10_v3(pnors[i]);
1405       }
1406     }
1407   }
1408 }
1409
1410 /** Ensure #MeshRenderData.vert_normals_pack */
1411 static void mesh_render_data_ensure_vert_normals_pack(MeshRenderData *rdata)
1412 {
1413   GPUPackedNormal *vnors_pack = rdata->vert_normals_pack;
1414   if (vnors_pack == NULL) {
1415     if (rdata->edit_bmesh) {
1416       BMesh *bm = rdata->edit_bmesh->bm;
1417       BMIter viter;
1418       BMVert *eve;
1419       int i;
1420
1421       vnors_pack = rdata->vert_normals_pack = MEM_mallocN(sizeof(*vnors_pack) * rdata->vert_len,
1422                                                           __func__);
1423       BM_ITER_MESH_INDEX (eve, &viter, bm, BM_VERT, i) {
1424         vnors_pack[i] = GPU_normal_convert_i10_v3(eve->no);
1425       }
1426     }
1427     else {
1428       /* data from mesh used directly */
1429       BLI_assert(0);
1430     }
1431   }
1432 }
1433
1434 /** Ensure #MeshRenderData.vert_color */
1435 static void UNUSED_FUNCTION(mesh_render_data_ensure_vert_color)(MeshRenderData *rdata)
1436 {
1437   char(*vcol)[3] = rdata->vert_color;
1438   if (vcol == NULL) {
1439     if (rdata->edit_bmesh) {
1440       BMesh *bm = rdata->edit_bmesh->bm;
1441       const int cd_loop_color_offset = CustomData_get_offset(&bm->ldata, CD_MLOOPCOL);
1442       if (cd_loop_color_offset == -1) {
1443         goto fallback;
1444       }
1445
1446       vcol = rdata->vert_color = MEM_mallocN(sizeof(*vcol) * rdata->loop_len, __func__);
1447
1448       BMIter fiter;
1449       BMFace *efa;
1450       int i = 0;
1451
1452       BM_ITER_MESH (efa, &fiter, bm, BM_FACES_OF_MESH) {
1453         BMLoop *l_iter, *l_first;
1454         l_iter = l_first = BM_FACE_FIRST_LOOP(efa);
1455         do {
1456           const MLoopCol *lcol = BM_ELEM_CD_GET_VOID_P(l_iter, cd_loop_color_offset);
1457           vcol[i][0] = lcol->r;
1458           vcol[i][1] = lcol->g;
1459           vcol[i][2] = lcol->b;
1460           i += 1;
1461         } while ((l_iter = l_iter->next) != l_first);
1462       }
1463       BLI_assert(i == rdata->loop_len);
1464     }
1465     else {
1466       if (rdata->mloopcol == NULL) {
1467         goto fallback;
1468       }
1469
1470       vcol = rdata->vert_color = MEM_mallocN(sizeof(*vcol) * rdata->loop_len, __func__);
1471
1472       for (int i = 0; i < rdata->loop_len; i++) {
1473         vcol[i][0] = rdata->mloopcol[i].r;
1474         vcol[i][1] = rdata->mloopcol[i].g;
1475         vcol[i][2] = rdata->mloopcol[i].b;
1476       }
1477     }
1478   }
1479   return;
1480
1481 fallback:
1482   vcol = rdata->vert_color = MEM_mallocN(sizeof(*vcol) * rdata->loop_len, __func__);
1483
1484   for (int i = 0; i < rdata->loop_len; i++) {
1485     vcol[i][0] = 255;
1486     vcol[i][1] = 255;
1487     vcol[i][2] = 255;
1488   }
1489 }
1490
1491 static float evaluate_vertex_weight(const MDeformVert *dvert, const DRW_MeshWeightState *wstate)
1492 {
1493   float input = 0.0f;
1494   bool show_alert_color = false;
1495
1496   if (wstate->flags & DRW_MESH_WEIGHT_STATE_MULTIPAINT) {
1497     /* Multi-Paint feature */
1498     input = BKE_defvert_multipaint_collective_weight(
1499         dvert,
1500         wstate->defgroup_len,
1501         wstate->defgroup_sel,
1502         wstate->defgroup_sel_count,
1503         (wstate->flags & DRW_MESH_WEIGHT_STATE_AUTO_NORMALIZE) != 0);
1504
1505     /* make it black if the selected groups have no weight on a vertex */
1506     if (input == 0.0f) {
1507       show_alert_color = true;
1508     }
1509   }
1510   else {
1511     /* default, non tricky behavior */
1512     input = defvert_find_weight(dvert, wstate->defgroup_active);
1513
1514     if (input == 0.0f) {
1515       switch (wstate->alert_mode) {
1516         case OB_DRAW_GROUPUSER_ACTIVE:
1517           show_alert_color = true;
1518           break;
1519
1520         case OB_DRAW_GROUPUSER_ALL:
1521           show_alert_color = defvert_is_weight_zero(dvert, wstate->defgroup_len);
1522           break;
1523       }
1524     }
1525   }
1526
1527   if (show_alert_color) {
1528     return -1.0f;
1529   }
1530   else {
1531     CLAMP(input, 0.0f, 1.0f);
1532     return input;
1533   }
1534 }
1535
1536 /** Ensure #MeshRenderData.vert_weight */
1537 static void mesh_render_data_ensure_vert_weight(MeshRenderData *rdata,
1538                                                 const struct DRW_MeshWeightState *wstate)
1539 {
1540   float *vweight = rdata->vert_weight;
1541   if (vweight == NULL) {
1542     if (wstate->defgroup_active == -1) {
1543       goto fallback;
1544     }
1545
1546     if (rdata->edit_bmesh) {
1547       BMesh *bm = rdata->edit_bmesh->bm;
1548       const int cd_dvert_offset = CustomData_get_offset(&bm->vdata, CD_MDEFORMVERT);
1549       if (cd_dvert_offset == -1) {
1550         goto fallback;
1551       }
1552
1553       BMIter viter;
1554       BMVert *eve;
1555       int i;
1556
1557       vweight = rdata->vert_weight = MEM_mallocN(sizeof(*vweight) * rdata->vert_len, __func__);
1558       BM_ITER_MESH_INDEX (eve, &viter, bm, BM_VERT, i) {
1559         const MDeformVert *dvert = BM_ELEM_CD_GET_VOID_P(eve, cd_dvert_offset);
1560         vweight[i] = evaluate_vertex_weight(dvert, wstate);
1561       }
1562     }
1563     else {
1564       if (rdata->dvert == NULL) {
1565         goto fallback;
1566       }
1567
1568       vweight = rdata->vert_weight = MEM_mallocN(sizeof(*vweight) * rdata->vert_len, __func__);
1569       for (int i = 0; i < rdata->vert_len; i++) {
1570         vweight[i] = evaluate_vertex_weight(&rdata->dvert[i], wstate);
1571       }
1572     }
1573   }
1574   return;
1575
1576 fallback:
1577   vweight = rdata->vert_weight = MEM_callocN(sizeof(*vweight) * rdata->vert_len, __func__);
1578
1579   if ((wstate->defgroup_active < 0) && (wstate->defgroup_len > 0)) {
1580     copy_vn_fl(vweight, rdata->vert_len, -2.0f);
1581   }
1582   else if (wstate->alert_mode != OB_DRAW_GROUPUSER_NONE) {
1583     copy_vn_fl(vweight, rdata->vert_len, -1.0f);
1584   }
1585 }
1586
1587 /** \} */
1588
1589 /* ---------------------------------------------------------------------- */
1590 /** \name Internal Cache Generation
1591  * \{ */
1592
1593 static uchar mesh_render_data_face_flag(MeshRenderData *rdata, const BMFace *efa, const int cd_ofs)
1594 {
1595   uchar fflag = 0;
1596
1597   if (efa == rdata->efa_act) {
1598     fflag |= VFLAG_FACE_ACTIVE;
1599   }
1600   if (BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
1601     fflag |= VFLAG_FACE_SELECTED;
1602   }
1603
1604   if (efa == rdata->efa_act_uv) {
1605     fflag |= VFLAG_FACE_UV_ACTIVE;
1606   }
1607   if ((cd_ofs != -1) && uvedit_face_select_test_ex(rdata->toolsettings, (BMFace *)efa, cd_ofs)) {
1608     fflag |= VFLAG_FACE_UV_SELECT;
1609   }
1610
1611 #ifdef WITH_FREESTYLE
1612   if (rdata->cd.offset.freestyle_face != -1) {
1613     const FreestyleFace *ffa = BM_ELEM_CD_GET_VOID_P(efa, rdata->cd.offset.freestyle_face);
1614     if (ffa->flag & FREESTYLE_FACE_MARK) {
1615       fflag |= VFLAG_FACE_FREESTYLE;
1616     }
1617   }
1618 #endif
1619
1620   return fflag;
1621 }
1622
1623 static void mesh_render_data_edge_flag(const MeshRenderData *rdata,
1624                                        const BMEdge *eed,
1625                                        EdgeDrawAttr *eattr)
1626 {
1627   const ToolSettings *ts = rdata->toolsettings;
1628   const bool is_vertex_select_mode = (ts != NULL) && (ts->selectmode & SCE_SELECT_VERTEX) != 0;
1629   const bool is_face_only_select_mode = (ts != NULL) && (ts->selectmode == SCE_SELECT_FACE);
1630
1631   if (eed == rdata->eed_act) {
1632     eattr->e_flag |= VFLAG_EDGE_ACTIVE;
1633   }
1634   if (!is_vertex_select_mode && BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
1635     eattr->e_flag |= VFLAG_EDGE_SELECTED;
1636   }
1637   if (is_vertex_select_mode && BM_elem_flag_test(eed->v1, BM_ELEM_SELECT) &&
1638       BM_elem_flag_test(eed->v2, BM_ELEM_SELECT)) {
1639     eattr->e_flag |= VFLAG_EDGE_SELECTED;
1640     eattr->e_flag |= VFLAG_VERT_SELECTED;
1641   }
1642   if (BM_elem_flag_test(eed, BM_ELEM_SEAM)) {
1643     eattr->e_flag |= VFLAG_EDGE_SEAM;
1644   }
1645   if (!BM_elem_flag_test(eed, BM_ELEM_SMOOTH)) {
1646     eattr->e_flag |= VFLAG_EDGE_SHARP;
1647   }
1648
1649   /* Use active edge color for active face edges because
1650    * specular highlights make it hard to see T55456#510873.
1651    *
1652    * This isn't ideal since it can't be used when mixing edge/face modes
1653    * but it's still better then not being able to see the active face. */
1654   if (is_face_only_select_mode) {
1655     if (rdata->efa_act != NULL) {
1656       if (BM_edge_in_face(eed, rdata->efa_act)) {
1657         eattr->e_flag |= VFLAG_EDGE_ACTIVE;
1658       }
1659     }
1660   }
1661
1662   /* Use a byte for value range */
1663   if (rdata->cd.offset.crease != -1) {
1664     float crease = BM_ELEM_CD_GET_FLOAT(eed, rdata->cd.offset.crease);
1665     if (crease > 0) {
1666       eattr->crease = (uchar)(crease * 255.0f);
1667     }
1668   }
1669   /* Use a byte for value range */
1670   if (rdata->cd.offset.bweight != -1) {
1671     float bweight = BM_ELEM_CD_GET_FLOAT(eed, rdata->cd.offset.bweight);
1672     if (bweight > 0) {
1673       eattr->bweight = (uchar)(bweight * 255.0f);
1674     }
1675   }
1676 #ifdef WITH_FREESTYLE
1677   if (rdata->cd.offset.freestyle_edge != -1) {
1678     const FreestyleEdge *fed = BM_ELEM_CD_GET_VOID_P(eed, rdata->cd.offset.freestyle_edge);
1679     if (fed->flag & FREESTYLE_EDGE_MARK) {
1680       eattr->e_flag |= VFLAG_EDGE_FREESTYLE;
1681     }
1682   }
1683 #endif
1684 }
1685
1686 static void mesh_render_data_loop_flag(MeshRenderData *rdata,
1687                                        BMLoop *loop,
1688                                        const int cd_ofs,
1689                                        EdgeDrawAttr *eattr)
1690 {
1691   if (cd_ofs == -1) {
1692     return;
1693   }
1694   MLoopUV *luv = BM_ELEM_CD_GET_VOID_P(loop, cd_ofs);
1695   if (luv != NULL && (luv->flag & MLOOPUV_PINNED)) {
1696     eattr->v_flag |= VFLAG_VERT_UV_PINNED;
1697   }
1698   if (uvedit_uv_select_test_ex(rdata->toolsettings, loop, cd_ofs)) {
1699     eattr->v_flag |= VFLAG_VERT_UV_SELECT;
1700   }
1701   if (uvedit_edge_select_test_ex(rdata->toolsettings, loop, cd_ofs)) {
1702     eattr->v_flag |= VFLAG_EDGE_UV_SELECT;
1703   }
1704 }
1705
1706 static void mesh_render_data_vert_flag(MeshRenderData *rdata,
1707                                        const BMVert *eve,
1708                                        EdgeDrawAttr *eattr)
1709 {
1710   if (eve == rdata->eve_act) {
1711     eattr->e_flag |= VFLAG_VERT_ACTIVE;
1712   }
1713   if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
1714     eattr->e_flag |= VFLAG_VERT_SELECTED;
1715   }
1716 }
1717
1718 static bool add_edit_facedot(MeshRenderData *rdata,
1719                              GPUVertBuf *vbo,
1720                              const uint fdot_pos_id,
1721                              const uint fdot_nor_flag_id,
1722                              const int poly,
1723                              const int base_vert_idx)
1724 {
1725   BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_LOOP | MR_DATATYPE_POLY));
1726   float pnor[3], center[3];
1727   int facedot_flag;
1728   if (rdata->edit_bmesh) {
1729     BMEditMesh *em = rdata->edit_bmesh;
1730     const BMFace *efa = BM_face_at_index(em->bm, poly);
1731     if (BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
1732       return false;
1733     }
1734     if (rdata->edit_data && rdata->edit_data->vertexCos) {
1735       copy_v3_v3(center, rdata->edit_data->polyCos[poly]);
1736       copy_v3_v3(pnor, rdata->edit_data->polyNos[poly]);
1737     }
1738     else {
1739       BM_face_calc_center_median(efa, center);
1740       copy_v3_v3(pnor, efa->no);
1741     }
1742     facedot_flag = BM_elem_flag_test(efa, BM_ELEM_SELECT) ? ((efa == em->bm->act_face) ? -1 : 1) :
1743                                                             0;
1744   }
1745   else {
1746     MVert *mvert = rdata->mvert;
1747     const MPoly *mpoly = rdata->mpoly + poly;
1748     const MLoop *mloop = rdata->mloop + mpoly->loopstart;
1749
1750     BKE_mesh_calc_poly_center(mpoly, mloop, mvert, center);
1751     BKE_mesh_calc_poly_normal(mpoly, mloop, mvert, pnor);
1752     /* No selection if not in edit mode. */
1753     facedot_flag = 0;
1754   }
1755
1756   GPUPackedNormal nor = GPU_normal_convert_i10_v3(pnor);
1757   nor.w = facedot_flag;
1758   GPU_vertbuf_attr_set(vbo, fdot_nor_flag_id, base_vert_idx, &nor);
1759   GPU_vertbuf_attr_set(vbo, fdot_pos_id, base_vert_idx, center);
1760
1761   return true;
1762 }
1763 static bool add_edit_facedot_mapped(MeshRenderData *rdata,
1764                                     GPUVertBuf *vbo,
1765                                     const uint fdot_pos_id,
1766                                     const uint fdot_nor_flag_id,
1767                                     const int poly,
1768                                     const int base_vert_idx)
1769 {
1770   BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_LOOP | MR_DATATYPE_POLY));
1771   float pnor[3], center[3];
1772   const int *p_origindex = rdata->mapped.p_origindex;
1773   const int p_orig = p_origindex[poly];
1774   if (p_orig == ORIGINDEX_NONE) {
1775     return false;
1776   }
1777   BMEditMesh *em = rdata->edit_bmesh;
1778   const BMFace *efa = BM_face_at_index(em->bm, p_orig);
1779   if (BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
1780     return false;
1781   }
1782
1783   Mesh *me_cage = em->mesh_eval_cage;
1784   const MVert *mvert = me_cage->mvert;
1785   const MLoop *mloop = me_cage->mloop;
1786   const MPoly *mpoly = me_cage->mpoly;
1787
1788   const MPoly *mp = mpoly + poly;
1789   const MLoop *ml = mloop + mp->loopstart;
1790
1791   BKE_mesh_calc_poly_center(mp, ml, mvert, center);
1792   BKE_mesh_calc_poly_normal(mp, ml, mvert, pnor);
1793
1794   GPUPackedNormal nor = GPU_normal_convert_i10_v3(pnor);
1795   nor.w = BM_elem_flag_test(efa, BM_ELEM_SELECT) ? ((efa == em->bm->act_face) ? -1 : 1) : 0;
1796   GPU_vertbuf_attr_set(vbo, fdot_nor_flag_id, base_vert_idx, &nor);
1797   GPU_vertbuf_attr_set(vbo, fdot_pos_id, base_vert_idx, center);
1798
1799   return true;
1800 }
1801
1802 /** \} */
1803
1804 /* ---------------------------------------------------------------------- */
1805 /** \name Vertex Group Selection
1806  * \{ */
1807
1808 /** Reset the selection structure, deallocating heap memory as appropriate. */
1809 static void drw_mesh_weight_state_clear(struct DRW_MeshWeightState *wstate)
1810 {
1811   MEM_SAFE_FREE(wstate->defgroup_sel);
1812
1813   memset(wstate, 0, sizeof(*wstate));
1814
1815   wstate->defgroup_active = -1;
1816 }
1817
1818 /** Copy selection data from one structure to another, including heap memory. */
1819 static void drw_mesh_weight_state_copy(struct DRW_MeshWeightState *wstate_dst,
1820                                        const struct DRW_MeshWeightState *wstate_src)
1821 {
1822   MEM_SAFE_FREE(wstate_dst->defgroup_sel);
1823
1824   memcpy(wstate_dst, wstate_src, sizeof(*wstate_dst));
1825
1826   if (wstate_src->defgroup_sel) {
1827     wstate_dst->defgroup_sel = MEM_dupallocN(wstate_src->defgroup_sel);
1828   }
1829 }
1830
1831 /** Compare two selection structures. */
1832 static bool drw_mesh_weight_state_compare(const struct DRW_MeshWeightState *a,
1833                                           const struct DRW_MeshWeightState *b)
1834 {
1835   return a->defgroup_active == b->defgroup_active && a->defgroup_len == b->defgroup_len &&
1836          a->flags == b->flags && a->alert_mode == b->alert_mode &&
1837          a->defgroup_sel_count == b->defgroup_sel_count &&
1838          ((!a->defgroup_sel && !b->defgroup_sel) ||
1839           (a->defgroup_sel && b->defgroup_sel &&
1840            memcmp(a->defgroup_sel, b->defgroup_sel, a->defgroup_len * sizeof(bool)) == 0));
1841 }
1842
1843 static void drw_mesh_weight_state_extract(Object *ob,
1844                                           Mesh *me,
1845                                           const ToolSettings *ts,
1846                                           bool paint_mode,
1847                                           struct DRW_MeshWeightState *wstate)
1848 {
1849   /* Extract complete vertex weight group selection state and mode flags. */
1850   memset(wstate, 0, sizeof(*wstate));
1851
1852   wstate->defgroup_active = ob->actdef - 1;
1853   wstate->defgroup_len = BLI_listbase_count(&ob->defbase);
1854
1855   wstate->alert_mode = ts->weightuser;
1856
1857   if (paint_mode && ts->multipaint) {
1858     /* Multipaint needs to know all selected bones, not just the active group.
1859      * This is actually a relatively expensive operation, but caching would be difficult. */
1860     wstate->defgroup_sel = BKE_object_defgroup_selected_get(
1861         ob, wstate->defgroup_len, &wstate->defgroup_sel_count);
1862
1863     if (wstate->defgroup_sel_count > 1) {
1864       wstate->flags |= DRW_MESH_WEIGHT_STATE_MULTIPAINT |
1865                        (ts->auto_normalize ? DRW_MESH_WEIGHT_STATE_AUTO_NORMALIZE : 0);
1866
1867       if (me->editflag & ME_EDIT_MIRROR_X) {
1868         BKE_object_defgroup_mirror_selection(ob,
1869                                              wstate->defgroup_len,
1870                                              wstate->defgroup_sel,
1871                                              wstate->defgroup_sel,
1872                                              &wstate->defgroup_sel_count);
1873       }
1874     }
1875     /* With only one selected bone Multipaint reverts to regular mode. */
1876     else {
1877       wstate->defgroup_sel_count = 0;
1878       MEM_SAFE_FREE(wstate->defgroup_sel);
1879     }
1880   }
1881 }
1882
1883 /** \} */
1884
1885 /* ---------------------------------------------------------------------- */
1886 /** \name Mesh GPUBatch Cache
1887  * \{ */
1888
1889 typedef struct MeshBatchCache {
1890   /* In order buffers: All verts only specified once
1891    * or once per loop. To be used with a GPUIndexBuf. */
1892   struct {
1893     /* Vertex data. */
1894     GPUVertBuf *pos_nor;
1895     GPUVertBuf *weights;
1896     /* Loop data. */
1897     GPUVertBuf *loop_pos_nor;
1898     GPUVertBuf *loop_uv_tan;
1899     GPUVertBuf *loop_vcol;
1900     GPUVertBuf *loop_edge_fac;
1901     GPUVertBuf *loop_orco;
1902   } ordered;
1903
1904   /* Edit Mesh Data:
1905    * Edit cage can be different from final mesh so vertex count
1906    * might differ. */
1907   struct {
1908     /* TODO(fclem): Reuse ordered.loop_pos_nor and maybe even
1909      * ordered.loop_uv_tan when cage match final mesh. */
1910     GPUVertBuf *loop_pos_nor;
1911     GPUVertBuf *loop_data;
1912     GPUVertBuf *loop_lnor;
1913     GPUVertBuf *facedots_pos_nor_data;
1914     /* UV data without modifier applied.
1915      * Vertex count is always the one of the cage. */
1916     GPUVertBuf *loop_uv;
1917     GPUVertBuf *loop_uv_data;
1918     GPUVertBuf *loop_stretch_angle;
1919     GPUVertBuf *loop_stretch_area;
1920     GPUVertBuf *facedots_uv;
1921     GPUVertBuf *facedots_uv_data;
1922     /* Selection */
1923     GPUVertBuf *loop_vert_idx;
1924     GPUVertBuf *loop_edge_idx;
1925     GPUVertBuf *loop_face_idx;
1926     GPUVertBuf *facedots_idx;
1927   } edit;
1928
1929   /* Index Buffers:
1930    * Only need to be updated when topology changes. */
1931   struct {
1932     /* Indices to verts. */
1933     GPUIndexBuf *surf_tris;
1934     GPUIndexBuf *edges_lines;
1935     GPUIndexBuf *edges_adj_lines;
1936     GPUIndexBuf *loose_edges_lines;
1937     /* Indices to vloops. */
1938     GPUIndexBuf *loops_tris;
1939     GPUIndexBuf *loops_lines;
1940     GPUIndexBuf *loops_line_strips;
1941     /* Edit mode. */
1942     GPUIndexBuf *edit_loops_points; /* verts */
1943     GPUIndexBuf *edit_loops_lines;  /* edges */
1944     GPUIndexBuf *edit_loops_tris;   /* faces */
1945     /* Edit UVs */
1946     GPUIndexBuf *edituv_loops_points;      /* verts */
1947     GPUIndexBuf *edituv_loops_line_strips; /* edges */
1948     GPUIndexBuf *edituv_loops_tri_fans;    /* faces */
1949   } ibo;
1950
1951   struct {
1952     /* Surfaces / Render */
1953     GPUBatch *surface;
1954     GPUBatch *surface_weights;
1955     /* Edit mode */
1956     GPUBatch *edit_triangles;
1957     GPUBatch *edit_vertices;
1958     GPUBatch *edit_edges;
1959     GPUBatch *edit_lnor;
1960     GPUBatch *edit_facedots;
1961     /* Edit UVs */
1962     GPUBatch *edituv_faces_strech_area;
1963     GPUBatch *edituv_faces_strech_angle;
1964     GPUBatch *edituv_faces;
1965     GPUBatch *edituv_edges;
1966     GPUBatch *edituv_verts;
1967     GPUBatch *edituv_facedots;
1968     /* Edit selection */
1969     GPUBatch *edit_selection_verts;
1970     GPUBatch *edit_selection_edges;
1971     GPUBatch *edit_selection_faces;
1972     GPUBatch *edit_selection_facedots;
1973     /* Common display / Other */
1974     GPUBatch *all_verts;
1975     GPUBatch *all_edges;
1976     GPUBatch *loose_edges;
1977     GPUBatch *edge_detection;
1978     GPUBatch *wire_edges;     /* Individual edges with face normals. */
1979     GPUBatch *wire_loops;     /* Loops around faces. */
1980     GPUBatch *wire_loops_uvs; /* Same as wire_loops but only has uvs. */
1981   } batch;
1982
1983   GPUIndexBuf **surf_per_mat_tris;
1984   GPUBatch **surf_per_mat;
1985
1986   /* arrays of bool uniform names (and value) that will be use to
1987    * set srgb conversion for auto attributes.*/
1988   char *auto_layer_names;
1989   int *auto_layer_is_srgb;
1990   int auto_layer_len;
1991
1992   /* settings to determine if cache is invalid */
1993   bool is_maybe_dirty;
1994   bool is_dirty; /* Instantly invalidates cache, skipping mesh check */
1995   int edge_len;
1996   int tri_len;
1997   int poly_len;
1998   int vert_len;
1999   int mat_len;
2000   bool is_editmode;
2001   bool is_uvsyncsel;
2002
2003   struct DRW_MeshWeightState weight_state;
2004
2005   DRW_MeshCDMask cd_used, cd_needed, cd_used_over_time;
2006
2007   /* XXX, only keep for as long as sculpt mode uses shaded drawing. */
2008   bool is_sculpt_points_tag;
2009
2010   /* Valid only if edge_detection is up to date. */
2011   bool is_manifold;
2012 } MeshBatchCache;
2013
2014 /* GPUBatch cache management. */
2015
2016 static bool mesh_batch_cache_valid(Mesh *me)
2017 {
2018   MeshBatchCache *cache = me->runtime.batch_cache;
2019
2020   if (cache == NULL) {
2021     return false;
2022   }
2023
2024   if (cache->mat_len != mesh_render_mat_len_get(me)) {
2025     return false;
2026   }
2027
2028   if (cache->is_editmode != (me->edit_mesh != NULL)) {
2029     return false;
2030   }
2031
2032   if (cache->is_dirty) {
2033     return false;
2034   }
2035
2036   if (cache->is_maybe_dirty == false) {
2037     return true;
2038   }
2039   else {
2040     if (cache->is_editmode) {
2041       return false;
2042     }
2043     else if ((cache->vert_len != mesh_render_verts_len_get(me)) ||
2044              (cache->edge_len != mesh_render_edges_len_get(me)) ||
2045              (cache->tri_len != mesh_render_looptri_len_get(me)) ||
2046              (cache->poly_len != mesh_render_polys_len_get(me)) ||
2047              (cache->mat_len != mesh_render_mat_len_get(me))) {
2048       return false;
2049     }
2050   }
2051
2052   return true;
2053 }
2054
2055 static void mesh_batch_cache_init(Mesh *me)
2056 {
2057   MeshBatchCache *cache = me->runtime.batch_cache;
2058
2059   if (!cache) {
2060     cache = me->runtime.batch_cache = MEM_callocN(sizeof(*cache), __func__);
2061   }
2062   else {
2063     memset(cache, 0, sizeof(*cache));
2064   }
2065
2066   cache->is_editmode = me->edit_mesh != NULL;
2067
2068   if (cache->is_editmode == false) {
2069     cache->edge_len = mesh_render_edges_len_get(me);
2070     cache->tri_len = mesh_render_looptri_len_get(me);
2071     cache->poly_len = mesh_render_polys_len_get(me);
2072     cache->vert_len = mesh_render_verts_len_get(me);
2073   }
2074
2075   cache->mat_len = mesh_render_mat_len_get(me);
2076   cache->surf_per_mat_tris = MEM_callocN(sizeof(*cache->surf_per_mat_tris) * cache->mat_len,
2077                                          __func__);
2078   cache->surf_per_mat = MEM_callocN(sizeof(*cache->surf_per_mat) * cache->mat_len, __func__);
2079
2080   cache->is_maybe_dirty = false;
2081   cache->is_dirty = false;
2082
2083   drw_mesh_weight_state_clear(&cache->weight_state);
2084 }
2085
2086 static MeshBatchCache *mesh_batch_cache_get(Mesh *me)
2087 {
2088   if (!mesh_batch_cache_valid(me)) {
2089     mesh_batch_cache_clear(me);
2090     mesh_batch_cache_init(me);
2091   }
2092   return me->runtime.batch_cache;
2093 }
2094
2095 static void mesh_batch_cache_check_vertex_group(MeshBatchCache *cache,
2096                                                 const struct DRW_MeshWeightState *wstate)
2097 {
2098   if (!drw_mesh_weight_state_compare(&cache->weight_state, wstate)) {
2099     GPU_BATCH_CLEAR_SAFE(cache->batch.surface_weights);
2100     GPU_VERTBUF_DISCARD_SAFE(cache->ordered.weights);
2101
2102     drw_mesh_weight_state_clear(&cache->weight_state);
2103   }
2104 }
2105
2106 static void mesh_batch_cache_discard_shaded_tri(MeshBatchCache *cache)
2107 {
2108   GPU_VERTBUF_DISCARD_SAFE(cache->ordered.loop_pos_nor);
2109   GPU_VERTBUF_DISCARD_SAFE(cache->ordered.loop_uv_tan);
2110   GPU_VERTBUF_DISCARD_SAFE(cache->ordered.loop_vcol);
2111   GPU_VERTBUF_DISCARD_SAFE(cache->ordered.loop_orco);
2112
2113   if (cache->surf_per_mat_tris) {
2114     for (int i = 0; i < cache->mat_len; i++) {
2115       GPU_INDEXBUF_DISCARD_SAFE(cache->surf_per_mat_tris[i]);
2116     }
2117   }
2118   MEM_SAFE_FREE(cache->surf_per_mat_tris);
2119   if (cache->surf_per_mat) {
2120     for (int i = 0; i < cache->mat_len; i++) {
2121       GPU_BATCH_DISCARD_SAFE(cache->surf_per_mat[i]);
2122     }
2123   }
2124   MEM_SAFE_FREE(cache->surf_per_mat);
2125
2126   MEM_SAFE_FREE(cache->auto_layer_names);
2127   MEM_SAFE_FREE(cache->auto_layer_is_srgb);
2128
2129   mesh_cd_layers_type_clear(&cache->cd_used);
2130
2131   cache->mat_len = 0;
2132 }
2133
2134 static void mesh_batch_cache_discard_uvedit(MeshBatchCache *cache)
2135 {
2136   GPU_VERTBUF_DISCARD_SAFE(cache->edit.loop_stretch_angle);
2137   GPU_VERTBUF_DISCARD_SAFE(cache->edit.loop_stretch_area);
2138   GPU_VERTBUF_DISCARD_SAFE(cache->edit.loop_uv);
2139   GPU_VERTBUF_DISCARD_SAFE(cache->edit.loop_uv_data);
2140   GPU_VERTBUF_DISCARD_SAFE(cache->edit.facedots_uv);
2141   GPU_VERTBUF_DISCARD_SAFE(cache->edit.facedots_uv_data);
2142   GPU_INDEXBUF_DISCARD_SAFE(cache->ibo.edituv_loops_tri_fans);
2143   GPU_INDEXBUF_DISCARD_SAFE(cache->ibo.edituv_loops_line_strips);
2144   GPU_INDEXBUF_DISCARD_SAFE(cache->ibo.edituv_loops_points);
2145   GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces_strech_area);
2146   GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces_strech_angle);
2147   GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces);
2148   GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_edges);
2149   GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_verts);
2150   GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_facedots);
2151 }
2152
2153 void DRW_mesh_batch_cache_dirty_tag(Mesh *me, int mode)
2154 {
2155   MeshBatchCache *cache = me->runtime.batch_cache;
2156   if (cache == NULL) {
2157     return;
2158   }
2159   switch (mode) {
2160     case BKE_MESH_BATCH_DIRTY_MAYBE_ALL:
2161       cache->is_maybe_dirty = true;
2162       break;
2163     case BKE_MESH_BATCH_DIRTY_SELECT:
2164       GPU_VERTBUF_DISCARD_SAFE(cache->edit.loop_data);
2165       GPU_VERTBUF_DISCARD_SAFE(cache->edit.facedots_pos_nor_data);
2166       GPU_BATCH_DISCARD_SAFE(cache->batch.edit_triangles);
2167       GPU_BATCH_DISCARD_SAFE(cache->batch.edit_vertices);
2168       GPU_BATCH_DISCARD_SAFE(cache->batch.edit_edges);
2169       GPU_BATCH_DISCARD_SAFE(cache->batch.edit_facedots);
2170       /* Paint mode selection */
2171       /* TODO only do that in paint mode. */
2172       GPU_VERTBUF_DISCARD_SAFE(cache->ordered.loop_pos_nor);
2173       GPU_BATCH_DISCARD_SAFE(cache->batch.surface);
2174       GPU_BATCH_DISCARD_SAFE(cache->batch.wire_loops);
2175       if (cache->surf_per_mat) {
2176         for (int i = 0; i < cache->mat_len; i++) {
2177           GPU_BATCH_DISCARD_SAFE(cache->surf_per_mat[i]);
2178         }
2179       }
2180       /* Because visible UVs depends on edit mode selection, discard everything. */
2181       mesh_batch_cache_discard_uvedit(cache);
2182       break;
2183     case BKE_MESH_BATCH_DIRTY_ALL:
2184       cache->is_dirty = true;
2185       break;
2186     case BKE_MESH_BATCH_DIRTY_SHADING:
2187       mesh_batch_cache_discard_shaded_tri(cache);
2188       mesh_batch_cache_discard_uvedit(cache);
2189       break;
2190     case BKE_MESH_BATCH_DIRTY_SCULPT_COORDS:
2191       cache->is_sculpt_points_tag = true;
2192       break;
2193     case BKE_MESH_BATCH_DIRTY_UVEDIT_ALL:
2194       mesh_batch_cache_discard_uvedit(cache);
2195       break;
2196     case BKE_MESH_BATCH_DIRTY_UVEDIT_SELECT:
2197       GPU_VERTBUF_DISCARD_SAFE(cache->edit.loop_uv_data);
2198       GPU_VERTBUF_DISCARD_SAFE(cache->edit.facedots_uv_data);
2199       GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces_strech_area);
2200       GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces_strech_angle);
2201       GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces);
2202       GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_edges);
2203       GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_verts);
2204       GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_facedots);
2205       break;
2206     default:
2207       BLI_assert(0);
2208   }
2209 }
2210
2211 static void mesh_batch_cache_clear(Mesh *me)
2212 {
2213   MeshBatchCache *cache = me->runtime.batch_cache;
2214   if (!cache) {
2215     return;
2216   }
2217
2218   for (int i = 0; i < sizeof(cache->ordered) / sizeof(void *); ++i) {
2219     GPUVertBuf **vbo = (GPUVertBuf **)&cache->ordered;
2220     GPU_VERTBUF_DISCARD_SAFE(vbo[i]);
2221   }
2222   for (int i = 0; i < sizeof(cache->edit) / sizeof(void *); ++i) {
2223     GPUVertBuf **vbo = (GPUVertBuf **)&cache->edit;
2224     GPU_VERTBUF_DISCARD_SAFE(vbo[i]);
2225   }
2226   for (int i = 0; i < sizeof(cache->ibo) / sizeof(void *); ++i) {
2227     GPUIndexBuf **ibo = (GPUIndexBuf **)&cache->ibo;
2228     GPU_INDEXBUF_DISCARD_SAFE(ibo[i]);
2229   }
2230   for (int i = 0; i < sizeof(cache->batch) / sizeof(void *); ++i) {
2231     GPUBatch **batch = (GPUBatch **)&cache->batch;
2232     GPU_BATCH_DISCARD_SAFE(batch[i]);
2233   }
2234
2235   mesh_batch_cache_discard_shaded_tri(cache);
2236
2237   mesh_batch_cache_discard_uvedit(cache);
2238
2239   drw_mesh_weight_state_clear(&cache->weight_state);
2240 }
2241
2242 void DRW_mesh_batch_cache_free(Mesh *me)
2243 {
2244   mesh_batch_cache_clear(me);
2245   MEM_SAFE_FREE(me->runtime.batch_cache);
2246 }
2247
2248 /* GPUBatch cache usage. */
2249
2250 static void mesh_create_edit_vertex_loops(MeshRenderData *rdata,
2251                                           GPUVertBuf *vbo_pos_nor,
2252                                           GPUVertBuf *vbo_lnor,
2253                                           GPUVertBuf *vbo_uv,
2254                                           GPUVertBuf *vbo_data,
2255                                           GPUVertBuf *vbo_verts,
2256                                           GPUVertBuf *vbo_edges,
2257                                           GPUVertBuf *vbo_faces)
2258 {
2259 #if 0
2260   const int vert_len = mesh_render_data_verts_len_get_maybe_mapped(rdata);
2261   const int edge_len = mesh_render_data_edges_len_get_maybe_mapped(rdata);
2262 #endif
2263   const int poly_len = mesh_render_data_polys_len_get_maybe_mapped(rdata);
2264   const int lvert_len = mesh_render_data_loose_verts_len_get_maybe_mapped(rdata);
2265   const int ledge_len = mesh_render_data_loose_edges_len_get_maybe_mapped(rdata);
2266   const int loop_len = mesh_render_data_loops_len_get_maybe_mapped(rdata);
2267   const int tot_loop_len = loop_len + ledge_len * 2 + lvert_len;
2268   float(*lnors)[3] = rdata->loop_normals;
2269   uchar fflag;
2270
2271   /* Static formats */
2272   static struct {
2273     GPUVertFormat sel_id, pos_nor, lnor, flag, uv;
2274   } format = {{0}};
2275   static struct {
2276     uint sel_id, pos, nor, lnor, data, uvs;
2277   } attr_id;
2278   if (format.sel_id.attr_len == 0) {
2279     attr_id.sel_id = GPU_vertformat_attr_add(
2280         &format.sel_id, "color", GPU_COMP_U32, 1, GPU_FETCH_INT);
2281     attr_id.pos = GPU_vertformat_attr_add(
2282         &format.pos_nor, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
2283     attr_id.nor = GPU_vertformat_attr_add(
2284         &format.pos_nor, "vnor", GPU_COMP_I10, 3, GPU_FETCH_INT_TO_FLOAT_UNIT);
2285     attr_id.lnor = GPU_vertformat_attr_add(
2286         &format.lnor, "lnor", GPU_COMP_I10, 3, GPU_FETCH_INT_TO_FLOAT_UNIT);
2287     attr_id.data = GPU_vertformat_attr_add(&format.flag, "data", GPU_COMP_U8, 4, GPU_FETCH_INT);
2288     attr_id.uvs = GPU_vertformat_attr_add(&format.uv, "u", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
2289     GPU_vertformat_alias_add(&format.uv, "pos");
2290     GPU_vertformat_alias_add(&format.flag, "flag");
2291   }
2292
2293   GPUVertBufRaw raw_verts, raw_edges, raw_faces, raw_pos, raw_nor, raw_lnor, raw_uv, raw_data;
2294   if (DRW_TEST_ASSIGN_VBO(vbo_pos_nor)) {
2295     GPU_vertbuf_init_with_format(vbo_pos_nor, &format.pos_nor);
2296     GPU_vertbuf_data_alloc(vbo_pos_nor, tot_loop_len);
2297     GPU_vertbuf_attr_get_raw_data(vbo_pos_nor, attr_id.pos, &raw_pos);
2298     GPU_vertbuf_attr_get_raw_data(vbo_pos_nor, attr_id.nor, &raw_nor);
2299   }
2300   if (DRW_TEST_ASSIGN_VBO(vbo_lnor)) {
2301     GPU_vertbuf_init_with_format(vbo_lnor, &format.lnor);
2302     GPU_vertbuf_data_alloc(vbo_lnor, tot_loop_len);
2303     GPU_vertbuf_attr_get_raw_data(vbo_lnor, attr_id.lnor, &raw_lnor);
2304   }
2305   if (DRW_TEST_ASSIGN_VBO(vbo_data)) {
2306     GPU_vertbuf_init_with_format(vbo_data, &format.flag);
2307     GPU_vertbuf_data_alloc(vbo_data, tot_loop_len);
2308     GPU_vertbuf_attr_get_raw_data(vbo_data, attr_id.data, &raw_data);
2309   }
2310   if (DRW_TEST_ASSIGN_VBO(vbo_uv)) {
2311     GPU_vertbuf_init_with_format(vbo_uv, &format.uv);
2312     GPU_vertbuf_data_alloc(vbo_uv, tot_loop_len);
2313     GPU_vertbuf_attr_get_raw_data(vbo_uv, attr_id.uvs, &raw_uv);
2314   }
2315   /* Select Idx */
2316   if (DRW_TEST_ASSIGN_VBO(vbo_verts)) {
2317     GPU_vertbuf_init_with_format(vbo_verts, &format.sel_id);
2318     GPU_vertbuf_data_alloc(vbo_verts, tot_loop_len);
2319     GPU_vertbuf_attr_get_raw_data(vbo_verts, attr_id.sel_id, &raw_verts);
2320   }
2321   if (DRW_TEST_ASSIGN_VBO(vbo_edges)) {
2322     GPU_vertbuf_init_with_format(vbo_edges, &format.sel_id);
2323     GPU_vertbuf_data_alloc(vbo_edges, tot_loop_len);
2324     GPU_vertbuf_attr_get_raw_data(vbo_edges, attr_id.sel_id, &raw_edges);
2325   }
2326   if (DRW_TEST_ASSIGN_VBO(vbo_faces)) {
2327     GPU_vertbuf_init_with_format(vbo_faces, &format.sel_id);
2328     GPU_vertbuf_data_alloc(vbo_faces, tot_loop_len);
2329     GPU_vertbuf_attr_get_raw_data(vbo_faces, attr_id.sel_id, &raw_faces);
2330   }
2331
2332   if (rdata->edit_bmesh && rdata->mapped.use == false) {
2333     BMesh *bm = rdata->edit_bmesh->bm;
2334     BMIter iter_efa, iter_loop, iter_vert;
2335     BMFace *efa;
2336     BMEdge *eed;
2337     BMVert *eve;
2338     BMLoop *loop;
2339     const int cd_loop_uv_offset = CustomData_get_offset(&bm->ldata, CD_MLOOPUV);
2340
2341     /* Face Loops */
2342     BM_ITER_MESH (efa, &iter_efa, bm, BM_FACES_OF_MESH) {
2343       int fidx = BM_elem_index_get(efa);
2344       if (vbo_data) {
2345         fflag = mesh_render_data_face_flag(rdata, efa, cd_loop_uv_offset);
2346       }
2347       BM_ITER_ELEM (loop, &iter_loop, efa, BM_LOOPS_OF_FACE) {
2348         if (vbo_pos_nor) {
2349           GPUPackedNormal *vnor = (GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_nor);
2350           *vnor = GPU_normal_convert_i10_v3(loop->v->no);
2351           copy_v3_v3(GPU_vertbuf_raw_step(&raw_pos), loop->v->co);
2352         }
2353         if (vbo_lnor) {
2354           const float *nor = (lnors) ? lnors[BM_elem_index_get(loop)] : efa->no;
2355           GPUPackedNormal *lnor = (GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_lnor);
2356           *lnor = GPU_normal_convert_i10_v3(nor);
2357         }
2358         if (vbo_data) {
2359           EdgeDrawAttr eattr = {.v_flag = fflag};
2360           mesh_render_data_edge_flag(rdata, loop->e, &eattr);
2361           mesh_render_data_vert_flag(rdata, loop->v, &eattr);
2362           mesh_render_data_loop_flag(rdata, loop, cd_loop_uv_offset, &eattr);
2363           memcpy(GPU_vertbuf_raw_step(&raw_data), &eattr, sizeof(EdgeDrawAttr));
2364         }
2365         if (vbo_uv) {
2366           MLoopUV *luv = BM_ELEM_CD_GET_VOID_P(loop, cd_loop_uv_offset);
2367           copy_v2_v2(GPU_vertbuf_raw_step(&raw_uv), luv->uv);
2368         }
2369         /* Select Idx */
2370         if (vbo_verts) {
2371           int vidx = BM_elem_index_get(loop->v);
2372           *((uint *)GPU_vertbuf_raw_step(&raw_verts)) = vidx;
2373         }
2374         if (vbo_edges) {
2375           int eidx = BM_elem_index_get(loop->e);
2376           *((uint *)GPU_vertbuf_raw_step(&raw_edges)) = eidx;
2377         }
2378         if (vbo_faces) {
2379           *((uint *)GPU_vertbuf_raw_step(&raw_faces)) = fidx;
2380         }
2381       }
2382     }
2383     /* Loose edges */
2384     for (int e = 0; e < ledge_len; e++) {
2385       eed = BM_edge_at_index(bm, rdata->loose_edges[e]);
2386       BM_ITER_ELEM (eve, &iter_vert, eed, BM_VERTS_OF_EDGE) {
2387         if (vbo_pos_nor) {
2388           GPUPackedNormal *vnor = (GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_nor);
2389           *vnor = GPU_normal_convert_i10_v3(eve->no);
2390           copy_v3_v3(GPU_vertbuf_raw_step(&raw_pos), eve->co);
2391         }
2392         if (vbo_data) {
2393           EdgeDrawAttr eattr = {0};
2394           mesh_render_data_edge_flag(rdata, eed, &eattr);
2395           mesh_render_data_vert_flag(rdata, eve, &eattr);
2396           memcpy(GPU_vertbuf_raw_step(&raw_data), &eattr, sizeof(EdgeDrawAttr));
2397         }
2398         if (vbo_lnor) {
2399           memset(GPU_vertbuf_raw_step(&raw_lnor), 0, sizeof(GPUPackedNormal));
2400         }
2401         /* Select Idx */
2402         if (vbo_verts) {
2403           int vidx = BM_elem_index_get(eve);
2404           *((uint *)GPU_vertbuf_raw_step(&raw_verts)) = vidx;
2405         }
2406         if (vbo_edges) {
2407           int eidx = BM_elem_index_get(eed);
2408           *((uint *)GPU_vertbuf_raw_step(&raw_edges)) = eidx;
2409         }
2410       }
2411     }
2412     /* Loose verts */
2413     for (int e = 0; e < lvert_len; e++) {
2414       eve = BM_vert_at_index(bm, rdata->loose_verts[e]);
2415       if (vbo_pos_nor) {
2416         GPUPackedNormal *vnor = (GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_nor);
2417         *vnor = GPU_normal_convert_i10_v3(eve->no);
2418         copy_v3_v3(GPU_vertbuf_raw_step(&raw_pos), eve->co);
2419       }
2420       if (vbo_lnor) {
2421         memset(GPU_vertbuf_raw_step(&raw_lnor), 0, sizeof(GPUPackedNormal));
2422       }
2423       if (vbo_data) {
2424         EdgeDrawAttr eattr = {0};
2425         mesh_render_data_vert_flag(rdata, eve, &eattr);
2426         memcpy(GPU_vertbuf_raw_step(&raw_data), &eattr, sizeof(EdgeDrawAttr));
2427       }
2428       /* Select Idx */
2429       if (vbo_verts) {
2430         int vidx = BM_elem_index_get(eve);
2431         *((uint *)GPU_vertbuf_raw_step(&raw_verts)) = vidx;
2432       }
2433     }
2434   }
2435   else if (rdata->mapped.use == true) {
2436     BMesh *bm = rdata->edit_bmesh->bm;
2437     const int cd_loop_uv_offset = CustomData_get_offset(&bm->ldata, CD_MLOOPUV);
2438
2439     const MPoly *mpoly = rdata->mapped.me_cage->mpoly;
2440     const MEdge *medge = rdata->mapped.me_cage->medge;
2441     const MVert *mvert = rdata->mapped.me_cage->mvert;
2442     const MLoop *mloop = rdata->mapped.me_cage->mloop;
2443
2444     const int *v_origindex = rdata->mapped.v_origindex;
2445     const int *e_origindex = rdata->mapped.e_origindex;
2446     const int *p_origindex = rdata->mapped.p_origindex;
2447
2448     /* Face Loops */
2449     for (int poly = 0; poly < poly_len; poly++, mpoly++) {
2450       const MLoop *l = &mloop[mpoly->loopstart];
2451       int fidx = p_origindex[poly];
2452       BMFace *efa = NULL;
2453       if (vbo_data) {
2454         fflag = 0;
2455         if (fidx != ORIGINDEX_NONE) {
2456           efa = BM_face_at_index(bm, fidx);
2457           fflag = mesh_render_data_face_flag(rdata, efa, cd_loop_uv_offset);
2458         }
2459       }
2460       for (int i = 0; i < mpoly->totloop; i++, l++) {
2461         if (vbo_pos_nor) {
2462           copy_v3_v3(GPU_vertbuf_raw_step(&raw_pos), mvert[l->v].co);
2463         }
2464         if (vbo_lnor || vbo_pos_nor) {
2465           GPUPackedNormal vnor = GPU_normal_convert_i10_s3(mvert[l->v].no);
2466           if (vbo_pos_nor) {
2467             *(GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_nor) = vnor;
2468           }
2469           if (vbo_lnor) {
2470             /* Mapped does not support lnors yet. */
2471             *(GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_lnor) = vnor;
2472           }
2473         }
2474         if (vbo_data) {
2475           EdgeDrawAttr eattr = {.v_flag = fflag};
2476           int vidx = v_origindex[l->v];
2477           int eidx = e_origindex[l->e];
2478           if (vidx != ORIGINDEX_NONE) {
2479             BMVert *eve = BM_vert_at_index(bm, vidx);
2480             mesh_render_data_vert_flag(rdata, eve, &eattr);
2481           }
2482           if (eidx != ORIGINDEX_NONE) {
2483             BMEdge *eed = BM_edge_at_index(bm, eidx);
2484             mesh_render_data_edge_flag(rdata, eed, &eattr);
2485             if (efa) {
2486               BMLoop *loop = BM_face_edge_share_loop(efa, eed);
2487               if (loop) {
2488                 mesh_render_data_loop_flag(rdata, loop, cd_loop_uv_offset, &eattr);
2489               }
2490             }
2491           }
2492           memcpy(GPU_vertbuf_raw_step(&raw_data), &eattr, sizeof(EdgeDrawAttr));
2493         }
2494         if (vbo_uv) {
2495           MLoopUV *luv = &rdata->mloopuv[mpoly->loopstart + i];
2496           copy_v2_v2(GPU_vertbuf_raw_step(&raw_uv), luv->uv);
2497         }
2498         /* Select Idx */
2499         if (vbo_verts) {
2500           int vidx = v_origindex[l->v];
2501           *((uint *)GPU_vertbuf_raw_step(&raw_verts)) = vidx;
2502         }
2503         if (vbo_edges) {
2504           int eidx = e_origindex[l->e];
2505           *((uint *)GPU_vertbuf_raw_step(&raw_edges)) = eidx;
2506         }
2507         if (vbo_faces) {
2508           *((uint *)GPU_vertbuf_raw_step(&raw_faces)) = fidx;
2509         }
2510       }
2511     }
2512     /* Loose edges */
2513     for (int j = 0; j < ledge_len; j++) {
2514       const int e = rdata->mapped.loose_edges[j];
2515       for (int i = 0; i < 2; ++i) {
2516         int v = (i == 0) ? medge[e].v1 : medge[e].v2;
2517         if (vbo_pos_nor) {
2518           GPUPackedNormal vnor = GPU_normal_convert_i10_s3(mvert[v].no);
2519           *(GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_nor) = vnor;
2520           copy_v3_v3(GPU_vertbuf_raw_step(&raw_pos), mvert[v].co);
2521         }
2522         if (vbo_lnor) {
2523           memset(GPU_vertbuf_raw_step(&raw_lnor), 0, sizeof(GPUPackedNormal));
2524         }
2525         if (vbo_data) {
2526           EdgeDrawAttr eattr = {0};
2527           int vidx = v_origindex[v];
2528           int eidx = e_origindex[e];
2529           if (vidx != ORIGINDEX_NONE) {
2530             BMVert *eve = BM_vert_at_index(bm, vidx);
2531             mesh_render_data_vert_flag(rdata, eve, &eattr);
2532           }
2533           if (eidx != ORIGINDEX_NONE) {
2534             BMEdge *eed = BM_edge_at_index(bm, eidx);
2535             mesh_render_data_edge_flag(rdata, eed, &eattr);
2536           }
2537           memcpy(GPU_vertbuf_raw_step(&raw_data), &eattr, sizeof(EdgeDrawAttr));
2538         }
2539         /* Select Idx */
2540         if (vbo_verts) {
2541           int vidx = v_origindex[v];
2542           *((uint *)GPU_vertbuf_raw_step(&raw_verts)) = vidx;
2543         }
2544         if (vbo_edges) {
2545           int eidx = e_origindex[e];
2546           *((uint *)GPU_vertbuf_raw_step(&raw_edges)) = eidx;
2547         }
2548       }
2549     }
2550     /* Loose verts */
2551     for (int i = 0; i < lvert_len; i++) {
2552       const int v = rdata->mapped.loose_verts[i];
2553       if (vbo_pos_nor) {
2554         GPUPackedNormal vnor = GPU_normal_convert_i10_s3(mvert[v].no);
2555         *(GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_nor) = vnor;
2556         copy_v3_v3(GPU_vertbuf_raw_step(&raw_pos), mvert[v].co);
2557       }
2558       if (vbo_lnor) {
2559         memset(GPU_vertbuf_raw_step(&raw_lnor), 0, sizeof(GPUPackedNormal));
2560       }
2561       if (vbo_data) {
2562         EdgeDrawAttr eattr = {0};
2563         int vidx = v_origindex[v];
2564         if (vidx != ORIGINDEX_NONE) {
2565           BMVert *eve = BM_vert_at_index(bm, vidx);
2566           mesh_render_data_vert_flag(rdata, eve, &eattr);
2567         }
2568         memcpy(GPU_vertbuf_raw_step(&raw_data), &eattr, sizeof(EdgeDrawAttr));
2569       }
2570       /* Select Idx */
2571       if (vbo_verts) {
2572         int vidx = v_origindex[v];
2573         *((uint *)GPU_vertbuf_raw_step(&raw_verts)) = vidx;
2574       }
2575     }
2576   }
2577   else {
2578     const MPoly *mpoly = rdata->mpoly;
2579     const MVert *mvert = rdata->mvert;
2580     const MLoop *mloop = rdata->mloop;
2581
2582     const int *v_origindex = CustomData_get_layer(&rdata->me->vdata, CD_ORIGINDEX);
2583     const int *e_origindex = CustomData_get_layer(&rdata->me->edata, CD_ORIGINDEX);
2584     const int *p_origindex = CustomData_get_layer(&rdata->me->pdata, CD_ORIGINDEX);
2585
2586     /* Face Loops */
2587     for (int poly = 0; poly < poly_len; poly++, mpoly++) {
2588       const MLoop *l = &mloop[mpoly->loopstart];
2589       int fidx = p_origindex ? p_origindex[poly] : poly;
2590       for (int i = 0; i < mpoly->totloop; i++, l++) {
2591         if (vbo_pos_nor) {
2592           copy_v3_v3(GPU_vertbuf_raw_step(&raw_pos), mvert[l->v].co);
2593         }
2594         if (vbo_lnor || vbo_pos_nor) {
2595           GPUPackedNormal vnor = GPU_normal_convert_i10_s3(mvert[l->v].no);
2596           if (vbo_pos_nor) {
2597             *(GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_nor) = vnor;
2598           }
2599           if (vbo_lnor) {
2600             /* Mapped does not support lnors yet. */
2601             *(GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_lnor) = vnor;
2602           }
2603         }
2604         if (vbo_uv) {
2605           MLoopUV *luv = &rdata->mloopuv[mpoly->loopstart + i];
2606           copy_v2_v2(GPU_vertbuf_raw_step(&raw_uv), luv->uv);
2607         }
2608         /* Select Idx */
2609         if (vbo_verts) {
2610           int vidx = v_origindex ? v_origindex[l->v] : l->v;
2611           *((uint *)GPU_vertbuf_raw_step(&raw_verts)) = vidx;
2612         }
2613         if (vbo_edges) {
2614           int eidx = e_origindex ? e_origindex[l->e] : l->e;
2615           *((uint *)GPU_vertbuf_raw_step(&raw_edges)) = eidx;
2616         }
2617         if (vbo_faces) {
2618           *((uint *)GPU_vertbuf_raw_step(&raw_faces)) = fidx;
2619         }
2620       }
2621     }
2622     /* TODO(fclem): Until we find a way to detect
2623      * loose verts easily outside of edit mode, this
2624      * will remain disabled. */
2625 #if 0
2626     /* Loose edges */
2627     for (int e = 0; e < edge_len; e++, medge++) {
2628       int eidx = e_origindex[e];
2629       if (eidx != ORIGINDEX_NONE && (medge->flag & ME_LOOSEEDGE)) {
2630         for (int i = 0; i < 2; ++i) {
2631           int vidx = (i == 0) ? medge->v1 : medge->v2;
2632           if (vbo_pos) {
2633             copy_v3_v3(GPU_vertbuf_raw_step(&raw_pos), mvert[vidx].co);
2634           }
2635           if (vbo_verts) {
2636             *((uint *)GPU_vertbuf_raw_step(&raw_verts)) = vidx;
2637           }
2638           if (vbo_edges) {
2639             *((uint *)GPU_vertbuf_raw_step(&raw_edges)) = eidx;
2640           }
2641         }
2642       }
2643     }
2644     /* Loose verts */
2645     for (int v = 0; v < vert_len; v++, mvert++) {
2646       int vidx = v_origindex[v];
2647       if (vidx != ORIGINDEX_NONE) {
2648         MVert *eve = BM_vert_at_index(bm, vidx);
2649         if (eve->e == NULL) {
2650           if (vbo_pos) {
2651             copy_v3_v3(GPU_vertbuf_raw_step(&raw_pos), mvert->co);
2652           }
2653           if (vbo_verts) {
2654             *((uint *)GPU_vertbuf_raw_step(&raw_verts)) = vidx;
2655           }
2656         }
2657       }
2658     }
2659 #endif
2660   }
2661   /* Don't resize */
2662 }
2663
2664 /* TODO: We could use gl_PrimitiveID as index instead of using another VBO. */
2665 static void mesh_create_edit_facedots_select_id(MeshRenderData *rdata, GPUVertBuf *vbo)
2666 {
2667   const int poly_len = mesh_render_data_polys_len_get_maybe_mapped(rdata);
2668
2669   static GPUVertFormat format = {0};
2670   static struct {
2671     uint idx;
2672   } attr_id;
2673   if (format.attr_len == 0) {
2674     attr_id.idx = GPU_vertformat_attr_add(&format, "color", GPU_COMP_U32, 1, GPU_FETCH_INT);
2675   }
2676
2677   GPUVertBufRaw idx_step;
2678   GPU_vertbuf_init_with_format(vbo, &format);
2679   GPU_vertbuf_data_alloc(vbo, poly_len);
2680   GPU_vertbuf_attr_get_raw_data(vbo, attr_id.idx, &idx_step);
2681
2682   /* Keep in sync with mesh_create_edit_facedots(). */
2683   if (rdata->mapped.use == false) {
2684     if (rdata->edit_bmesh) {
2685       for (int poly = 0; poly < poly_len; poly++) {
2686         const BMFace *efa = BM_face_at_index(rdata->edit_bmesh->bm, poly);
2687         if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
2688           *((uint *)GPU_vertbuf_raw_step(&idx_step)) = poly;
2689         }
2690       }
2691     }
2692     else {
2693       for (int poly = 0; poly < poly_len; poly++) {
2694         *((uint *)GPU_vertbuf_raw_step(&idx_step)) = poly;
2695       }
2696     }
2697   }
2698   else {
2699     const int *p_origindex = rdata->mapped.p_origindex;
2700     for (int poly = 0; poly < poly_len; poly++) {
2701       const int p_orig = p_origindex[poly];
2702       if (p_orig != ORIGINDEX_NONE) {
2703         const BMFace *efa = BM_face_at_index(rdata->edit_bmesh->bm, p_orig);
2704         if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
2705           *((uint *)GPU_vertbuf_raw_step(&idx_step)) = poly;
2706         }
2707       }
2708     }
2709   }
2710
2711   /* Resize & Finish */
2712   int facedot_len_used = GPU_vertbuf_raw_used(&idx_step);
2713   if (facedot_len_used != poly_len) {
2714     GPU_vertbuf_data_resize(vbo, facedot_len_used);
2715   }
2716 }
2717
2718 static void mesh_create_pos_and_nor(MeshRenderData *rdata, GPUVertBuf *vbo)
2719 {
2720   static GPUVertFormat format = {0};
2721   static struct {
2722     uint pos, nor;
2723   } attr_id;
2724   if (format.attr_len == 0) {
2725     attr_id.pos = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
2726     attr_id.nor = GPU_vertformat_attr_add(
2727         &format, "nor", GPU_COMP_I10, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
2728   }
2729
2730   GPU_vertbuf_init_with_format(vbo, &format);
2731   const int vbo_len_capacity = mesh_render_data_verts_len_get_maybe_mapped(rdata);
2732   GPU_vertbuf_data_alloc(vbo, vbo_len_capacity);
2733
2734   if (rdata->mapped.use == false) {
2735     if (rdata->edit_bmesh) {
2736       BMesh *bm = rdata->edit_bmesh->bm;
2737       BMIter iter;
2738       BMVert *eve;
2739       uint i;
2740
2741       mesh_render_data_ensure_vert_normals_pack(rdata);
2742       GPUPackedNormal *vnor = rdata->vert_normals_pack;
2743
2744       BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) {
2745         GPU_vertbuf_attr_set(vbo, attr_id.pos, i, eve->co);
2746         GPU_vertbuf_attr_set(vbo, attr_id.nor, i, &vnor[i]);
2747       }
2748       BLI_assert(i == vbo_len_capacity);
2749     }
2750     else {
2751       for (int i = 0; i < vbo_len_capacity; i++) {
2752         const MVert *mv = &rdata->mvert[i];
2753         GPUPackedNormal vnor_pack = GPU_normal_convert_i10_s3(mv->no);
2754         vnor_pack.w = (mv->flag & ME_HIDE) ? -1 : ((mv->flag & SELECT) ? 1 : 0);
2755         GPU_vertbuf_attr_set(vbo, attr_id.pos, i, rdata->mvert[i].co);
2756         GPU_vertbuf_attr_set(vbo, attr_id.nor, i, &vnor_pack);
2757       }
2758     }
2759   }
2760   else {
2761     const MVert *mvert = rdata->mapped.me_cage->mvert;
2762     const int *v_origindex = rdata->mapped.v_origindex;
2763     for (int i = 0; i < vbo_len_capacity; i++) {
2764       const int v_orig = v_origindex[i];
2765       if (v_orig != ORIGINDEX_NONE) {
2766         const MVert *mv = &mvert[i];
2767         GPUPackedNormal vnor_pack = GPU_normal_convert_i10_s3(mv->no);
2768         vnor_pack.w = (mv->flag & ME_HIDE) ? -1 : ((mv->flag & SELECT) ? 1 : 0);
2769         GPU_vertbuf_attr_set(vbo, attr_id.pos, i, mv->co);
2770         GPU_vertbuf_attr_set(vbo, attr_id.nor, i, &vnor_pack);
2771       }
2772     }
2773   }
2774 }
2775
2776 static void mesh_create_weights(MeshRenderData *rdata,
2777                                 GPUVertBuf *vbo,
2778                                 DRW_MeshWeightState *wstate)
2779 {
2780   static GPUVertFormat format = {0};
2781   static struct {
2782     uint weight;
2783   } attr_id;
2784   if (format.attr_len == 0) {
2785     attr_id.weight = GPU_vertformat_attr_add(&format, "weight", GPU_COMP_F32, 1, GPU_FETCH_FLOAT);
2786   }
2787
2788   const int vbo_len_capacity = mesh_render_data_verts_len_get_maybe_mapped(rdata);
2789
2790   mesh_render_data_ensure_vert_weight(rdata, wstate);
2791   const float *vert_weight = rdata->vert_weight;
2792
2793   GPU_vertbuf_init_with_format(vbo, &format);
2794   /* Meh, another allocation / copy for no benefit.
2795    * Needed because rdata->vert_weight is freed afterwards and
2796    * GPU module don't have a GPU_vertbuf_data_from_memory or similar. */
2797   /* TODO get rid of the extra allocation/copy. */
2798   GPU_vertbuf_data_alloc(vbo, vbo_len_capacity);
2799   GPU_vertbuf_attr_fill(vbo, attr_id.weight, vert_weight);
2800 }
2801
2802 static float mesh_loop_edge_factor_get(const float f_no[3],
2803                                        const float v_co[3],
2804                                        const float v_no[3],
2805                                        const float v_next_co[3])
2806 {
2807   float enor[3], evec[3];
2808   sub_v3_v3v3(evec, v_next_co, v_co);
2809   cross_v3_v3v3(enor, v_no, evec);
2810   normalize_v3(enor);
2811   float d = fabsf(dot_v3v3(enor, f_no));
2812   /* Rescale to the slider range. */
2813   d *= (1.0f / 0.065f);
2814   CLAMP(d, 0.0f, 1.0f);
2815   return d;
2816 }
2817
2818 static void vertbuf_raw_step_u8(GPUVertBufRaw *wd_step, const uchar wiredata)
2819 {
2820   *((uchar *)GPU_vertbuf_raw_step(wd_step)) = wiredata;
2821 }
2822
2823 static void vertbuf_raw_step_u8_to_f32(GPUVertBufRaw *wd_step, const uchar wiredata)
2824 {
2825   *((float *)GPU_vertbuf_raw_step(wd_step)) = wiredata / 255.0f;
2826 }
2827
2828 static void mesh_create_loop_edge_fac(MeshRenderData *rdata, GPUVertBuf *vbo)
2829 {
2830   static GPUVertFormat format = {0};
2831   static struct {
2832     uint wd;
2833   } attr_id;
2834   static union {
2835     float f;
2836     uchar u;
2837   } data;
2838   static void (*vertbuf_raw_step)(GPUVertBufRaw *, const uchar);
2839   if (format.attr_len == 0) {
2840     if (!GPU_crappy_amd_driver()) {
2841       /* Some AMD drivers strangely crash with a vbo with this format. */
2842       attr_id.wd = GPU_vertformat_attr_add(
2843           &format, "wd", GPU_COMP_U8, 1, GPU_FETCH_INT_TO_FLOAT_UNIT);
2844       vertbuf_raw_step = vertbuf_raw_step_u8;
2845       data.u = UCHAR_MAX;
2846     }
2847     else {
2848       attr_id.wd = GPU_vertformat_attr_add(&format, "wd", GPU_COMP_F32, 1, GPU_FETCH_FLOAT);
2849       vertbuf_raw_step = vertbuf_raw_step_u8_to_f32;
2850       data.f = 1.0f;
2851     }
2852   }
2853   const int poly_len = mesh_render_data_polys_len_get(rdata);
2854   const int loop_len = mesh_render_data_loops_len_get(rdata);
2855   const int edge_len = mesh_render_data_edges_len_get(rdata);
2856
2857   GPU_vertbuf_init_with_format(vbo, &format);
2858   GPU_vertbuf_data_alloc(vbo, loop_len);
2859
2860   GPUVertBufRaw wd_step;
2861   GPU_vertbuf_attr_get_raw_data(vbo, attr_id.wd, &wd_step);
2862
2863   if (rdata->mapped.use == false) {
2864     if (rdata->edit_bmesh) {
2865       BMesh *bm = rdata->edit_bmesh->bm;
2866       BMIter iter_efa, iter_loop;
2867       BMFace *efa;
2868       BMLoop *loop;
2869       uint f;
2870
2871       BM_ITER_MESH_INDEX (efa, &iter_efa, bm, BM_FACES_OF_MESH, f) {
2872         BM_ITER_ELEM (loop, &iter_loop, efa, BM_LOOPS_OF_FACE) {
2873           float ratio = mesh_loop_edge_factor_get(
2874               efa->no, loop->v->co, loop->v->no, loop->next->v->co);
2875           vertbuf_raw_step(&wd_step, ratio * 255);
2876         }
2877       }
2878       BLI_assert(GPU_vertbuf_raw_used(&wd_step) == loop_len);
2879     }
2880     else {
2881       const MVert *mvert = rdata->mvert;
2882       const MPoly *mpoly = rdata->mpoly;
2883       const MLoop *mloop = rdata->mloop;
2884       MEdge *medge = (MEdge *)rdata->medge;
2885       bool use_edge_render = false;
2886
2887       /* TODO(fclem) We don't need them to be packed. But we need rdata->poly_normals */
2888       mesh_render_data_ensure_poly_normals_pack(rdata);
2889
2890       /* Reset flag */
2891       for (int edge = 0; edge < edge_len; ++edge) {
2892         /* NOTE: not thread safe. */
2893         medge[edge].flag &= ~ME_EDGE_TMP_TAG;
2894
2895         /* HACK(fclem) Feels like a hack. Detecting the need for edge render. */
2896         if ((medge[edge].flag & ME_EDGERENDER) == 0) {
2897           use_edge_render = true;
2898         }
2899       }
2900
2901       for (int a = 0; a < poly_len; a++, mpoly++) {
2902         const float *fnor = rdata->poly_normals[a];
2903         for (int b = 0; b < mpoly->totloop; b++) {
2904           const MLoop *ml1 = &mloop[mpoly->loopstart + b];
2905           const MLoop *ml2 = &mloop[mpoly->loopstart + (b + 1) % mpoly->totloop];
2906
2907           /* Will only work for edges that have an odd number of faces connected. */
2908           MEdge *ed = (MEdge *)rdata->medge + ml1->e;
2909           ed->flag ^= ME_EDGE_TMP_TAG;
2910
2911           if (use_edge_render) {
2912             vertbuf_raw_step(&wd_step, (ed->flag & ME_EDGERENDER) ? 255 : 0);
2913           }
2914           else {
2915             float vnor_f[3];
2916             normal_short_to_float_v3(vnor_f, mvert[ml1->v].no);
2917             float ratio = mesh_loop_edge_factor_get(
2918                 fnor, mvert[ml1->v].co, vnor_f, mvert[ml2->v].co);
2919             vertbuf_raw_step(&wd_step, ratio * 253 + 1);
2920           }
2921         }
2922       }
2923       /* Gather non-manifold edges. */
2924       for (int l = 0; l < loop_len; l++, mloop++) {
2925         MEdge *ed = (MEdge *)rdata->medge + mloop->e;
2926         if (ed->flag & ME_EDGE_TMP_TAG) {
2927           GPU_vertbuf_attr_set(vbo, attr_id.wd, l, &data);
2928         }
2929       }
2930
2931       BLI_assert(loop_len == GPU_vertbuf_raw_used(&wd_step));
2932     }
2933   }
2934   else {
2935     BLI_assert(0);
2936   }
2937 }
2938
2939 static void mesh_create_loop_pos_and_nor(MeshRenderData *rdata, GPUVertBuf *vbo)
2940 {
2941   /* TODO deduplicate format creation*/
2942   static GPUVertFormat format = {0};
2943   static struct {
2944     uint pos, nor;
2945   } attr_id;
2946   if (format.attr_len == 0) {
2947     attr_id.pos = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
2948     attr_id.nor = GPU_vertformat_attr_add(
2949         &format, "nor", GPU_COMP_I10, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
2950   }
2951   const int poly_len = mesh_render_data_polys_len_get(rdata);
2952   const int loop_len = mesh_render_data_loops_len_get(rdata);
2953
2954   GPU_vertbuf_init_with_format(vbo, &format);
2955   GPU_vertbuf_data_alloc(vbo, loop_len);
2956
2957   GPUVertBufRaw pos_step, nor_step;
2958   GPU_vertbuf_attr_get_raw_data(vbo, attr_id.pos, &pos_step);
2959   GPU_vertbuf_attr_get_raw_data(vbo, attr_id.nor, &nor_step);
2960
2961   if (rdata->mapped.use == false) {
2962     if (rdata->edit_bmesh) {
2963       const GPUPackedNormal *vnor, *pnor;
2964       const float(*lnors)[3] = rdata->loop_normals;
2965       BMesh *bm = rdata->edit_bmesh->bm;
2966       BMIter iter_efa, iter_loop;
2967       BMFace *efa;
2968       BMLoop *loop;
2969       uint f;
2970
2971       if (rdata->loop_normals == NULL) {
2972         mesh_render_data_ensure_poly_normals_pack(rdata);
2973         mesh_render_data_ensure_vert_normals_pack(rdata);
2974         vnor = rdata->vert_normals_pack;
2975         pnor = rdata->poly_normals_pack;
2976       }
2977
2978       BM_ITER_MESH_INDEX (efa, &iter_efa, bm, BM_FACES_OF_MESH, f) {
2979         const bool face_smooth = BM_elem_flag_test(efa, BM_ELEM_SMOOTH);
2980
2981         BM_ITER_ELEM (loop, &iter_loop, efa, BM_LOOPS_OF_FACE) {
2982           BLI_assert(GPU_vertbuf_raw_used(&pos_step) == BM_elem_index_get(loop));
2983           copy_v3_v3(GPU_vertbuf_raw_step(&pos_step), loop->v->co);
2984
2985           if (lnors) {
2986             GPUPackedNormal plnor = GPU_normal_convert_i10_v3(lnors[BM_elem_index_get(loop)]);
2987             *((GPUPackedNormal *)GPU_vertbuf_raw_step(&nor_step)) = plnor;
2988           }
2989           else if (!face_smooth) {
2990             *((GPUPackedNormal *)GPU_vertbuf_raw_step(&nor_step)) = pnor[f];
2991           }
2992           else {
2993             *((GPUPackedNormal *)GPU_vertbuf_raw_step(
2994                 &nor_step)) = vnor[BM_elem_index_get(loop->v)];
2995           }
2996         }
2997       }
2998       BLI_assert(GPU_vertbuf_raw_used(&pos_step) == loop_len);
2999     }
3000     else {
3001       const MVert *mvert = rdata->mvert;
3002       const MPoly *mpoly = rdata->mpoly;
3003
3004       if (rdata->loop_normals == NULL) {
3005         mesh_render_data_ensure_poly_normals_pack(rdata);
3006       }
3007
3008       for (int a = 0; a < poly_len; a++, mpoly++) {
3009         const MLoop *mloop = rdata->mloop + mpoly->loopstart;
3010         const float(*lnors)[3] = (rdata->loop_normals) ? &rdata->loop_normals[mpoly->loopstart] :
3011                                                          NULL;
3012         const GPUPackedNormal *fnor = (mpoly->flag & ME_SMOOTH) ? NULL :
3013                                                                   &rdata->poly_normals_pack[a];
3014         const int hide_select_flag = (mpoly->flag & ME_HIDE) ?
3015                                          -1 :
3016                                          ((mpoly->flag & ME_FACE_SEL) ? 1 : 0);
3017         for (int b = 0; b < mpoly->totloop; b++, mloop++) {
3018           copy_v3_v3(GPU_vertbuf_raw_step(&pos_step), mvert[mloop->v].co);
3019           GPUPackedNormal *pnor = (GPUPackedNormal *)GPU_vertbuf_raw_step(&nor_step);
3020           if (lnors) {
3021             *pnor = GPU_normal_convert_i10_v3(lnors[b]);
3022           }
3023           else if (fnor) {
3024             *pnor = *fnor;
3025           }
3026           else {
3027             *pnor = GPU_normal_convert_i10_s3(mvert[mloop->v].no);
3028           }
3029           pnor->w = hide_select_flag;
3030         }
3031       }
3032
3033       BLI_assert(loop_len == GPU_vertbuf_raw_used(&pos_step));
3034     }
3035   }
3036   else {
3037     const int *p_origindex = rdata->mapped.p_origindex;
3038     const MVert *mvert = rdata->mvert;
3039     const MPoly *mpoly = rdata->mpoly;
3040
3041     if (rdata->loop_normals == NULL) {
3042       mesh_render_data_ensure_poly_normals_pack(rdata);
3043     }
3044
3045     for (int a = 0; a < poly_len; a++, mpoly++) {
3046       const MLoop *mloop = rdata->mloop + mpoly->loopstart;
3047       const float(*lnors)[3] = (rdata->loop_normals) ? &rdata->loop_normals[mpoly->loopstart] :
3048                                                        NULL;
3049       const GPUPackedNormal *fnor = (mpoly->flag & ME_SMOOTH) ? NULL :
3050                                                                 &rdata->poly_normals_pack[a];
3051       if (p_origindex[a] == ORIGINDEX_NONE) {
3052         continue;
3053       }
3054       for (int b = 0; b < mpoly->totloop; b++, mloop++) {
3055         copy_v3_v3(GPU_vertbuf_raw_step(&pos_step), mvert[mloop->v].co);
3056         GPUPackedNormal *pnor = (GPUPackedNormal *)GPU_vertbuf_raw_step(&nor_step);
3057         if (lnors) {
3058           *pnor = GPU_normal_convert_i10_v3(lnors[b]);
3059         }
3060         else if (fnor) {
3061           *pnor = *fnor;
3062         }
3063         else {
3064           *pnor = GPU_normal_convert_i10_s3(mvert[mloop->v].no);
3065         }
3066       }
3067     }
3068   }
3069
3070   int vbo_len_used = GPU_vertbuf_raw_used(&pos_step);
3071   if (vbo_len_used < loop_len) {
3072     GPU_vertbuf_data_resize(vbo, vbo_len_used);
3073   }
3074 }
3075
3076 static void mesh_create_loop_orco(MeshRenderData *rdata, GPUVertBuf *vbo)
3077 {
3078   const uint loops_len = mesh_render_data_loops_len_get(rdata);
3079
3080   /* initialize vertex format */
3081   GPUVertFormat format = {0};
3082   GPUVertBufRaw vbo_step;
3083
3084   /* FIXME(fclem): We use the last component as a way to differentiate from generic vertex attribs.
3085    * This is a substential waste of Vram and should be done another way. Unfortunately,
3086    * at the time of writting, I did not found any other "non disruptive" alternative. */
3087   uint attr_id = GPU_vertformat_attr_add(&format, "orco", GPU_COMP_F32, 4, GPU_FETCH_FLOAT);
3088
3089   GPU_vertbuf_init_with_format(vbo, &format);
3090   GPU_vertbuf_data_alloc(vbo, loops_len);
3091   GPU_vertbuf_attr_get_raw_data(vbo, attr_id, &vbo_step);
3092
3093   if (rdata->edit_bmesh) {
3094     BMesh *bm = rdata->edit_bmesh->bm;
3095     BMIter iter_efa, iter_loop;
3096     BMFace *efa;
3097     BMLoop *loop;
3098
3099     BM_ITER_MESH (efa, &iter_efa, bm, BM_FACES_OF_MESH) {
3100       BM_ITER_ELEM (loop, &iter_loop, efa, BM_LOOPS_OF_FACE) {
3101         float *data = (float *)GPU_vertbuf_raw_step(&vbo_step);
3102         copy_v3_v3(data, rdata->orco[BM_elem_index_get(loop->v)]);
3103         data[3] = 0.0; /* Tag as not a generic attrib */
3104       }
3105     }
3106   }
3107   else {
3108     for (uint l = 0; l < loops_len; l++) {
3109       float *data = (float *)GPU_vertbuf_raw_step(&vbo_step);
3110       copy_v3_v3(data, rdata->orco[rdata->mloop[l].v]);
3111       data[3] = 0.0; /* Tag as not a generic attrib */
3112     }
3113   }
3114 }
3115
3116 static void mesh_create_loop_uv_and_tan(MeshRenderData *rdata, GPUVertBuf *vbo)
3117 {
3118   const uint loops_len = mesh_render_data_loops_len_get(rdata);
3119   const uint uv_len = rdata->cd.layers.uv_len;
3120   const uint tangent_len = rdata->cd.layers.tangent_len;
3121   const uint layers_combined_len = uv_len + tangent_len;
3122
3123   GPUVertBufRaw *layers_combined_step = BLI_array_alloca(layers_combined_step,
3124                                                          layers_combined_len);
3125   GPUVertBufRaw *uv_step = layers_combined_step;
3126   GPUVertBufRaw *tangent_step = uv_step + uv_len;
3127
3128   uint *layers_combined_id = BLI_array_alloca(layers_combined_id, layers_combined_len);
3129   uint *uv_id = layers_combined_id;
3130   uint *tangent_id = uv_id + uv_len;
3131
3132   /* initialize vertex format */
3133   GPUVertFormat format = {0};
3134
3135   for (uint i = 0; i < uv_len; i++) {
3136     const char *attr_name = mesh_render_data_uv_layer_uuid_get(rdata, i);
3137 #if 0 /* these are clamped. Maybe use them as an option in the future */
3138     uv_id[i] = GPU_vertformat_attr_add(
3139         &format, attr_name, GPU_COMP_I16, 2, GPU_FETCH_INT_TO_FLOAT_UNIT);
3140 #else
3141     uv_id[i] = GPU_vertformat_attr_add(&format, attr_name, GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
3142 #endif
3143     /* Auto Name */
3144     attr_name = mesh_render_data_uv_auto_layer_uuid_get(rdata, i);
3145     GPU_vertformat_alias_add(&format, attr_name);
3146
3147     if (i == rdata->cd.layers.uv_active) {
3148       GPU_vertformat_alias_add(&format, "u");
3149     }
3150     if (i == rdata->cd.layers.uv_mask_active) {
3151       GPU_vertformat_alias_add(&format, "mu");
3152     }
3153   }
3154
3155   for (uint i = 0; i < tangent_len; i++) {
3156     const char *attr_name = mesh_render_data_tangent_layer_uuid_get(rdata, i);
3157 #ifdef USE_COMP_MESH_DATA
3158     tangent_id[i] = GPU_vertformat_attr_add(
3159         &format, attr_name, GPU_COMP_I16, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
3160 #else
3161     tangent_id[i] = GPU_vertformat_attr_add(&format, attr_name, GPU_COMP_F32, 4, GPU_FETCH_FLOAT);
3162 #endif
3163     if (i == rdata->cd.layers.tangent_active) {
3164       GPU_vertformat_alias_add(&format, "t");
3165     }
3166   }
3167
3168   /* HACK: Create a dummy attribute in case there is no valid UV/tangent layer. */
3169   if (layers_combined_len == 0) {
3170     GPU_vertformat_attr_add(&format, "dummy", GPU_COMP_U8, 1, GPU_FETCH_INT_TO_FLOAT_UNIT);
3171   }
3172
3173   GPU_vertbuf_init_with_format(vbo, &format);
3174   GPU_vertbuf_data_alloc(vbo, loops_len);
3175
3176   for (uint i = 0; i < uv_len; i++) {
3177     GPU_vertbuf_attr_get_raw_data(vbo, uv_id[i], &uv_step[i]);
3178   }
3179   for (uint i = 0; i < tangent_len; i++) {
3180     GPU_vertbuf_attr_get_raw_data(vbo, tangent_id[i], &tangent_step[i]);
3181   }
3182
3183   if (rdata->edit_bmesh) {
3184     BMesh *bm = rdata->edit_bmesh->bm;
3185     BMIter iter_efa, iter_loop;
3186     BMFace *efa;
3187     BMLoop *loop;
3188
3189     BM_ITER_MESH (efa, &iter_efa, bm, BM_FACES_OF_MESH) {
3190       BM_ITER_ELEM (loop, &iter_loop, efa, BM_LOOPS_OF_FACE) {
3191         /* UVs */
3192         for (uint j = 0; j < uv_len; j++) {
3193           const uint layer_offset = rdata->cd.offset.uv[j];
3194           const float *elem = ((MLoopUV *)BM_ELEM_CD_GET_VOID_P(loop, layer_offset))->uv;
3195           copy_v2_v2(GPU_vertbuf_raw_step(&uv_step[j]), elem);
3196         }
3197         /* TANGENTs */
3198         for (uint j = 0; j < tangent_len; j++) {
3199           float(*layer_data)[4] = rdata->cd.layers.tangent[j];
3200           const float *elem = layer_data[BM_elem_index_get(loop)];
3201 #ifdef USE_COMP_MESH_DATA
3202           normal_float_to_short_v4(GPU_vertbuf_raw_step(&tangent_step[j]), elem);
3203 #else
3204           copy_v4_v4(GPU_vertbuf_raw_step(&tangent_step[j]), elem);
3205 #endif
3206         }
3207       }
3208     }
3209   }
3210   else {
3211     for (uint loop = 0; loop < loops_len; loop++) {
3212       /* UVs */
3213       for (uint j = 0; j < uv_len; j++) {
3214         const MLoopUV *layer_data = rdata->cd.layers.uv[j];
3215         const float *elem = layer_data[loop].uv;
3216         copy_v2_v2(GPU_vertbuf_raw_step(&uv_step[j]), elem);
3217       }
3218       /* TANGENTs */
3219       for (uint j = 0; j < tangent_len; j++) {
3220         float(*layer_data)[4] = rdata->cd.layers.tangent[j];
3221         const float *elem = layer_data[loop];
3222 #ifdef USE_COMP_MESH_DATA
3223         normal_float_to_short_v4(GPU_vertbuf_raw_step(&tangent_step[j]), elem);
3224 #else
3225         copy_v4_v4(GPU_vertbuf_raw_step(&tangent_step[j]), elem);
3226 #endif
3227       }
3228     }
3229   }
3230
3231 #ifndef NDEBUG
3232   /* Check all layers are write aligned. */
3233   if (layers_combined_len > 0) {
3234     int vbo_len_used = GPU_vertbuf_raw_used(&layers_combined_step[0]);
3235     for (uint i = 0; i < layers_combined_len; i++) {
3236       BLI_assert(vbo_len_used == GPU_vertbuf_raw_used(&layers_combined_step[i]));
3237     }
3238   }
3239 #endif
3240
3241 #undef USE_COMP_MESH_DATA
3242 }
3243
3244 static void mesh_create_loop_vcol(MeshRenderData *rdata, GPUVertBuf *vbo)
3245 {
3246   const uint loops_len = mesh_render_data_loops_len_get(rdata);
3247   const uint vcol_len = rdata->cd.layers.vcol_len;
3248
3249   GPUVertBufRaw *vcol_step = BLI_array_alloca(vcol_step, vcol_len);
3250   uint *vcol_id = BLI_array_alloca(vcol_id, vcol_len);
3251
3252   /* initialize vertex format */
3253   GPUVertFormat format = {0};
3254
3255   for (uint i = 0; i < vcol_len; i++) {
3256     const char *attr_name = mesh_render_data_vcol_layer_uuid_get(rdata, i);
3257     vcol_id[i] = GPU_vertformat_attr_add(
3258         &format, attr_name, GPU_COMP_U8, 3, GPU_FETCH_INT_TO_FLOAT_UNIT);
3259     /* Auto layer */
3260     if (rdata->cd.layers.auto_vcol[i]) {
3261       attr_name = mesh_render_data_vcol_auto_layer_uuid_get(rdata, i);
3262       GPU_vertformat_alias_add(&format, attr_name);
3263     }
3264     if (i == rdata->cd.layers.vcol_active) {
3265       GPU_vertformat_alias_add(&format, "c");
3266     }
3267   }
3268
3269   GPU_vertbuf_init_with_format(vbo, &format);
3270   GPU_vertbuf_data_alloc(vbo, loops_len);
3271
3272   for (uint i = 0; i < vcol_len; i++) {
3273     GPU_vertbuf_attr_get_raw_data(vbo, vcol_id[i], &vcol_step[i]);
3274   }
3275
3276   if (rdata->edit_bmesh) {
3277     BMesh *bm = rdata->edit_bmesh->bm;
3278     BMIter iter_efa, iter_loop;
3279     BMFace *efa;
3280     BMLoop *loop;
3281
3282     BM_ITER_MESH (efa, &iter_efa, bm, BM_FACES_OF_MESH) {
3283       BM_ITER_ELEM (loop, &iter_loop, efa, BM_LOOPS_OF_FACE) {
3284         for (uint j = 0; j < vcol_len; j++) {
3285           const uint layer_offset = rdata->cd.offset.vcol[j];
3286           const uchar *elem = &((MLoopCol *)BM_ELEM_CD_GET_VOID_P(loop, layer_offset))->r;
3287           copy_v3_v3_uchar(GPU_vertbuf_raw_step(&vcol_step[j]), elem);
3288         }
3289       }
3290     }
3291   }
3292   else {
3293     for (uint loop = 0; loop < loops_len; loop++) {
3294       for (uint j = 0; j < vcol_len; j++) {
3295         const MLoopCol *layer_data = rdata->cd.layers.vcol[j];
3296         const uchar *elem = &layer_data[loop].r;
3297         copy_v3_v3_uchar(GPU_vertbuf_raw_step(&vcol_step[j]), elem);
3298       }
3299     }
3300   }
3301
3302 #ifndef NDEBUG
3303   /* Check all layers are write aligned. */
3304   if (vcol_len > 0) {
3305     int vbo_len_used = GPU_vertbuf_raw_used(&vcol_step[0]);
3306     for (uint i = 0; i < vcol_len; i++) {
3307       BLI_assert(vbo_len_used == GPU_vertbuf_raw_used(&vcol_step[i]));
3308     }
3309   }
3310 #endif
3311
3312 #undef USE_COMP_MESH_DATA
3313 }
3314
3315 static void mesh_create_edit_facedots(MeshRenderData *rdata, GPUVertBuf *vbo_facedots_pos_nor_data)
3316 {
3317   const int poly_len = mesh_render_data_polys_len_get_maybe_mapped(rdata);
3318   const int verts_facedot_len = poly_len;
3319   int facedot_len_used = 0;
3320
3321   static struct {
3322     uint fdot_pos, fdot_nor_flag;
3323   } attr_id;
3324   static GPUVertFormat facedot_format = {0};
3325   if (facedot_format.attr_len == 0) {
3326     attr_id.fdot_pos = GPU_vertformat_attr_add(
3327         &facedot_format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
3328     attr_id.fdot_nor_flag = GPU_vertformat_attr_add(
3329         &facedot_format, "norAndFlag", GPU_COMP_I10, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
3330   }
3331
3332   if (DRW_TEST_ASSIGN_VBO(vbo_facedots_pos_nor_data)) {
3333     GPU_vertbuf_init_with_format(vbo_facedots_pos_nor_data, &facedot_format);
3334     GPU_vertbuf_data_alloc(vbo_facedots_pos_nor_data, verts_facedot_len);
3335     /* TODO(fclem): Maybe move data generation to mesh_render_data_create() */
3336     if (rdata->edit_bmesh) {
3337       if (rdata->edit_data && rdata->edit_data->vertexCos != NULL) {
3338         BKE_editmesh_cache_ensure_poly_normals(rdata->edit_bmesh, rdata->edit_data);
3339         BKE_editmesh_cache_ensure_poly_centers(rdata->edit_bmesh, rdata->edit_data);
3340       }
3341     }
3342   }
3343
3344   if (rdata->mapped.use == false) {
3345     for (int i = 0; i < poly_len; i++) {
3346       if (add_edit_facedot(rdata,
3347                            vbo_facedots_pos_nor_data,
3348                            attr_id.fdot_pos,
3349                            attr_id.fdot_nor_flag,
3350                            i,
3351                            facedot_len_used)) {
3352         facedot_len_used += 1;
3353       }
3354     }
3355   }
3356   else {
3357 #if 0 /* TODO(fclem): Mapped facedots are not following the original face. */
3358     Mesh *me_cage = rdata->mapped.me_cage;
3359     const MVert *mvert = me_cage->mvert;
3360     const MEdge *medge = me_cage->medge;
3361     const int *e_origindex = rdata->mapped.e_origindex;
3362     const int *v_origindex = rdata->mapped.v_origindex;
3363 #endif
3364     for (int i = 0; i < poly_len; i++) {
3365       if (add_edit_facedot_mapped(rdata,
3366                                   vbo_facedots_pos_nor_data,
3367                                   attr_id.fdot_pos,
3368                                   attr_id.fdot_nor_flag,
3369                                   i,
3370                                   facedot_len_used)) {
3371         facedot_len_used += 1;
3372       }
3373     }
3374   }
3375
3376   /* Resize & Finish */
3377   if (facedot_len_used != verts_facedot_len) {
3378     if (vbo_facedots_pos_nor_data != NULL) {
3379       GPU_vertbuf_data_resize(vbo_facedots_pos_nor_data, facedot_len_used);
3380     }
3381   }
3382 }
3383
3384 /* Indices */
3385
3386 #define NO_EDGE INT_MAX
3387 static void mesh_create_edges_adjacency_lines(MeshRenderData *rdata,
3388                                               GPUIndexBuf *ibo,
3389                                               bool *r_is_manifold,
3390                                               const bool use_hide)
3391 {
3392   const MLoopTri *mlooptri;
3393   const int vert_len = mesh_render_data_verts_len_get_maybe_mapped(rdata);
3394   const int tri_len = mesh_render_data_looptri_len_get_maybe_mapped(rdata);
3395
3396   *r_is_manifold = true;
3397
3398   /* Allocate max but only used indices are sent to GPU. */
3399   GPUIndexBufBuilder elb;
3400   GPU_indexbuf_init(&elb, GPU_PRIM_LINES_ADJ, tri_len * 3, vert_len);
3401
3402   if (rdata->mapped.use) {
3403     Mesh *me_cage = rdata->mapped.me_cage;
3404     mlooptri = BKE_mesh_runtime_looptri_ensure(me_cage);
3405   }
3406   else {
3407     mlooptri = rdata->mlooptri;
3408   }
3409
3410   EdgeHash *eh = BLI_edgehash_new_ex(__func__, tri_len * 3);
3411   /* Create edges for each pair of triangles sharing an edge. */
3412   for (int i = 0; i < tri_len; i++) {
3413     for (int e = 0; e < 3; e++) {
3414       uint v0, v1, v2;
3415       if (rdata->mapped.use) {
3416         const MLoop *mloop = rdata->mloop;
3417         const MLoopTri *mlt = mlooptri + i;
3418         const int p_orig = rdata->mapped.p_origindex[mlt->poly];
3419         if (p_orig != ORIGINDEX_NONE) {
3420           BMesh *bm = rdata->edit_bmesh->bm;
3421           BMFace *efa = BM_face_at_index(bm, p_orig);
3422           /* Assume 'use_hide' */
3423           if (BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
3424             break;
3425           }
3426         }
3427         v0 = mloop[mlt->tri[e]].v;
3428         v1 = mloop[mlt->tri[(e + 1) % 3]].v;
3429         v2 = mloop[mlt->tri[(e + 2) % 3]].v;
3430       }
3431       else if (rdata->edit_bmesh) {
3432         const BMLoop **bm_looptri = (const BMLoop **)rdata->edit_bmesh->looptris[i];
3433         if (BM_elem_flag_test(bm_looptri[0]->f, BM_ELEM_HIDDEN)) {
3434           break;
3435         }
3436         v0 = BM_elem_index_get(bm_looptri[e]->v);
3437         v1 = BM_elem_index_get(bm_looptri[(e + 1) % 3]->v);
3438         v2 = BM_elem_index_get(bm_looptri[(e + 2) % 3]->v);
3439       }
3440       else {
3441         const MLoop *mloop = rdata->mloop;
3442         const MLoopTri *mlt = mlooptri + i;
3443         const MPoly *mp = &rdata->mpoly[mlt->poly];
3444         if (use_hide && (mp->flag & ME_HIDE)) {
3445           break;
3446         }
3447         v0 = mloop[mlt->tri[e]].v;
3448         v1 = mloop[mlt->tri[(e + 1) % 3]].v;
3449         v2 = mloop[mlt->tri[(e + 2) % 3]].v;
3450       }
3451       bool inv_indices = (v1 > v2);
3452       void **pval;
3453       bool value_is_init = BLI_edgehash_ensure_p(eh, v1, v2, &pval);
3454       int v_data = POINTER_AS_INT(*pval);
3455       if (!value_is_init || v_data == NO_EDGE) {
3456         /* Save the winding order inside the sign bit. Because the
3457          * edgehash sort the keys and we need to compare winding later. */
3458         int value = (int)v0 + 1; /* Int 0 bm_looptricannot be signed */
3459         *pval = POINTER_FROM_INT((inv_indices) ? -value : value);
3460       }
3461       else {
3462         /* HACK Tag as not used. Prevent overhead of BLI_edgehash_remove. */
3463         *pval = POINTER_FROM_INT(NO_EDGE);
3464         bool inv_opposite = (v_data < 0);
3465         uint v_opposite = (uint)abs(v_data) - 1;
3466
3467         if (inv_opposite == inv_indices) {
3468           /* Don't share edge if triangles have non matching winding. */
3469           GPU_indexbuf_add_line_adj_verts(&elb, v0, v1, v2, v0);
3470           GPU_indexbuf_add_line_adj_verts(&elb, v_opposite, v1, v2, v_opposite);
3471           *r_is_manifold = false;
3472         }
3473         else {
3474           GPU_indexbuf_add_line_adj_verts(&elb, v0, v1, v2, v_opposite);
3475         }
3476       }
3477     }
3478   }