Mesh Batch Cache: Speedup: Use flags to early remove unecessary checks
[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   GPUVertAttrLayers gpu_attrs = {{{0}}};
427   DRW_MeshCDMask cd_used;
428   mesh_cd_layers_type_clear(&cd_used);
429
430   for (int i = 0; i < gpumat_array_len; i++) {
431     GPUMaterial *gpumat = gpumat_array[i];
432     if (gpumat) {
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       for (int i_src = 0; i_src < cd_layers_src.uv_len; i_src++, i_dst++) {
1146         if ((cd_used->tan & (1 << i_src)) == 0) {
1147           i_dst--;
1148           if (rdata->cd.layers.tangent_active >= i_src) {
1149             rdata->cd.layers.tangent_active--;
1150           }
1151         }
1152         else {
1153           const char *name = CustomData_get_layer_name(cd_ldata, CD_MLOOPUV, i_src);
1154           uint hash = BLI_ghashutil_strhash_p(name);
1155
1156           BLI_snprintf(
1157               rdata->cd.uuid.tangent[i_dst], sizeof(*rdata->cd.uuid.tangent), "t%u", hash);
1158
1159           /* Done adding tangents. */
1160
1161           /* note: BKE_editmesh_loop_tangent_calc calculates 'CD_TANGENT',
1162            * not 'CD_MLOOPTANGENT' (as done below). It's OK, they're compatible. */
1163
1164           /* note: normally we'd use 'i_src' here, but 'i_dst' is in sync with 'rdata->cd.output'
1165            */
1166           rdata->cd.layers.tangent[i_dst] = CustomData_get_layer_n(
1167               &rdata->cd.output.ldata, CD_TANGENT, i_dst);
1168           if (rdata->tri_len != 0) {
1169             BLI_assert(rdata->cd.layers.tangent[i_dst] != NULL);
1170           }
1171         }
1172       }
1173       if (cd_used->tan_orco != 0) {
1174         const char *name = CustomData_get_layer_name(&rdata->cd.output.ldata, CD_TANGENT, i_dst);
1175         uint hash = BLI_ghashutil_strhash_p(name);
1176         BLI_snprintf(rdata->cd.uuid.tangent[i_dst], sizeof(*rdata->cd.uuid.tangent), "t%u", hash);
1177
1178         rdata->cd.layers.tangent[i_dst] = CustomData_get_layer_n(
1179             &rdata->cd.output.ldata, CD_TANGENT, i_dst);
1180       }
1181     }
1182
1183 #undef me
1184   }
1185
1186   return rdata;
1187 }
1188
1189 /* Warning replace mesh pointer. */
1190 #define MBC_GET_FINAL_MESH(me) \
1191   /* Hack to show the final result. */ \
1192   const bool _use_em_final = ((me)->edit_mesh && (me)->edit_mesh->mesh_eval_final && \
1193                               ((me)->edit_mesh->mesh_eval_final->runtime.is_original == false)); \
1194   Mesh _me_fake; \
1195   if (_use_em_final) { \
1196     _me_fake = *(me)->edit_mesh->mesh_eval_final; \
1197     _me_fake.mat = (me)->mat; \
1198     _me_fake.totcol = (me)->totcol; \
1199     (me) = &_me_fake; \
1200   } \
1201   ((void)0)
1202
1203 static void mesh_render_data_free(MeshRenderData *rdata)
1204 {
1205   if (rdata->is_orco_allocated) {
1206     MEM_SAFE_FREE(rdata->orco);
1207   }
1208   MEM_SAFE_FREE(rdata->cd.offset.uv);
1209   MEM_SAFE_FREE(rdata->cd.offset.vcol);
1210   MEM_SAFE_FREE(rdata->cd.uuid.auto_mix);
1211   MEM_SAFE_FREE(rdata->cd.uuid.uv);
1212   MEM_SAFE_FREE(rdata->cd.uuid.vcol);
1213   MEM_SAFE_FREE(rdata->cd.uuid.tangent);
1214   MEM_SAFE_FREE(rdata->cd.layers.uv);
1215   MEM_SAFE_FREE(rdata->cd.layers.vcol);
1216   MEM_SAFE_FREE(rdata->cd.layers.tangent);
1217   MEM_SAFE_FREE(rdata->cd.layers.auto_vcol);
1218   MEM_SAFE_FREE(rdata->loose_verts);
1219   MEM_SAFE_FREE(rdata->loose_edges);
1220   MEM_SAFE_FREE(rdata->edges_adjacent_polys);
1221   MEM_SAFE_FREE(rdata->mlooptri);
1222   MEM_SAFE_FREE(rdata->loop_normals);
1223   MEM_SAFE_FREE(rdata->poly_normals);
1224   MEM_SAFE_FREE(rdata->poly_normals_pack);
1225   MEM_SAFE_FREE(rdata->vert_normals_pack);
1226   MEM_SAFE_FREE(rdata->vert_weight);
1227   MEM_SAFE_FREE(rdata->edge_select_bool);
1228   MEM_SAFE_FREE(rdata->edge_visible_bool);
1229   MEM_SAFE_FREE(rdata->vert_color);
1230
1231   MEM_SAFE_FREE(rdata->mapped.loose_verts);
1232   MEM_SAFE_FREE(rdata->mapped.loose_edges);
1233
1234   CustomData_free(&rdata->cd.output.ldata, rdata->loop_len);
1235
1236   MEM_freeN(rdata);
1237 }
1238
1239 /** \} */
1240
1241 /* ---------------------------------------------------------------------- */
1242 /** \name Accessor Functions
1243  * \{ */
1244
1245 static const char *mesh_render_data_uv_auto_layer_uuid_get(const MeshRenderData *rdata, int layer)
1246 {
1247   BLI_assert(rdata->types & MR_DATATYPE_SHADING);
1248   return rdata->cd.uuid.auto_mix[layer];
1249 }
1250
1251 static const char *mesh_render_data_vcol_auto_layer_uuid_get(const MeshRenderData *rdata,
1252                                                              int layer)
1253 {
1254   BLI_assert(rdata->types & MR_DATATYPE_SHADING);
1255   return rdata->cd.uuid.auto_mix[rdata->cd.layers.uv_len + layer];
1256 }
1257
1258 static const char *mesh_render_data_uv_layer_uuid_get(const MeshRenderData *rdata, int layer)
1259 {
1260   BLI_assert(rdata->types & MR_DATATYPE_SHADING);
1261   return rdata->cd.uuid.uv[layer];
1262 }
1263
1264 static const char *mesh_render_data_vcol_layer_uuid_get(const MeshRenderData *rdata, int layer)
1265 {
1266   BLI_assert(rdata->types & MR_DATATYPE_SHADING);
1267   return rdata->cd.uuid.vcol[layer];
1268 }
1269
1270 static const char *mesh_render_data_tangent_layer_uuid_get(const MeshRenderData *rdata, int layer)
1271 {
1272   BLI_assert(rdata->types & MR_DATATYPE_SHADING);
1273   return rdata->cd.uuid.tangent[layer];
1274 }
1275
1276 static int UNUSED_FUNCTION(mesh_render_data_verts_len_get)(const MeshRenderData *rdata)
1277 {
1278   BLI_assert(rdata->types & MR_DATATYPE_VERT);
1279   return rdata->vert_len;
1280 }
1281 static int mesh_render_data_verts_len_get_maybe_mapped(const MeshRenderData *rdata)
1282 {
1283   BLI_assert(rdata->types & MR_DATATYPE_VERT);
1284   return ((rdata->mapped.use == false) ? rdata->vert_len : rdata->mapped.vert_len);
1285 }
1286
1287 static int UNUSED_FUNCTION(mesh_render_data_loose_verts_len_get)(const MeshRenderData *rdata)
1288 {
1289   BLI_assert(rdata->types & MR_DATATYPE_LOOSE_VERT);
1290   return rdata->loose_vert_len;
1291 }
1292 static int mesh_render_data_loose_verts_len_get_maybe_mapped(const MeshRenderData *rdata)
1293 {
1294   BLI_assert(rdata->types & MR_DATATYPE_LOOSE_VERT);
1295   return ((rdata->mapped.use == false) ? rdata->loose_vert_len : rdata->mapped.loose_vert_len);
1296 }
1297
1298 static int mesh_render_data_edges_len_get(const MeshRenderData *rdata)
1299 {
1300   BLI_assert(rdata->types & MR_DATATYPE_EDGE);
1301   return rdata->edge_len;
1302 }
1303 static int mesh_render_data_edges_len_get_maybe_mapped(const MeshRenderData *rdata)
1304 {
1305   BLI_assert(rdata->types & MR_DATATYPE_EDGE);
1306   return ((rdata->mapped.use == false) ? rdata->edge_len : rdata->mapped.edge_len);
1307 }
1308
1309 static int UNUSED_FUNCTION(mesh_render_data_loose_edges_len_get)(const MeshRenderData *rdata)
1310 {
1311   BLI_assert(rdata->types & MR_DATATYPE_LOOSE_EDGE);
1312   return rdata->loose_edge_len;
1313 }
1314 static int mesh_render_data_loose_edges_len_get_maybe_mapped(const MeshRenderData *rdata)
1315 {
1316   BLI_assert(rdata->types & MR_DATATYPE_LOOSE_EDGE);
1317   return ((rdata->mapped.use == false) ? rdata->loose_edge_len : rdata->mapped.loose_edge_len);
1318 }
1319
1320 static int mesh_render_data_looptri_len_get(const MeshRenderData *rdata)
1321 {
1322   BLI_assert(rdata->types & MR_DATATYPE_LOOPTRI);
1323   return rdata->tri_len;
1324 }
1325 static int mesh_render_data_looptri_len_get_maybe_mapped(const MeshRenderData *rdata)
1326 {
1327   BLI_assert(rdata->types & MR_DATATYPE_LOOPTRI);
1328   return ((rdata->mapped.use == false) ? rdata->tri_len : rdata->mapped.tri_len);
1329 }
1330
1331 static int UNUSED_FUNCTION(mesh_render_data_mat_len_get)(const MeshRenderData *rdata)
1332 {
1333   BLI_assert(rdata->types & MR_DATATYPE_POLY);
1334   return rdata->mat_len;
1335 }
1336
1337 static int mesh_render_data_loops_len_get(const MeshRenderData *rdata)
1338 {
1339   BLI_assert(rdata->types & MR_DATATYPE_LOOP);
1340   return rdata->loop_len;
1341 }
1342
1343 static int mesh_render_data_loops_len_get_maybe_mapped(const MeshRenderData *rdata)
1344 {
1345   BLI_assert(rdata->types & MR_DATATYPE_LOOP);
1346   return ((rdata->mapped.use == false) ? rdata->loop_len : rdata->mapped.loop_len);
1347 }
1348
1349 static int mesh_render_data_polys_len_get(const MeshRenderData *rdata)
1350 {
1351   BLI_assert(rdata->types & MR_DATATYPE_POLY);
1352   return rdata->poly_len;
1353 }
1354 static int mesh_render_data_polys_len_get_maybe_mapped(const MeshRenderData *rdata)
1355 {
1356   BLI_assert(rdata->types & MR_DATATYPE_POLY);
1357   return ((rdata->mapped.use == false) ? rdata->poly_len : rdata->mapped.poly_len);
1358 }
1359
1360 /** \} */
1361
1362 /* ---------------------------------------------------------------------- */
1363
1364 /** \name Internal Cache (Lazy Initialization)
1365  * \{ */
1366
1367 /** Ensure #MeshRenderData.poly_normals_pack */
1368 static void mesh_render_data_ensure_poly_normals_pack(MeshRenderData *rdata)
1369 {
1370   GPUPackedNormal *pnors_pack = rdata->poly_normals_pack;
1371   if (pnors_pack == NULL) {
1372     if (rdata->edit_bmesh) {
1373       BMesh *bm = rdata->edit_bmesh->bm;
1374       BMIter fiter;
1375       BMFace *efa;
1376       int i;
1377
1378       pnors_pack = rdata->poly_normals_pack = MEM_mallocN(sizeof(*pnors_pack) * rdata->poly_len,
1379                                                           __func__);
1380       if (rdata->edit_data && rdata->edit_data->vertexCos != NULL) {
1381         BKE_editmesh_cache_ensure_poly_normals(rdata->edit_bmesh, rdata->edit_data);
1382         const float(*pnors)[3] = rdata->edit_data->polyNos;
1383         for (i = 0; i < bm->totface; i++) {
1384           pnors_pack[i] = GPU_normal_convert_i10_v3(pnors[i]);
1385         }
1386       }
1387       else {
1388         BM_ITER_MESH_INDEX (efa, &fiter, bm, BM_FACES_OF_MESH, i) {
1389           pnors_pack[i] = GPU_normal_convert_i10_v3(efa->no);
1390         }
1391       }
1392     }
1393     else {
1394       float(*pnors)[3] = rdata->poly_normals;
1395
1396       if (!pnors) {
1397         pnors = rdata->poly_normals = MEM_mallocN(sizeof(*pnors) * rdata->poly_len, __func__);
1398         BKE_mesh_calc_normals_poly(rdata->mvert,
1399                                    NULL,
1400                                    rdata->vert_len,
1401                                    rdata->mloop,
1402                                    rdata->mpoly,
1403                                    rdata->loop_len,
1404                                    rdata->poly_len,
1405                                    pnors,
1406                                    true);
1407       }
1408
1409       pnors_pack = rdata->poly_normals_pack = MEM_mallocN(sizeof(*pnors_pack) * rdata->poly_len,
1410                                                           __func__);
1411       for (int i = 0; i < rdata->poly_len; i++) {
1412         pnors_pack[i] = GPU_normal_convert_i10_v3(pnors[i]);
1413       }
1414     }
1415   }
1416 }
1417
1418 /** Ensure #MeshRenderData.vert_normals_pack */
1419 static void mesh_render_data_ensure_vert_normals_pack(MeshRenderData *rdata)
1420 {
1421   GPUPackedNormal *vnors_pack = rdata->vert_normals_pack;
1422   if (vnors_pack == NULL) {
1423     if (rdata->edit_bmesh) {
1424       BMesh *bm = rdata->edit_bmesh->bm;
1425       BMIter viter;
1426       BMVert *eve;
1427       int i;
1428
1429       vnors_pack = rdata->vert_normals_pack = MEM_mallocN(sizeof(*vnors_pack) * rdata->vert_len,
1430                                                           __func__);
1431       BM_ITER_MESH_INDEX (eve, &viter, bm, BM_VERT, i) {
1432         vnors_pack[i] = GPU_normal_convert_i10_v3(eve->no);
1433       }
1434     }
1435     else {
1436       /* data from mesh used directly */
1437       BLI_assert(0);
1438     }
1439   }
1440 }
1441
1442 /** Ensure #MeshRenderData.vert_color */
1443 static void UNUSED_FUNCTION(mesh_render_data_ensure_vert_color)(MeshRenderData *rdata)
1444 {
1445   char(*vcol)[3] = rdata->vert_color;
1446   if (vcol == NULL) {
1447     if (rdata->edit_bmesh) {
1448       BMesh *bm = rdata->edit_bmesh->bm;
1449       const int cd_loop_color_offset = CustomData_get_offset(&bm->ldata, CD_MLOOPCOL);
1450       if (cd_loop_color_offset == -1) {
1451         goto fallback;
1452       }
1453
1454       vcol = rdata->vert_color = MEM_mallocN(sizeof(*vcol) * rdata->loop_len, __func__);
1455
1456       BMIter fiter;
1457       BMFace *efa;
1458       int i = 0;
1459
1460       BM_ITER_MESH (efa, &fiter, bm, BM_FACES_OF_MESH) {
1461         BMLoop *l_iter, *l_first;
1462         l_iter = l_first = BM_FACE_FIRST_LOOP(efa);
1463         do {
1464           const MLoopCol *lcol = BM_ELEM_CD_GET_VOID_P(l_iter, cd_loop_color_offset);
1465           vcol[i][0] = lcol->r;
1466           vcol[i][1] = lcol->g;
1467           vcol[i][2] = lcol->b;
1468           i += 1;
1469         } while ((l_iter = l_iter->next) != l_first);
1470       }
1471       BLI_assert(i == rdata->loop_len);
1472     }
1473     else {
1474       if (rdata->mloopcol == NULL) {
1475         goto fallback;
1476       }
1477
1478       vcol = rdata->vert_color = MEM_mallocN(sizeof(*vcol) * rdata->loop_len, __func__);
1479
1480       for (int i = 0; i < rdata->loop_len; i++) {
1481         vcol[i][0] = rdata->mloopcol[i].r;
1482         vcol[i][1] = rdata->mloopcol[i].g;
1483         vcol[i][2] = rdata->mloopcol[i].b;
1484       }
1485     }
1486   }
1487   return;
1488
1489 fallback:
1490   vcol = rdata->vert_color = MEM_mallocN(sizeof(*vcol) * rdata->loop_len, __func__);
1491
1492   for (int i = 0; i < rdata->loop_len; i++) {
1493     vcol[i][0] = 255;
1494     vcol[i][1] = 255;
1495     vcol[i][2] = 255;
1496   }
1497 }
1498
1499 static float evaluate_vertex_weight(const MDeformVert *dvert, const DRW_MeshWeightState *wstate)
1500 {
1501   float input = 0.0f;
1502   bool show_alert_color = false;
1503
1504   if (wstate->flags & DRW_MESH_WEIGHT_STATE_MULTIPAINT) {
1505     /* Multi-Paint feature */
1506     input = BKE_defvert_multipaint_collective_weight(
1507         dvert,
1508         wstate->defgroup_len,
1509         wstate->defgroup_sel,
1510         wstate->defgroup_sel_count,
1511         (wstate->flags & DRW_MESH_WEIGHT_STATE_AUTO_NORMALIZE) != 0);
1512
1513     /* make it black if the selected groups have no weight on a vertex */
1514     if (input == 0.0f) {
1515       show_alert_color = true;
1516     }
1517   }
1518   else {
1519     /* default, non tricky behavior */
1520     input = defvert_find_weight(dvert, wstate->defgroup_active);
1521
1522     if (input == 0.0f) {
1523       switch (wstate->alert_mode) {
1524         case OB_DRAW_GROUPUSER_ACTIVE:
1525           show_alert_color = true;
1526           break;
1527
1528         case OB_DRAW_GROUPUSER_ALL:
1529           show_alert_color = defvert_is_weight_zero(dvert, wstate->defgroup_len);
1530           break;
1531       }
1532     }
1533   }
1534
1535   if (show_alert_color) {
1536     return -1.0f;
1537   }
1538   else {
1539     CLAMP(input, 0.0f, 1.0f);
1540     return input;
1541   }
1542 }
1543
1544 /** Ensure #MeshRenderData.vert_weight */
1545 static void mesh_render_data_ensure_vert_weight(MeshRenderData *rdata,
1546                                                 const struct DRW_MeshWeightState *wstate)
1547 {
1548   float *vweight = rdata->vert_weight;
1549   if (vweight == NULL) {
1550     if (wstate->defgroup_active == -1) {
1551       goto fallback;
1552     }
1553
1554     if (rdata->edit_bmesh) {
1555       BMesh *bm = rdata->edit_bmesh->bm;
1556       const int cd_dvert_offset = CustomData_get_offset(&bm->vdata, CD_MDEFORMVERT);
1557       if (cd_dvert_offset == -1) {
1558         goto fallback;
1559       }
1560
1561       BMIter viter;
1562       BMVert *eve;
1563       int i;
1564
1565       vweight = rdata->vert_weight = MEM_mallocN(sizeof(*vweight) * rdata->vert_len, __func__);
1566       BM_ITER_MESH_INDEX (eve, &viter, bm, BM_VERT, i) {
1567         const MDeformVert *dvert = BM_ELEM_CD_GET_VOID_P(eve, cd_dvert_offset);
1568         vweight[i] = evaluate_vertex_weight(dvert, wstate);
1569       }
1570     }
1571     else {
1572       if (rdata->dvert == NULL) {
1573         goto fallback;
1574       }
1575
1576       vweight = rdata->vert_weight = MEM_mallocN(sizeof(*vweight) * rdata->vert_len, __func__);
1577       for (int i = 0; i < rdata->vert_len; i++) {
1578         vweight[i] = evaluate_vertex_weight(&rdata->dvert[i], wstate);
1579       }
1580     }
1581   }
1582   return;
1583
1584 fallback:
1585   vweight = rdata->vert_weight = MEM_callocN(sizeof(*vweight) * rdata->vert_len, __func__);
1586
1587   if ((wstate->defgroup_active < 0) && (wstate->defgroup_len > 0)) {
1588     copy_vn_fl(vweight, rdata->vert_len, -2.0f);
1589   }
1590   else if (wstate->alert_mode != OB_DRAW_GROUPUSER_NONE) {
1591     copy_vn_fl(vweight, rdata->vert_len, -1.0f);
1592   }
1593 }
1594
1595 /** \} */
1596
1597 /* ---------------------------------------------------------------------- */
1598 /** \name Internal Cache Generation
1599  * \{ */
1600
1601 static uchar mesh_render_data_face_flag(MeshRenderData *rdata, const BMFace *efa, const int cd_ofs)
1602 {
1603   uchar fflag = 0;
1604
1605   if (efa == rdata->efa_act) {
1606     fflag |= VFLAG_FACE_ACTIVE;
1607   }
1608   if (BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
1609     fflag |= VFLAG_FACE_SELECTED;
1610   }
1611
1612   if (efa == rdata->efa_act_uv) {
1613     fflag |= VFLAG_FACE_UV_ACTIVE;
1614   }
1615   if ((cd_ofs != -1) && uvedit_face_select_test_ex(rdata->toolsettings, (BMFace *)efa, cd_ofs)) {
1616     fflag |= VFLAG_FACE_UV_SELECT;
1617   }
1618
1619 #ifdef WITH_FREESTYLE
1620   if (rdata->cd.offset.freestyle_face != -1) {
1621     const FreestyleFace *ffa = BM_ELEM_CD_GET_VOID_P(efa, rdata->cd.offset.freestyle_face);
1622     if (ffa->flag & FREESTYLE_FACE_MARK) {
1623       fflag |= VFLAG_FACE_FREESTYLE;
1624     }
1625   }
1626 #endif
1627
1628   return fflag;
1629 }
1630
1631 static void mesh_render_data_edge_flag(const MeshRenderData *rdata,
1632                                        const BMEdge *eed,
1633                                        EdgeDrawAttr *eattr)
1634 {
1635   const ToolSettings *ts = rdata->toolsettings;
1636   const bool is_vertex_select_mode = (ts != NULL) && (ts->selectmode & SCE_SELECT_VERTEX) != 0;
1637   const bool is_face_only_select_mode = (ts != NULL) && (ts->selectmode == SCE_SELECT_FACE);
1638
1639   if (eed == rdata->eed_act) {
1640     eattr->e_flag |= VFLAG_EDGE_ACTIVE;
1641   }
1642   if (!is_vertex_select_mode && BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
1643     eattr->e_flag |= VFLAG_EDGE_SELECTED;
1644   }
1645   if (is_vertex_select_mode && BM_elem_flag_test(eed->v1, BM_ELEM_SELECT) &&
1646       BM_elem_flag_test(eed->v2, BM_ELEM_SELECT)) {
1647     eattr->e_flag |= VFLAG_EDGE_SELECTED;
1648     eattr->e_flag |= VFLAG_VERT_SELECTED;
1649   }
1650   if (BM_elem_flag_test(eed, BM_ELEM_SEAM)) {
1651     eattr->e_flag |= VFLAG_EDGE_SEAM;
1652   }
1653   if (!BM_elem_flag_test(eed, BM_ELEM_SMOOTH)) {
1654     eattr->e_flag |= VFLAG_EDGE_SHARP;
1655   }
1656
1657   /* Use active edge color for active face edges because
1658    * specular highlights make it hard to see T55456#510873.
1659    *
1660    * This isn't ideal since it can't be used when mixing edge/face modes
1661    * but it's still better then not being able to see the active face. */
1662   if (is_face_only_select_mode) {
1663     if (rdata->efa_act != NULL) {
1664       if (BM_edge_in_face(eed, rdata->efa_act)) {
1665         eattr->e_flag |= VFLAG_EDGE_ACTIVE;
1666       }
1667     }
1668   }
1669
1670   /* Use a byte for value range */
1671   if (rdata->cd.offset.crease != -1) {
1672     float crease = BM_ELEM_CD_GET_FLOAT(eed, rdata->cd.offset.crease);
1673     if (crease > 0) {
1674       eattr->crease = (uchar)(crease * 255.0f);
1675     }
1676   }
1677   /* Use a byte for value range */
1678   if (rdata->cd.offset.bweight != -1) {
1679     float bweight = BM_ELEM_CD_GET_FLOAT(eed, rdata->cd.offset.bweight);
1680     if (bweight > 0) {
1681       eattr->bweight = (uchar)(bweight * 255.0f);
1682     }
1683   }
1684 #ifdef WITH_FREESTYLE
1685   if (rdata->cd.offset.freestyle_edge != -1) {
1686     const FreestyleEdge *fed = BM_ELEM_CD_GET_VOID_P(eed, rdata->cd.offset.freestyle_edge);
1687     if (fed->flag & FREESTYLE_EDGE_MARK) {
1688       eattr->e_flag |= VFLAG_EDGE_FREESTYLE;
1689     }
1690   }
1691 #endif
1692 }
1693
1694 static void mesh_render_data_loop_flag(MeshRenderData *rdata,
1695                                        BMLoop *loop,
1696                                        const int cd_ofs,
1697                                        EdgeDrawAttr *eattr)
1698 {
1699   if (cd_ofs == -1) {
1700     return;
1701   }
1702   MLoopUV *luv = BM_ELEM_CD_GET_VOID_P(loop, cd_ofs);
1703   if (luv != NULL && (luv->flag & MLOOPUV_PINNED)) {
1704     eattr->v_flag |= VFLAG_VERT_UV_PINNED;
1705   }
1706   if (uvedit_uv_select_test_ex(rdata->toolsettings, loop, cd_ofs)) {
1707     eattr->v_flag |= VFLAG_VERT_UV_SELECT;
1708   }
1709   if (uvedit_edge_select_test_ex(rdata->toolsettings, loop, cd_ofs)) {
1710     eattr->v_flag |= VFLAG_EDGE_UV_SELECT;
1711   }
1712 }
1713
1714 static void mesh_render_data_vert_flag(MeshRenderData *rdata,
1715                                        const BMVert *eve,
1716                                        EdgeDrawAttr *eattr)
1717 {
1718   if (eve == rdata->eve_act) {
1719     eattr->e_flag |= VFLAG_VERT_ACTIVE;
1720   }
1721   if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
1722     eattr->e_flag |= VFLAG_VERT_SELECTED;
1723   }
1724 }
1725
1726 static bool add_edit_facedot(MeshRenderData *rdata,
1727                              GPUVertBuf *vbo,
1728                              const uint fdot_pos_id,
1729                              const uint fdot_nor_flag_id,
1730                              const int poly,
1731                              const int base_vert_idx)
1732 {
1733   BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_LOOP | MR_DATATYPE_POLY));
1734   float pnor[3], center[3];
1735   int facedot_flag;
1736   if (rdata->edit_bmesh) {
1737     BMEditMesh *em = rdata->edit_bmesh;
1738     const BMFace *efa = BM_face_at_index(em->bm, poly);
1739     if (BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
1740       return false;
1741     }
1742     if (rdata->edit_data && rdata->edit_data->vertexCos) {
1743       copy_v3_v3(center, rdata->edit_data->polyCos[poly]);
1744       copy_v3_v3(pnor, rdata->edit_data->polyNos[poly]);
1745     }
1746     else {
1747       BM_face_calc_center_median(efa, center);
1748       copy_v3_v3(pnor, efa->no);
1749     }
1750     facedot_flag = BM_elem_flag_test(efa, BM_ELEM_SELECT) ? ((efa == em->bm->act_face) ? -1 : 1) :
1751                                                             0;
1752   }
1753   else {
1754     MVert *mvert = rdata->mvert;
1755     const MPoly *mpoly = rdata->mpoly + poly;
1756     const MLoop *mloop = rdata->mloop + mpoly->loopstart;
1757
1758     BKE_mesh_calc_poly_center(mpoly, mloop, mvert, center);
1759     BKE_mesh_calc_poly_normal(mpoly, mloop, mvert, pnor);
1760     /* No selection if not in edit mode. */
1761     facedot_flag = 0;
1762   }
1763
1764   GPUPackedNormal nor = GPU_normal_convert_i10_v3(pnor);
1765   nor.w = facedot_flag;
1766   GPU_vertbuf_attr_set(vbo, fdot_nor_flag_id, base_vert_idx, &nor);
1767   GPU_vertbuf_attr_set(vbo, fdot_pos_id, base_vert_idx, center);
1768
1769   return true;
1770 }
1771 static bool add_edit_facedot_mapped(MeshRenderData *rdata,
1772                                     GPUVertBuf *vbo,
1773                                     const uint fdot_pos_id,
1774                                     const uint fdot_nor_flag_id,
1775                                     const int poly,
1776                                     const int base_vert_idx)
1777 {
1778   BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_LOOP | MR_DATATYPE_POLY));
1779   float pnor[3], center[3];
1780   const int *p_origindex = rdata->mapped.p_origindex;
1781   const int p_orig = p_origindex[poly];
1782   if (p_orig == ORIGINDEX_NONE) {
1783     return false;
1784   }
1785   BMEditMesh *em = rdata->edit_bmesh;
1786   const BMFace *efa = BM_face_at_index(em->bm, p_orig);
1787   if (BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
1788     return false;
1789   }
1790
1791   Mesh *me_cage = em->mesh_eval_cage;
1792   const MVert *mvert = me_cage->mvert;
1793   const MLoop *mloop = me_cage->mloop;
1794   const MPoly *mpoly = me_cage->mpoly;
1795
1796   const MPoly *mp = mpoly + poly;
1797   const MLoop *ml = mloop + mp->loopstart;
1798
1799   BKE_mesh_calc_poly_center(mp, ml, mvert, center);
1800   BKE_mesh_calc_poly_normal(mp, ml, mvert, pnor);
1801
1802   GPUPackedNormal nor = GPU_normal_convert_i10_v3(pnor);
1803   nor.w = BM_elem_flag_test(efa, BM_ELEM_SELECT) ? ((efa == em->bm->act_face) ? -1 : 1) : 0;
1804   GPU_vertbuf_attr_set(vbo, fdot_nor_flag_id, base_vert_idx, &nor);
1805   GPU_vertbuf_attr_set(vbo, fdot_pos_id, base_vert_idx, center);
1806
1807   return true;
1808 }
1809
1810 /** \} */
1811
1812 /* ---------------------------------------------------------------------- */
1813 /** \name Vertex Group Selection
1814  * \{ */
1815
1816 /** Reset the selection structure, deallocating heap memory as appropriate. */
1817 static void drw_mesh_weight_state_clear(struct DRW_MeshWeightState *wstate)
1818 {
1819   MEM_SAFE_FREE(wstate->defgroup_sel);
1820
1821   memset(wstate, 0, sizeof(*wstate));
1822
1823   wstate->defgroup_active = -1;
1824 }
1825
1826 /** Copy selection data from one structure to another, including heap memory. */
1827 static void drw_mesh_weight_state_copy(struct DRW_MeshWeightState *wstate_dst,
1828                                        const struct DRW_MeshWeightState *wstate_src)
1829 {
1830   MEM_SAFE_FREE(wstate_dst->defgroup_sel);
1831
1832   memcpy(wstate_dst, wstate_src, sizeof(*wstate_dst));
1833
1834   if (wstate_src->defgroup_sel) {
1835     wstate_dst->defgroup_sel = MEM_dupallocN(wstate_src->defgroup_sel);
1836   }
1837 }
1838
1839 /** Compare two selection structures. */
1840 static bool drw_mesh_weight_state_compare(const struct DRW_MeshWeightState *a,
1841                                           const struct DRW_MeshWeightState *b)
1842 {
1843   return a->defgroup_active == b->defgroup_active && a->defgroup_len == b->defgroup_len &&
1844          a->flags == b->flags && a->alert_mode == b->alert_mode &&
1845          a->defgroup_sel_count == b->defgroup_sel_count &&
1846          ((!a->defgroup_sel && !b->defgroup_sel) ||
1847           (a->defgroup_sel && b->defgroup_sel &&
1848            memcmp(a->defgroup_sel, b->defgroup_sel, a->defgroup_len * sizeof(bool)) == 0));
1849 }
1850
1851 static void drw_mesh_weight_state_extract(Object *ob,
1852                                           Mesh *me,
1853                                           const ToolSettings *ts,
1854                                           bool paint_mode,
1855                                           struct DRW_MeshWeightState *wstate)
1856 {
1857   /* Extract complete vertex weight group selection state and mode flags. */
1858   memset(wstate, 0, sizeof(*wstate));
1859
1860   wstate->defgroup_active = ob->actdef - 1;
1861   wstate->defgroup_len = BLI_listbase_count(&ob->defbase);
1862
1863   wstate->alert_mode = ts->weightuser;
1864
1865   if (paint_mode && ts->multipaint) {
1866     /* Multipaint needs to know all selected bones, not just the active group.
1867      * This is actually a relatively expensive operation, but caching would be difficult. */
1868     wstate->defgroup_sel = BKE_object_defgroup_selected_get(
1869         ob, wstate->defgroup_len, &wstate->defgroup_sel_count);
1870
1871     if (wstate->defgroup_sel_count > 1) {
1872       wstate->flags |= DRW_MESH_WEIGHT_STATE_MULTIPAINT |
1873                        (ts->auto_normalize ? DRW_MESH_WEIGHT_STATE_AUTO_NORMALIZE : 0);
1874
1875       if (me->editflag & ME_EDIT_MIRROR_X) {
1876         BKE_object_defgroup_mirror_selection(ob,
1877                                              wstate->defgroup_len,
1878                                              wstate->defgroup_sel,
1879                                              wstate->defgroup_sel,
1880                                              &wstate->defgroup_sel_count);
1881       }
1882     }
1883     /* With only one selected bone Multipaint reverts to regular mode. */
1884     else {
1885       wstate->defgroup_sel_count = 0;
1886       MEM_SAFE_FREE(wstate->defgroup_sel);
1887     }
1888   }
1889 }
1890
1891 /** \} */
1892
1893 /* ---------------------------------------------------------------------- */
1894 /** \name Mesh GPUBatch Cache
1895  * \{ */
1896
1897 typedef enum DRWBatchFlag {
1898   MBC_SURFACE = (1 << 0),
1899   MBC_SURFACE_WEIGHTS = (1 << 1),
1900   MBC_EDIT_TRIANGLES = (1 << 2),
1901   MBC_EDIT_VERTICES = (1 << 3),
1902   MBC_EDIT_EDGES = (1 << 4),
1903   MBC_EDIT_LNOR = (1 << 5),
1904   MBC_EDIT_FACEDOTS = (1 << 6),
1905   MBC_EDIT_MESH_ANALYSIS = (1 << 7),
1906   MBC_EDITUV_FACES_STRECH_AREA = (1 << 8),
1907   MBC_EDITUV_FACES_STRECH_ANGLE = (1 << 9),
1908   MBC_EDITUV_FACES = (1 << 10),
1909   MBC_EDITUV_EDGES = (1 << 11),
1910   MBC_EDITUV_VERTS = (1 << 12),
1911   MBC_EDITUV_FACEDOTS = (1 << 13),
1912   MBC_EDIT_SELECTION_VERTS = (1 << 14),
1913   MBC_EDIT_SELECTION_EDGES = (1 << 15),
1914   MBC_EDIT_SELECTION_FACES = (1 << 16),
1915   MBC_EDIT_SELECTION_FACEDOTS = (1 << 17),
1916   MBC_ALL_VERTS = (1 << 18),
1917   MBC_ALL_EDGES = (1 << 19),
1918   MBC_LOOSE_EDGES = (1 << 20),
1919   MBC_EDGE_DETECTION = (1 << 21),
1920   MBC_WIRE_EDGES = (1 << 22),
1921   MBC_WIRE_LOOPS = (1 << 23),
1922   MBC_WIRE_LOOPS_UVS = (1 << 24),
1923   MBC_SURF_PER_MAT = (1 << 25),
1924 } DRWBatchFlag;
1925
1926 #define MBC_EDITUV \
1927   (MBC_EDITUV_FACES_STRECH_AREA | MBC_EDITUV_FACES_STRECH_ANGLE | MBC_EDITUV_FACES | \
1928    MBC_EDITUV_EDGES | MBC_EDITUV_VERTS | MBC_EDITUV_FACEDOTS)
1929
1930 typedef struct MeshBatchCache {
1931   /* In order buffers: All verts only specified once
1932    * or once per loop. To be used with a GPUIndexBuf. */
1933   struct {
1934     /* Vertex data. */
1935     GPUVertBuf *pos_nor;
1936     GPUVertBuf *weights;
1937     /* Loop data. */
1938     GPUVertBuf *loop_pos_nor;
1939     GPUVertBuf *loop_uv_tan;
1940     GPUVertBuf *loop_vcol;
1941     GPUVertBuf *loop_edge_fac;
1942     GPUVertBuf *loop_orco;
1943   } ordered;
1944
1945   /* Edit Mesh Data:
1946    * Edit cage can be different from final mesh so vertex count
1947    * might differ. */
1948   struct {
1949     /* TODO(fclem): Reuse ordered.loop_pos_nor and maybe even
1950      * ordered.loop_uv_tan when cage match final mesh. */
1951     GPUVertBuf *loop_pos_nor;
1952     GPUVertBuf *loop_data;
1953     GPUVertBuf *loop_lnor;
1954     GPUVertBuf *facedots_pos_nor_data;
1955     GPUVertBuf *loop_mesh_analysis;
1956     /* UV data without modifier applied.
1957      * Vertex count is always the one of the cage. */
1958     GPUVertBuf *loop_uv;
1959     GPUVertBuf *loop_uv_data;
1960     GPUVertBuf *loop_stretch_angle;
1961     GPUVertBuf *loop_stretch_area;
1962     GPUVertBuf *facedots_uv;
1963     GPUVertBuf *facedots_uv_data;
1964     /* Selection */
1965     GPUVertBuf *loop_vert_idx;
1966     GPUVertBuf *loop_edge_idx;
1967     GPUVertBuf *loop_face_idx;
1968     GPUVertBuf *facedots_idx;
1969   } edit;
1970
1971   /* Index Buffers:
1972    * Only need to be updated when topology changes. */
1973   struct {
1974     /* Indices to verts. */
1975     GPUIndexBuf *surf_tris;
1976     GPUIndexBuf *edges_lines;
1977     GPUIndexBuf *edges_adj_lines;
1978     GPUIndexBuf *loose_edges_lines;
1979     /* Indices to vloops. */
1980     GPUIndexBuf *loops_tris;
1981     GPUIndexBuf *loops_lines;
1982     GPUIndexBuf *loops_line_strips;
1983     /* Edit mode. */
1984     GPUIndexBuf *edit_loops_points; /* verts */
1985     GPUIndexBuf *edit_loops_lines;  /* edges */
1986     GPUIndexBuf *edit_loops_tris;   /* faces */
1987     /* Edit UVs */
1988     GPUIndexBuf *edituv_loops_points;      /* verts */
1989     GPUIndexBuf *edituv_loops_line_strips; /* edges */
1990     GPUIndexBuf *edituv_loops_tri_fans;    /* faces */
1991   } ibo;
1992
1993   struct {
1994     /* Surfaces / Render */
1995     GPUBatch *surface;
1996     GPUBatch *surface_weights;
1997     /* Edit mode */
1998     GPUBatch *edit_triangles;
1999     GPUBatch *edit_vertices;
2000     GPUBatch *edit_edges;
2001     GPUBatch *edit_lnor;
2002     GPUBatch *edit_facedots;
2003     GPUBatch *edit_mesh_analysis;
2004     /* Edit UVs */
2005     GPUBatch *edituv_faces_strech_area;
2006     GPUBatch *edituv_faces_strech_angle;
2007     GPUBatch *edituv_faces;
2008     GPUBatch *edituv_edges;
2009     GPUBatch *edituv_verts;
2010     GPUBatch *edituv_facedots;
2011     /* Edit selection */
2012     GPUBatch *edit_selection_verts;
2013     GPUBatch *edit_selection_edges;
2014     GPUBatch *edit_selection_faces;
2015     GPUBatch *edit_selection_facedots;
2016     /* Common display / Other */
2017     GPUBatch *all_verts;
2018     GPUBatch *all_edges;
2019     GPUBatch *loose_edges;
2020     GPUBatch *edge_detection;
2021     GPUBatch *wire_edges;     /* Individual edges with face normals. */
2022     GPUBatch *wire_loops;     /* Loops around faces. */
2023     GPUBatch *wire_loops_uvs; /* Same as wire_loops but only has uvs. */
2024   } batch;
2025
2026   GPUIndexBuf **surf_per_mat_tris;
2027   GPUBatch **surf_per_mat;
2028
2029   /* arrays of bool uniform names (and value) that will be use to
2030    * set srgb conversion for auto attributes.*/
2031   char *auto_layer_names;
2032   int *auto_layer_is_srgb;
2033   int auto_layer_len;
2034
2035   DRWBatchFlag batch_requested;
2036   DRWBatchFlag batch_ready;
2037
2038   /* settings to determine if cache is invalid */
2039   bool is_maybe_dirty;
2040   bool is_dirty; /* Instantly invalidates cache, skipping mesh check */
2041   int edge_len;
2042   int tri_len;
2043   int poly_len;
2044   int vert_len;
2045   int mat_len;
2046   bool is_editmode;
2047   bool is_uvsyncsel;
2048
2049   struct DRW_MeshWeightState weight_state;
2050
2051   DRW_MeshCDMask cd_used, cd_needed, cd_used_over_time;
2052
2053   int lastmatch;
2054
2055   /* Valid only if edge_detection is up to date. */
2056   bool is_manifold;
2057 } MeshBatchCache;
2058
2059 BLI_INLINE void mesh_batch_cache_add_request(MeshBatchCache *cache, DRWBatchFlag new_flag)
2060 {
2061   atomic_fetch_and_or_uint32((uint32_t *)(&cache->batch_requested), *(uint32_t *)&new_flag);
2062 }
2063
2064 /* GPUBatch cache management. */
2065
2066 static bool mesh_batch_cache_valid(Mesh *me)
2067 {
2068   MeshBatchCache *cache = me->runtime.batch_cache;
2069
2070   if (cache == NULL) {
2071     return false;
2072   }
2073
2074   if (cache->mat_len != mesh_render_mat_len_get(me)) {
2075     return false;
2076   }
2077
2078   if (cache->is_editmode != (me->edit_mesh != NULL)) {
2079     return false;
2080   }
2081
2082   if (cache->is_dirty) {
2083     return false;
2084   }
2085
2086   if (cache->is_maybe_dirty == false) {
2087     return true;
2088   }
2089   else {
2090     if (cache->is_editmode) {
2091       return false;
2092     }
2093     else if ((cache->vert_len != mesh_render_verts_len_get(me)) ||
2094              (cache->edge_len != mesh_render_edges_len_get(me)) ||
2095              (cache->tri_len != mesh_render_looptri_len_get(me)) ||
2096              (cache->poly_len != mesh_render_polys_len_get(me)) ||
2097              (cache->mat_len != mesh_render_mat_len_get(me))) {
2098       return false;
2099     }
2100   }
2101
2102   return true;
2103 }
2104
2105 static void mesh_batch_cache_init(Mesh *me)
2106 {
2107   MeshBatchCache *cache = me->runtime.batch_cache;
2108
2109   if (!cache) {
2110     cache = me->runtime.batch_cache = MEM_callocN(sizeof(*cache), __func__);
2111   }
2112   else {
2113     memset(cache, 0, sizeof(*cache));
2114   }
2115
2116   cache->is_editmode = me->edit_mesh != NULL;
2117
2118   if (cache->is_editmode == false) {
2119     cache->edge_len = mesh_render_edges_len_get(me);
2120     cache->tri_len = mesh_render_looptri_len_get(me);
2121     cache->poly_len = mesh_render_polys_len_get(me);
2122     cache->vert_len = mesh_render_verts_len_get(me);
2123   }
2124
2125   cache->mat_len = mesh_render_mat_len_get(me);
2126   cache->surf_per_mat_tris = MEM_callocN(sizeof(*cache->surf_per_mat_tris) * cache->mat_len,
2127                                          __func__);
2128   cache->surf_per_mat = MEM_callocN(sizeof(*cache->surf_per_mat) * cache->mat_len, __func__);
2129
2130   cache->is_maybe_dirty = false;
2131   cache->is_dirty = false;
2132
2133   drw_mesh_weight_state_clear(&cache->weight_state);
2134 }
2135
2136 void DRW_mesh_batch_cache_validate(Mesh *me)
2137 {
2138   if (!mesh_batch_cache_valid(me)) {
2139     mesh_batch_cache_clear(me);
2140     mesh_batch_cache_init(me);
2141   }
2142 }
2143
2144 static MeshBatchCache *mesh_batch_cache_get(Mesh *me)
2145 {
2146   return me->runtime.batch_cache;
2147 }
2148
2149 static void mesh_batch_cache_check_vertex_group(MeshBatchCache *cache,
2150                                                 const struct DRW_MeshWeightState *wstate)
2151 {
2152   if (!drw_mesh_weight_state_compare(&cache->weight_state, wstate)) {
2153     GPU_BATCH_CLEAR_SAFE(cache->batch.surface_weights);
2154     GPU_VERTBUF_DISCARD_SAFE(cache->ordered.weights);
2155
2156     cache->batch_ready &= ~MBC_SURFACE_WEIGHTS;
2157
2158     drw_mesh_weight_state_clear(&cache->weight_state);
2159   }
2160 }
2161
2162 static void mesh_batch_cache_discard_shaded_tri(MeshBatchCache *cache)
2163 {
2164   GPU_VERTBUF_DISCARD_SAFE(cache->ordered.loop_pos_nor);
2165   GPU_VERTBUF_DISCARD_SAFE(cache->ordered.loop_uv_tan);
2166   GPU_VERTBUF_DISCARD_SAFE(cache->ordered.loop_vcol);
2167   GPU_VERTBUF_DISCARD_SAFE(cache->ordered.loop_orco);
2168
2169   if (cache->surf_per_mat_tris) {
2170     for (int i = 0; i < cache->mat_len; i++) {
2171       GPU_INDEXBUF_DISCARD_SAFE(cache->surf_per_mat_tris[i]);
2172     }
2173   }
2174   MEM_SAFE_FREE(cache->surf_per_mat_tris);
2175   if (cache->surf_per_mat) {
2176     for (int i = 0; i < cache->mat_len; i++) {
2177       GPU_BATCH_DISCARD_SAFE(cache->surf_per_mat[i]);
2178     }
2179   }
2180   MEM_SAFE_FREE(cache->surf_per_mat);
2181
2182   cache->batch_ready &= ~MBC_SURF_PER_MAT;
2183
2184   MEM_SAFE_FREE(cache->auto_layer_names);
2185   MEM_SAFE_FREE(cache->auto_layer_is_srgb);
2186
2187   mesh_cd_layers_type_clear(&cache->cd_used);
2188
2189   cache->mat_len = 0;
2190 }
2191
2192 static void mesh_batch_cache_discard_uvedit(MeshBatchCache *cache)
2193 {
2194   GPU_VERTBUF_DISCARD_SAFE(cache->edit.loop_stretch_angle);
2195   GPU_VERTBUF_DISCARD_SAFE(cache->edit.loop_stretch_area);
2196   GPU_VERTBUF_DISCARD_SAFE(cache->edit.loop_uv);
2197   GPU_VERTBUF_DISCARD_SAFE(cache->edit.loop_uv_data);
2198   GPU_VERTBUF_DISCARD_SAFE(cache->edit.facedots_uv);
2199   GPU_VERTBUF_DISCARD_SAFE(cache->edit.facedots_uv_data);
2200   GPU_INDEXBUF_DISCARD_SAFE(cache->ibo.edituv_loops_tri_fans);
2201   GPU_INDEXBUF_DISCARD_SAFE(cache->ibo.edituv_loops_line_strips);
2202   GPU_INDEXBUF_DISCARD_SAFE(cache->ibo.edituv_loops_points);
2203   GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces_strech_area);
2204   GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces_strech_angle);
2205   GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces);
2206   GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_edges);
2207   GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_verts);
2208   GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_facedots);
2209
2210   cache->batch_ready &= ~MBC_EDITUV;
2211 }
2212
2213 void DRW_mesh_batch_cache_dirty_tag(Mesh *me, int mode)
2214 {
2215   MeshBatchCache *cache = me->runtime.batch_cache;
2216   if (cache == NULL) {
2217     return;
2218   }
2219   switch (mode) {
2220     case BKE_MESH_BATCH_DIRTY_MAYBE_ALL:
2221       cache->is_maybe_dirty = true;
2222       break;
2223     case BKE_MESH_BATCH_DIRTY_SELECT:
2224       GPU_VERTBUF_DISCARD_SAFE(cache->edit.loop_data);
2225       GPU_VERTBUF_DISCARD_SAFE(cache->edit.facedots_pos_nor_data);
2226       GPU_BATCH_DISCARD_SAFE(cache->batch.edit_triangles);
2227       GPU_BATCH_DISCARD_SAFE(cache->batch.edit_vertices);
2228       GPU_BATCH_DISCARD_SAFE(cache->batch.edit_edges);
2229       GPU_BATCH_DISCARD_SAFE(cache->batch.edit_facedots);
2230       GPU_BATCH_DISCARD_SAFE(cache->batch.edit_mesh_analysis);
2231       cache->batch_ready &= ~(MBC_EDIT_TRIANGLES | MBC_EDIT_VERTICES | MBC_EDIT_EDGES |
2232                               MBC_EDIT_FACEDOTS | MBC_EDIT_MESH_ANALYSIS);
2233       /* Because visible UVs depends on edit mode selection, discard everything. */
2234       mesh_batch_cache_discard_uvedit(cache);
2235       break;
2236     case BKE_MESH_BATCH_DIRTY_SELECT_PAINT:
2237       /* Paint mode selection flag is packed inside the nor attrib.
2238        * Note that it can be slow if auto smooth is enabled. (see T63946) */
2239       GPU_VERTBUF_DISCARD_SAFE(cache->ordered.loop_pos_nor);
2240       GPU_BATCH_DISCARD_SAFE(cache->batch.surface);
2241       GPU_BATCH_DISCARD_SAFE(cache->batch.wire_loops);
2242       if (cache->surf_per_mat) {
2243         for (int i = 0; i < cache->mat_len; i++) {
2244           GPU_BATCH_DISCARD_SAFE(cache->surf_per_mat[i]);
2245         }
2246       }
2247       cache->batch_ready &= ~(MBC_SURFACE | MBC_WIRE_LOOPS | MBC_SURF_PER_MAT);
2248       break;
2249     case BKE_MESH_BATCH_DIRTY_ALL:
2250       cache->is_dirty = true;
2251       break;
2252     case BKE_MESH_BATCH_DIRTY_SHADING:
2253       mesh_batch_cache_discard_shaded_tri(cache);
2254       mesh_batch_cache_discard_uvedit(cache);
2255       break;
2256     case BKE_MESH_BATCH_DIRTY_SCULPT_COORDS:
2257       cache->is_sculpt_points_tag = true;
2258       break;
2259     case BKE_MESH_BATCH_DIRTY_UVEDIT_ALL:
2260       mesh_batch_cache_discard_uvedit(cache);
2261       break;
2262     case BKE_MESH_BATCH_DIRTY_UVEDIT_SELECT:
2263       GPU_VERTBUF_DISCARD_SAFE(cache->edit.loop_uv_data);
2264       GPU_VERTBUF_DISCARD_SAFE(cache->edit.facedots_uv_data);
2265       GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces_strech_area);
2266       GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces_strech_angle);
2267       GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces);
2268       GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_edges);
2269       GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_verts);
2270       GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_facedots);
2271       cache->batch_ready &= ~MBC_EDITUV;
2272       break;
2273     default:
2274       BLI_assert(0);
2275   }
2276 }
2277
2278 static void mesh_batch_cache_clear(Mesh *me)
2279 {
2280   MeshBatchCache *cache = me->runtime.batch_cache;
2281   if (!cache) {
2282     return;
2283   }
2284
2285   for (int i = 0; i < sizeof(cache->ordered) / sizeof(void *); ++i) {
2286     GPUVertBuf **vbo = (GPUVertBuf **)&cache->ordered;
2287     GPU_VERTBUF_DISCARD_SAFE(vbo[i]);
2288   }
2289   for (int i = 0; i < sizeof(cache->edit) / sizeof(void *); ++i) {
2290     GPUVertBuf **vbo = (GPUVertBuf **)&cache->edit;
2291     GPU_VERTBUF_DISCARD_SAFE(vbo[i]);
2292   }
2293   for (int i = 0; i < sizeof(cache->ibo) / sizeof(void *); ++i) {
2294     GPUIndexBuf **ibo = (GPUIndexBuf **)&cache->ibo;
2295     GPU_INDEXBUF_DISCARD_SAFE(ibo[i]);
2296   }
2297   for (int i = 0; i < sizeof(cache->batch) / sizeof(void *); ++i) {
2298     GPUBatch **batch = (GPUBatch **)&cache->batch;
2299     GPU_BATCH_DISCARD_SAFE(batch[i]);
2300   }
2301
2302   mesh_batch_cache_discard_shaded_tri(cache);
2303
2304   mesh_batch_cache_discard_uvedit(cache);
2305
2306   cache->batch_ready = 0;
2307
2308   drw_mesh_weight_state_clear(&cache->weight_state);
2309 }
2310
2311 void DRW_mesh_batch_cache_free(Mesh *me)
2312 {
2313   mesh_batch_cache_clear(me);
2314   MEM_SAFE_FREE(me->runtime.batch_cache);
2315 }
2316
2317 /* GPUBatch cache usage. */
2318
2319 static void mesh_create_edit_vertex_loops(MeshRenderData *rdata,
2320                                           GPUVertBuf *vbo_pos_nor,
2321                                           GPUVertBuf *vbo_lnor,
2322                                           GPUVertBuf *vbo_uv,
2323                                           GPUVertBuf *vbo_data,
2324                                           GPUVertBuf *vbo_verts,
2325                                           GPUVertBuf *vbo_edges,
2326                                           GPUVertBuf *vbo_faces)
2327 {
2328 #if 0
2329   const int vert_len = mesh_render_data_verts_len_get_maybe_mapped(rdata);
2330   const int edge_len = mesh_render_data_edges_len_get_maybe_mapped(rdata);
2331 #endif
2332   const int poly_len = mesh_render_data_polys_len_get_maybe_mapped(rdata);
2333   const int lvert_len = mesh_render_data_loose_verts_len_get_maybe_mapped(rdata);
2334   const int ledge_len = mesh_render_data_loose_edges_len_get_maybe_mapped(rdata);
2335   const int loop_len = mesh_render_data_loops_len_get_maybe_mapped(rdata);
2336   const int tot_loop_len = loop_len + ledge_len * 2 + lvert_len;
2337   float(*lnors)[3] = rdata->loop_normals;
2338   uchar fflag;
2339
2340   /* Static formats */
2341   static struct {
2342     GPUVertFormat sel_id, pos_nor, lnor, flag, uv;
2343   } format = {{0}};
2344   static struct {
2345     uint sel_id, pos, nor, lnor, data, uvs;
2346   } attr_id;
2347   if (format.sel_id.attr_len == 0) {
2348     attr_id.sel_id = GPU_vertformat_attr_add(
2349         &format.sel_id, "color", GPU_COMP_U32, 1, GPU_FETCH_INT);
2350     attr_id.pos = GPU_vertformat_attr_add(
2351         &format.pos_nor, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
2352     attr_id.nor = GPU_vertformat_attr_add(
2353         &format.pos_nor, "vnor", GPU_COMP_I10, 3, GPU_FETCH_INT_TO_FLOAT_UNIT);
2354     attr_id.lnor = GPU_vertformat_attr_add(
2355         &format.lnor, "lnor", GPU_COMP_I10, 3, GPU_FETCH_INT_TO_FLOAT_UNIT);
2356     attr_id.data = GPU_vertformat_attr_add(&format.flag, "data", GPU_COMP_U8, 4, GPU_FETCH_INT);
2357     attr_id.uvs = GPU_vertformat_attr_add(&format.uv, "u", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
2358     GPU_vertformat_alias_add(&format.uv, "pos");
2359     GPU_vertformat_alias_add(&format.flag, "flag");
2360   }
2361
2362   GPUVertBufRaw raw_verts, raw_edges, raw_faces, raw_pos, raw_nor, raw_lnor, raw_uv, raw_data;
2363   if (DRW_TEST_ASSIGN_VBO(vbo_pos_nor)) {
2364     GPU_vertbuf_init_with_format(vbo_pos_nor, &format.pos_nor);
2365     GPU_vertbuf_data_alloc(vbo_pos_nor, tot_loop_len);
2366     GPU_vertbuf_attr_get_raw_data(vbo_pos_nor, attr_id.pos, &raw_pos);
2367     GPU_vertbuf_attr_get_raw_data(vbo_pos_nor, attr_id.nor, &raw_nor);
2368   }
2369   if (DRW_TEST_ASSIGN_VBO(vbo_lnor)) {
2370     GPU_vertbuf_init_with_format(vbo_lnor, &format.lnor);
2371     GPU_vertbuf_data_alloc(vbo_lnor, tot_loop_len);
2372     GPU_vertbuf_attr_get_raw_data(vbo_lnor, attr_id.lnor, &raw_lnor);
2373   }
2374   if (DRW_TEST_ASSIGN_VBO(vbo_data)) {
2375     GPU_vertbuf_init_with_format(vbo_data, &format.flag);
2376     GPU_vertbuf_data_alloc(vbo_data, tot_loop_len);
2377     GPU_vertbuf_attr_get_raw_data(vbo_data, attr_id.data, &raw_data);
2378   }
2379   if (DRW_TEST_ASSIGN_VBO(vbo_uv)) {
2380     GPU_vertbuf_init_with_format(vbo_uv, &format.uv);
2381     GPU_vertbuf_data_alloc(vbo_uv, tot_loop_len);
2382     GPU_vertbuf_attr_get_raw_data(vbo_uv, attr_id.uvs, &raw_uv);
2383   }
2384   /* Select Idx */
2385   if (DRW_TEST_ASSIGN_VBO(vbo_verts)) {
2386     GPU_vertbuf_init_with_format(vbo_verts, &format.sel_id);
2387     GPU_vertbuf_data_alloc(vbo_verts, tot_loop_len);
2388     GPU_vertbuf_attr_get_raw_data(vbo_verts, attr_id.sel_id, &raw_verts);
2389   }
2390   if (DRW_TEST_ASSIGN_VBO(vbo_edges)) {
2391     GPU_vertbuf_init_with_format(vbo_edges, &format.sel_id);
2392     GPU_vertbuf_data_alloc(vbo_edges, tot_loop_len);
2393     GPU_vertbuf_attr_get_raw_data(vbo_edges, attr_id.sel_id, &raw_edges);
2394   }
2395   if (DRW_TEST_ASSIGN_VBO(vbo_faces)) {
2396     GPU_vertbuf_init_with_format(vbo_faces, &format.sel_id);
2397     GPU_vertbuf_data_alloc(vbo_faces, tot_loop_len);
2398     GPU_vertbuf_attr_get_raw_data(vbo_faces, attr_id.sel_id, &raw_faces);
2399   }
2400
2401   if (rdata->edit_bmesh && rdata->mapped.use == false) {
2402     BMesh *bm = rdata->edit_bmesh->bm;
2403     BMIter iter_efa, iter_loop, iter_vert;
2404     BMFace *efa;
2405     BMEdge *eed;
2406     BMVert *eve;
2407     BMLoop *loop;
2408     const int cd_loop_uv_offset = CustomData_get_offset(&bm->ldata, CD_MLOOPUV);
2409
2410     /* Face Loops */
2411     BM_ITER_MESH (efa, &iter_efa, bm, BM_FACES_OF_MESH) {
2412       int fidx = BM_elem_index_get(efa);
2413       if (vbo_data) {
2414         fflag = mesh_render_data_face_flag(rdata, efa, cd_loop_uv_offset);
2415       }
2416       BM_ITER_ELEM (loop, &iter_loop, efa, BM_LOOPS_OF_FACE) {
2417         if (vbo_pos_nor) {
2418           GPUPackedNormal *vnor = (GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_nor);
2419           *vnor = GPU_normal_convert_i10_v3(loop->v->no);
2420           copy_v3_v3(GPU_vertbuf_raw_step(&raw_pos), loop->v->co);
2421         }
2422         if (vbo_lnor) {
2423           const float *nor = (lnors) ? lnors[BM_elem_index_get(loop)] : efa->no;
2424           GPUPackedNormal *lnor = (GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_lnor);
2425           *lnor = GPU_normal_convert_i10_v3(nor);
2426         }
2427         if (vbo_data) {
2428           EdgeDrawAttr eattr = {.v_flag = fflag};
2429           mesh_render_data_edge_flag(rdata, loop->e, &eattr);
2430           mesh_render_data_vert_flag(rdata, loop->v, &eattr);
2431           mesh_render_data_loop_flag(rdata, loop, cd_loop_uv_offset, &eattr);
2432           memcpy(GPU_vertbuf_raw_step(&raw_data), &eattr, sizeof(EdgeDrawAttr));
2433         }
2434         if (vbo_uv) {
2435           MLoopUV *luv = BM_ELEM_CD_GET_VOID_P(loop, cd_loop_uv_offset);
2436           copy_v2_v2(GPU_vertbuf_raw_step(&raw_uv), luv->uv);
2437         }
2438         /* Select Idx */
2439         if (vbo_verts) {
2440           int vidx = BM_elem_index_get(loop->v);
2441           *((uint *)GPU_vertbuf_raw_step(&raw_verts)) = vidx;
2442         }
2443         if (vbo_edges) {
2444           int eidx = BM_elem_index_get(loop->e);
2445           *((uint *)GPU_vertbuf_raw_step(&raw_edges)) = eidx;
2446         }
2447         if (vbo_faces) {
2448           *((uint *)GPU_vertbuf_raw_step(&raw_faces)) = fidx;
2449         }
2450       }
2451     }
2452     /* Loose edges */
2453     for (int e = 0; e < ledge_len; e++) {
2454       eed = BM_edge_at_index(bm, rdata->loose_edges[e]);
2455       BM_ITER_ELEM (eve, &iter_vert, eed, BM_VERTS_OF_EDGE) {
2456         if (vbo_pos_nor) {
2457           GPUPackedNormal *vnor = (GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_nor);
2458           *vnor = GPU_normal_convert_i10_v3(eve->no);
2459           copy_v3_v3(GPU_vertbuf_raw_step(&raw_pos), eve->co);
2460         }
2461         if (vbo_data) {
2462           EdgeDrawAttr eattr = {0};
2463           mesh_render_data_edge_flag(rdata, eed, &eattr);
2464           mesh_render_data_vert_flag(rdata, eve, &eattr);
2465           memcpy(GPU_vertbuf_raw_step(&raw_data), &eattr, sizeof(EdgeDrawAttr));
2466         }
2467         if (vbo_lnor) {
2468           memset(GPU_vertbuf_raw_step(&raw_lnor), 0, sizeof(GPUPackedNormal));
2469         }
2470         /* Select Idx */
2471         if (vbo_verts) {
2472           int vidx = BM_elem_index_get(eve);
2473           *((uint *)GPU_vertbuf_raw_step(&raw_verts)) = vidx;
2474         }
2475         if (vbo_edges) {
2476           int eidx = BM_elem_index_get(eed);
2477           *((uint *)GPU_vertbuf_raw_step(&raw_edges)) = eidx;
2478         }
2479       }
2480     }
2481     /* Loose verts */
2482     for (int e = 0; e < lvert_len; e++) {
2483       eve = BM_vert_at_index(bm, rdata->loose_verts[e]);
2484       if (vbo_pos_nor) {
2485         GPUPackedNormal *vnor = (GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_nor);
2486         *vnor = GPU_normal_convert_i10_v3(eve->no);
2487         copy_v3_v3(GPU_vertbuf_raw_step(&raw_pos), eve->co);
2488       }
2489       if (vbo_lnor) {
2490         memset(GPU_vertbuf_raw_step(&raw_lnor), 0, sizeof(GPUPackedNormal));
2491       }
2492       if (vbo_data) {
2493         EdgeDrawAttr eattr = {0};
2494         mesh_render_data_vert_flag(rdata, eve, &eattr);
2495         memcpy(GPU_vertbuf_raw_step(&raw_data), &eattr, sizeof(EdgeDrawAttr));
2496       }
2497       /* Select Idx */
2498       if (vbo_verts) {
2499         int vidx = BM_elem_index_get(eve);
2500         *((uint *)GPU_vertbuf_raw_step(&raw_verts)) = vidx;
2501       }
2502     }
2503   }
2504   else if (rdata->mapped.use == true) {
2505     BMesh *bm = rdata->edit_bmesh->bm;
2506     const int cd_loop_uv_offset = CustomData_get_offset(&bm->ldata, CD_MLOOPUV);
2507
2508     const MPoly *mpoly = rdata->mapped.me_cage->mpoly;
2509     const MEdge *medge = rdata->mapped.me_cage->medge;
2510     const MVert *mvert = rdata->mapped.me_cage->mvert;
2511     const MLoop *mloop = rdata->mapped.me_cage->mloop;
2512
2513     const int *v_origindex = rdata->mapped.v_origindex;
2514     const int *e_origindex = rdata->mapped.e_origindex;
2515     const int *p_origindex = rdata->mapped.p_origindex;
2516
2517     /* Face Loops */
2518     for (int poly = 0; poly < poly_len; poly++, mpoly++) {
2519       const MLoop *l = &mloop[mpoly->loopstart];
2520       int fidx = p_origindex[poly];
2521       BMFace *efa = NULL;
2522       if (vbo_data) {
2523         fflag = 0;
2524         if (fidx != ORIGINDEX_NONE) {
2525           efa = BM_face_at_index(bm, fidx);
2526           fflag = mesh_render_data_face_flag(rdata, efa, cd_loop_uv_offset);
2527         }
2528       }
2529       for (int i = 0; i < mpoly->totloop; i++, l++) {
2530         if (vbo_pos_nor) {
2531           copy_v3_v3(GPU_vertbuf_raw_step(&raw_pos), mvert[l->v].co);
2532         }
2533         if (vbo_lnor || vbo_pos_nor) {
2534           GPUPackedNormal vnor = GPU_normal_convert_i10_s3(mvert[l->v].no);
2535           if (vbo_pos_nor) {
2536             *(GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_nor) = vnor;
2537           }
2538           if (vbo_lnor) {
2539             /* Mapped does not support lnors yet. */
2540             *(GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_lnor) = vnor;
2541           }
2542         }
2543         if (vbo_data) {
2544           EdgeDrawAttr eattr = {.v_flag = fflag};
2545           int vidx = v_origindex[l->v];
2546           int eidx = e_origindex[l->e];
2547           if (vidx != ORIGINDEX_NONE) {
2548             BMVert *eve = BM_vert_at_index(bm, vidx);
2549             mesh_render_data_vert_flag(rdata, eve, &eattr);
2550           }
2551           if (eidx != ORIGINDEX_NONE) {
2552             BMEdge *eed = BM_edge_at_index(bm, eidx);
2553             mesh_render_data_edge_flag(rdata, eed, &eattr);
2554             if (efa) {
2555               BMLoop *loop = BM_face_edge_share_loop(efa, eed);
2556               if (loop) {
2557                 mesh_render_data_loop_flag(rdata, loop, cd_loop_uv_offset, &eattr);
2558               }
2559             }
2560           }
2561           memcpy(GPU_vertbuf_raw_step(&raw_data), &eattr, sizeof(EdgeDrawAttr));
2562         }
2563         if (vbo_uv) {
2564           MLoopUV *luv = &rdata->mloopuv[mpoly->loopstart + i];
2565           copy_v2_v2(GPU_vertbuf_raw_step(&raw_uv), luv->uv);
2566         }
2567         /* Select Idx */
2568         if (vbo_verts) {
2569           int vidx = v_origindex[l->v];
2570           *((uint *)GPU_vertbuf_raw_step(&raw_verts)) = vidx;
2571         }
2572         if (vbo_edges) {
2573           int eidx = e_origindex[l->e];
2574           *((uint *)GPU_vertbuf_raw_step(&raw_edges)) = eidx;
2575         }
2576         if (vbo_faces) {
2577           *((uint *)GPU_vertbuf_raw_step(&raw_faces)) = fidx;
2578         }
2579       }
2580     }
2581     /* Loose edges */
2582     for (int j = 0; j < ledge_len; j++) {
2583       const int e = rdata->mapped.loose_edges[j];
2584       for (int i = 0; i < 2; ++i) {
2585         int v = (i == 0) ? medge[e].v1 : medge[e].v2;
2586         if (vbo_pos_nor) {
2587           GPUPackedNormal vnor = GPU_normal_convert_i10_s3(mvert[v].no);
2588           *(GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_nor) = vnor;
2589           copy_v3_v3(GPU_vertbuf_raw_step(&raw_pos), mvert[v].co);
2590         }
2591         if (vbo_lnor) {
2592           memset(GPU_vertbuf_raw_step(&raw_lnor), 0, sizeof(GPUPackedNormal));
2593         }
2594         if (vbo_data) {
2595           EdgeDrawAttr eattr = {0};
2596           int vidx = v_origindex[v];
2597           int eidx = e_origindex[e];
2598           if (vidx != ORIGINDEX_NONE) {
2599             BMVert *eve = BM_vert_at_index(bm, vidx);
2600             mesh_render_data_vert_flag(rdata, eve, &eattr);
2601           }
2602           if (eidx != ORIGINDEX_NONE) {
2603             BMEdge *eed = BM_edge_at_index(bm, eidx);
2604             mesh_render_data_edge_flag(rdata, eed, &eattr);
2605           }
2606           memcpy(GPU_vertbuf_raw_step(&raw_data), &eattr, sizeof(EdgeDrawAttr));
2607         }
2608         /* Select Idx */
2609         if (vbo_verts) {
2610           int vidx = v_origindex[v];
2611           *((uint *)GPU_vertbuf_raw_step(&raw_verts)) = vidx;
2612         }
2613         if (vbo_edges) {
2614           int eidx = e_origindex[e];
2615           *((uint *)GPU_vertbuf_raw_step(&raw_edges)) = eidx;
2616         }
2617       }
2618     }
2619     /* Loose verts */
2620     for (int i = 0; i < lvert_len; i++) {
2621       const int v = rdata->mapped.loose_verts[i];
2622       if (vbo_pos_nor) {
2623         GPUPackedNormal vnor = GPU_normal_convert_i10_s3(mvert[v].no);
2624         *(GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_nor) = vnor;
2625         copy_v3_v3(GPU_vertbuf_raw_step(&raw_pos), mvert[v].co);
2626       }
2627       if (vbo_lnor) {
2628         memset(GPU_vertbuf_raw_step(&raw_lnor), 0, sizeof(GPUPackedNormal));
2629       }
2630       if (vbo_data) {
2631         EdgeDrawAttr eattr = {0};
2632         int vidx = v_origindex[v];
2633         if (vidx != ORIGINDEX_NONE) {
2634           BMVert *eve = BM_vert_at_index(bm, vidx);
2635           mesh_render_data_vert_flag(rdata, eve, &eattr);
2636         }
2637         memcpy(GPU_vertbuf_raw_step(&raw_data), &eattr, sizeof(EdgeDrawAttr));
2638       }
2639       /* Select Idx */
2640       if (vbo_verts) {
2641         int vidx = v_origindex[v];
2642         *((uint *)GPU_vertbuf_raw_step(&raw_verts)) = vidx;
2643       }
2644     }
2645   }
2646   else {
2647     const MPoly *mpoly = rdata->mpoly;
2648     const MVert *mvert = rdata->mvert;
2649     const MLoop *mloop = rdata->mloop;
2650
2651     const int *v_origindex = CustomData_get_layer(&rdata->me->vdata, CD_ORIGINDEX);
2652     const int *e_origindex = CustomData_get_layer(&rdata->me->edata, CD_ORIGINDEX);
2653     const int *p_origindex = CustomData_get_layer(&rdata->me->pdata, CD_ORIGINDEX);
2654
2655     /* Face Loops */
2656     for (int poly = 0; poly < poly_len; poly++, mpoly++) {
2657       const MLoop *l = &mloop[mpoly->loopstart];
2658       int fidx = p_origindex ? p_origindex[poly] : poly;
2659       for (int i = 0; i < mpoly->totloop; i++, l++) {
2660         if (vbo_pos_nor) {
2661           copy_v3_v3(GPU_vertbuf_raw_step(&raw_pos), mvert[l->v].co);
2662         }
2663         if (vbo_lnor || vbo_pos_nor) {
2664           GPUPackedNormal vnor = GPU_normal_convert_i10_s3(mvert[l->v].no);
2665           if (vbo_pos_nor) {
2666             *(GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_nor) = vnor;
2667           }
2668           if (vbo_lnor) {
2669             /* Mapped does not support lnors yet. */
2670             *(GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_lnor) = vnor;
2671           }
2672         }
2673         if (vbo_uv) {
2674           MLoopUV *luv = &rdata->mloopuv[mpoly->loopstart + i];
2675           copy_v2_v2(GPU_vertbuf_raw_step(&raw_uv), luv->uv);
2676         }
2677         /* Select Idx */
2678         if (vbo_verts) {
2679           int vidx = v_origindex ? v_origindex[l->v] : l->v;
2680           *((uint *)GPU_vertbuf_raw_step(&raw_verts)) = vidx;
2681         }
2682         if (vbo_edges) {
2683           int eidx = e_origindex ? e_origindex[l->e] : l->e;
2684           *((uint *)GPU_vertbuf_raw_step(&raw_edges)) = eidx;
2685         }
2686         if (vbo_faces) {
2687           *((uint *)GPU_vertbuf_raw_step(&raw_faces)) = fidx;
2688         }
2689       }
2690     }
2691     /* TODO(fclem): Until we find a way to detect
2692      * loose verts easily outside of edit mode, this
2693      * will remain disabled. */
2694 #if 0
2695     /* Loose edges */
2696     for (int e = 0; e < edge_len; e++, medge++) {
2697       int eidx = e_origindex[e];
2698       if (eidx != ORIGINDEX_NONE && (medge->flag & ME_LOOSEEDGE)) {
2699         for (int i = 0; i < 2; ++i) {
2700           int vidx = (i == 0) ? medge->v1 : medge->v2;
2701           if (vbo_pos) {
2702             copy_v3_v3(GPU_vertbuf_raw_step(&raw_pos), mvert[vidx].co);
2703           }
2704           if (vbo_verts) {
2705             *((uint *)GPU_vertbuf_raw_step(&raw_verts)) = vidx;
2706           }
2707           if (vbo_edges) {
2708             *((uint *)GPU_vertbuf_raw_step(&raw_edges)) = eidx;
2709           }
2710         }
2711       }
2712     }
2713     /* Loose verts */
2714     for (int v = 0; v < vert_len; v++, mvert++) {
2715       int vidx = v_origindex[v];
2716       if (vidx != ORIGINDEX_NONE) {
2717         MVert *eve = BM_vert_at_index(bm, vidx);
2718         if (eve->e == NULL) {
2719           if (vbo_pos) {
2720             copy_v3_v3(GPU_vertbuf_raw_step(&raw_pos), mvert->co);
2721           }
2722           if (vbo_verts) {
2723             *((uint *)GPU_vertbuf_raw_step(&raw_verts)) = vidx;
2724           }
2725         }
2726       }
2727     }
2728 #endif
2729   }
2730   /* Don't resize */
2731 }
2732
2733 /* TODO: We could use gl_PrimitiveID as index instead of using another VBO. */
2734 static void mesh_create_edit_facedots_select_id(MeshRenderData *rdata, GPUVertBuf *vbo)
2735 {
2736   const int poly_len = mesh_render_data_polys_len_get_maybe_mapped(rdata);
2737
2738   static GPUVertFormat format = {0};
2739   static struct {
2740     uint idx;
2741   } attr_id;
2742   if (format.attr_len == 0) {
2743     attr_id.idx = GPU_vertformat_attr_add(&format, "color", GPU_COMP_U32, 1, GPU_FETCH_INT);
2744   }
2745
2746   GPUVertBufRaw idx_step;
2747   GPU_vertbuf_init_with_format(vbo, &format);
2748   GPU_vertbuf_data_alloc(vbo, poly_len);
2749   GPU_vertbuf_attr_get_raw_data(vbo, attr_id.idx, &idx_step);
2750
2751   /* Keep in sync with mesh_create_edit_facedots(). */
2752   if (rdata->mapped.use == false) {
2753     if (rdata->edit_bmesh) {
2754       for (int poly = 0; poly < poly_len; poly++) {
2755         const BMFace *efa = BM_face_at_index(rdata->edit_bmesh->bm, poly);
2756         if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
2757           *((uint *)GPU_vertbuf_raw_step(&idx_step)) = poly;
2758         }
2759       }
2760     }
2761     else {
2762       for (int poly = 0; poly < poly_len; poly++) {
2763         *((uint *)GPU_vertbuf_raw_step(&idx_step)) = poly;
2764       }
2765     }
2766   }
2767   else {
2768     const int *p_origindex = rdata->mapped.p_origindex;
2769     for (int poly = 0; poly < poly_len; poly++) {
2770       const int p_orig = p_origindex[poly];
2771       if (p_orig != ORIGINDEX_NONE) {
2772         const BMFace *efa = BM_face_at_index(rdata->edit_bmesh->bm, p_orig);
2773         if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
2774           *((uint *)GPU_vertbuf_raw_step(&idx_step)) = poly;
2775         }
2776       }
2777     }
2778   }
2779
2780   /* Resize & Finish */
2781   int facedot_len_used = GPU_vertbuf_raw_used(&idx_step);
2782   if (facedot_len_used != poly_len) {
2783     GPU_vertbuf_data_resize(vbo, facedot_len_used);
2784   }
2785 }
2786
2787 static void mesh_create_pos_and_nor(MeshRenderData *rdata, GPUVertBuf *vbo)
2788 {
2789   static GPUVertFormat format = {0};
2790   static struct {
2791     uint pos, nor;
2792   } attr_id;
2793   if (format.attr_len == 0) {
2794     attr_id.pos = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
2795     attr_id.nor = GPU_vertformat_attr_add(
2796         &format, "nor", GPU_COMP_I10, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
2797   }
2798
2799   GPU_vertbuf_init_with_format(vbo, &format);
2800   const int vbo_len_capacity = mesh_render_data_verts_len_get_maybe_mapped(rdata);
2801   GPU_vertbuf_data_alloc(vbo, vbo_len_capacity);
2802
2803   if (rdata->mapped.use == false) {
2804     if (rdata->edit_bmesh) {
2805       BMesh *bm = rdata->edit_bmesh->bm;
2806       BMIter iter;
2807       BMVert *eve;
2808       uint i;
2809
2810       mesh_render_data_ensure_vert_normals_pack(rdata);
2811       GPUPackedNormal *vnor = rdata->vert_normals_pack;
2812
2813       BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) {
2814         GPU_vertbuf_attr_set(vbo, attr_id.pos, i, eve->co);
2815         GPU_vertbuf_attr_set(vbo, attr_id.nor, i, &vnor[i]);
2816       }
2817       BLI_assert(i == vbo_len_capacity);
2818     }
2819     else {
2820       for (int i = 0; i < vbo_len_capacity; i++) {
2821         const MVert *mv = &rdata->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, rdata->mvert[i].co);
2825         GPU_vertbuf_attr_set(vbo, attr_id.nor, i, &vnor_pack);
2826       }
2827     }
2828   }
2829   else {
2830     const MVert *mvert = rdata->mapped.me_cage->mvert;
2831     const int *v_origindex = rdata->mapped.v_origindex;
2832     for (int i = 0; i < vbo_len_capacity; i++) {
2833       const int v_orig = v_origindex[i];
2834       if (v_orig != ORIGINDEX_NONE) {
2835         const MVert *mv = &mvert[i];
2836         GPUPackedNormal vnor_pack = GPU_normal_convert_i10_s3(mv->no);
2837         vnor_pack.w = (mv->flag & ME_HIDE) ? -1 : ((mv->flag & SELECT) ? 1 : 0);
2838         GPU_vertbuf_attr_set(vbo, attr_id.pos, i, mv->co);
2839         GPU_vertbuf_attr_set(vbo, attr_id.nor, i, &vnor_pack);
2840       }
2841     }
2842   }
2843 }
2844
2845 static void mesh_create_weights(MeshRenderData *rdata,
2846                                 GPUVertBuf *vbo,
2847                                 DRW_MeshWeightState *wstate)
2848 {
2849   static GPUVertFormat format = {0};
2850   static struct {
2851     uint weight;
2852   } attr_id;
2853   if (format.attr_len == 0) {
2854     attr_id.weight = GPU_vertformat_attr_add(&format, "weight", GPU_COMP_F32, 1, GPU_FETCH_FLOAT);
2855   }
2856
2857   const int vbo_len_capacity = mesh_render_data_verts_len_get_maybe_mapped(rdata);
2858
2859   mesh_render_data_ensure_vert_weight(rdata, wstate);
2860   const float *vert_weight = rdata->vert_weight;
2861
2862   GPU_vertbuf_init_with_format(vbo, &format);
2863   /* Meh, another allocation / copy for no benefit.
2864    * Needed because rdata->vert_weight is freed afterwards and
2865    * GPU module don't have a GPU_vertbuf_data_from_memory or similar. */
2866   /* TODO get rid of the extra allocation/copy. */
2867   GPU_vertbuf_data_alloc(vbo, vbo_len_capacity);
2868   GPU_vertbuf_attr_fill(vbo, attr_id.weight, vert_weight);
2869 }
2870
2871 static float mesh_loop_edge_factor_get(const float f_no[3],
2872                                        const float v_co[3],
2873                                        const float v_no[3],
2874                                        const float v_next_co[3])
2875 {
2876   float enor[3], evec[3];
2877   sub_v3_v3v3(evec, v_next_co, v_co);
2878   cross_v3_v3v3(enor, v_no, evec);
2879   normalize_v3(enor);
2880   float d = fabsf(dot_v3v3(enor, f_no));
2881   /* Rescale to the slider range. */
2882   d *= (1.0f / 0.065f);
2883   CLAMP(d, 0.0f, 1.0f);
2884   return d;
2885 }
2886
2887 static void vertbuf_raw_step_u8(GPUVertBufRaw *wd_step, const uchar wiredata)
2888 {
2889   *((uchar *)GPU_vertbuf_raw_step(wd_step)) = wiredata;
2890 }
2891
2892 static void vertbuf_raw_step_u8_to_f32(GPUVertBufRaw *wd_step, const uchar wiredata)
2893 {
2894   *((float *)GPU_vertbuf_raw_step(wd_step)) = wiredata / 255.0f;
2895 }
2896
2897 static void mesh_create_loop_edge_fac(MeshRenderData *rdata, GPUVertBuf *vbo)
2898 {
2899   static GPUVertFormat format = {0};
2900   static struct {
2901     uint wd;
2902   } attr_id;
2903   static union {
2904     float f;
2905     uchar u;
2906   } data;
2907   static void (*vertbuf_raw_step)(GPUVertBufRaw *, const uchar);
2908   if (format.attr_len == 0) {
2909     if (!GPU_crappy_amd_driver()) {
2910       /* Some AMD drivers strangely crash with a vbo with this format. */
2911       attr_id.wd = GPU_vertformat_attr_add(
2912           &format, "wd", GPU_COMP_U8, 1, GPU_FETCH_INT_TO_FLOAT_UNIT);
2913       vertbuf_raw_step = vertbuf_raw_step_u8;
2914       data.u = UCHAR_MAX;
2915     }
2916     else {
2917       attr_id.wd = GPU_vertformat_attr_add(&format, "wd", GPU_COMP_F32, 1, GPU_FETCH_FLOAT);
2918       vertbuf_raw_step = vertbuf_raw_step_u8_to_f32;
2919       data.f = 1.0f;
2920     }
2921   }
2922   const int poly_len = mesh_render_data_polys_len_get(rdata);
2923   const int loop_len = mesh_render_data_loops_len_get(rdata);
2924   const int edge_len = mesh_render_data_edges_len_get(rdata);
2925
2926   GPU_vertbuf_init_with_format(vbo, &format);
2927   GPU_vertbuf_data_alloc(vbo, loop_len);
2928
2929   GPUVertBufRaw wd_step;
2930   GPU_vertbuf_attr_get_raw_data(vbo, attr_id.wd, &wd_step);
2931
2932   if (rdata->mapped.use == false) {
2933     if (rdata->edit_bmesh) {
2934       BMesh *bm = rdata->edit_bmesh->bm;
2935       BMIter iter_efa, iter_loop;
2936       BMFace *efa;
2937       BMLoop *loop;
2938       uint f;
2939
2940       BM_ITER_MESH_INDEX (efa, &iter_efa, bm, BM_FACES_OF_MESH, f) {
2941         BM_ITER_ELEM (loop, &iter_loop, efa, BM_LOOPS_OF_FACE) {
2942           float ratio = mesh_loop_edge_factor_get(
2943               efa->no, loop->v->co, loop->v->no, loop->next->v->co);
2944           vertbuf_raw_step(&wd_step, ratio * 255);
2945         }
2946       }
2947       BLI_assert(GPU_vertbuf_raw_used(&wd_step) == loop_len);
2948     }
2949     else {
2950       const MVert *mvert = rdata->mvert;
2951       const MPoly *mpoly = rdata->mpoly;
2952       const MLoop *mloop = rdata->mloop;
2953       MEdge *medge = (MEdge *)rdata->medge;
2954       bool use_edge_render = false;
2955
2956       /* TODO(fclem) We don't need them to be packed. But we need rdata->poly_normals */
2957       mesh_render_data_ensure_poly_normals_pack(rdata);
2958
2959       /* Reset flag */
2960       for (int edge = 0; edge < edge_len; ++edge) {
2961         /* NOTE: not thread safe. */
2962         medge[edge].flag &= ~ME_EDGE_TMP_TAG;
2963
2964         /* HACK(fclem) Feels like a hack. Detecting the need for edge render. */
2965         if ((medge[edge].flag & ME_EDGERENDER) == 0) {
2966           use_edge_render = true;
2967         }
2968       }
2969
2970       for (int a = 0; a < poly_len; a++, mpoly++) {
2971         const float *fnor = rdata->poly_normals[a];
2972         for (int b = 0; b < mpoly->totloop; b++) {
2973           const MLoop *ml1 = &mloop[mpoly->loopstart + b];
2974           const MLoop *ml2 = &mloop[mpoly->loopstart + (b + 1) % mpoly->totloop];
2975
2976           /* Will only work for edges that have an odd number of faces connected. */
2977           MEdge *ed = (MEdge *)rdata->medge + ml1->e;
2978           ed->flag ^= ME_EDGE_TMP_TAG;
2979
2980           if (use_edge_render) {
2981             vertbuf_raw_step(&wd_step, (ed->flag & ME_EDGERENDER) ? 255 : 0);
2982           }
2983           else {
2984             float vnor_f[3];
2985             normal_short_to_float_v3(vnor_f, mvert[ml1->v].no);
2986             float ratio = mesh_loop_edge_factor_get(
2987                 fnor, mvert[ml1->v].co, vnor_f, mvert[ml2->v].co);
2988             vertbuf_raw_step(&wd_step, ratio * 253 + 1);
2989           }
2990         }
2991       }
2992       /* Gather non-manifold edges. */
2993       for (int l = 0; l < loop_len; l++, mloop++) {
2994         MEdge *ed = (MEdge *)rdata->medge + mloop->e;
2995         if (ed->flag & ME_EDGE_TMP_TAG) {
2996           GPU_vertbuf_attr_set(vbo, attr_id.wd, l, &data);
2997         }
2998       }
2999
3000       BLI_assert(loop_len == GPU_vertbuf_raw_used(&wd_step));
3001     }
3002   }
3003   else {
3004     BLI_assert(0);
3005   }
3006 }
3007
3008 static void mesh_create_loop_pos_and_nor(MeshRenderData *rdata, GPUVertBuf *vbo)
3009 {
3010   /* TODO deduplicate format creation*/
3011   static GPUVertFormat format = {0};
3012   static struct {
3013     uint pos, nor;
3014   } attr_id;
3015   if (format.attr_len == 0) {
3016     attr_id.pos = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
3017     attr_id.nor = GPU_vertformat_attr_add(
3018         &format, "nor", GPU_COMP_I10, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
3019   }
3020   const int poly_len = mesh_render_data_polys_len_get(rdata);
3021   const int loop_len = mesh_render_data_loops_len_get(rdata);
3022
3023   GPU_vertbuf_init_with_format(vbo, &format);
3024   GPU_vertbuf_data_alloc(vbo, loop_len);
3025
3026   GPUVertBufRaw pos_step, nor_step;
3027   GPU_vertbuf_attr_get_raw_data(vbo, attr_id.pos, &pos_step);
3028   GPU_vertbuf_attr_get_raw_data(vbo, attr_id.nor, &nor_step);
3029
3030   if (rdata->mapped.use == false) {
3031     if (rdata->edit_bmesh) {
3032       const GPUPackedNormal *vnor, *pnor;
3033       const float(*lnors)[3] = rdata->loop_normals;
3034       BMesh *bm = rdata->edit_bmesh->bm;
3035       BMIter iter_efa, iter_loop;
3036       BMFace *efa;
3037       BMLoop *loop;
3038       uint f;
3039
3040       if (rdata->loop_normals == NULL) {
3041         mesh_render_data_ensure_poly_normals_pack(rdata);
3042         mesh_render_data_ensure_vert_normals_pack(rdata);
3043         vnor = rdata->vert_normals_pack;
3044         pnor = rdata->poly_normals_pack;
3045       }
3046
3047       BM_ITER_MESH_INDEX (efa, &iter_efa, bm, BM_FACES_OF_MESH, f) {
3048         const bool face_smooth = BM_elem_flag_test(efa, BM_ELEM_SMOOTH);
3049
3050         BM_ITER_ELEM (loop, &iter_loop, efa, BM_LOOPS_OF_FACE) {
3051           BLI_assert(GPU_vertbuf_raw_used(&pos_step) == BM_elem_index_get(loop));
3052           copy_v3_v3(GPU_vertbuf_raw_step(&pos_step), loop->v->co);
3053
3054           if (lnors) {
3055             GPUPackedNormal plnor = GPU_normal_convert_i10_v3(lnors[BM_elem_index_get(loop)]);
3056             *((GPUPackedNormal *)GPU_vertbuf_raw_step(&nor_step)) = plnor;
3057           }
3058           else if (!face_smooth) {
3059             *((GPUPackedNormal *)GPU_vertbuf_raw_step(&nor_step)) = pnor[f];
3060           }
3061           else {
3062             *((GPUPackedNormal *)GPU_vertbuf_raw_step(
3063                 &nor_step)) = vnor[BM_elem_index_get(loop->v)];
3064           }
3065         }
3066       }
3067       BLI_assert(GPU_vertbuf_raw_used(&pos_step) == loop_len);
3068     }
3069     else {
3070       const MVert *mvert = rdata->mvert;
3071       const MPoly *mpoly = rdata->mpoly;
3072
3073       if (rdata->loop_normals == NULL) {
3074         mesh_render_data_ensure_poly_normals_pack(rdata);
3075       }
3076
3077       for (int a = 0; a < poly_len; a++, mpoly++) {
3078         const MLoop *mloop = rdata->mloop + mpoly->loopstart;
3079         const float(*lnors)[3] = (rdata->loop_normals) ? &rdata->loop_normals[mpoly->loopstart] :
3080                                                          NULL;
3081         const GPUPackedNormal *fnor = (mpoly->flag & ME_SMOOTH) ? NULL :
3082                                                                   &rdata->poly_normals_pack[a];
3083         const int hide_select_flag = (mpoly->flag & ME_HIDE) ?
3084                                          -1 :
3085                                          ((mpoly->flag & ME_FACE_SEL) ? 1 : 0);
3086         for (int b = 0; b < mpoly->totloop; b++, mloop++) {
3087           copy_v3_v3(GPU_vertbuf_raw_step(&pos_step), mvert[mloop->v].co);
3088           GPUPackedNormal *pnor = (GPUPackedNormal *)GPU_vertbuf_raw_step(&nor_step);
3089           if (lnors) {
3090             *pnor = GPU_normal_convert_i10_v3(lnors[b]);
3091           }
3092           else if (fnor) {
3093             *pnor = *fnor;
3094           }
3095           else {
3096             *pnor = GPU_normal_convert_i10_s3(mvert[mloop->v].no);
3097           }
3098           pnor->w = hide_select_flag;
3099         }
3100       }
3101
3102       BLI_assert(loop_len == GPU_vertbuf_raw_used(&pos_step));
3103     }
3104   }
3105   else {
3106     const int *p_origindex = rdata->mapped.p_origindex;
3107     const MVert *mvert = rdata->mvert;
3108     const MPoly *mpoly = rdata->mpoly;
3109
3110     if (rdata->loop_normals == NULL) {
3111       mesh_render_data_ensure_poly_normals_pack(rdata);
3112     }
3113
3114     for (int a = 0; a < poly_len; a++, mpoly++) {
3115       const MLoop *mloop = rdata->mloop + mpoly->loopstart;
3116       const float(*lnors)[3] = (rdata->loop_normals) ? &rdata->loop_normals[mpoly->loopstart] :
3117                                                        NULL;
3118       const GPUPackedNormal *fnor = (mpoly->flag & ME_SMOOTH) ? NULL :
3119                                                                 &rdata->poly_normals_pack[a];
3120       if (p_origindex[a] == ORIGINDEX_NONE) {
3121         continue;
3122       }
3123       for (int b = 0; b < mpoly->totloop; b++, mloop++) {
3124         copy_v3_v3(GPU_vertbuf_raw_step(&pos_step), mvert[mloop->v].co);
3125         GPUPackedNormal *pnor = (GPUPackedNormal *)GPU_vertbuf_raw_step(&nor_step);
3126         if (lnors) {
3127           *pnor = GPU_normal_convert_i10_v3(lnors[b]);
3128         }
3129         else if (fnor) {
3130           *pnor = *fnor;
3131         }
3132         else {
3133           *pnor = GPU_normal_convert_i10_s3(mvert[mloop->v].no);
3134         }
3135       }
3136     }
3137   }
3138
3139   int vbo_len_used = GPU_vertbuf_raw_used(&pos_step);
3140   if (vbo_len_used < loop_len) {
3141     GPU_vertbuf_data_resize(vbo, vbo_len_used);
3142   }
3143 }
3144
3145 static void mesh_create_loop_orco(MeshRenderData *rdata, GPUVertBuf *vbo)
3146 {
3147   const uint loops_len = mesh_render_data_loops_len_get(rdata);
3148
3149   /* initialize vertex format */
3150   GPUVertFormat format = {0};
3151   GPUVertBufRaw vbo_step;
3152
3153   /* FIXME(fclem): We use the last component as a way to differentiate from generic vertex attribs.
3154    * This is a substential waste of Vram and should be done another way. Unfortunately,
3155    * at the time of writting, I did not found any other "non disruptive" alternative. */
3156   uint attr_id = GPU_vertformat_attr_add(&format, "orco", GPU_COMP_F32, 4, GPU_FETCH_FLOAT);
3157
3158   GPU_vertbuf_init_with_format(vbo, &format);
3159   GPU_vertbuf_data_alloc(vbo, loops_len);
3160   GPU_vertbuf_attr_get_raw_data(vbo, attr_id, &vbo_step);
3161
3162   if (rdata->edit_bmesh) {
3163     BMesh *bm = rdata->edit_bmesh->bm;
3164     BMIter iter_efa, iter_loop;
3165     BMFace *efa;
3166     BMLoop *loop;
3167
3168     BM_ITER_MESH (efa, &iter_efa, bm, BM_FACES_OF_MESH) {
3169       BM_ITER_ELEM (loop, &iter_loop, efa, BM_LOOPS_OF_FACE) {
3170         float *data = (float *)GPU_vertbuf_raw_step(&vbo_step);
3171         copy_v3_v3(data, rdata->orco[BM_elem_index_get(loop->v)]);
3172         data[3] = 0.0; /* Tag as not a generic attrib */
3173       }
3174     }
3175   }
3176   else {
3177     for (uint l = 0; l < loops_len; l++) {
3178       float *data = (float *)GPU_vertbuf_raw_step(&vbo_step);
3179       copy_v3_v3(data, rdata->orco[rdata->mloop[l].v]);
3180       data[3] = 0.0; /* Tag as not a generic attrib */
3181     }
3182   }
3183 }
3184
3185 static void mesh_create_loop_uv_and_tan(MeshRenderData *rdata, GPUVertBuf *vbo)
3186 {
3187   const uint loops_len = mesh_render_data_loops_len_get(rdata);
3188   const uint uv_len = rdata->cd.layers.uv_len;
3189   const uint tangent_len = rdata->cd.layers.tangent_len;
3190   const uint layers_combined_len = uv_len + tangent_len;
3191
3192   GPUVertBufRaw *layers_combined_step = BLI_array_alloca(layers_combined_step,
3193                                                          layers_combined_len);
3194   GPUVertBufRaw *uv_step = layers_combined_step;
3195   GPUVertBufRaw *tangent_step = uv_step + uv_len;
3196
3197   uint *layers_combined_id = BLI_array_alloca(layers_combined_id, layers_combined_len);
3198   uint *uv_id = layers_combined_id;
3199   uint *tangent_id = uv_id + uv_len;
3200
3201   /* initialize vertex format */
3202   GPUVertFormat format = {0};
3203
3204   for (uint i = 0; i < uv_len; i++) {
3205     const char *attr_name = mesh_render_data_uv_layer_uuid_get(rdata, i);
3206 #if 0 /* these are clamped. Maybe use them as an option in the future */
3207     uv_id[i] = GPU_vertformat_attr_add(
3208         &format, attr_name, GPU_COMP_I16, 2, GPU_FETCH_INT_TO_FLOAT_UNIT);
3209 #else
3210     uv_id[i] = GPU_vertformat_attr_add(&format, attr_name, GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
3211 #endif
3212     /* Auto Name */
3213     attr_name = mesh_render_data_uv_auto_layer_uuid_get(rdata, i);
3214     GPU_vertformat_alias_add(&format, attr_name);
3215
3216     if (i == rdata->cd.layers.uv_active) {
3217       GPU_vertformat_alias_add(&format, "u");
3218     }
3219     if (i == rdata->cd.layers.uv_mask_active) {
3220       GPU_vertformat_alias_add(&format, "mu");
3221     }
3222   }
3223
3224   for (uint i = 0; i < tangent_len; i++) {
3225     const char *attr_name = mesh_render_data_tangent_layer_uuid_get(rdata, i);
3226 #ifdef USE_COMP_MESH_DATA
3227     tangent_id[i] = GPU_vertformat_attr_add(
3228         &format, attr_name, GPU_COMP_I16, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
3229 #else
3230     tangent_id[i] = GPU_vertformat_attr_add(&format, attr_name, GPU_COMP_F32, 4, GPU_FETCH_FLOAT);
3231 #endif
3232     if (i == rdata->cd.layers.tangent_active) {
3233       GPU_vertformat_alias_add(&format, "t");
3234     }
3235   }
3236
3237   /* HACK: Create a dummy attribute in case there is no valid UV/tangent layer. */
3238   if (layers_combined_len == 0) {
3239     GPU_vertformat_attr_add(&format, "dummy", GPU_COMP_U8, 1, GPU_FETCH_INT_TO_FLOAT_UNIT);
3240   }
3241
3242   GPU_vertbuf_init_with_format(vbo, &format);
3243   GPU_vertbuf_data_alloc(vbo, loops_len);
3244
3245   for (uint i = 0; i < uv_len; i++) {
3246     GPU_vertbuf_attr_get_raw_data(vbo, uv_id[i], &uv_step[i]);
3247   }
3248   for (uint i = 0; i < tangent_len; i++) {
3249     GPU_vertbuf_attr_get_raw_data(vbo, tangent_id[i], &tangent_step[i]);
3250   }
3251
3252   if (rdata->edit_bmesh) {
3253     BMesh *bm = rdata->edit_bmesh->bm;
3254     BMIter iter_efa, iter_loop;
3255     BMFace *efa;
3256     BMLoop *loop;
3257
3258     BM_ITER_MESH (efa, &iter_efa, bm, BM_FACES_OF_MESH) {
3259       BM_ITER_ELEM (loop, &iter_loop, efa, BM_LOOPS_OF_FACE) {
3260         /* UVs */
3261         for (uint j = 0; j < uv_len; j++) {
3262           const uint layer_offset = rdata->cd.offset.uv[j];
3263           const float *elem = ((MLoopUV *)BM_ELEM_CD_GET_VOID_P(loop, layer_offset))->uv;
3264           copy_v2_v2(GPU_vertbuf_raw_step(&uv_step[j]), elem);
3265         }
3266         /* TANGENTs */
3267         for (uint j = 0; j < tangent_len; j++) {
3268           float(*layer_data)[4] = rdata->cd.layers.tangent[j];
3269           const float *elem = layer_data[BM_elem_index_get(loop)];
3270 #ifdef USE_COMP_MESH_DATA
3271           normal_float_to_short_v4(GPU_vertbuf_raw_step(&tangent_step[j]), elem);
3272 #else
3273           copy_v4_v4(GPU_vertbuf_raw_step(&tangent_step[j]), elem);
3274 #endif
3275         }
3276       }
3277     }
3278   }
3279   else {
3280     for (uint loop = 0; loop < loops_len; loop++) {
3281       /* UVs */
3282       for (uint j = 0; j < uv_len; j++) {
3283         const MLoopUV *layer_data = rdata->cd.layers.uv[j];
3284         const float *elem = layer_data[loop].uv;
3285         copy_v2_v2(GPU_vertbuf_raw_step(&uv_step[j]), elem);
3286       }
3287       /* TANGENTs */
3288       for (uint j = 0; j < tangent_len; j++) {
3289         float(*layer_data)[4] = rdata->cd.layers.tangent[j];
3290         const float *elem = layer_data[loop];
3291 #ifdef USE_COMP_MESH_DATA
3292         normal_float_to_short_v4(GPU_vertbuf_raw_step(&tangent_step[j]), elem);
3293 #else
3294         copy_v4_v4(GPU_vertbuf_raw_step(&tangent_step[j]), elem);
3295 #endif
3296       }
3297     }
3298   }
3299
3300 #ifndef NDEBUG
3301   /* Check all layers are write aligned. */
3302   if (layers_combined_len > 0) {
3303     int vbo_len_used = GPU_vertbuf_raw_used(&layers_combined_step[0]);
3304     for (uint i = 0; i < layers_combined_len; i++) {
3305       BLI_assert(vbo_len_used == GPU_vertbuf_raw_used(&layers_combined_step[i]));
3306     }
3307   }
3308 #endif
3309
3310 #undef USE_COMP_MESH_DATA
3311 }
3312
3313 static void mesh_create_loop_vcol(MeshRenderData *rdata, GPUVertBuf *vbo)
3314 {
3315   const uint loops_len = mesh_render_data_loops_len_get(rdata);
3316   const uint vcol_len = rdata->cd.layers.vcol_len;
3317
3318   GPUVertBufRaw *vcol_step = BLI_array_alloca(vcol_step, vcol_len);
3319   uint *vcol_id = BLI_array_alloca(vcol_id, vcol_len);
3320
3321   /* initialize vertex format */
3322   GPUVertFormat format = {0};
3323
3324   for (uint i = 0; i < vcol_len; i++) {
3325     const char *attr_name = mesh_render_data_vcol_layer_uuid_get(rdata, i);
3326     vcol_id[i] = GPU_vertformat_attr_add(
3327         &format, attr_name, GPU_COMP_U8, 3, GPU_FETCH_INT_TO_FLOAT_UNIT);
3328     /* Auto layer */
3329     if (rdata->cd.layers.auto_vcol[i]) {
3330       attr_name = mesh_render_data_vcol_auto_layer_uuid_get(rdata, i);
3331       GPU_vertformat_alias_add(&format, attr_name);
3332     }
3333     if (i == rdata->cd.layers.vcol_active) {
3334       GPU_vertformat_alias_add(&format, "c");
3335     }
3336   }
3337
3338   GPU_vertbuf_init_with_format(vbo, &format);
3339   GPU_vertbuf_data_alloc(vbo, loops_len);
3340
3341   for (uint i = 0; i < vcol_len; i++) {
3342     GPU_vertbuf_attr_get_raw_data(vbo, vcol_id[i], &vcol_step[i]);
3343   }
3344
3345   if (rdata->edit_bmesh) {
3346     BMesh *bm = rdata->edit_bmesh->bm;
3347     BMIter iter_efa, iter_loop;
3348     BMFace *efa;
3349     BMLoop *loop;
3350
3351     BM_ITER_MESH (efa, &iter_efa, bm, BM_FACES_OF_MESH) {
3352       BM_ITER_ELEM (loop, &iter_loop, efa, BM_LOOPS_OF_FACE) {
3353         for (uint j = 0; j < vcol_len; j++) {
3354           const uint layer_offset = rdata->cd.offset.vcol[j];
3355           const uchar *elem = &((MLoopCol *)BM_ELEM_CD_GET_VOID_P(loop, layer_offset))->r;
3356           copy_v3_v3_uchar(GPU_vertbuf_raw_step(&vcol_step[j]), elem);
3357         }
3358       }
3359     }
3360   }
3361   else {
3362     for (uint loop = 0; loop < loops_len; loop++) {
3363       for (uint j = 0; j < vcol_len; j++) {
3364         const MLoopCol *layer_data = rdata->cd.layers.vcol[j];
3365         const uchar *elem = &layer_data[loop].r;
3366         copy_v3_v3_uchar(GPU_vertbuf_raw_step(&vcol_step[j]), elem);
3367       }
3368     }
3369   }
3370
3371 #ifndef NDEBUG
3372   /* Check all layers are write aligned. */
3373   if (vcol_len > 0) {
3374     int vbo_len_used = GPU_vertbuf_raw_used(&vcol_step[0]);
3375     for (uint i = 0; i < vcol_len; i++) {
3376       BLI_assert(vbo_len_used == GPU_vertbuf_raw_used(&vcol_step[i]));
3377     }
3378   }
3379 #endif
3380
3381 #undef USE_COMP_MESH_DATA
3382 }
3383
3384 static void mesh_create_edit_facedots(MeshRenderData *rdata, GPUVertBuf *vbo_facedots_pos_nor_data)
3385 {
3386   const int poly_len = mesh_render_data_polys_len_get_maybe_mapped(rdata);
3387   const int verts_facedot_len = poly_len;
3388   int facedot_len_used = 0;
3389
3390   static struct {
3391     uint fdot_pos, fdot_nor_flag;
3392   } attr_id;
3393   static GPUVertFormat facedot_format = {0};
3394   if (facedot_format.attr_len == 0) {
3395     attr_id.fdot_pos = GPU_vertformat_attr_add(
3396         &facedot_format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
3397     attr_id.fdot_nor_flag = GPU_vertformat_attr_add(
3398         &facedot_format, "norAndFlag", GPU_COMP_I10, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
3399   }
3400
3401   if (DRW_TEST_ASSIGN_VBO(vbo_facedots_pos_nor_data)) {
3402     GPU_vertbuf_init_with_format(vbo_facedots_pos_nor_data, &facedot_format);
3403     GPU_vertbuf_data_alloc(vbo_facedots_pos_nor_data, verts_facedot_len);
3404     /* TODO(fclem): Maybe move data generation to mesh_render_data_create() */
3405     if (rdata->edit_bmesh) {
3406       if (rdata->edit_data && rdata->edit_data->vertexCos != NULL) {
3407         BKE_editmesh_cache_ensure_poly_normals(rdata->edit_bmesh, rdata->edit_data);
3408         BKE_editmesh_cache_ensure_poly_centers(rdata->edit_bmesh, rdata->edit_data);
3409       }
3410     }
3411   }
3412
3413   if (rdata->mapped.use == false) {
3414     for (int i = 0; i < poly_len; i++) {
3415       if (add_edit_facedot(rdata,
3416                            vbo_facedots_pos_nor_data,
3417                            attr_id.fdot_pos,
3418                            attr_id.fdot_nor_flag,
3419                            i,
3420                            facedot_len_used)) {
3421         facedot_len_used += 1;
3422       }
3423     }
3424   }
3425   else {
3426 #if 0 /* TODO(fclem): Mapped facedots are not following the original face. */
3427     Mesh *me_cage = rdata->mapped.me_cage;
3428     const MVert *mvert = me_cage->mvert;
3429     const MEdge *medge = me_cage->medge;
3430     const int *e_origindex = rdata->mapped.e_origindex;
3431     const int *v_origindex = rdata->mapped.v_origindex;
3432 #endif
3433     for (int i = 0; i < poly_len; i++) {
3434       if (add_edit_facedot_mapped(rdata,
3435                                   vbo_facedots_pos_nor_data,
3436                                   attr_id.fdot_pos,
3437                                   attr_id.fdot_nor_flag,
3438                                   i,
3439                                   facedot_len_used)) {
3440         facedot_len_used += 1;
3441       }
3442     }
3443   }
3444
3445   /* Resize & Finish */
3446   if (facedot_len_used != verts_facedot_len) {
3447     if (vbo_facedots_pos_nor_data != NULL) {
3448       GPU_vertbuf_data_resize(vbo_facedots_pos_nor_data, facedot_len_used);
3449     }
3450   }
3451 }
3452
3453 static void mesh_create_edit_mesh_analysis(MeshRenderData *rdata, GPUVertBuf *vbo_mesh_analysis)
3454 {
3455   const MeshStatVis *mesh_stat_vis = &rdata->toolsettings->statvis;
3456
3457   int mesh_analysis_len_used = 0;
3458
3459   const uint loops_len = mesh_render_data_loops_len_get(rdata);
3460   BMesh *bm = rdata->edit_bmesh->bm;
3461   BMIter iter_efa, iter_loop;
3462   BMFace *efa;
3463   BMLoop *loop;
3464
3465   static struct {
3466     uint weight;
3467   } attr_id;
3468   static GPUVertFormat mesh_analysis_format = {0};
3469   if (mesh_analysis_format.attr_len == 0) {
3470     attr_id.weight = GPU_vertformat_attr_add(
3471         &mesh_analysis_format, "weight_color", GPU_COMP_U8, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
3472   }
3473
3474   /* TODO(jbakker): Maybe move data generation to mesh_render_data_create() */
3475   BKE_editmesh_statvis_calc(rdata->edit_bmesh, rdata->edit_data, mesh_stat_vis);
3476
3477   if (DRW_TEST_ASSIGN_VBO(vbo_mesh_analysis)) {
3478     GPU_vertbuf_init_with_format(vbo_mesh_analysis, &mesh_analysis_format);
3479     GPU_vertbuf_data_alloc(vbo_mesh_analysis, loops_len);
3480   }
3481
3482   const bool is_vertex_data = mesh_stat_vis->type == SCE_STATVIS_SHARP;
3483   if (is_vertex_data) {
3484     BM_ITER_MESH (efa, &iter_efa, bm, BM_FACES_OF_MESH) {
3485       BM_ITER_ELEM (loop, &iter_loop, efa, BM_LOOPS_OF_FACE) {
3486         uint vertex_index = BM_elem_index_get(loop->v);
3487         GPU_vertbuf_attr_set(vbo_mesh_analysis,
3488