GPencil: Primitive: Polyline Tool
[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_bitmap.h"
29 #include "BLI_buffer.h"
30 #include "BLI_utildefines.h"
31 #include "BLI_math_vector.h"
32 #include "BLI_math_bits.h"
33 #include "BLI_string.h"
34 #include "BLI_alloca.h"
35 #include "BLI_edgehash.h"
36
37 #include "DNA_mesh_types.h"
38 #include "DNA_meshdata_types.h"
39 #include "DNA_object_types.h"
40 #include "DNA_scene_types.h"
41
42 #include "BKE_customdata.h"
43 #include "BKE_deform.h"
44 #include "BKE_editmesh.h"
45 #include "BKE_editmesh_cache.h"
46 #include "BKE_editmesh_tangent.h"
47 #include "BKE_mesh.h"
48 #include "BKE_mesh_tangent.h"
49 #include "BKE_mesh_runtime.h"
50 #include "BKE_modifier.h"
51 #include "BKE_object_deform.h"
52
53 #include "atomic_ops.h"
54
55 #include "bmesh.h"
56
57 #include "GPU_batch.h"
58 #include "GPU_material.h"
59
60 #include "DRW_render.h"
61
62 #include "ED_mesh.h"
63 #include "ED_uvedit.h"
64
65 #include "draw_cache_inline.h"
66 #include "draw_cache_extract.h"
67
68 #include "draw_cache_impl.h" /* own include */
69
70 static void mesh_batch_cache_clear(Mesh *me);
71
72 /* Return true is all layers in _b_ are inside _a_. */
73 BLI_INLINE bool mesh_cd_layers_type_overlap(DRW_MeshCDMask a, DRW_MeshCDMask b)
74 {
75   return (*((uint32_t *)&a) & *((uint32_t *)&b)) == *((uint32_t *)&b);
76 }
77
78 BLI_INLINE bool mesh_cd_layers_type_equal(DRW_MeshCDMask a, DRW_MeshCDMask b)
79 {
80   return *((uint32_t *)&a) == *((uint32_t *)&b);
81 }
82
83 BLI_INLINE void mesh_cd_layers_type_merge(DRW_MeshCDMask *a, DRW_MeshCDMask b)
84 {
85   atomic_fetch_and_or_uint32((uint32_t *)a, *(uint32_t *)&b);
86 }
87
88 BLI_INLINE void mesh_cd_layers_type_clear(DRW_MeshCDMask *a)
89 {
90   *((uint32_t *)a) = 0;
91 }
92
93 static void mesh_cd_calc_edit_uv_layer(const Mesh *UNUSED(me), DRW_MeshCDMask *cd_used)
94 {
95   cd_used->edit_uv = 1;
96 }
97
98 static void mesh_cd_calc_active_uv_layer(const Mesh *me, DRW_MeshCDMask *cd_used)
99 {
100   const Mesh *me_final = (me->edit_mesh) ? me->edit_mesh->mesh_eval_final : me;
101   const CustomData *cd_ldata = &me_final->ldata;
102
103   int layer = CustomData_get_active_layer(cd_ldata, CD_MLOOPUV);
104   if (layer != -1) {
105     cd_used->uv |= (1 << layer);
106   }
107 }
108
109 static void mesh_cd_calc_active_mask_uv_layer(const Mesh *me, DRW_MeshCDMask *cd_used)
110 {
111   const Mesh *me_final = (me->edit_mesh) ? me->edit_mesh->mesh_eval_final : me;
112   const CustomData *cd_ldata = &me_final->ldata;
113
114   int layer = CustomData_get_stencil_layer(cd_ldata, CD_MLOOPUV);
115   if (layer != -1) {
116     cd_used->uv |= (1 << layer);
117   }
118 }
119
120 static void mesh_cd_calc_active_vcol_layer(const Mesh *me, DRW_MeshCDMask *cd_used)
121 {
122   const Mesh *me_final = (me->edit_mesh) ? me->edit_mesh->mesh_eval_final : me;
123   const CustomData *cd_ldata = &me_final->ldata;
124
125   int layer = CustomData_get_active_layer(cd_ldata, CD_MLOOPCOL);
126   if (layer != -1) {
127     cd_used->vcol |= (1 << layer);
128   }
129 }
130
131 static DRW_MeshCDMask mesh_cd_calc_used_gpu_layers(const Mesh *me,
132                                                    struct GPUMaterial **gpumat_array,
133                                                    int gpumat_array_len)
134 {
135   const Mesh *me_final = (me->edit_mesh) ? me->edit_mesh->mesh_eval_final : me;
136   const CustomData *cd_ldata = &me_final->ldata;
137
138   /* See: DM_vertex_attributes_from_gpu for similar logic */
139   DRW_MeshCDMask cd_used;
140   mesh_cd_layers_type_clear(&cd_used);
141
142   for (int i = 0; i < gpumat_array_len; i++) {
143     GPUMaterial *gpumat = gpumat_array[i];
144     if (gpumat) {
145       GPUVertAttrLayers gpu_attrs;
146       GPU_material_vertex_attrs(gpumat, &gpu_attrs);
147       for (int j = 0; j < gpu_attrs.totlayer; j++) {
148         const char *name = gpu_attrs.layer[j].name;
149         int type = gpu_attrs.layer[j].type;
150         int layer = -1;
151
152         if (type == CD_AUTO_FROM_NAME) {
153           /* We need to deduct what exact layer is used.
154            *
155            * We do it based on the specified name.
156            */
157           if (name[0] != '\0') {
158             layer = CustomData_get_named_layer(cd_ldata, CD_MLOOPUV, name);
159             type = CD_MTFACE;
160
161             if (layer == -1) {
162               layer = CustomData_get_named_layer(cd_ldata, CD_MLOOPCOL, name);
163               type = CD_MCOL;
164             }
165 #if 0 /* Tangents are always from UV's - this will never happen. */
166             if (layer == -1) {
167               layer = CustomData_get_named_layer(cd_ldata, CD_TANGENT, name);
168               type = CD_TANGENT;
169             }
170 #endif
171             if (layer == -1) {
172               continue;
173             }
174           }
175           else {
176             /* Fall back to the UV layer, which matches old behavior. */
177             type = CD_MTFACE;
178           }
179         }
180
181         switch (type) {
182           case CD_MTFACE: {
183             if (layer == -1) {
184               layer = (name[0] != '\0') ? CustomData_get_named_layer(cd_ldata, CD_MLOOPUV, name) :
185                                           CustomData_get_render_layer(cd_ldata, CD_MLOOPUV);
186             }
187             if (layer != -1) {
188               cd_used.uv |= (1 << layer);
189             }
190             break;
191           }
192           case CD_TANGENT: {
193             if (layer == -1) {
194               layer = (name[0] != '\0') ? CustomData_get_named_layer(cd_ldata, CD_MLOOPUV, name) :
195                                           CustomData_get_render_layer(cd_ldata, CD_MLOOPUV);
196
197               /* Only fallback to orco (below) when we have no UV layers, see: T56545 */
198               if (layer == -1 && name[0] != '\0') {
199                 layer = CustomData_get_render_layer(cd_ldata, CD_MLOOPUV);
200               }
201             }
202             if (layer != -1) {
203               cd_used.tan |= (1 << layer);
204             }
205             else {
206               /* no UV layers at all => requesting orco */
207               cd_used.tan_orco = 1;
208               cd_used.orco = 1;
209             }
210             break;
211           }
212           case CD_MCOL: {
213             if (layer == -1) {
214               layer = (name[0] != '\0') ? CustomData_get_named_layer(cd_ldata, CD_MLOOPCOL, name) :
215                                           CustomData_get_render_layer(cd_ldata, CD_MLOOPCOL);
216             }
217             if (layer != -1) {
218               cd_used.vcol |= (1 << layer);
219             }
220             break;
221           }
222           case CD_ORCO: {
223             cd_used.orco = 1;
224             break;
225           }
226         }
227       }
228     }
229   }
230   return cd_used;
231 }
232
233 static void mesh_cd_extract_auto_layers_names_and_srgb(Mesh *me,
234                                                        DRW_MeshCDMask cd_used,
235                                                        char **r_auto_layers_names,
236                                                        int **r_auto_layers_srgb,
237                                                        int *r_auto_layers_len)
238 {
239   const Mesh *me_final = (me->edit_mesh) ? me->edit_mesh->mesh_eval_final : me;
240   const CustomData *cd_ldata = &me_final->ldata;
241
242   int uv_len_used = count_bits_i(cd_used.uv);
243   int vcol_len_used = count_bits_i(cd_used.vcol);
244   int uv_len = CustomData_number_of_layers(cd_ldata, CD_MLOOPUV);
245   int vcol_len = CustomData_number_of_layers(cd_ldata, CD_MLOOPCOL);
246
247   uint auto_names_len = 32 * (uv_len_used + vcol_len_used);
248   uint auto_ofs = 0;
249   /* Allocate max, resize later. */
250   char *auto_names = MEM_callocN(sizeof(char) * auto_names_len, __func__);
251   int *auto_is_srgb = MEM_callocN(sizeof(int) * (uv_len_used + vcol_len_used), __func__);
252
253   for (int i = 0; i < uv_len; i++) {
254     if ((cd_used.uv & (1 << i)) != 0) {
255       const char *name = CustomData_get_layer_name(cd_ldata, CD_MLOOPUV, i);
256       char safe_name[GPU_MAX_SAFE_ATTRIB_NAME];
257       GPU_vertformat_safe_attrib_name(name, safe_name, GPU_MAX_SAFE_ATTRIB_NAME);
258       auto_ofs += BLI_snprintf_rlen(
259           auto_names + auto_ofs, auto_names_len - auto_ofs, "ba%s", safe_name);
260       /* +1 to include '\0' terminator. */
261       auto_ofs += 1;
262     }
263   }
264
265   uint auto_is_srgb_ofs = uv_len_used;
266   for (int i = 0; i < vcol_len; i++) {
267     if ((cd_used.vcol & (1 << i)) != 0) {
268       const char *name = CustomData_get_layer_name(cd_ldata, CD_MLOOPCOL, i);
269       /* We only do vcols that are not overridden by a uv layer with same name. */
270       if (CustomData_get_named_layer_index(cd_ldata, CD_MLOOPUV, name) == -1) {
271         char safe_name[GPU_MAX_SAFE_ATTRIB_NAME];
272         GPU_vertformat_safe_attrib_name(name, safe_name, GPU_MAX_SAFE_ATTRIB_NAME);
273         auto_ofs += BLI_snprintf_rlen(
274             auto_names + auto_ofs, auto_names_len - auto_ofs, "ba%s", safe_name);
275         /* +1 to include '\0' terminator. */
276         auto_ofs += 1;
277         auto_is_srgb[auto_is_srgb_ofs] = true;
278         auto_is_srgb_ofs++;
279       }
280     }
281   }
282
283   auto_names = MEM_reallocN(auto_names, sizeof(char) * auto_ofs);
284   auto_is_srgb = MEM_reallocN(auto_is_srgb, sizeof(int) * auto_is_srgb_ofs);
285
286   /* WATCH: May have been referenced somewhere before freeing. */
287   MEM_SAFE_FREE(*r_auto_layers_names);
288   MEM_SAFE_FREE(*r_auto_layers_srgb);
289
290   *r_auto_layers_names = auto_names;
291   *r_auto_layers_srgb = auto_is_srgb;
292   *r_auto_layers_len = auto_is_srgb_ofs;
293 }
294
295 /** \} */
296
297 /* ---------------------------------------------------------------------- */
298 /** \name Vertex Group Selection
299  * \{ */
300
301 /** Reset the selection structure, deallocating heap memory as appropriate. */
302 static void drw_mesh_weight_state_clear(struct DRW_MeshWeightState *wstate)
303 {
304   MEM_SAFE_FREE(wstate->defgroup_sel);
305
306   memset(wstate, 0, sizeof(*wstate));
307
308   wstate->defgroup_active = -1;
309 }
310
311 /** Copy selection data from one structure to another, including heap memory. */
312 static void drw_mesh_weight_state_copy(struct DRW_MeshWeightState *wstate_dst,
313                                        const struct DRW_MeshWeightState *wstate_src)
314 {
315   MEM_SAFE_FREE(wstate_dst->defgroup_sel);
316
317   memcpy(wstate_dst, wstate_src, sizeof(*wstate_dst));
318
319   if (wstate_src->defgroup_sel) {
320     wstate_dst->defgroup_sel = MEM_dupallocN(wstate_src->defgroup_sel);
321   }
322 }
323
324 /** Compare two selection structures. */
325 static bool drw_mesh_weight_state_compare(const struct DRW_MeshWeightState *a,
326                                           const struct DRW_MeshWeightState *b)
327 {
328   return a->defgroup_active == b->defgroup_active && a->defgroup_len == b->defgroup_len &&
329          a->flags == b->flags && a->alert_mode == b->alert_mode &&
330          a->defgroup_sel_count == b->defgroup_sel_count &&
331          ((!a->defgroup_sel && !b->defgroup_sel) ||
332           (a->defgroup_sel && b->defgroup_sel &&
333            memcmp(a->defgroup_sel, b->defgroup_sel, a->defgroup_len * sizeof(bool)) == 0));
334 }
335
336 static void drw_mesh_weight_state_extract(Object *ob,
337                                           Mesh *me,
338                                           const ToolSettings *ts,
339                                           bool paint_mode,
340                                           struct DRW_MeshWeightState *wstate)
341 {
342   /* Extract complete vertex weight group selection state and mode flags. */
343   memset(wstate, 0, sizeof(*wstate));
344
345   wstate->defgroup_active = ob->actdef - 1;
346   wstate->defgroup_len = BLI_listbase_count(&ob->defbase);
347
348   wstate->alert_mode = ts->weightuser;
349
350   if (paint_mode && ts->multipaint) {
351     /* Multipaint needs to know all selected bones, not just the active group.
352      * This is actually a relatively expensive operation, but caching would be difficult. */
353     wstate->defgroup_sel = BKE_object_defgroup_selected_get(
354         ob, wstate->defgroup_len, &wstate->defgroup_sel_count);
355
356     if (wstate->defgroup_sel_count > 1) {
357       wstate->flags |= DRW_MESH_WEIGHT_STATE_MULTIPAINT |
358                        (ts->auto_normalize ? DRW_MESH_WEIGHT_STATE_AUTO_NORMALIZE : 0);
359
360       if (me->editflag & ME_EDIT_MIRROR_X) {
361         BKE_object_defgroup_mirror_selection(ob,
362                                              wstate->defgroup_len,
363                                              wstate->defgroup_sel,
364                                              wstate->defgroup_sel,
365                                              &wstate->defgroup_sel_count);
366       }
367     }
368     /* With only one selected bone Multipaint reverts to regular mode. */
369     else {
370       wstate->defgroup_sel_count = 0;
371       MEM_SAFE_FREE(wstate->defgroup_sel);
372     }
373   }
374 }
375
376 /** \} */
377
378 /* ---------------------------------------------------------------------- */
379 /** \name Mesh GPUBatch Cache
380  * \{ */
381
382 BLI_INLINE void mesh_batch_cache_add_request(MeshBatchCache *cache, DRWBatchFlag new_flag)
383 {
384   atomic_fetch_and_or_uint32((uint32_t *)(&cache->batch_requested), *(uint32_t *)&new_flag);
385 }
386
387 /* GPUBatch cache management. */
388
389 static bool mesh_batch_cache_valid(Mesh *me)
390 {
391   MeshBatchCache *cache = me->runtime.batch_cache;
392
393   if (cache == NULL) {
394     return false;
395   }
396
397   if (cache->is_editmode != (me->edit_mesh != NULL)) {
398     return false;
399   }
400
401   if (cache->is_dirty) {
402     return false;
403   }
404
405   if (cache->mat_len != mesh_render_mat_len_get(me)) {
406     return false;
407   }
408
409   return true;
410 }
411
412 static void mesh_batch_cache_init(Mesh *me)
413 {
414   MeshBatchCache *cache = me->runtime.batch_cache;
415
416   if (!cache) {
417     cache = me->runtime.batch_cache = MEM_callocN(sizeof(*cache), __func__);
418   }
419   else {
420     memset(cache, 0, sizeof(*cache));
421   }
422
423   cache->is_editmode = me->edit_mesh != NULL;
424
425   if (cache->is_editmode == false) {
426     // cache->edge_len = mesh_render_edges_len_get(me);
427     // cache->tri_len = mesh_render_looptri_len_get(me);
428     // cache->poly_len = mesh_render_polys_len_get(me);
429     // cache->vert_len = mesh_render_verts_len_get(me);
430   }
431
432   cache->mat_len = mesh_render_mat_len_get(me);
433   cache->surface_per_mat = MEM_callocN(sizeof(*cache->surface_per_mat) * cache->mat_len, __func__);
434
435   cache->is_dirty = false;
436   cache->batch_ready = 0;
437   cache->batch_requested = 0;
438
439   drw_mesh_weight_state_clear(&cache->weight_state);
440 }
441
442 void DRW_mesh_batch_cache_validate(Mesh *me)
443 {
444   if (!mesh_batch_cache_valid(me)) {
445     mesh_batch_cache_clear(me);
446     mesh_batch_cache_init(me);
447   }
448 }
449
450 static MeshBatchCache *mesh_batch_cache_get(Mesh *me)
451 {
452   return me->runtime.batch_cache;
453 }
454
455 static void mesh_batch_cache_check_vertex_group(MeshBatchCache *cache,
456                                                 const struct DRW_MeshWeightState *wstate)
457 {
458   if (!drw_mesh_weight_state_compare(&cache->weight_state, wstate)) {
459     FOREACH_MESH_BUFFER_CACHE(cache, mbufcache)
460     {
461       GPU_VERTBUF_DISCARD_SAFE(mbufcache->vbo.weights);
462     }
463     GPU_BATCH_CLEAR_SAFE(cache->batch.surface_weights);
464
465     cache->batch_ready &= ~MBC_SURFACE_WEIGHTS;
466
467     drw_mesh_weight_state_clear(&cache->weight_state);
468   }
469 }
470
471 static void mesh_batch_cache_discard_shaded_batches(MeshBatchCache *cache)
472 {
473   if (cache->surface_per_mat) {
474     for (int i = 0; i < cache->mat_len; i++) {
475       GPU_BATCH_DISCARD_SAFE(cache->surface_per_mat[i]);
476     }
477   }
478   cache->batch_ready &= ~MBC_SURF_PER_MAT;
479 }
480
481 static void mesh_batch_cache_discard_shaded_tri(MeshBatchCache *cache)
482 {
483   FOREACH_MESH_BUFFER_CACHE(cache, mbufcache)
484   {
485     GPU_VERTBUF_DISCARD_SAFE(mbufcache->vbo.pos_nor);
486     GPU_VERTBUF_DISCARD_SAFE(mbufcache->vbo.uv);
487     GPU_VERTBUF_DISCARD_SAFE(mbufcache->vbo.tan);
488     GPU_VERTBUF_DISCARD_SAFE(mbufcache->vbo.vcol);
489     GPU_VERTBUF_DISCARD_SAFE(mbufcache->vbo.orco);
490   }
491   mesh_batch_cache_discard_shaded_batches(cache);
492   mesh_cd_layers_type_clear(&cache->cd_used);
493
494   MEM_SAFE_FREE(cache->surface_per_mat);
495   MEM_SAFE_FREE(cache->auto_layer_names);
496   MEM_SAFE_FREE(cache->auto_layer_is_srgb);
497
498   cache->mat_len = 0;
499 }
500
501 static void mesh_batch_cache_discard_uvedit(MeshBatchCache *cache)
502 {
503   FOREACH_MESH_BUFFER_CACHE(cache, mbufcache)
504   {
505     GPU_VERTBUF_DISCARD_SAFE(mbufcache->vbo.stretch_angle);
506     GPU_VERTBUF_DISCARD_SAFE(mbufcache->vbo.stretch_area);
507     GPU_VERTBUF_DISCARD_SAFE(mbufcache->vbo.uv);
508     GPU_VERTBUF_DISCARD_SAFE(mbufcache->vbo.edituv_data);
509     GPU_VERTBUF_DISCARD_SAFE(mbufcache->vbo.fdots_uv);
510     GPU_VERTBUF_DISCARD_SAFE(mbufcache->vbo.fdots_edituv_data);
511     GPU_INDEXBUF_DISCARD_SAFE(mbufcache->ibo.edituv_tris);
512     GPU_INDEXBUF_DISCARD_SAFE(mbufcache->ibo.edituv_lines);
513     GPU_INDEXBUF_DISCARD_SAFE(mbufcache->ibo.edituv_points);
514     GPU_INDEXBUF_DISCARD_SAFE(mbufcache->ibo.edituv_fdots);
515   }
516   GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces_stretch_area);
517   GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces_stretch_angle);
518   GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces);
519   GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_edges);
520   GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_verts);
521   GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_fdots);
522   GPU_BATCH_DISCARD_SAFE(cache->batch.wire_loops_uvs);
523
524   cache->tot_area = 0.0f;
525   cache->tot_uv_area = 0.0f;
526
527   cache->batch_ready &= ~MBC_EDITUV;
528
529   /* We discarded the vbo.uv so we need to reset the cd_used flag. */
530   cache->cd_used.uv = 0;
531   cache->cd_used.edit_uv = 0;
532
533   /* Discard other batches that uses vbo.uv */
534   mesh_batch_cache_discard_shaded_batches(cache);
535
536   GPU_BATCH_DISCARD_SAFE(cache->batch.surface);
537   cache->batch_ready &= ~MBC_SURFACE;
538 }
539
540 static void mesh_batch_cache_discard_uvedit_select(MeshBatchCache *cache)
541 {
542   FOREACH_MESH_BUFFER_CACHE(cache, mbufcache)
543   {
544     GPU_VERTBUF_DISCARD_SAFE(mbufcache->vbo.edituv_data);
545     GPU_VERTBUF_DISCARD_SAFE(mbufcache->vbo.fdots_edituv_data);
546     GPU_INDEXBUF_DISCARD_SAFE(mbufcache->ibo.edituv_tris);
547     GPU_INDEXBUF_DISCARD_SAFE(mbufcache->ibo.edituv_lines);
548     GPU_INDEXBUF_DISCARD_SAFE(mbufcache->ibo.edituv_points);
549     GPU_INDEXBUF_DISCARD_SAFE(mbufcache->ibo.edituv_fdots);
550   }
551   GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces_stretch_area);
552   GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces_stretch_angle);
553   GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces);
554   GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_edges);
555   GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_verts);
556   GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_fdots);
557   GPU_BATCH_DISCARD_SAFE(cache->batch.wire_loops_uvs);
558   cache->batch_ready &= ~MBC_EDITUV;
559 }
560
561 void DRW_mesh_batch_cache_dirty_tag(Mesh *me, int mode)
562 {
563   MeshBatchCache *cache = me->runtime.batch_cache;
564   if (cache == NULL) {
565     return;
566   }
567   switch (mode) {
568     case BKE_MESH_BATCH_DIRTY_SELECT:
569       FOREACH_MESH_BUFFER_CACHE(cache, mbufcache)
570       {
571         GPU_VERTBUF_DISCARD_SAFE(mbufcache->vbo.edit_data);
572         GPU_VERTBUF_DISCARD_SAFE(mbufcache->vbo.fdots_nor);
573       }
574       GPU_BATCH_DISCARD_SAFE(cache->batch.edit_triangles);
575       GPU_BATCH_DISCARD_SAFE(cache->batch.edit_vertices);
576       GPU_BATCH_DISCARD_SAFE(cache->batch.edit_edges);
577       GPU_BATCH_DISCARD_SAFE(cache->batch.edit_fdots);
578       GPU_BATCH_DISCARD_SAFE(cache->batch.edit_selection_verts);
579       GPU_BATCH_DISCARD_SAFE(cache->batch.edit_selection_edges);
580       GPU_BATCH_DISCARD_SAFE(cache->batch.edit_selection_faces);
581       GPU_BATCH_DISCARD_SAFE(cache->batch.edit_selection_fdots);
582       GPU_BATCH_DISCARD_SAFE(cache->batch.edit_mesh_analysis);
583       cache->batch_ready &= ~(MBC_EDIT_TRIANGLES | MBC_EDIT_VERTICES | MBC_EDIT_EDGES |
584                               MBC_EDIT_FACEDOTS | MBC_EDIT_SELECTION_FACEDOTS |
585                               MBC_EDIT_SELECTION_FACES | MBC_EDIT_SELECTION_EDGES |
586                               MBC_EDIT_SELECTION_VERTS | MBC_EDIT_MESH_ANALYSIS);
587       /* Because visible UVs depends on edit mode selection, discard topology. */
588       mesh_batch_cache_discard_uvedit_select(cache);
589       break;
590     case BKE_MESH_BATCH_DIRTY_SELECT_PAINT:
591       /* Paint mode selection flag is packed inside the nor attrib.
592        * Note that it can be slow if auto smooth is enabled. (see T63946) */
593       FOREACH_MESH_BUFFER_CACHE(cache, mbufcache)
594       {
595         GPU_INDEXBUF_DISCARD_SAFE(mbufcache->ibo.lines_paint_mask);
596         GPU_VERTBUF_DISCARD_SAFE(mbufcache->vbo.pos_nor);
597         GPU_VERTBUF_DISCARD_SAFE(mbufcache->vbo.lnor);
598       }
599       GPU_BATCH_DISCARD_SAFE(cache->batch.surface);
600       GPU_BATCH_DISCARD_SAFE(cache->batch.wire_loops);
601       GPU_BATCH_DISCARD_SAFE(cache->batch.wire_edges);
602       if (cache->surface_per_mat) {
603         for (int i = 0; i < cache->mat_len; i++) {
604           GPU_BATCH_DISCARD_SAFE(cache->surface_per_mat[i]);
605         }
606       }
607       cache->batch_ready &= ~(MBC_SURFACE | MBC_WIRE_EDGES | MBC_WIRE_LOOPS | MBC_SURF_PER_MAT);
608       break;
609     case BKE_MESH_BATCH_DIRTY_ALL:
610       cache->is_dirty = true;
611       break;
612     case BKE_MESH_BATCH_DIRTY_SHADING:
613       mesh_batch_cache_discard_shaded_tri(cache);
614       mesh_batch_cache_discard_uvedit(cache);
615       break;
616     case BKE_MESH_BATCH_DIRTY_UVEDIT_ALL:
617       mesh_batch_cache_discard_uvedit(cache);
618       break;
619     case BKE_MESH_BATCH_DIRTY_UVEDIT_SELECT:
620       FOREACH_MESH_BUFFER_CACHE(cache, mbufcache)
621       {
622         GPU_VERTBUF_DISCARD_SAFE(mbufcache->vbo.edituv_data);
623         GPU_VERTBUF_DISCARD_SAFE(mbufcache->vbo.fdots_edituv_data);
624       }
625       GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces_stretch_area);
626       GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces_stretch_angle);
627       GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces);
628       GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_edges);
629       GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_verts);
630       GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_fdots);
631       cache->batch_ready &= ~MBC_EDITUV;
632       break;
633     default:
634       BLI_assert(0);
635   }
636 }
637
638 static void mesh_batch_cache_clear(Mesh *me)
639 {
640   MeshBatchCache *cache = me->runtime.batch_cache;
641   if (!cache) {
642     return;
643   }
644   FOREACH_MESH_BUFFER_CACHE(cache, mbufcache)
645   {
646     GPUVertBuf **vbos = (GPUVertBuf **)&mbufcache->vbo;
647     GPUIndexBuf **ibos = (GPUIndexBuf **)&mbufcache->ibo;
648     for (int i = 0; i < sizeof(mbufcache->vbo) / sizeof(void *); i++) {
649       GPU_VERTBUF_DISCARD_SAFE(vbos[i]);
650     }
651     for (int i = 0; i < sizeof(mbufcache->ibo) / sizeof(void *); i++) {
652       GPU_INDEXBUF_DISCARD_SAFE(ibos[i]);
653     }
654   }
655   for (int i = 0; i < sizeof(cache->batch) / sizeof(void *); i++) {
656     GPUBatch **batch = (GPUBatch **)&cache->batch;
657     GPU_BATCH_DISCARD_SAFE(batch[i]);
658   }
659
660   mesh_batch_cache_discard_shaded_tri(cache);
661
662   mesh_batch_cache_discard_uvedit(cache);
663
664   cache->batch_ready = 0;
665
666   drw_mesh_weight_state_clear(&cache->weight_state);
667 }
668
669 void DRW_mesh_batch_cache_free(Mesh *me)
670 {
671   mesh_batch_cache_clear(me);
672   MEM_SAFE_FREE(me->runtime.batch_cache);
673 }
674
675 /** \} */
676
677 /* ---------------------------------------------------------------------- */
678 /** \name Public API
679  * \{ */
680
681 static void texpaint_request_active_uv(MeshBatchCache *cache, Mesh *me)
682 {
683   DRW_MeshCDMask cd_needed;
684   mesh_cd_layers_type_clear(&cd_needed);
685   mesh_cd_calc_active_uv_layer(me, &cd_needed);
686
687   BLI_assert(cd_needed.uv != 0 &&
688              "No uv layer available in texpaint, but batches requested anyway!");
689
690   mesh_cd_calc_active_mask_uv_layer(me, &cd_needed);
691   mesh_cd_layers_type_merge(&cache->cd_needed, cd_needed);
692 }
693
694 static void texpaint_request_active_vcol(MeshBatchCache *cache, Mesh *me)
695 {
696   DRW_MeshCDMask cd_needed;
697   mesh_cd_layers_type_clear(&cd_needed);
698   mesh_cd_calc_active_vcol_layer(me, &cd_needed);
699
700   BLI_assert(cd_needed.vcol != 0 &&
701              "No vcol layer available in vertpaint, but batches requested anyway!");
702
703   mesh_cd_layers_type_merge(&cache->cd_needed, cd_needed);
704 }
705
706 GPUBatch *DRW_mesh_batch_cache_get_all_verts(Mesh *me)
707 {
708   MeshBatchCache *cache = mesh_batch_cache_get(me);
709   mesh_batch_cache_add_request(cache, MBC_ALL_VERTS);
710   return DRW_batch_request(&cache->batch.all_verts);
711 }
712
713 GPUBatch *DRW_mesh_batch_cache_get_all_edges(Mesh *me)
714 {
715   MeshBatchCache *cache = mesh_batch_cache_get(me);
716   mesh_batch_cache_add_request(cache, MBC_ALL_EDGES);
717   return DRW_batch_request(&cache->batch.all_edges);
718 }
719
720 GPUBatch *DRW_mesh_batch_cache_get_surface(Mesh *me)
721 {
722   MeshBatchCache *cache = mesh_batch_cache_get(me);
723   mesh_batch_cache_add_request(cache, MBC_SURFACE);
724   return DRW_batch_request(&cache->batch.surface);
725 }
726
727 GPUBatch *DRW_mesh_batch_cache_get_loose_edges(Mesh *me)
728 {
729   MeshBatchCache *cache = mesh_batch_cache_get(me);
730   mesh_batch_cache_add_request(cache, MBC_LOOSE_EDGES);
731   if (cache->no_loose_wire) {
732     return NULL;
733   }
734   else {
735     return DRW_batch_request(&cache->batch.loose_edges);
736   }
737 }
738
739 GPUBatch *DRW_mesh_batch_cache_get_surface_weights(Mesh *me)
740 {
741   MeshBatchCache *cache = mesh_batch_cache_get(me);
742   mesh_batch_cache_add_request(cache, MBC_SURFACE_WEIGHTS);
743   return DRW_batch_request(&cache->batch.surface_weights);
744 }
745
746 GPUBatch *DRW_mesh_batch_cache_get_edge_detection(Mesh *me, bool *r_is_manifold)
747 {
748   MeshBatchCache *cache = mesh_batch_cache_get(me);
749   mesh_batch_cache_add_request(cache, MBC_EDGE_DETECTION);
750   /* Even if is_manifold is not correct (not updated),
751    * the default (not manifold) is just the worst case. */
752   if (r_is_manifold) {
753     *r_is_manifold = cache->is_manifold;
754   }
755   return DRW_batch_request(&cache->batch.edge_detection);
756 }
757
758 GPUBatch *DRW_mesh_batch_cache_get_wireframes_face(Mesh *me)
759 {
760   MeshBatchCache *cache = mesh_batch_cache_get(me);
761   mesh_batch_cache_add_request(cache, MBC_WIRE_EDGES);
762   return DRW_batch_request(&cache->batch.wire_edges);
763 }
764
765 GPUBatch *DRW_mesh_batch_cache_get_edit_mesh_analysis(Mesh *me)
766 {
767   MeshBatchCache *cache = mesh_batch_cache_get(me);
768   mesh_batch_cache_add_request(cache, MBC_EDIT_MESH_ANALYSIS);
769   return DRW_batch_request(&cache->batch.edit_mesh_analysis);
770 }
771
772 GPUBatch **DRW_mesh_batch_cache_get_surface_shaded(Mesh *me,
773                                                    struct GPUMaterial **gpumat_array,
774                                                    uint gpumat_array_len,
775                                                    char **auto_layer_names,
776                                                    int **auto_layer_is_srgb,
777                                                    int *auto_layer_count)
778 {
779   MeshBatchCache *cache = mesh_batch_cache_get(me);
780   DRW_MeshCDMask cd_needed = mesh_cd_calc_used_gpu_layers(me, gpumat_array, gpumat_array_len);
781
782   BLI_assert(gpumat_array_len == cache->mat_len);
783
784   mesh_cd_layers_type_merge(&cache->cd_needed, cd_needed);
785
786   if (!mesh_cd_layers_type_overlap(cache->cd_used, cd_needed)) {
787     mesh_cd_extract_auto_layers_names_and_srgb(me,
788                                                cache->cd_needed,
789                                                &cache->auto_layer_names,
790                                                &cache->auto_layer_is_srgb,
791                                                &cache->auto_layer_len);
792   }
793
794   mesh_batch_cache_add_request(cache, MBC_SURF_PER_MAT);
795
796   if (auto_layer_names) {
797     *auto_layer_names = cache->auto_layer_names;
798     *auto_layer_is_srgb = cache->auto_layer_is_srgb;
799     *auto_layer_count = cache->auto_layer_len;
800   }
801   for (int i = 0; i < cache->mat_len; i++) {
802     DRW_batch_request(&cache->surface_per_mat[i]);
803   }
804   return cache->surface_per_mat;
805 }
806
807 GPUBatch **DRW_mesh_batch_cache_get_surface_texpaint(Mesh *me)
808 {
809   MeshBatchCache *cache = mesh_batch_cache_get(me);
810   mesh_batch_cache_add_request(cache, MBC_SURF_PER_MAT);
811   texpaint_request_active_uv(cache, me);
812   for (int i = 0; i < cache->mat_len; i++) {
813     DRW_batch_request(&cache->surface_per_mat[i]);
814   }
815   return cache->surface_per_mat;
816 }
817
818 GPUBatch *DRW_mesh_batch_cache_get_surface_texpaint_single(Mesh *me)
819 {
820   MeshBatchCache *cache = mesh_batch_cache_get(me);
821   texpaint_request_active_uv(cache, me);
822   mesh_batch_cache_add_request(cache, MBC_SURFACE);
823   return DRW_batch_request(&cache->batch.surface);
824 }
825
826 GPUBatch *DRW_mesh_batch_cache_get_surface_vertpaint(Mesh *me)
827 {
828   MeshBatchCache *cache = mesh_batch_cache_get(me);
829   texpaint_request_active_vcol(cache, me);
830   mesh_batch_cache_add_request(cache, MBC_SURFACE);
831   return DRW_batch_request(&cache->batch.surface);
832 }
833
834 /** \} */
835
836 /* ---------------------------------------------------------------------- */
837 /** \name Edit Mode API
838  * \{ */
839
840 GPUBatch *DRW_mesh_batch_cache_get_edit_triangles(Mesh *me)
841 {
842   MeshBatchCache *cache = mesh_batch_cache_get(me);
843   mesh_batch_cache_add_request(cache, MBC_EDIT_TRIANGLES);
844   return DRW_batch_request(&cache->batch.edit_triangles);
845 }
846
847 GPUBatch *DRW_mesh_batch_cache_get_edit_edges(Mesh *me)
848 {
849   MeshBatchCache *cache = mesh_batch_cache_get(me);
850   mesh_batch_cache_add_request(cache, MBC_EDIT_EDGES);
851   return DRW_batch_request(&cache->batch.edit_edges);
852 }
853
854 GPUBatch *DRW_mesh_batch_cache_get_edit_vertices(Mesh *me)
855 {
856   MeshBatchCache *cache = mesh_batch_cache_get(me);
857   mesh_batch_cache_add_request(cache, MBC_EDIT_VERTICES);
858   return DRW_batch_request(&cache->batch.edit_vertices);
859 }
860
861 GPUBatch *DRW_mesh_batch_cache_get_edit_vnors(Mesh *me)
862 {
863   MeshBatchCache *cache = mesh_batch_cache_get(me);
864   mesh_batch_cache_add_request(cache, MBC_EDIT_VNOR);
865   return DRW_batch_request(&cache->batch.edit_vnor);
866 }
867
868 GPUBatch *DRW_mesh_batch_cache_get_edit_lnors(Mesh *me)
869 {
870   MeshBatchCache *cache = mesh_batch_cache_get(me);
871   mesh_batch_cache_add_request(cache, MBC_EDIT_LNOR);
872   return DRW_batch_request(&cache->batch.edit_lnor);
873 }
874
875 GPUBatch *DRW_mesh_batch_cache_get_edit_facedots(Mesh *me)
876 {
877   MeshBatchCache *cache = mesh_batch_cache_get(me);
878   mesh_batch_cache_add_request(cache, MBC_EDIT_FACEDOTS);
879   return DRW_batch_request(&cache->batch.edit_fdots);
880 }
881
882 GPUBatch *DRW_mesh_batch_cache_get_edit_skin_roots(Mesh *me)
883 {
884   MeshBatchCache *cache = mesh_batch_cache_get(me);
885   mesh_batch_cache_add_request(cache, MBC_SKIN_ROOTS);
886   return DRW_batch_request(&cache->batch.edit_skin_roots);
887 }
888
889 /** \} */
890
891 /* ---------------------------------------------------------------------- */
892 /** \name Edit Mode selection API
893  * \{ */
894
895 GPUBatch *DRW_mesh_batch_cache_get_triangles_with_select_id(Mesh *me)
896 {
897   MeshBatchCache *cache = mesh_batch_cache_get(me);
898   mesh_batch_cache_add_request(cache, MBC_EDIT_SELECTION_FACES);
899   return DRW_batch_request(&cache->batch.edit_selection_faces);
900 }
901
902 GPUBatch *DRW_mesh_batch_cache_get_facedots_with_select_id(Mesh *me)
903 {
904   MeshBatchCache *cache = mesh_batch_cache_get(me);
905   mesh_batch_cache_add_request(cache, MBC_EDIT_SELECTION_FACEDOTS);
906   return DRW_batch_request(&cache->batch.edit_selection_fdots);
907 }
908
909 GPUBatch *DRW_mesh_batch_cache_get_edges_with_select_id(Mesh *me)
910 {
911   MeshBatchCache *cache = mesh_batch_cache_get(me);
912   mesh_batch_cache_add_request(cache, MBC_EDIT_SELECTION_EDGES);
913   return DRW_batch_request(&cache->batch.edit_selection_edges);
914 }
915
916 GPUBatch *DRW_mesh_batch_cache_get_verts_with_select_id(Mesh *me)
917 {
918   MeshBatchCache *cache = mesh_batch_cache_get(me);
919   mesh_batch_cache_add_request(cache, MBC_EDIT_SELECTION_VERTS);
920   return DRW_batch_request(&cache->batch.edit_selection_verts);
921 }
922
923 /** \} */
924
925 /* ---------------------------------------------------------------------- */
926 /** \name UV Image editor API
927  * \{ */
928
929 static void edituv_request_active_uv(MeshBatchCache *cache, Mesh *me)
930 {
931   DRW_MeshCDMask cd_needed;
932   mesh_cd_layers_type_clear(&cd_needed);
933   mesh_cd_calc_edit_uv_layer(me, &cd_needed);
934
935   BLI_assert(cd_needed.edit_uv != 0 &&
936              "No uv layer available in edituv, but batches requested anyway!");
937
938   mesh_cd_calc_active_mask_uv_layer(me, &cd_needed);
939   mesh_cd_layers_type_merge(&cache->cd_needed, cd_needed);
940 }
941
942 /* Creates the GPUBatch for drawing the UV Stretching Area Overlay.
943  * Optional retrieves the total area or total uv area of the mesh.
944  *
945  * The `cache->tot_area` and cache->tot_uv_area` update are calculation are
946  * only valid after calling `DRW_mesh_batch_cache_create_requested`. */
947 GPUBatch *DRW_mesh_batch_cache_get_edituv_faces_stretch_area(Mesh *me,
948                                                              float **tot_area,
949                                                              float **tot_uv_area)
950 {
951   MeshBatchCache *cache = mesh_batch_cache_get(me);
952   edituv_request_active_uv(cache, me);
953   mesh_batch_cache_add_request(cache, MBC_EDITUV_FACES_STRETCH_AREA);
954
955   if (tot_area != NULL) {
956     *tot_area = &cache->tot_area;
957   }
958   if (tot_uv_area != NULL) {
959     *tot_uv_area = &cache->tot_uv_area;
960   }
961   return DRW_batch_request(&cache->batch.edituv_faces_stretch_area);
962 }
963
964 GPUBatch *DRW_mesh_batch_cache_get_edituv_faces_stretch_angle(Mesh *me)
965 {
966   MeshBatchCache *cache = mesh_batch_cache_get(me);
967   edituv_request_active_uv(cache, me);
968   mesh_batch_cache_add_request(cache, MBC_EDITUV_FACES_STRETCH_ANGLE);
969   return DRW_batch_request(&cache->batch.edituv_faces_stretch_angle);
970 }
971
972 GPUBatch *DRW_mesh_batch_cache_get_edituv_faces(Mesh *me)
973 {
974   MeshBatchCache *cache = mesh_batch_cache_get(me);
975   edituv_request_active_uv(cache, me);
976   mesh_batch_cache_add_request(cache, MBC_EDITUV_FACES);
977   return DRW_batch_request(&cache->batch.edituv_faces);
978 }
979
980 GPUBatch *DRW_mesh_batch_cache_get_edituv_edges(Mesh *me)
981 {
982   MeshBatchCache *cache = mesh_batch_cache_get(me);
983   edituv_request_active_uv(cache, me);
984   mesh_batch_cache_add_request(cache, MBC_EDITUV_EDGES);
985   return DRW_batch_request(&cache->batch.edituv_edges);
986 }
987
988 GPUBatch *DRW_mesh_batch_cache_get_edituv_verts(Mesh *me)
989 {
990   MeshBatchCache *cache = mesh_batch_cache_get(me);
991   edituv_request_active_uv(cache, me);
992   mesh_batch_cache_add_request(cache, MBC_EDITUV_VERTS);
993   return DRW_batch_request(&cache->batch.edituv_verts);
994 }
995
996 GPUBatch *DRW_mesh_batch_cache_get_edituv_facedots(Mesh *me)
997 {
998   MeshBatchCache *cache = mesh_batch_cache_get(me);
999   edituv_request_active_uv(cache, me);
1000   mesh_batch_cache_add_request(cache, MBC_EDITUV_FACEDOTS);
1001   return DRW_batch_request(&cache->batch.edituv_fdots);
1002 }
1003
1004 GPUBatch *DRW_mesh_batch_cache_get_uv_edges(Mesh *me)
1005 {
1006   MeshBatchCache *cache = mesh_batch_cache_get(me);
1007   edituv_request_active_uv(cache, me);
1008   mesh_batch_cache_add_request(cache, MBC_WIRE_LOOPS_UVS);
1009   return DRW_batch_request(&cache->batch.wire_loops_uvs);
1010 }
1011
1012 GPUBatch *DRW_mesh_batch_cache_get_surface_edges(Mesh *me)
1013 {
1014   MeshBatchCache *cache = mesh_batch_cache_get(me);
1015   texpaint_request_active_uv(cache, me);
1016   mesh_batch_cache_add_request(cache, MBC_WIRE_LOOPS);
1017   return DRW_batch_request(&cache->batch.wire_loops);
1018 }
1019
1020 /** \} */
1021
1022 /* ---------------------------------------------------------------------- */
1023 /** \name Grouped batch generation
1024  * \{ */
1025
1026 /* Thread safety need to be assured by caller. Don't call this during drawing.
1027  * Note: For now this only free the shading batches / vbo if any cd layers is
1028  * not needed anymore. */
1029 void DRW_mesh_batch_cache_free_old(Mesh *me, int ctime)
1030 {
1031   MeshBatchCache *cache = me->runtime.batch_cache;
1032
1033   if (cache == NULL) {
1034     return;
1035   }
1036
1037   if (mesh_cd_layers_type_equal(cache->cd_used_over_time, cache->cd_used)) {
1038     cache->lastmatch = ctime;
1039   }
1040
1041   if (ctime - cache->lastmatch > U.vbotimeout) {
1042     mesh_batch_cache_discard_shaded_tri(cache);
1043   }
1044
1045   mesh_cd_layers_type_clear(&cache->cd_used_over_time);
1046 }
1047
1048 /* Can be called for any surface type. Mesh *me is the final mesh. */
1049 void DRW_mesh_batch_cache_create_requested(
1050     Object *ob, Mesh *me, const Scene *scene, const bool is_paint_mode, const bool use_hide)
1051 {
1052   GPUIndexBuf **saved_elem_ranges = NULL;
1053   const ToolSettings *ts = NULL;
1054   if (scene) {
1055     ts = scene->toolsettings;
1056   }
1057   MeshBatchCache *cache = mesh_batch_cache_get(me);
1058
1059   /* Early out */
1060   if (cache->batch_requested == 0) {
1061 #ifdef DEBUG
1062     goto check;
1063 #endif
1064     return;
1065   }
1066
1067   DRWBatchFlag batch_requested = cache->batch_requested;
1068   cache->batch_requested = 0;
1069
1070   if (batch_requested & MBC_SURFACE_WEIGHTS) {
1071     /* Check vertex weights. */
1072     if ((cache->batch.surface_weights != NULL) && (ts != NULL)) {
1073       struct DRW_MeshWeightState wstate;
1074       BLI_assert(ob->type == OB_MESH);
1075       drw_mesh_weight_state_extract(ob, me, ts, is_paint_mode, &wstate);
1076       mesh_batch_cache_check_vertex_group(cache, &wstate);
1077       drw_mesh_weight_state_copy(&cache->weight_state, &wstate);
1078       drw_mesh_weight_state_clear(&wstate);
1079     }
1080   }
1081
1082   /* HACK: if MBC_SURF_PER_MAT is requested and ibo.tris is already available, it won't have it's
1083    * index ranges initialized. So discard ibo.tris in order to recreate it.
1084    * This needs to happen before saved_elem_ranges is populated. */
1085   if ((batch_requested & MBC_SURF_PER_MAT) != 0 && (cache->batch_ready & MBC_SURF_PER_MAT) == 0) {
1086     FOREACH_MESH_BUFFER_CACHE(cache, mbuffercache)
1087     {
1088       GPU_INDEXBUF_DISCARD_SAFE(mbuffercache->ibo.tris);
1089     }
1090     /* Clear all batches that reference ibo.tris. */
1091     GPU_BATCH_CLEAR_SAFE(cache->batch.surface);
1092     GPU_BATCH_CLEAR_SAFE(cache->batch.surface_weights);
1093     GPU_BATCH_CLEAR_SAFE(cache->batch.edit_mesh_analysis);
1094     GPU_BATCH_CLEAR_SAFE(cache->batch.edit_triangles);
1095     GPU_BATCH_CLEAR_SAFE(cache->batch.edit_lnor);
1096     GPU_BATCH_CLEAR_SAFE(cache->batch.edit_selection_faces);
1097     for (int i = 0; i < cache->mat_len; i++) {
1098       GPU_BATCH_CLEAR_SAFE(cache->surface_per_mat[i]);
1099     }
1100
1101     cache->batch_ready &= ~(MBC_SURFACE | MBC_SURFACE_WEIGHTS | MBC_EDIT_MESH_ANALYSIS |
1102                             MBC_EDIT_TRIANGLES | MBC_EDIT_LNOR | MBC_EDIT_SELECTION_FACES);
1103   }
1104
1105   if (batch_requested &
1106       (MBC_SURFACE | MBC_SURF_PER_MAT | MBC_WIRE_LOOPS_UVS | MBC_EDITUV_FACES_STRETCH_AREA |
1107        MBC_EDITUV_FACES_STRETCH_ANGLE | MBC_EDITUV_FACES | MBC_EDITUV_EDGES | MBC_EDITUV_VERTS)) {
1108     /* Modifiers will only generate an orco layer if the mesh is deformed. */
1109     if (cache->cd_needed.orco != 0) {
1110       /* Orco is always extracted from final mesh. */
1111       Mesh *me_final = (me->edit_mesh) ? me->edit_mesh->mesh_eval_final : me;
1112       if (CustomData_get_layer(&me_final->vdata, CD_ORCO) == NULL) {
1113         /* Skip orco calculation */
1114         cache->cd_needed.orco = 0;
1115       }
1116     }
1117
1118     /* Verify that all surface batches have needed attribute layers.
1119      */
1120     /* TODO(fclem): We could be a bit smarter here and only do it per
1121      * material. */
1122     bool cd_overlap = mesh_cd_layers_type_overlap(cache->cd_used, cache->cd_needed);
1123     if (cd_overlap == false) {
1124       FOREACH_MESH_BUFFER_CACHE(cache, mbuffercache)
1125       {
1126         if ((cache->cd_used.uv & cache->cd_needed.uv) != cache->cd_needed.uv) {
1127           GPU_VERTBUF_DISCARD_SAFE(mbuffercache->vbo.uv);
1128         }
1129         if ((cache->cd_used.tan & cache->cd_needed.tan) != cache->cd_needed.tan ||
1130             cache->cd_used.tan_orco != cache->cd_needed.tan_orco) {
1131           GPU_VERTBUF_DISCARD_SAFE(mbuffercache->vbo.tan);
1132         }
1133         if (cache->cd_used.orco != cache->cd_needed.orco) {
1134           GPU_VERTBUF_DISCARD_SAFE(mbuffercache->vbo.orco);
1135         }
1136         if ((cache->cd_used.vcol & cache->cd_needed.vcol) != cache->cd_needed.vcol) {
1137           GPU_VERTBUF_DISCARD_SAFE(mbuffercache->vbo.vcol);
1138         }
1139       }
1140       /* XXX save element buffer to avoid recreating them.
1141        * This is only if the cd_needed changes so it is ok to keep them.*/
1142       if (cache->surface_per_mat[0] && cache->surface_per_mat[0]->elem) {
1143         saved_elem_ranges = MEM_callocN(sizeof(saved_elem_ranges) * cache->mat_len, __func__);
1144         for (int i = 0; i < cache->mat_len; i++) {
1145           saved_elem_ranges[i] = cache->surface_per_mat[i]->elem;
1146           /* Avoid deletion as the batch is owner. */
1147           cache->surface_per_mat[i]->elem = NULL;
1148           cache->surface_per_mat[i]->owns_flag &= ~GPU_BATCH_OWNS_INDEX;
1149         }
1150       }
1151       /* We can't discard batches at this point as they have been
1152        * referenced for drawing. Just clear them in place. */
1153       for (int i = 0; i < cache->mat_len; i++) {
1154         GPU_BATCH_CLEAR_SAFE(cache->surface_per_mat[i]);
1155       }
1156       GPU_BATCH_CLEAR_SAFE(cache->batch.surface);
1157       cache->batch_ready &= ~(MBC_SURFACE | MBC_SURF_PER_MAT);
1158
1159       mesh_cd_layers_type_merge(&cache->cd_used, cache->cd_needed);
1160     }
1161     mesh_cd_layers_type_merge(&cache->cd_used_over_time, cache->cd_needed);
1162     mesh_cd_layers_type_clear(&cache->cd_needed);
1163   }
1164
1165   if (batch_requested & MBC_EDITUV) {
1166     /* Discard UV batches if sync_selection changes */
1167     if (ts != NULL) {
1168       const bool is_uvsyncsel = (ts->uv_flag & UV_SYNC_SELECTION);
1169       if (cache->is_uvsyncsel != is_uvsyncsel) {
1170         cache->is_uvsyncsel = is_uvsyncsel;
1171         FOREACH_MESH_BUFFER_CACHE(cache, mbuffercache)
1172         {
1173           GPU_VERTBUF_DISCARD_SAFE(mbuffercache->vbo.edituv_data);
1174           GPU_VERTBUF_DISCARD_SAFE(mbuffercache->vbo.fdots_uv);
1175           GPU_INDEXBUF_DISCARD_SAFE(mbuffercache->ibo.edituv_tris);
1176           GPU_INDEXBUF_DISCARD_SAFE(mbuffercache->ibo.edituv_lines);
1177           GPU_INDEXBUF_DISCARD_SAFE(mbuffercache->ibo.edituv_points);
1178         }
1179         /* We only clear the batches as they may already have been
1180          * referenced. */
1181         GPU_BATCH_CLEAR_SAFE(cache->batch.wire_loops_uvs);
1182         GPU_BATCH_CLEAR_SAFE(cache->batch.edituv_faces_stretch_area);
1183         GPU_BATCH_CLEAR_SAFE(cache->batch.edituv_faces_stretch_angle);
1184         GPU_BATCH_CLEAR_SAFE(cache->batch.edituv_faces);
1185         GPU_BATCH_CLEAR_SAFE(cache->batch.edituv_edges);
1186         GPU_BATCH_CLEAR_SAFE(cache->batch.edituv_verts);
1187         GPU_BATCH_CLEAR_SAFE(cache->batch.edituv_fdots);
1188         cache->batch_ready &= ~MBC_EDITUV;
1189       }
1190     }
1191   }
1192
1193   /* Second chance to early out */
1194   if ((batch_requested & ~cache->batch_ready) == 0) {
1195 #ifdef DEBUG
1196     goto check;
1197 #endif
1198     return;
1199   }
1200
1201   cache->batch_ready |= batch_requested;
1202
1203   const bool do_cage = (me->edit_mesh &&
1204                         (me->edit_mesh->mesh_eval_final != me->edit_mesh->mesh_eval_cage));
1205
1206   const bool do_uvcage = me->edit_mesh && !me->edit_mesh->mesh_eval_final->runtime.is_original;
1207
1208   MeshBufferCache *mbufcache = &cache->final;
1209
1210   /* Init batches and request VBOs & IBOs */
1211   if (DRW_batch_requested(cache->batch.surface, GPU_PRIM_TRIS)) {
1212     DRW_ibo_request(cache->batch.surface, &mbufcache->ibo.tris);
1213     /* Order matters. First ones override latest vbos' attribs. */
1214     DRW_vbo_request(cache->batch.surface, &mbufcache->vbo.lnor);
1215     DRW_vbo_request(cache->batch.surface, &mbufcache->vbo.pos_nor);
1216     if (cache->cd_used.uv != 0) {
1217       DRW_vbo_request(cache->batch.surface, &mbufcache->vbo.uv);
1218     }
1219     if (cache->cd_used.vcol != 0) {
1220       DRW_vbo_request(cache->batch.surface, &mbufcache->vbo.vcol);
1221     }
1222   }
1223   if (DRW_batch_requested(cache->batch.all_verts, GPU_PRIM_POINTS)) {
1224     DRW_vbo_request(cache->batch.all_verts, &mbufcache->vbo.pos_nor);
1225   }
1226   if (DRW_batch_requested(cache->batch.all_edges, GPU_PRIM_LINES)) {
1227     DRW_ibo_request(cache->batch.all_edges, &mbufcache->ibo.lines);
1228     DRW_vbo_request(cache->batch.all_edges, &mbufcache->vbo.pos_nor);
1229   }
1230   if (DRW_batch_requested(cache->batch.loose_edges, GPU_PRIM_LINES)) {
1231     DRW_ibo_request(cache->batch.loose_edges, &mbufcache->ibo.lines);
1232     DRW_vbo_request(cache->batch.loose_edges, &mbufcache->vbo.pos_nor);
1233   }
1234   if (DRW_batch_requested(cache->batch.edge_detection, GPU_PRIM_LINES_ADJ)) {
1235     DRW_ibo_request(cache->batch.edge_detection, &mbufcache->ibo.lines_adjacency);
1236     DRW_vbo_request(cache->batch.edge_detection, &mbufcache->vbo.pos_nor);
1237   }
1238   if (DRW_batch_requested(cache->batch.surface_weights, GPU_PRIM_TRIS)) {
1239     DRW_ibo_request(cache->batch.surface_weights, &mbufcache->ibo.tris);
1240     DRW_vbo_request(cache->batch.surface_weights, &mbufcache->vbo.pos_nor);
1241     DRW_vbo_request(cache->batch.surface_weights, &mbufcache->vbo.weights);
1242   }
1243   if (DRW_batch_requested(cache->batch.wire_loops, GPU_PRIM_LINES)) {
1244     DRW_ibo_request(cache->batch.wire_loops, &mbufcache->ibo.lines_paint_mask);
1245     /* Order matters. First ones override latest vbos' attribs. */
1246     DRW_vbo_request(cache->batch.wire_loops, &mbufcache->vbo.lnor);
1247     DRW_vbo_request(cache->batch.wire_loops, &mbufcache->vbo.pos_nor);
1248   }
1249   if (DRW_batch_requested(cache->batch.wire_edges, GPU_PRIM_LINES)) {
1250     DRW_ibo_request(cache->batch.wire_edges, &mbufcache->ibo.lines);
1251     DRW_vbo_request(cache->batch.wire_edges, &mbufcache->vbo.pos_nor);
1252     DRW_vbo_request(cache->batch.wire_edges, &mbufcache->vbo.edge_fac);
1253   }
1254   if (DRW_batch_requested(cache->batch.wire_loops_uvs, GPU_PRIM_LINES)) {
1255     DRW_ibo_request(cache->batch.wire_loops_uvs, &mbufcache->ibo.edituv_lines);
1256     /* For paint overlay. Active layer should have been queried. */
1257     if (cache->cd_used.uv != 0) {
1258       DRW_vbo_request(cache->batch.wire_loops_uvs, &mbufcache->vbo.uv);
1259     }
1260   }
1261   if (DRW_batch_requested(cache->batch.edit_mesh_analysis, GPU_PRIM_TRIS)) {
1262     DRW_ibo_request(cache->batch.edit_mesh_analysis, &mbufcache->ibo.tris);
1263     DRW_vbo_request(cache->batch.edit_mesh_analysis, &mbufcache->vbo.pos_nor);
1264     DRW_vbo_request(cache->batch.edit_mesh_analysis, &mbufcache->vbo.mesh_analysis);
1265   }
1266
1267   /* Per Material */
1268   for (int i = 0; i < cache->mat_len; i++) {
1269     if (DRW_batch_requested(cache->surface_per_mat[i], GPU_PRIM_TRIS)) {
1270       if (saved_elem_ranges && saved_elem_ranges[i]) {
1271         /* XXX assign old element buffer range (it did not change).*/
1272         GPU_batch_elembuf_set(cache->surface_per_mat[i], saved_elem_ranges[i], true);
1273       }
1274       else {
1275         DRW_ibo_request(cache->surface_per_mat[i], &mbufcache->ibo.tris);
1276       }
1277       /* Order matters. First ones override latest vbos' attribs. */
1278       DRW_vbo_request(cache->surface_per_mat[i], &mbufcache->vbo.lnor);
1279       DRW_vbo_request(cache->surface_per_mat[i], &mbufcache->vbo.pos_nor);
1280       if (cache->cd_used.uv != 0) {
1281         DRW_vbo_request(cache->surface_per_mat[i], &mbufcache->vbo.uv);
1282       }
1283       if ((cache->cd_used.tan != 0) || (cache->cd_used.tan_orco != 0)) {
1284         DRW_vbo_request(cache->surface_per_mat[i], &mbufcache->vbo.tan);
1285       }
1286       if (cache->cd_used.vcol != 0) {
1287         DRW_vbo_request(cache->surface_per_mat[i], &mbufcache->vbo.vcol);
1288       }
1289       if (cache->cd_used.orco != 0) {
1290         DRW_vbo_request(cache->surface_per_mat[i], &mbufcache->vbo.orco);
1291       }
1292     }
1293   }
1294
1295   MEM_SAFE_FREE(saved_elem_ranges);
1296
1297   mbufcache = (do_cage) ? &cache->cage : &cache->final;
1298
1299   /* Edit Mesh */
1300   if (DRW_batch_requested(cache->batch.edit_triangles, GPU_PRIM_TRIS)) {
1301     DRW_ibo_request(cache->batch.edit_triangles, &mbufcache->ibo.tris);
1302     DRW_vbo_request(cache->batch.edit_triangles, &mbufcache->vbo.pos_nor);
1303     DRW_vbo_request(cache->batch.edit_triangles, &mbufcache->vbo.edit_data);
1304   }
1305   if (DRW_batch_requested(cache->batch.edit_vertices, GPU_PRIM_POINTS)) {
1306     DRW_ibo_request(cache->batch.edit_vertices, &mbufcache->ibo.points);
1307     DRW_vbo_request(cache->batch.edit_vertices, &mbufcache->vbo.pos_nor);
1308     DRW_vbo_request(cache->batch.edit_vertices, &mbufcache->vbo.edit_data);
1309   }
1310   if (DRW_batch_requested(cache->batch.edit_edges, GPU_PRIM_LINES)) {
1311     DRW_ibo_request(cache->batch.edit_edges, &mbufcache->ibo.lines);
1312     DRW_vbo_request(cache->batch.edit_edges, &mbufcache->vbo.pos_nor);
1313     DRW_vbo_request(cache->batch.edit_edges, &mbufcache->vbo.edit_data);
1314   }
1315   if (DRW_batch_requested(cache->batch.edit_vnor, GPU_PRIM_POINTS)) {
1316     DRW_ibo_request(cache->batch.edit_vnor, &mbufcache->ibo.points);
1317     DRW_vbo_request(cache->batch.edit_vnor, &mbufcache->vbo.pos_nor);
1318   }
1319   if (DRW_batch_requested(cache->batch.edit_lnor, GPU_PRIM_POINTS)) {
1320     DRW_ibo_request(cache->batch.edit_lnor, &mbufcache->ibo.tris);
1321     DRW_vbo_request(cache->batch.edit_lnor, &mbufcache->vbo.pos_nor);
1322     DRW_vbo_request(cache->batch.edit_lnor, &mbufcache->vbo.lnor);
1323   }
1324   if (DRW_batch_requested(cache->batch.edit_fdots, GPU_PRIM_POINTS)) {
1325     DRW_ibo_request(cache->batch.edit_fdots, &mbufcache->ibo.fdots);
1326     DRW_vbo_request(cache->batch.edit_fdots, &mbufcache->vbo.fdots_pos);
1327     DRW_vbo_request(cache->batch.edit_fdots, &mbufcache->vbo.fdots_nor);
1328   }
1329   if (DRW_batch_requested(cache->batch.edit_skin_roots, GPU_PRIM_LINES)) {
1330     DRW_vbo_request(cache->batch.edit_skin_roots, &mbufcache->vbo.skin_roots);
1331     /* HACK(fclem): This is to workaround the deferred batch init
1332      * that prevent drawing using DRW_shgroup_call_instances_with_attribs.
1333      * So we instead create the whole instancing batch here.
1334      * Note that we use GPU_PRIM_LINES instead of expected GPU_PRIM_LINE_STRIP
1335      * in order to mimic the old stipple pattern. */
1336     cache->batch.edit_skin_roots->inst = cache->batch.edit_skin_roots->verts[0];
1337     cache->batch.edit_skin_roots->verts[0] = NULL;
1338     GPUBatch *circle = DRW_cache_screenspace_circle_get();
1339     GPU_batch_vertbuf_add(cache->batch.edit_skin_roots, circle->verts[0]);
1340   }
1341
1342   /* Selection */
1343   if (DRW_batch_requested(cache->batch.edit_selection_verts, GPU_PRIM_POINTS)) {
1344     DRW_ibo_request(cache->batch.edit_selection_verts, &mbufcache->ibo.points);
1345     DRW_vbo_request(cache->batch.edit_selection_verts, &mbufcache->vbo.pos_nor);
1346     DRW_vbo_request(cache->batch.edit_selection_verts, &mbufcache->vbo.vert_idx);
1347   }
1348   if (DRW_batch_requested(cache->batch.edit_selection_edges, GPU_PRIM_LINES)) {
1349     DRW_ibo_request(cache->batch.edit_selection_edges, &mbufcache->ibo.lines);
1350     DRW_vbo_request(cache->batch.edit_selection_edges, &mbufcache->vbo.pos_nor);
1351     DRW_vbo_request(cache->batch.edit_selection_edges, &mbufcache->vbo.edge_idx);
1352   }
1353   if (DRW_batch_requested(cache->batch.edit_selection_faces, GPU_PRIM_TRIS)) {
1354     DRW_ibo_request(cache->batch.edit_selection_faces, &mbufcache->ibo.tris);
1355     DRW_vbo_request(cache->batch.edit_selection_faces, &mbufcache->vbo.pos_nor);
1356     DRW_vbo_request(cache->batch.edit_selection_faces, &mbufcache->vbo.poly_idx);
1357   }
1358   if (DRW_batch_requested(cache->batch.edit_selection_fdots, GPU_PRIM_POINTS)) {
1359     DRW_ibo_request(cache->batch.edit_selection_fdots, &mbufcache->ibo.fdots);
1360     DRW_vbo_request(cache->batch.edit_selection_fdots, &mbufcache->vbo.fdots_pos);
1361     DRW_vbo_request(cache->batch.edit_selection_fdots, &mbufcache->vbo.fdot_idx);
1362   }
1363
1364   /**
1365    * TODO: The code and data structure is ready to support modified UV display
1366    * but the selection code for UVs needs to support it first. So for now, only
1367    * display the cage in all cases.
1368    */
1369   mbufcache = (do_uvcage) ? &cache->uv_cage : &cache->final;
1370
1371   /* Edit UV */
1372   if (DRW_batch_requested(cache->batch.edituv_faces, GPU_PRIM_TRIS)) {
1373     DRW_ibo_request(cache->batch.edituv_faces, &mbufcache->ibo.edituv_tris);
1374     DRW_vbo_request(cache->batch.edituv_faces, &mbufcache->vbo.uv);
1375     DRW_vbo_request(cache->batch.edituv_faces, &mbufcache->vbo.edituv_data);
1376   }
1377   if (DRW_batch_requested(cache->batch.edituv_faces_stretch_area, GPU_PRIM_TRIS)) {
1378     DRW_ibo_request(cache->batch.edituv_faces_stretch_area, &mbufcache->ibo.edituv_tris);
1379     DRW_vbo_request(cache->batch.edituv_faces_stretch_area, &mbufcache->vbo.uv);
1380     DRW_vbo_request(cache->batch.edituv_faces_stretch_area, &mbufcache->vbo.edituv_data);
1381     DRW_vbo_request(cache->batch.edituv_faces_stretch_area, &mbufcache->vbo.stretch_area);
1382   }
1383   if (DRW_batch_requested(cache->batch.edituv_faces_stretch_angle, GPU_PRIM_TRIS)) {
1384     DRW_ibo_request(cache->batch.edituv_faces_stretch_angle, &mbufcache->ibo.edituv_tris);
1385     DRW_vbo_request(cache->batch.edituv_faces_stretch_angle, &mbufcache->vbo.uv);
1386     DRW_vbo_request(cache->batch.edituv_faces_stretch_angle, &mbufcache->vbo.edituv_data);
1387     DRW_vbo_request(cache->batch.edituv_faces_stretch_angle, &mbufcache->vbo.stretch_angle);
1388   }
1389   if (DRW_batch_requested(cache->batch.edituv_edges, GPU_PRIM_LINES)) {
1390     DRW_ibo_request(cache->batch.edituv_edges, &mbufcache->ibo.edituv_lines);
1391     DRW_vbo_request(cache->batch.edituv_edges, &mbufcache->vbo.uv);
1392     DRW_vbo_request(cache->batch.edituv_edges, &mbufcache->vbo.edituv_data);
1393   }
1394   if (DRW_batch_requested(cache->batch.edituv_verts, GPU_PRIM_POINTS)) {
1395     DRW_ibo_request(cache->batch.edituv_verts, &mbufcache->ibo.edituv_points);
1396     DRW_vbo_request(cache->batch.edituv_verts, &mbufcache->vbo.uv);
1397     DRW_vbo_request(cache->batch.edituv_verts, &mbufcache->vbo.edituv_data);
1398   }
1399   if (DRW_batch_requested(cache->batch.edituv_fdots, GPU_PRIM_POINTS)) {
1400     DRW_ibo_request(cache->batch.edituv_fdots, &mbufcache->ibo.edituv_fdots);
1401     DRW_vbo_request(cache->batch.edituv_fdots, &mbufcache->vbo.fdots_uv);
1402     DRW_vbo_request(cache->batch.edituv_fdots, &mbufcache->vbo.fdots_edituv_data);
1403   }
1404
1405   /* Meh loose Scene const correctness here. */
1406   const bool use_subsurf_fdots = scene ? modifiers_usesSubsurfFacedots((Scene *)scene, ob) : false;
1407
1408   if (do_uvcage) {
1409     mesh_buffer_cache_create_requested(
1410         cache, cache->uv_cage, me, false, true, false, &cache->cd_used, ts, true);
1411   }
1412
1413   if (do_cage) {
1414     mesh_buffer_cache_create_requested(
1415         cache, cache->cage, me, false, false, use_subsurf_fdots, &cache->cd_used, ts, true);
1416   }
1417
1418   mesh_buffer_cache_create_requested(
1419       cache, cache->final, me, true, false, use_subsurf_fdots, &cache->cd_used, ts, use_hide);
1420
1421 #ifdef DEBUG
1422 check:
1423   /* Make sure all requested batches have been setup. */
1424   for (int i = 0; i < sizeof(cache->batch) / sizeof(void *); i++) {
1425     BLI_assert(!DRW_batch_requested(((GPUBatch **)&cache->batch)[i], 0));
1426   }
1427   for (int i = 0; i < sizeof(cache->final.vbo) / sizeof(void *); i++) {
1428     BLI_assert(!DRW_vbo_requested(((GPUVertBuf **)&cache->final.vbo)[i]));
1429   }
1430   for (int i = 0; i < sizeof(cache->final.ibo) / sizeof(void *); i++) {
1431     BLI_assert(!DRW_ibo_requested(((GPUIndexBuf **)&cache->final.ibo)[i]));
1432   }
1433   for (int i = 0; i < sizeof(cache->cage.vbo) / sizeof(void *); i++) {
1434     BLI_assert(!DRW_vbo_requested(((GPUVertBuf **)&cache->cage.vbo)[i]));
1435   }
1436   for (int i = 0; i < sizeof(cache->cage.ibo) / sizeof(void *); i++) {
1437     BLI_assert(!DRW_ibo_requested(((GPUIndexBuf **)&cache->cage.ibo)[i]));
1438   }
1439   for (int i = 0; i < sizeof(cache->uv_cage.vbo) / sizeof(void *); i++) {
1440     BLI_assert(!DRW_vbo_requested(((GPUVertBuf **)&cache->uv_cage.vbo)[i]));
1441   }
1442   for (int i = 0; i < sizeof(cache->uv_cage.ibo) / sizeof(void *); i++) {
1443     BLI_assert(!DRW_ibo_requested(((GPUIndexBuf **)&cache->uv_cage.ibo)[i]));
1444   }
1445 #endif
1446 }
1447
1448 /** \} */