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.
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.
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.
16 * Copyright 2016, Blender Foundation.
19 /** \file overlay_mode.c
20 * \ingroup draw_engine
23 #include "DNA_mesh_types.h"
24 #include "DNA_view3d_types.h"
26 #include "BKE_editmesh.h"
27 #include "BKE_object.h"
28 #include "BKE_global.h"
30 #include "GPU_shader.h"
31 #include "DRW_render.h"
35 typedef struct OVERLAY_StorageList {
36 struct OVERLAY_PrivateData *g_data;
37 } OVERLAY_StorageList;
39 typedef struct OVERLAY_PassList {
40 struct DRWPass *face_orientation_pass;
41 struct DRWPass *face_wireframe_pass;
44 typedef struct OVERLAY_Data {
46 DRWViewportEmptyList *fbl;
47 DRWViewportEmptyList *txl;
48 OVERLAY_PassList *psl;
49 OVERLAY_StorageList *stl;
52 typedef struct OVERLAY_PrivateData {
53 DRWShadingGroup *face_orientation_shgrp;
54 DRWShadingGroup *face_wires_shgrp;
55 DRWShadingGroup *flat_wires_shgrp;
56 DRWShadingGroup *sculpt_wires_shgrp;
57 View3DOverlay overlay;
58 float wire_step_param[2];
59 bool ghost_stencil_test;
61 } OVERLAY_PrivateData; /* Transient data */
63 typedef struct OVERLAY_Shaders {
64 /* Face orientation shader */
65 struct GPUShader *face_orientation;
66 /* Wireframe shader */
67 struct GPUShader *select_wireframe;
68 struct GPUShader *face_wireframe;
69 struct GPUShader *face_wireframe_sculpt;
72 /* *********** STATIC *********** */
74 OVERLAY_Shaders sh_data[GPU_SHADER_CFG_LEN];
77 extern char datatoc_gpu_shader_cfg_world_clip_lib_glsl[];
80 extern char datatoc_overlay_face_orientation_frag_glsl[];
81 extern char datatoc_overlay_face_orientation_vert_glsl[];
83 extern char datatoc_overlay_face_wireframe_vert_glsl[];
84 extern char datatoc_overlay_face_wireframe_geom_glsl[];
85 extern char datatoc_overlay_face_wireframe_frag_glsl[];
86 extern char datatoc_gpu_shader_depth_only_frag_glsl[];
89 static void overlay_engine_init(void *vedata)
91 OVERLAY_Data *data = vedata;
92 OVERLAY_StorageList *stl = data->stl;
94 const DRWContextState *draw_ctx = DRW_context_state_get();
95 OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->shader_cfg];
96 const bool is_clip = (draw_ctx->rv3d->rflag & RV3D_CLIPPING) != 0;
99 DRW_state_clip_planes_set_from_rv3d(draw_ctx->rv3d);
103 /* Alloc transient pointers */
104 stl->g_data = MEM_mallocN(sizeof(*stl->g_data), __func__);
106 stl->g_data->ghost_stencil_test = false;
108 const char *world_clip_lib_or_empty = is_clip ? datatoc_gpu_shader_cfg_world_clip_lib_glsl : "";
109 const char *world_clip_def_or_empty = is_clip ? "#define USE_WORLD_CLIP_PLANES\n" : "";
111 if (!sh_data->face_orientation) {
112 /* Face orientation */
113 sh_data->face_orientation = GPU_shader_create_from_arrays({
114 .vert = (const char *[]){world_clip_lib_or_empty, datatoc_overlay_face_orientation_vert_glsl, NULL},
115 .frag = (const char *[]){datatoc_overlay_face_orientation_frag_glsl, NULL},
116 .defs = (const char *[]){world_clip_def_or_empty, NULL},
120 if (!sh_data->face_wireframe) {
121 sh_data->select_wireframe = GPU_shader_create_from_arrays({
122 .vert = (const char *[]){world_clip_lib_or_empty, datatoc_overlay_face_wireframe_vert_glsl, NULL},
123 .geom = (const char *[]){world_clip_lib_or_empty, datatoc_overlay_face_wireframe_geom_glsl, NULL},
124 .frag = (const char *[]){datatoc_gpu_shader_depth_only_frag_glsl, NULL},
125 .defs = (const char *[]){world_clip_def_or_empty, "#define SELECT_EDGES\n", NULL},
127 sh_data->face_wireframe = GPU_shader_create_from_arrays({
128 .vert = (const char *[]){world_clip_lib_or_empty, datatoc_overlay_face_wireframe_vert_glsl, NULL},
129 .frag = (const char *[]){datatoc_overlay_face_wireframe_frag_glsl, NULL},
130 .defs = (const char *[]){world_clip_def_or_empty, NULL},
132 sh_data->face_wireframe_sculpt = GPU_shader_create_from_arrays({
133 .vert = (const char *[]){world_clip_lib_or_empty, datatoc_overlay_face_wireframe_vert_glsl, NULL},
134 .geom = (const char *[]){world_clip_lib_or_empty, datatoc_overlay_face_wireframe_geom_glsl, NULL},
135 .frag = (const char *[]){datatoc_overlay_face_wireframe_frag_glsl, NULL},
136 .defs = (const char *[]){world_clip_def_or_empty, "#define USE_SCULPT\n", NULL},
141 static void overlay_cache_init(void *vedata)
143 OVERLAY_Data *data = vedata;
144 OVERLAY_PassList *psl = data->psl;
145 OVERLAY_StorageList *stl = data->stl;
146 OVERLAY_PrivateData *g_data = stl->g_data;
148 const DRWContextState *draw_ctx = DRW_context_state_get();
149 RegionView3D *rv3d = draw_ctx->rv3d;
150 OVERLAY_Shaders *sh_data = &e_data.sh_data[draw_ctx->shader_cfg];
152 const DRWContextState *DCS = DRW_context_state_get();
154 View3D *v3d = DCS->v3d;
156 g_data->overlay = v3d->overlay;
157 g_data->show_overlays = (v3d->flag2 & V3D_RENDER_OVERRIDE) == 0;
160 memset(&g_data->overlay, 0, sizeof(g_data->overlay));
161 g_data->show_overlays = false;
164 if (g_data->show_overlays == false) {
165 g_data->overlay.flag = 0;
168 if (v3d->shading.type == OB_WIRE) {
169 g_data->overlay.flag |= V3D_OVERLAY_WIREFRAMES;
170 g_data->show_overlays = true;
174 /* Face Orientation Pass */
175 DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_EQUAL | DRW_STATE_BLEND;
176 psl->face_orientation_pass = DRW_pass_create("Face Orientation", state);
177 g_data->face_orientation_shgrp = DRW_shgroup_create(
178 sh_data->face_orientation, psl->face_orientation_pass);
179 if (rv3d->rflag & RV3D_CLIPPING) {
180 DRW_shgroup_world_clip_planes_from_rv3d(g_data->face_orientation_shgrp, rv3d);
186 DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_BLEND | DRW_STATE_FIRST_VERTEX_CONVENTION;
187 float wire_size = max_ff(0.0f, U.pixelsize - 1.0f) * 0.5f;
189 const bool use_select = (DRW_state_is_select() || DRW_state_is_depth());
190 GPUShader *sculpt_wire_sh = use_select ? sh_data->select_wireframe : sh_data->face_wireframe_sculpt;
191 GPUShader *face_wires_sh = use_select ? sh_data->select_wireframe : sh_data->face_wireframe;
192 GPUShader *flat_wires_sh = GPU_shader_get_builtin_shader(GPU_SHADER_3D_UNIFORM_COLOR);
194 psl->face_wireframe_pass = DRW_pass_create("Face Wires", state);
196 g_data->flat_wires_shgrp = DRW_shgroup_create(flat_wires_sh, psl->face_wireframe_pass);
197 if (rv3d->rflag & RV3D_CLIPPING) {
198 DRW_shgroup_world_clip_planes_from_rv3d(g_data->flat_wires_shgrp, rv3d);
201 g_data->sculpt_wires_shgrp = DRW_shgroup_create(sculpt_wire_sh, psl->face_wireframe_pass);
202 if (rv3d->rflag & RV3D_CLIPPING) {
203 DRW_shgroup_world_clip_planes_from_rv3d(g_data->sculpt_wires_shgrp, rv3d);
206 g_data->face_wires_shgrp = DRW_shgroup_create(face_wires_sh, psl->face_wireframe_pass);
207 DRW_shgroup_uniform_vec2(g_data->face_wires_shgrp, "wireStepParam", g_data->wire_step_param, 1);
208 if (rv3d->rflag & RV3D_CLIPPING) {
209 DRW_shgroup_world_clip_planes_from_rv3d(g_data->face_wires_shgrp, rv3d);
213 DRW_shgroup_uniform_float_copy(g_data->sculpt_wires_shgrp, "wireSize", wire_size);
214 DRW_shgroup_uniform_float_copy(g_data->face_wires_shgrp, "wireSize", wire_size);
217 /* Control aspect of the falloff. */
218 const float sharpness = 4.0f;
219 /* Scale and bias: Adjust with wiredata encoding. (see mesh_batch_cache_create_edges_wireframe_data) */
220 const float decompress = (0xFF / (float)(0xFF - 0x20));
221 g_data->wire_step_param[0] = -sharpness * decompress;
222 g_data->wire_step_param[1] = decompress + sharpness * stl->g_data->overlay.wireframe_threshold;
228 static void overlay_cache_populate(void *vedata, Object *ob)
230 OVERLAY_Data *data = vedata;
231 OVERLAY_StorageList *stl = data->stl;
232 OVERLAY_PrivateData *pd = stl->g_data;
233 const DRWContextState *draw_ctx = DRW_context_state_get();
234 RegionView3D *rv3d = draw_ctx->rv3d;
235 View3D *v3d = draw_ctx->v3d;
237 if ((!pd->show_overlays) ||
238 (ob->dt < OB_WIRE) ||
239 (!DRW_object_is_renderable(ob) && (ob->dt != OB_WIRE)))
244 if (DRW_object_is_renderable(ob) && pd->overlay.flag & V3D_OVERLAY_FACE_ORIENTATION) {
245 struct GPUBatch *geom = DRW_cache_object_surface_get(ob);
247 DRW_shgroup_call_add(pd->face_orientation_shgrp, geom, ob->obmat);
251 if ((pd->overlay.flag & V3D_OVERLAY_WIREFRAMES) ||
252 (v3d->shading.type == OB_WIRE) ||
253 (ob->dtx & OB_DRAWWIRE) ||
256 const bool is_edit_mode = BKE_object_is_in_editmode(ob);
257 bool has_edit_mesh_cage = false;
258 if (ob->type == OB_MESH) {
259 /* TODO: Should be its own function. */
260 Mesh *me = (Mesh *)ob->data;
261 BMEditMesh *embm = me->edit_btmesh;
263 has_edit_mesh_cage = embm->mesh_eval_cage && (embm->mesh_eval_cage != embm->mesh_eval_final);
267 /* Don't do that in edit Mesh mode, unless there is a modifier preview. */
268 if ((((ob != draw_ctx->object_edit) && !is_edit_mode) || has_edit_mesh_cage) ||
271 const bool is_active = (ob == draw_ctx->obact);
272 const bool is_sculpt_mode = is_active && (draw_ctx->object_mode & OB_MODE_SCULPT) != 0;
273 const bool all_wires = (pd->overlay.wireframe_threshold == 1.0f) ||
274 (ob->dtx & OB_DRAW_ALL_EDGES);
275 const bool is_wire = (ob->dt < OB_SOLID);
276 const int stencil_mask = (ob->dtx & OB_DRAWXRAY) ? 0x00 : 0xFF;
277 DRWShadingGroup *shgrp = NULL;
279 const float *rim_col = NULL;
280 const float *wire_col = NULL;
281 if (UNLIKELY(ob->base_flag & BASE_FROM_SET)) {
282 rim_col = G_draw.block.colorDupli;
283 wire_col = G_draw.block.colorDupli;
285 else if (UNLIKELY(ob->base_flag & BASE_FROM_DUPLI)) {
286 if (ob->base_flag & BASE_SELECTED) {
287 if (G.moving & G_TRANSFORM_OBJ) {
288 rim_col = G_draw.block.colorTransform;
291 rim_col = G_draw.block.colorDupliSelect;
295 rim_col = G_draw.block.colorDupli;
297 wire_col = G_draw.block.colorDupli;
299 else if ((ob->base_flag & BASE_SELECTED) &&
300 (!is_edit_mode && !is_sculpt_mode && !has_edit_mesh_cage))
302 if (G.moving & G_TRANSFORM_OBJ) {
303 rim_col = G_draw.block.colorTransform;
305 else if (ob == draw_ctx->obact) {
306 rim_col = G_draw.block.colorActive;
309 rim_col = G_draw.block.colorSelect;
311 wire_col = G_draw.block.colorWire;
314 rim_col = G_draw.block.colorWire;
315 wire_col = G_draw.block.colorWire;
317 BLI_assert(rim_col && wire_col);
319 /* This fixes only the biggest case which is a plane in ortho view. */
321 bool is_flat_object_viewed_from_side = (
322 (rv3d->persp == RV3D_ORTHO) &&
323 DRW_object_is_flat(ob, &flat_axis) &&
324 DRW_object_axis_orthogonal_to_view(ob, flat_axis));
326 if (is_flat_object_viewed_from_side && !is_sculpt_mode) {
327 /* Avoid losing flat objects when in ortho views (see T56549) */
328 struct GPUBatch *geom = DRW_cache_object_all_edges_get(ob);
330 shgrp = pd->flat_wires_shgrp;
331 shgrp = DRW_shgroup_create_sub(shgrp);
332 DRW_shgroup_stencil_mask(shgrp, stencil_mask);
333 DRW_shgroup_call_object_add(shgrp, geom, ob);
334 DRW_shgroup_uniform_vec4(shgrp, "color", rim_col, 1);
338 struct GPUBatch *geom = DRW_cache_object_face_wireframe_get(ob);
339 if (geom || is_sculpt_mode) {
340 shgrp = (is_sculpt_mode) ? pd->sculpt_wires_shgrp : pd->face_wires_shgrp;
341 shgrp = DRW_shgroup_create_sub(shgrp);
343 static float all_wires_params[2] = {0.0f, 10.0f}; /* Parameters for all wires */
344 DRW_shgroup_uniform_vec2(
345 shgrp, "wireStepParam", (all_wires) ?
346 all_wires_params : pd->wire_step_param, 1);
348 if (!(DRW_state_is_select() || DRW_state_is_depth())) {
349 DRW_shgroup_stencil_mask(shgrp, stencil_mask);
350 DRW_shgroup_uniform_vec3(shgrp, "wireColor", wire_col, 1);
351 DRW_shgroup_uniform_vec3(shgrp, "rimColor", rim_col, 1);
354 if (is_sculpt_mode) {
355 DRW_shgroup_call_sculpt_add(shgrp, ob, ob->obmat);
358 DRW_shgroup_call_add(shgrp, geom, ob->obmat);
362 if (is_wire && shgrp != NULL) {
363 /* If object is wireframe, don't try to use stencil test. */
364 DRW_shgroup_state_disable(shgrp, DRW_STATE_STENCIL_EQUAL);
366 if (ob->dtx & OB_DRAWXRAY) {
367 DRW_shgroup_state_disable(shgrp, DRW_STATE_DEPTH_LESS_EQUAL);
370 else if ((ob->dtx & OB_DRAWXRAY) && shgrp != NULL) {
371 pd->ghost_stencil_test = true;
377 static void overlay_cache_finish(void *vedata)
379 OVERLAY_Data *data = vedata;
380 OVERLAY_PassList *psl = data->psl;
381 OVERLAY_StorageList *stl = data->stl;
383 const DRWContextState *ctx = DRW_context_state_get();
384 View3D *v3d = ctx->v3d;
386 /* only in solid mode */
387 if (v3d->shading.type == OB_SOLID && (v3d->shading.flag & XRAY_FLAG(v3d)) == 0) {
388 if (stl->g_data->ghost_stencil_test) {
389 DRW_pass_state_add(psl->face_wireframe_pass, DRW_STATE_STENCIL_EQUAL);
394 static void overlay_draw_scene(void *vedata)
396 OVERLAY_Data *data = vedata;
397 OVERLAY_PassList *psl = data->psl;
398 DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get();
400 if (DRW_state_is_fbo()) {
401 GPU_framebuffer_bind(dfbl->default_fb);
403 DRW_draw_pass(psl->face_orientation_pass);
404 DRW_draw_pass(psl->face_wireframe_pass);
407 static void overlay_engine_free(void)
409 for (int sh_data_index = 0; sh_data_index < ARRAY_SIZE(e_data.sh_data); sh_data_index++) {
410 OVERLAY_Shaders *sh_data = &e_data.sh_data[sh_data_index];
411 GPUShader **sh_data_as_array = (GPUShader **)sh_data;
412 for (int i = 0; i < (sizeof(OVERLAY_Shaders) / sizeof(GPUShader *)); i++) {
413 DRW_SHADER_FREE_SAFE(sh_data_as_array[i]);
418 static const DrawEngineDataSize overlay_data_size = DRW_VIEWPORT_DATA_SIZE(OVERLAY_Data);
420 DrawEngineType draw_engine_overlay_type = {
424 &overlay_engine_init,
425 &overlay_engine_free,
427 &overlay_cache_populate,
428 &overlay_cache_finish,