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