GPencil: Fix unreported unable to deselect when masking is OFF
[blender.git] / source / blender / draw / modes / overlay_mode.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  * Copyright 2016, Blender Foundation.
17  */
18
19 /** \file
20  * \ingroup draw_engine
21  */
22
23 #include "DNA_mesh_types.h"
24 #include "DNA_view3d_types.h"
25
26 #include "BIF_glutil.h"
27
28 #include "BKE_editmesh.h"
29 #include "BKE_global.h"
30 #include "BKE_object.h"
31 #include "BKE_paint.h"
32
33 #include "BLI_hash.h"
34
35 #include "GPU_shader.h"
36 #include "DRW_render.h"
37
38 #include "ED_view3d.h"
39
40 #include "draw_mode_engines.h"
41
42 #ifdef __APPLE__
43 #  define USE_GEOM_SHADER_WORKAROUND 1
44 #else
45 #  define USE_GEOM_SHADER_WORKAROUND 0
46 #endif
47
48 /* Structures */
49
50 typedef struct OVERLAY_DupliData {
51   DRWShadingGroup *shgrp;
52   struct GPUBatch *geom;
53   short base_flag;
54 } OVERLAY_DupliData;
55
56 typedef struct OVERLAY_StorageList {
57   struct OVERLAY_PrivateData *g_data;
58 } OVERLAY_StorageList;
59
60 typedef struct OVERLAY_PassList {
61   struct DRWPass *face_orientation_pass;
62   struct DRWPass *face_wireframe_pass;
63   struct DRWPass *face_wireframe_only_pass;
64   struct DRWPass *face_wireframe_xray_pass;
65 } OVERLAY_PassList;
66
67 typedef struct OVERLAY_Data {
68   void *engine_type;
69   DRWViewportEmptyList *fbl;
70   DRWViewportEmptyList *txl;
71   OVERLAY_PassList *psl;
72   OVERLAY_StorageList *stl;
73 } OVERLAY_Data;
74
75 typedef struct OVERLAY_PrivateData {
76   DRWShadingGroup *face_orientation_shgrp;
77   DRWShadingGroup *face_wires_shgrp;
78   DRWShadingGroup *face_wires_xray_shgrp;
79   DRWView *view_wires;
80   BLI_mempool *wire_color_mempool;
81   View3DOverlay overlay;
82   float wire_step_param;
83   bool clear_stencil;
84   bool show_overlays;
85 } OVERLAY_PrivateData; /* Transient data */
86
87 typedef struct OVERLAY_Shaders {
88   /* Face orientation shader */
89   struct GPUShader *face_orientation;
90   /* Wireframe shader */
91   struct GPUShader *select_wireframe;
92   struct GPUShader *face_wireframe;
93 } OVERLAY_Shaders;
94
95 /* *********** STATIC *********** */
96 static struct {
97   OVERLAY_Shaders sh_data[GPU_SHADER_CFG_LEN];
98 } e_data = {{{NULL}}};
99
100 /* Shaders */
101 extern char datatoc_overlay_face_orientation_frag_glsl[];
102 extern char datatoc_overlay_face_orientation_vert_glsl[];
103
104 extern char datatoc_overlay_face_wireframe_vert_glsl[];
105 extern char datatoc_overlay_face_wireframe_geom_glsl[];
106 extern char datatoc_overlay_face_wireframe_frag_glsl[];
107 extern char datatoc_gpu_shader_depth_only_frag_glsl[];
108
109 extern char datatoc_common_view_lib_glsl[];
110
111 /* Functions */
112 static void overlay_engine_init(void *vedata)
113 {
114   OVERLAY_Data *data = vedata;
115   OVERLAY_StorageList *stl = data->stl;
116
117   const DRWContextState *draw_ctx = DRW_context_state_get();
118   OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
119
120   if (!stl->g_data) {
121     /* Alloc transient pointers */
122     stl->g_data = MEM_callocN(sizeof(*stl->g_data), __func__);
123   }
124
125   stl->g_data->clear_stencil = (draw_ctx->v3d->shading.type > OB_SOLID);
126
127   const GPUShaderConfigData *sh_cfg_data = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
128
129   if (!sh_data->face_orientation) {
130     /* Face orientation */
131     sh_data->face_orientation = GPU_shader_create_from_arrays({
132         .vert = (const char *[]){sh_cfg_data->lib,
133                                  datatoc_common_view_lib_glsl,
134                                  datatoc_overlay_face_orientation_vert_glsl,
135                                  NULL},
136         .frag = (const char *[]){datatoc_overlay_face_orientation_frag_glsl, NULL},
137         .defs = (const char *[]){sh_cfg_data->def, NULL},
138     });
139   }
140
141   if (!sh_data->face_wireframe) {
142     sh_data->select_wireframe = GPU_shader_create_from_arrays({
143         .vert = (const char *[]){sh_cfg_data->lib,
144                                  datatoc_common_view_lib_glsl,
145                                  datatoc_overlay_face_wireframe_vert_glsl,
146                                  NULL},
147         .geom = (const char *[]){sh_cfg_data->lib, datatoc_overlay_face_wireframe_geom_glsl, NULL},
148         .frag = (const char *[]){datatoc_gpu_shader_depth_only_frag_glsl, NULL},
149         .defs = (const char *[]){sh_cfg_data->def, "#define SELECT_EDGES\n", NULL},
150     });
151 #if USE_GEOM_SHADER_WORKAROUND
152     /* Apple drivers does not support wide wires. Use geometry shader as a workaround. */
153     sh_data->face_wireframe = GPU_shader_create_from_arrays({
154         .vert = (const char *[]){sh_cfg_data->lib,
155                                  datatoc_common_view_lib_glsl,
156                                  datatoc_overlay_face_wireframe_vert_glsl,
157                                  NULL},
158         .geom = (const char *[]){sh_cfg_data->lib, datatoc_overlay_face_wireframe_geom_glsl, NULL},
159         .frag = (const char *[]){datatoc_overlay_face_wireframe_frag_glsl, NULL},
160         .defs = (const char *[]){sh_cfg_data->def, "#define USE_GEOM\n", NULL},
161     });
162 #else
163     sh_data->face_wireframe = GPU_shader_create_from_arrays({
164         .vert = (const char *[]){sh_cfg_data->lib,
165                                  datatoc_common_view_lib_glsl,
166                                  datatoc_overlay_face_wireframe_vert_glsl,
167                                  NULL},
168         .frag = (const char *[]){datatoc_overlay_face_wireframe_frag_glsl, NULL},
169         .defs = (const char *[]){sh_cfg_data->def, NULL},
170     });
171 #endif
172   }
173
174   stl->g_data->view_wires = DRW_view_create_with_zoffset(draw_ctx->rv3d, 0.5f);
175 }
176
177 static void geometry_shader_uniforms(DRWShadingGroup *shgrp)
178 {
179   DRW_shgroup_uniform_float_copy(shgrp, "wireSize", U.pixelsize * 0.5f);
180   DRW_shgroup_uniform_vec2(shgrp, "viewportSize", DRW_viewport_size_get(), 1);
181   DRW_shgroup_uniform_vec2(shgrp, "viewportSizeInv", DRW_viewport_invert_size_get(), 1);
182 }
183
184 static void overlay_cache_init(void *vedata)
185 {
186   OVERLAY_Data *data = vedata;
187   OVERLAY_PassList *psl = data->psl;
188   OVERLAY_StorageList *stl = data->stl;
189   OVERLAY_PrivateData *g_data = stl->g_data;
190
191   const DRWContextState *draw_ctx = DRW_context_state_get();
192   RegionView3D *rv3d = draw_ctx->rv3d;
193   View3D *v3d = draw_ctx->v3d;
194   OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
195
196   if (v3d) {
197     g_data->overlay = v3d->overlay;
198     g_data->show_overlays = (v3d->flag2 & V3D_HIDE_OVERLAYS) == 0;
199   }
200   else {
201     memset(&g_data->overlay, 0, sizeof(g_data->overlay));
202     g_data->show_overlays = false;
203   }
204
205   if (g_data->show_overlays == false) {
206     g_data->overlay.flag = 0;
207   }
208
209   if (v3d->shading.type == OB_WIRE) {
210     g_data->overlay.flag |= V3D_OVERLAY_WIREFRAMES;
211
212     if (ELEM(v3d->shading.wire_color_type, V3D_SHADING_OBJECT_COLOR, V3D_SHADING_RANDOM_COLOR)) {
213       g_data->wire_color_mempool = BLI_mempool_create(sizeof(float[3]), 0, 512, 0);
214     }
215   }
216
217   {
218     /* Face Orientation Pass */
219     DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_EQUAL | DRW_STATE_BLEND_ALPHA;
220     psl->face_orientation_pass = DRW_pass_create("Face Orientation", state);
221     g_data->face_orientation_shgrp = DRW_shgroup_create(sh_data->face_orientation,
222                                                         psl->face_orientation_pass);
223     if (rv3d->rflag & RV3D_CLIPPING) {
224       DRW_shgroup_state_enable(g_data->face_orientation_shgrp, DRW_STATE_CLIP_PLANES);
225     }
226   }
227
228   {
229     /* Wireframe */
230     const bool use_select = (DRW_state_is_select() || DRW_state_is_depth());
231     GPUShader *face_wires_sh = use_select ? sh_data->select_wireframe : sh_data->face_wireframe;
232
233     DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL |
234                      DRW_STATE_STENCIL_EQUAL | DRW_STATE_FIRST_VERTEX_CONVENTION;
235     psl->face_wireframe_pass = DRW_pass_create("Wires", state);
236     g_data->face_wires_shgrp = DRW_shgroup_create(face_wires_sh, psl->face_wireframe_pass);
237
238     DRWState state_xray = DRW_STATE_WRITE_DEPTH | DRW_STATE_WRITE_STENCIL |
239                           DRW_STATE_DEPTH_GREATER_EQUAL | DRW_STATE_STENCIL_NEQUAL |
240                           DRW_STATE_FIRST_VERTEX_CONVENTION;
241     psl->face_wireframe_xray_pass = DRW_pass_create("Wires Only Xray", state_xray);
242     g_data->face_wires_xray_shgrp = DRW_shgroup_create(face_wires_sh,
243                                                        psl->face_wireframe_xray_pass);
244
245     if (use_select || USE_GEOM_SHADER_WORKAROUND) {
246       geometry_shader_uniforms(g_data->face_wires_shgrp);
247       geometry_shader_uniforms(g_data->face_wires_xray_shgrp);
248     }
249     if (rv3d->rflag & RV3D_CLIPPING) {
250       DRW_shgroup_state_enable(g_data->face_wires_shgrp, DRW_STATE_CLIP_PLANES);
251       DRW_shgroup_state_enable(g_data->face_wires_xray_shgrp, DRW_STATE_CLIP_PLANES);
252     }
253
254     g_data->wire_step_param = stl->g_data->overlay.wireframe_threshold - 254.0f / 255.0f;
255   }
256 }
257
258 static void overlay_wire_color_get(const View3D *v3d,
259                                    const OVERLAY_PrivateData *pd,
260                                    const Object *ob,
261                                    const bool use_coloring,
262                                    float **rim_col,
263                                    float **wire_col)
264 {
265 #ifndef NDEBUG
266   *rim_col = NULL;
267   *wire_col = NULL;
268 #endif
269   const DRWContextState *draw_ctx = DRW_context_state_get();
270
271   if (UNLIKELY(ob->base_flag & BASE_FROM_SET)) {
272     *rim_col = G_draw.block.colorDupli;
273     *wire_col = G_draw.block.colorDupli;
274   }
275   else if (UNLIKELY(ob->base_flag & BASE_FROM_DUPLI)) {
276     if (ob->base_flag & BASE_SELECTED) {
277       if (G.moving & G_TRANSFORM_OBJ) {
278         *rim_col = G_draw.block.colorTransform;
279       }
280       else {
281         *rim_col = G_draw.block.colorDupliSelect;
282       }
283     }
284     else {
285       *rim_col = G_draw.block.colorDupli;
286     }
287     *wire_col = G_draw.block.colorDupli;
288   }
289   else if ((ob->base_flag & BASE_SELECTED) && use_coloring) {
290     if (G.moving & G_TRANSFORM_OBJ) {
291       *rim_col = G_draw.block.colorTransform;
292     }
293     else if (ob == draw_ctx->obact) {
294       *rim_col = G_draw.block.colorActive;
295     }
296     else {
297       *rim_col = G_draw.block.colorSelect;
298     }
299     *wire_col = G_draw.block.colorWire;
300   }
301   else {
302     *rim_col = G_draw.block.colorWire;
303     *wire_col = G_draw.block.colorBackground;
304   }
305
306   if (v3d->shading.type == OB_WIRE) {
307     if (ELEM(v3d->shading.wire_color_type, V3D_SHADING_OBJECT_COLOR, V3D_SHADING_RANDOM_COLOR)) {
308       *wire_col = BLI_mempool_alloc(pd->wire_color_mempool);
309       *rim_col = BLI_mempool_alloc(pd->wire_color_mempool);
310
311       if (v3d->shading.wire_color_type == V3D_SHADING_OBJECT_COLOR) {
312         linearrgb_to_srgb_v3_v3(*wire_col, ob->color);
313         mul_v3_fl(*wire_col, 0.5f);
314         copy_v3_v3(*rim_col, *wire_col);
315       }
316       else {
317         uint hash = BLI_ghashutil_strhash_p_murmur(ob->id.name);
318         if (ob->id.lib) {
319           hash = (hash * 13) ^ BLI_ghashutil_strhash_p_murmur(ob->id.lib->name);
320         }
321
322         float hue = BLI_hash_int_01(hash);
323         float hsv[3] = {hue, 0.75f, 0.8f};
324         hsv_to_rgb_v(hsv, *wire_col);
325         copy_v3_v3(*rim_col, *wire_col);
326       }
327
328       if ((ob->base_flag & BASE_SELECTED) && use_coloring) {
329         /* "Normalize" color. */
330         add_v3_fl(*wire_col, 1e-4f);
331         float brightness = max_fff((*wire_col)[0], (*wire_col)[1], (*wire_col)[2]);
332         mul_v3_fl(*wire_col, (0.5f / brightness));
333         add_v3_fl(*rim_col, 0.75f);
334       }
335       else {
336         mul_v3_fl(*rim_col, 0.5f);
337         add_v3_fl(*wire_col, 0.5f);
338       }
339     }
340   }
341   BLI_assert(*rim_col && *wire_col);
342 }
343
344 static void overlay_cache_populate(void *vedata, Object *ob)
345 {
346   OVERLAY_Data *data = vedata;
347   OVERLAY_StorageList *stl = data->stl;
348   OVERLAY_PrivateData *pd = stl->g_data;
349   const DRWContextState *draw_ctx = DRW_context_state_get();
350   View3D *v3d = draw_ctx->v3d;
351
352   if ((ob->dt < OB_WIRE) || (!DRW_object_is_renderable(ob) && (ob->dt != OB_WIRE))) {
353     return;
354   }
355
356   if (DRW_object_is_renderable(ob) && pd->overlay.flag & V3D_OVERLAY_FACE_ORIENTATION) {
357     struct GPUBatch *geom = DRW_cache_object_surface_get(ob);
358     if (geom) {
359       DRW_shgroup_call(pd->face_orientation_shgrp, geom, ob);
360     }
361   }
362
363   if ((pd->overlay.flag & V3D_OVERLAY_WIREFRAMES) || (v3d->shading.type == OB_WIRE) ||
364       (ob->dtx & OB_DRAWWIRE) || (ob->dt == OB_WIRE)) {
365
366     /* Fast path for duplis. */
367     OVERLAY_DupliData **dupli_data = (OVERLAY_DupliData **)DRW_duplidata_get(vedata);
368     if (dupli_data) {
369       if (*dupli_data == NULL) {
370         *dupli_data = MEM_callocN(sizeof(OVERLAY_DupliData), "OVERLAY_DupliData");
371       }
372       else {
373         if ((*dupli_data)->shgrp && (*dupli_data)->geom) {
374           if ((*dupli_data)->base_flag == ob->base_flag) {
375             DRW_shgroup_call((*dupli_data)->shgrp, (*dupli_data)->geom, ob);
376           }
377           else {
378             /* Continue and create a new Shgroup. */
379           }
380         }
381         else {
382           return;
383         }
384       }
385     }
386
387     const bool is_edit_mode = BKE_object_is_in_editmode(ob);
388     bool has_edit_mesh_cage = false;
389     if (ob->type == OB_MESH) {
390       /* TODO: Should be its own function. */
391       Mesh *me = (Mesh *)ob->data;
392       BMEditMesh *embm = me->edit_mesh;
393       if (embm) {
394         has_edit_mesh_cage = embm->mesh_eval_cage &&
395                              (embm->mesh_eval_cage != embm->mesh_eval_final);
396       }
397     }
398
399     /* Don't do that in edit Mesh mode, unless there is a modifier preview. */
400     if ((!pd->show_overlays) ||
401         (((ob != draw_ctx->object_edit) && !is_edit_mode) || has_edit_mesh_cage) ||
402         ob->type != OB_MESH) {
403       const bool use_sculpt_pbvh = BKE_sculptsession_use_pbvh_draw(ob, draw_ctx->v3d);
404       const bool all_wires = (ob->dtx & OB_DRAW_ALL_EDGES);
405       const bool is_wire = (ob->dt < OB_SOLID);
406       const bool is_xray = (ob->dtx & OB_DRAWXRAY);
407       const bool use_coloring = (pd->show_overlays && !is_edit_mode && !use_sculpt_pbvh &&
408                                  !has_edit_mesh_cage);
409       DRWShadingGroup *shgrp = NULL;
410
411       struct GPUBatch *geom;
412       geom = DRW_cache_object_face_wireframe_get(ob);
413
414       if (geom || use_sculpt_pbvh) {
415         if (is_wire && is_xray) {
416           shgrp = DRW_shgroup_create_sub(pd->face_wires_xray_shgrp);
417         }
418         else {
419           shgrp = DRW_shgroup_create_sub(pd->face_wires_shgrp);
420         }
421
422         float wire_step_param = 10.0f;
423         if (!use_sculpt_pbvh) {
424           wire_step_param = (all_wires) ? 1.0f : pd->wire_step_param;
425         }
426         DRW_shgroup_uniform_float_copy(shgrp, "wireStepParam", wire_step_param);
427
428         if (!(DRW_state_is_select() || DRW_state_is_depth())) {
429           float *rim_col, *wire_col;
430           overlay_wire_color_get(v3d, pd, ob, use_coloring, &rim_col, &wire_col);
431           DRW_shgroup_uniform_vec3(shgrp, "wireColor", wire_col, 1);
432           DRW_shgroup_uniform_vec3(shgrp, "rimColor", rim_col, 1);
433           DRW_shgroup_stencil_mask(shgrp,
434                                    (is_xray && (is_wire || !pd->clear_stencil)) ? 0x00 : 0xFF);
435         }
436
437         if (use_sculpt_pbvh) {
438           DRW_shgroup_call_sculpt(shgrp, ob, true, false, false);
439         }
440         else {
441           DRW_shgroup_call(shgrp, geom, ob);
442         }
443       }
444
445       if (dupli_data) {
446         (*dupli_data)->shgrp = shgrp;
447         (*dupli_data)->geom = geom;
448         (*dupli_data)->base_flag = ob->base_flag;
449       }
450     }
451   }
452 }
453
454 static void overlay_draw_scene(void *vedata)
455 {
456   OVERLAY_Data *data = vedata;
457   OVERLAY_PassList *psl = data->psl;
458   OVERLAY_StorageList *stl = data->stl;
459   DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get();
460   DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
461
462   if (DRW_state_is_fbo()) {
463     GPU_framebuffer_bind(dfbl->default_fb);
464
465     /* In material/rendered mode, Stencil has not be rendered correctly.
466      * Clear it to avoid problems.*/
467     if (stl->g_data->clear_stencil) {
468       GPU_framebuffer_clear_stencil(dfbl->default_fb, 0xFF);
469     }
470   }
471   DRW_draw_pass(psl->face_orientation_pass);
472
473   /* Do a depth prepass to lower the depth where the xray wire objects can pass through */
474   DRW_draw_pass(psl->face_wireframe_xray_pass);
475
476   /* This is replaced by the next code block  */
477   // MULTISAMPLE_SYNC_ENABLE(dfbl, dtxl);
478
479   if (dfbl->multisample_fb != NULL && DRW_state_is_fbo()) {
480     DRW_stats_query_start("Multisample Blit");
481     GPU_framebuffer_bind(dfbl->multisample_fb);
482     GPU_framebuffer_clear_color(dfbl->multisample_fb, (const float[4]){0.0f});
483     /* Special blit: we need the original depth and stencil
484      * in the Multisample buffer. */
485     GPU_framebuffer_blit(
486         dfbl->default_fb, 0, dfbl->multisample_fb, 0, GPU_DEPTH_BIT | GPU_STENCIL_BIT);
487     DRW_stats_query_end();
488
489     /* Redo the prepass so we ge nice AA lines. */
490     DRW_draw_pass(psl->face_wireframe_xray_pass);
491   }
492
493   DRW_view_set_active(stl->g_data->view_wires);
494
495   DRW_pass_state_remove(psl->face_wireframe_xray_pass,
496                         DRW_STATE_DEPTH_GREATER_EQUAL | DRW_STATE_STENCIL_NEQUAL);
497   DRW_pass_state_add(psl->face_wireframe_xray_pass,
498                      DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_LESS_EQUAL |
499                          DRW_STATE_STENCIL_ALWAYS);
500   DRW_draw_pass(psl->face_wireframe_xray_pass);
501
502   DRW_draw_pass(psl->face_wireframe_pass);
503
504   DRW_view_set_active(NULL);
505
506   /* TODO(fclem): find a way to unify the multisample pass together
507    * (non meshes + armature + wireframe) */
508   MULTISAMPLE_SYNC_DISABLE(dfbl, dtxl);
509
510   /* XXX TODO(fclem) do not discard data after drawing! Store them per viewport. */
511   if (stl->g_data->wire_color_mempool) {
512     BLI_mempool_destroy(stl->g_data->wire_color_mempool);
513     stl->g_data->wire_color_mempool = NULL;
514   }
515 }
516
517 static void overlay_engine_free(void)
518 {
519   for (int sh_data_index = 0; sh_data_index < ARRAY_SIZE(e_data.sh_data); sh_data_index++) {
520     OVERLAY_Shaders *sh_data = &e_data.sh_data[sh_data_index];
521     GPUShader **sh_data_as_array = (GPUShader **)sh_data;
522     for (int i = 0; i < (sizeof(OVERLAY_Shaders) / sizeof(GPUShader *)); i++) {
523       DRW_SHADER_FREE_SAFE(sh_data_as_array[i]);
524     }
525   }
526 }
527
528 static const DrawEngineDataSize overlay_data_size = DRW_VIEWPORT_DATA_SIZE(OVERLAY_Data);
529
530 DrawEngineType draw_engine_overlay_type = {
531     NULL,
532     NULL,
533     N_("OverlayEngine"),
534     &overlay_data_size,
535     &overlay_engine_init,
536     &overlay_engine_free,
537     &overlay_cache_init,
538     &overlay_cache_populate,
539     NULL,
540     NULL,
541     &overlay_draw_scene,
542     NULL,
543     NULL,
544     NULL,
545 };