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