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