Edit Mode overlay: Moved Shaders to draw modules and resolved some draw issue.

We don't want to clutter gpu_shader.c with engine specific code
Added face's center dot
Simplified loose vert shader

21 files changed, 357 insertions, 117 deletions

diff --git a/source/blender/blenkernel/BKE_mesh_render.h b/source/blender/blenkernel/BKE_mesh_render.h
index 0370426d417..31c57d4513d 100644
--- a/source/blender/blenkernel/BKE_mesh_render.h
+++ b/source/blender/blenkernel/BKE_mesh_render.h
@@ -43,5 +43,6 @@ struct Batch *BKE_mesh_batch_cache_get_fancy_edges(struct Mesh *me);
 struct Batch *BKE_mesh_batch_cache_get_overlay_triangles(struct Mesh *me);
 struct Batch *BKE_mesh_batch_cache_get_overlay_loose_edges(struct Mesh *me);
 struct Batch *BKE_mesh_batch_cache_get_overlay_loose_verts(struct Mesh *me);
+struct Batch *BKE_mesh_batch_cache_get_overlay_facedots(struct Mesh *me);
 
 #endif /* __BKE_MESH_RENDER_H__ */
diff --git a/source/blender/blenkernel/intern/mesh_render.c b/source/blender/blenkernel/intern/mesh_render.c
index 9488b80f204..da88d35b986 100644
--- a/source/blender/blenkernel/intern/mesh_render.c
+++ b/source/blender/blenkernel/intern/mesh_render.c
@@ -298,7 +298,7 @@ static int UNUSED_FUNCTION(mesh_render_data_loops_num_get)(const MeshRenderData
 	return mrdata->totloop;
 }
 
-static int UNUSED_FUNCTION(mesh_render_data_polys_num_get)(const MeshRenderData *mrdata)
+static int mesh_render_data_polys_num_get(const MeshRenderData *mrdata)
 {
 	BLI_assert(mrdata->types & MR_DATATYPE_POLY);
 	return mrdata->totpoly;
@@ -334,6 +334,26 @@ static void mesh_render_data_edge_verts_indices_get(const MeshRenderData *mrdata
 	}
 }
 
+static void mesh_render_data_poly_center_select_get(MeshRenderData *mrdata, const int poly, float center[3], bool *selected)
+{
+	BLI_assert(mrdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_LOOP | MR_DATATYPE_POLY));
+
+	if (mrdata->edit_bmesh) {
+		const BMFace *bf = BM_face_at_index(mrdata->edit_bmesh->bm, poly);
+		BM_face_calc_center_mean(bf, center);
+		*selected = (BM_elem_flag_test(bf, BM_ELEM_SELECT) != 0) ? true : false;
+	}
+	else {
+		MVert *mvert = mrdata->mvert;
+		const MPoly *mpoly = mrdata->mpoly + poly;
+		const MLoop *mloop = mrdata->mloop + mpoly->loopstart;
+
+		BKE_mesh_calc_poly_center(mpoly, mloop, mvert, center);
+
+		*selected = false; /* No selection if not in edit mode */
+	}
+}
+
 static bool mesh_render_data_edge_exists(MeshRenderData *mrdata, const int v1, const int v2)
 {
 	BLI_assert(mrdata->types & MR_DATATYPE_EDGE);
@@ -705,6 +725,7 @@ typedef struct MeshBatchCache {
 	Batch *overlay_triangles;
 	Batch *overlay_loose_verts;
 	Batch *overlay_loose_edges;
+	Batch *overlay_facedots;
 
 	/* settings to determine if cache is invalid */
 	bool is_dirty;
@@ -806,6 +827,7 @@ void BKE_mesh_batch_cache_clear(Mesh *me)
 	if (cache->overlay_triangles) Batch_discard(cache->overlay_triangles);
 	if (cache->overlay_loose_verts) Batch_discard(cache->overlay_loose_verts);
 	if (cache->overlay_loose_edges) Batch_discard(cache->overlay_loose_edges);
+	if (cache->overlay_facedots) Batch_discard(cache->overlay_facedots);
 
 	if (cache->triangles_with_normals) {
 		Batch_discard_all(cache->triangles_with_normals);
@@ -1163,4 +1185,40 @@ Batch *BKE_mesh_batch_cache_get_overlay_loose_verts(Mesh *me)
 	return cache->overlay_loose_verts;
 }
 
+Batch *BKE_mesh_batch_cache_get_overlay_facedots(Mesh *me)
+{
+	MeshBatchCache *cache = mesh_batch_cache_get(me);
+
+	if (cache->overlay_facedots == NULL) {
+		MeshRenderData *mrdata = mesh_render_data_create(me, MR_DATATYPE_VERT | MR_DATATYPE_LOOP | MR_DATATYPE_POLY);
+
+		static VertexFormat format = { 0 };
+		static unsigned pos_id, data_id;
+		if (format.attrib_ct == 0) {
+			/* initialize vertex format */
+			pos_id = add_attrib(&format, "pos", GL_FLOAT, 3, KEEP_FLOAT);
+			data_id = add_attrib(&format, "data", GL_INT, 1, KEEP_INT);
+		}
+
+		const int poly_ct = mesh_render_data_polys_num_get(mrdata);
+
+		VertexBuffer *vbo = VertexBuffer_create_with_format(&format);
+		VertexBuffer_allocate_data(vbo, poly_ct);
+
+		for (int i = 0; i < poly_ct; ++i) {
+			float poly_center[3];
+			int selected = 0;
+			mesh_render_data_poly_center_select_get(mrdata, i, poly_center, (bool *)&selected);
+			setAttrib(vbo, pos_id, i, poly_center);
+			setAttrib(vbo, data_id, i, &selected);
+		}
+
+		cache->overlay_facedots = Batch_create(GL_POINTS, vbo, NULL);
+
+		mesh_render_data_free(mrdata);
+	}
+
+	return cache->overlay_facedots;
+}
+
 #undef MESH_RENDER_FUNCTION
diff --git a/source/blender/draw/CMakeLists.txt b/source/blender/draw/CMakeLists.txt
index 12722ff23ef..ea1d179aa40 100644
--- a/source/blender/draw/CMakeLists.txt
+++ b/source/blender/draw/CMakeLists.txt
@@ -27,7 +27,7 @@ set(INC
 	.
 	intern
 	engines/clay
-	modes/
+	modes
 
 	../blenkernel
 	../blenlib
@@ -82,6 +82,14 @@ data_to_c_simple(engines/clay/shaders/clay_vert.glsl SRC)
 data_to_c_simple(engines/clay/shaders/ssao_alchemy.glsl SRC)
 data_to_c_simple(engines/clay/shaders/ssao_groundtruth.glsl SRC)
 
+data_to_c_simple(modes/shaders/edit_overlay_frag.glsl SRC)
+data_to_c_simple(modes/shaders/edit_overlay_vert.glsl SRC)
+data_to_c_simple(modes/shaders/edit_overlay_geom_tri.glsl SRC)
+data_to_c_simple(modes/shaders/edit_overlay_geom_edge.glsl SRC)
+data_to_c_simple(modes/shaders/edit_overlay_loosevert_vert.glsl SRC)
+data_to_c_simple(modes/shaders/edit_overlay_facedot_frag.glsl SRC)
+data_to_c_simple(modes/shaders/edit_overlay_facedot_vert.glsl SRC)
+
 list(APPEND INC
 )
 
diff --git a/source/blender/draw/engines/clay/clay.c b/source/blender/draw/engines/clay/clay.c
index 54bae5de85c..bde1ffe2fa7 100644
--- a/source/blender/draw/engines/clay/clay.c
+++ b/source/blender/draw/engines/clay/clay.c
@@ -754,7 +754,7 @@ static void CLAY_collection_settings_create(RenderEngine *UNUSED(engine), Collec
 	BKE_collection_engine_property_add_float(ces, "ssao_factor_edge", 1.0f);
 }
 
-void clay_engine_free(void)
+void CLAY_engine_free(void)
 {
 	/* data.depth_sh Is builtin so it's automaticaly freed */
 	if (data.clay_sh) {
diff --git a/source/blender/draw/engines/clay/clay.h b/source/blender/draw/engines/clay/clay.h
index add2a45fbd7..34dd74b9500 100644
--- a/source/blender/draw/engines/clay/clay.h
+++ b/source/blender/draw/engines/clay/clay.h
@@ -31,6 +31,6 @@ extern RenderEngineType viewport_clay_type;
 struct RenderEngineSettings *CLAY_render_settings_create(void);
 struct MaterialEngineSettings *CLAY_material_settings_create(void);
 
-void clay_engine_free(void);
+void CLAY_engine_free(void);
 
 #endif /* __CLAY_H__ */
diff --git a/source/blender/draw/intern/draw_cache.c b/source/blender/draw/intern/draw_cache.c
index f8d81458435..c16e7c23f0d 100644
--- a/source/blender/draw/intern/draw_cache.c
+++ b/source/blender/draw/intern/draw_cache.c
@@ -868,8 +868,6 @@ Batch *DRW_cache_single_vert_get(void)
 /* Meshes */
 void DRW_cache_wire_overlay_get(Object *ob, Batch **tris, Batch **ledges, Batch **lverts)
 {
-	Batch *overlay_wire = NULL;
-
 	BLI_assert(ob->type == OB_MESH);
 
 	Mesh *me = ob->data;
@@ -877,8 +875,15 @@ void DRW_cache_wire_overlay_get(Object *ob, Batch **tris, Batch **ledges, Batch
 	*tris = BKE_mesh_batch_cache_get_overlay_triangles(me);
 	*ledges = BKE_mesh_batch_cache_get_overlay_loose_edges(me);
 	*lverts = BKE_mesh_batch_cache_get_overlay_loose_verts(me);
+}
+
+Batch *DRW_cache_face_centers_get(Object *ob)
+{
+	BLI_assert(ob->type == OB_MESH);
+
+	Mesh *me = ob->data;
 
-	return overlay_wire;
+	return BKE_mesh_batch_cache_get_overlay_facedots(me);
 }
 
 Batch *DRW_cache_wire_outline_get(Object *ob)
diff --git a/source/blender/draw/intern/draw_cache.h b/source/blender/draw/intern/draw_cache.h
index f34dc54729a..042bc65b17c 100644
--- a/source/blender/draw/intern/draw_cache.h
+++ b/source/blender/draw/intern/draw_cache.h
@@ -63,6 +63,7 @@ struct Batch *DRW_cache_bone_arrows_get(void);
 /* Meshes */
 void DRW_cache_wire_overlay_get(
 	struct Object *ob, struct Batch **tris, struct Batch **ledges, struct Batch **lverts);
+struct Batch *DRW_cache_face_centers_get(struct Object *ob);
 struct Batch *DRW_cache_wire_outline_get(struct Object *ob);
 struct Batch *DRW_cache_surface_get(struct Object *ob);
 
diff --git a/source/blender/draw/intern/draw_manager.c b/source/blender/draw/intern/draw_manager.c
index c9e788fd8a8..d4b773f8d1b 100644
--- a/source/blender/draw/intern/draw_manager.c
+++ b/source/blender/draw/intern/draw_manager.c
@@ -1372,7 +1372,9 @@ extern struct GPUUniformBuffer *globals_ubo; /* draw_mode_pass.c */
 void DRW_engines_free(void)
 {
 #ifdef WITH_CLAY_ENGINE
-	clay_engine_free();
+	CLAY_engine_free();
+
+	EDIT_MESH_engine_free();
 
 	DRW_shape_cache_free();
 
diff --git a/source/blender/draw/intern/draw_mode_pass.c b/source/blender/draw/intern/draw_mode_pass.c
index 1d16ef26f56..7bf34c4a9b1 100644
--- a/source/blender/draw/intern/draw_mode_pass.c
+++ b/source/blender/draw/intern/draw_mode_pass.c
@@ -113,7 +113,7 @@ void DRW_update_global_values(void)
 
 	/* M_SQRT2 to be at least the same size of the old square */
 	ts.sizeVertex = UI_GetThemeValuef(TH_VERTEX_SIZE) * M_SQRT2 / 2.0f;
-	ts.sizeFaceDot = UI_GetThemeValuef(TH_FACEDOT_SIZE) * M_SQRT2 / 2.0f;
+	ts.sizeFaceDot = UI_GetThemeValuef(TH_FACEDOT_SIZE) * M_SQRT2;
 	ts.sizeEdge = 1.0f / 2.0f; /* TODO Theme */
 	ts.sizeEdgeFix = 0.5f + 2.0f * (2.0f * (MAX2(ts.sizeVertex, ts.sizeEdge)) * M_SQRT1_2);
 	ts.sizeNormal = 1.0f; /* TODO compute */
diff --git a/source/blender/draw/modes/edit_mesh_mode.c b/source/blender/draw/modes/edit_mesh_mode.c
index 1f394870c40..4177e7b843f 100644
--- a/source/blender/draw/modes/edit_mesh_mode.c
+++ b/source/blender/draw/modes/edit_mesh_mode.c
@@ -46,43 +46,117 @@ static DRWShadingGroup *depth_shgrp_hidden_wire;
 static DRWShadingGroup *face_overlay_shgrp;
 static DRWShadingGroup *ledges_overlay_shgrp;
 static DRWShadingGroup *lverts_overlay_shgrp;
+static DRWShadingGroup *facedot_overlay_shgrp;
 
 extern struct GPUUniformBuffer *globals_ubo; /* draw_mode_pass.c */
 
+static struct GPUShader *overlay_tri_sh = NULL;
+static struct GPUShader *overlay_tri_fast_sh = NULL;
+static struct GPUShader *overlay_tri_vcol_sh = NULL;
+static struct GPUShader *overlay_tri_vcol_fast_sh = NULL;
+static struct GPUShader *overlay_edge_sh = NULL;
+static struct GPUShader *overlay_edge_vcol_sh = NULL;
+static struct GPUShader *overlay_vert_sh = NULL;
+static struct GPUShader *overlay_facedot_sh = NULL;
+
+extern char datatoc_edit_overlay_frag_glsl[];
+extern char datatoc_edit_overlay_vert_glsl[];
+extern char datatoc_edit_overlay_geom_tri_glsl[];
+extern char datatoc_edit_overlay_geom_edge_glsl[];
+extern char datatoc_edit_overlay_loosevert_vert_glsl[];
+extern char datatoc_edit_overlay_facedot_frag_glsl[];
+extern char datatoc_edit_overlay_facedot_vert_glsl[];
+
 void EDIT_MESH_cache_init(void)
 {
 	EDIT_MESH_PassList *psl = DRW_mode_pass_list_get();
-	static struct GPUShader *depth_sh;
-	static struct GPUShader *over_tri_sh, *over_vert_sh, *over_edge_sh, *over_tri_fast_sh;
+	static struct GPUShader *depth_sh, *tri_sh, *ledge_sh;
 
 	const struct bContext *C = DRW_get_context();
 	struct RegionView3D *rv3d = CTX_wm_region_view3d(C);
+	Scene *scene = CTX_data_scene(C);
+	ToolSettings *ts = scene->toolsettings;
 
 	if (!depth_sh)
 		depth_sh = DRW_shader_create_3D_depth_only();
-	if (!over_tri_fast_sh)
-		over_tri_fast_sh = GPU_shader_get_builtin_shader(GPU_SHADER_EDGES_OVERLAY_EDIT_TRI_FAST);
-	if (!over_tri_sh)
-		over_tri_sh = GPU_shader_get_builtin_shader(GPU_SHADER_EDGES_OVERLAY_EDIT_TRI);
-	if (!over_edge_sh)
-		over_edge_sh = GPU_shader_get_builtin_shader(GPU_SHADER_EDGES_OVERLAY_EDIT_EDGE);
-	if (!over_vert_sh)
-		over_vert_sh = GPU_shader_get_builtin_shader(GPU_SHADER_EDGES_OVERLAY_EDIT_VERT);
+
+	if (!overlay_tri_sh) {
+		overlay_tri_sh = DRW_shader_create(datatoc_edit_overlay_vert_glsl,
+		                                   datatoc_edit_overlay_geom_tri_glsl,
+		                                   datatoc_edit_overlay_frag_glsl, "#define EDGE_FIX\n");
+	}
+	if (!overlay_tri_fast_sh) {
+		overlay_tri_fast_sh = DRW_shader_create(datatoc_edit_overlay_vert_glsl,
+		                                       datatoc_edit_overlay_geom_tri_glsl,
+		                                       datatoc_edit_overlay_frag_glsl, NULL);
+	}
+	if (!overlay_tri_vcol_sh) {
+		overlay_tri_vcol_sh = DRW_shader_create(datatoc_edit_overlay_vert_glsl,
+		                                        datatoc_edit_overlay_geom_tri_glsl,
+		                                        datatoc_edit_overlay_frag_glsl, "#define EDGE_FIX\n"
+		                                                                        "#define VERTEX_SELECTION\n");
+	}
+	if (!overlay_tri_vcol_fast_sh) {
+		overlay_tri_vcol_fast_sh = DRW_shader_create(datatoc_edit_overlay_vert_glsl,
+		                                             datatoc_edit_overlay_geom_tri_glsl,
+		                                             datatoc_edit_overlay_frag_glsl, "#define VERTEX_SELECTION\n");
+	}
+	if (!overlay_edge_sh) {
+		overlay_edge_sh = DRW_shader_create(datatoc_edit_overlay_vert_glsl,
+		                                    datatoc_edit_overlay_geom_edge_glsl,
+		                                    datatoc_edit_overlay_frag_glsl, NULL);
+	}
+	if (!overlay_edge_vcol_sh) {
+		overlay_edge_vcol_sh = DRW_shader_create(datatoc_edit_overlay_vert_glsl,
+		                                         datatoc_edit_overlay_geom_edge_glsl,
+		                                         datatoc_edit_overlay_frag_glsl, "#define VERTEX_SELECTION\n");
+	}
+	if (!overlay_vert_sh) {
+		overlay_vert_sh = DRW_shader_create(datatoc_edit_overlay_loosevert_vert_glsl, NULL,
+		                                    datatoc_edit_overlay_frag_glsl, "#define VERTEX_SELECTION\n");
+	}
+	if (!overlay_facedot_sh) {
+		overlay_facedot_sh = DRW_shader_create(datatoc_edit_overlay_facedot_vert_glsl, NULL,
+		                                       datatoc_edit_overlay_facedot_frag_glsl, NULL);
+	}
+
+	if ((ts->selectmode & SCE_SELECT_VERTEX) != 0) {
+		ledge_sh = overlay_edge_vcol_sh;
+
+		if ((rv3d->rflag & RV3D_NAVIGATING) != 0)
+			tri_sh = overlay_tri_vcol_fast_sh;
+		else
+			tri_sh = overlay_tri_vcol_sh;
+	}
+	else {
+		ledge_sh = overlay_edge_sh;
+
+		if ((rv3d->rflag & RV3D_NAVIGATING) != 0)
+			tri_sh = overlay_tri_fast_sh;
+		else
+			tri_sh = overlay_tri_sh;
+	}
 
 	psl->depth_pass_hidden_wire = DRW_pass_create("Depth Pass Hidden Wire", DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS | DRW_STATE_CULL_BACK);
 	depth_shgrp_hidden_wire = DRW_shgroup_create(depth_sh, psl->depth_pass_hidden_wire);
 
-	psl->edit_face_overlay_pass = DRW_pass_create("Edit Mesh Face Overlay Pass", DRW_STATE_WRITE_DEPTH | DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_LESS | DRW_STATE_BLEND);
-	if ((rv3d->rflag & RV3D_NAVIGATING) != 0)
-		face_overlay_shgrp = DRW_shgroup_create(over_tri_fast_sh, psl->edit_face_overlay_pass);
-	else
-		face_overlay_shgrp = DRW_shgroup_create(over_tri_sh, psl->edit_face_overlay_pass);
-	ledges_overlay_shgrp = DRW_shgroup_create(over_edge_sh, psl->edit_face_overlay_pass);
-	lverts_overlay_shgrp = DRW_shgroup_create(over_vert_sh, psl->edit_face_overlay_pass);
-	DRW_shgroup_uniform_vec2(face_overlay_shgrp, "viewportSize", DRW_viewport_size_get(), 1);
+	psl->edit_face_overlay_pass = DRW_pass_create("Edit Mesh Face Overlay Pass", DRW_STATE_WRITE_DEPTH | DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_LESS | DRW_STATE_BLEND | DRW_STATE_POINT);
+
+	face_overlay_shgrp = DRW_shgroup_create(tri_sh, psl->edit_face_overlay_pass);
 	DRW_shgroup_uniform_block(face_overlay_shgrp, "globalsBlock", globals_ubo, 0);
+	DRW_shgroup_uniform_vec2(face_overlay_shgrp, "viewportSize", DRW_viewport_size_get(), 1);
+
+	ledges_overlay_shgrp = DRW_shgroup_create(ledge_sh, psl->edit_face_overlay_pass);
 	DRW_shgroup_uniform_vec2(ledges_overlay_shgrp, "viewportSize", DRW_viewport_size_get(), 1);
-	DRW_shgroup_uniform_vec2(lverts_overlay_shgrp, "viewportSize", DRW_viewport_size_get(), 1);
+
+	if ((ts->selectmode & (SCE_SELECT_VERTEX)) != 0) {
+		lverts_overlay_shgrp = DRW_shgroup_create(overlay_vert_sh, psl->edit_face_overlay_pass);
+		DRW_shgroup_uniform_vec2(lverts_overlay_shgrp, "viewportSize", DRW_viewport_size_get(), 1);
+	}
+
+	if ((ts->selectmode & (SCE_SELECT_FACE)) != 0) {
+		facedot_overlay_shgrp = DRW_shgroup_create(overlay_facedot_sh, psl->edit_face_overlay_pass);
+	}
 
 	DRW_mode_passes_setup(NULL,
 	                      NULL,
@@ -96,26 +170,34 @@ void EDIT_MESH_cache_init(void)
 void EDIT_MESH_cache_populate(Object *ob)
 {
 	struct Batch *geom;
-	struct Batch *geo_ovl_tris, *geo_ovl_ledges, *geo_ovl_lverts;
+	struct Batch *geo_ovl_tris, *geo_ovl_ledges, *geo_ovl_lverts, *geo_ovl_fcenter;
 	const struct bContext *C = DRW_get_context();
 	Scene *scene = CTX_data_scene(C);
 	Object *obedit = scene->obedit;
+	ToolSettings *ts = scene->toolsettings;
 
 	CollectionEngineSettings *ces_mode_ed = BKE_object_collection_engine_get(ob, COLLECTION_MODE_EDIT, "");
 	bool do_occlude_wire = BKE_collection_engine_property_value_get_bool(ces_mode_ed, "show_occlude_wire");
 
 	switch (ob->type) {
 		case OB_MESH:
-			geom = DRW_cache_surface_get(ob);
 			if (ob == obedit) {
 				DRW_cache_wire_overlay_get(ob, &geo_ovl_tris, &geo_ovl_ledges, &geo_ovl_lverts);
 				DRW_shgroup_call_add(face_overlay_shgrp, geo_ovl_tris, ob->obmat);
 				DRW_shgroup_call_add(ledges_overlay_shgrp, geo_ovl_ledges, ob->obmat);
-				DRW_shgroup_call_add(lverts_overlay_shgrp, geo_ovl_lverts, ob->obmat);
-			}
-			if (do_occlude_wire) {
-				DRW_shgroup_call_add(depth_shgrp_hidden_wire, geom, ob->obmat);
-				DRW_shgroup_wire_outline(ob, true, false, true);
+
+				if ((ts->selectmode & SCE_SELECT_VERTEX) != 0)
+					DRW_shgroup_call_add(lverts_overlay_shgrp, geo_ovl_lverts, ob->obmat);
+
+				if ((ts->selectmode & SCE_SELECT_FACE) != 0) {
+					geo_ovl_fcenter = DRW_cache_face_centers_get(ob);
+					DRW_shgroup_call_add(facedot_overlay_shgrp, geo_ovl_fcenter, ob->obmat);
+				}
+
+				if (do_occlude_wire) {
+					geom = DRW_cache_surface_get(ob);
+					DRW_shgroup_call_add(depth_shgrp_hidden_wire, geom, ob->obmat);
+				}
 			}
 			break;
 		case OB_LAMP:
@@ -160,3 +242,23 @@ void EDIT_MESH_collection_settings_create(CollectionEngineSettings *ces)
 	BLI_assert(ces);
 	BKE_collection_engine_property_add_int(ces, "show_occlude_wire", false);
 }
+
+void EDIT_MESH_engine_free(void)
+{
+	if (overlay_tri_sh)
+		DRW_shader_free(overlay_tri_sh);
+	if (overlay_tri_fast_sh)
+		DRW_shader_free(overlay_tri_fast_sh);
+	if (overlay_tri_vcol_sh)
+		DRW_shader_free(overlay_tri_vcol_sh);
+	if (overlay_tri_vcol_fast_sh)
+		DRW_shader_free(overlay_tri_vcol_fast_sh);
+	if (overlay_edge_sh)
+		DRW_shader_free(overlay_edge_sh);
+	if (overlay_edge_vcol_sh)
+		DRW_shader_free(overlay_edge_vcol_sh);
+	if (overlay_vert_sh)
+		DRW_shader_free(overlay_vert_sh);
+	if (overlay_facedot_sh)
+		DRW_shader_free(overlay_facedot_sh);
+}
\ No newline at end of file
diff --git a/source/blender/draw/modes/edit_mesh_mode.h b/source/blender/draw/modes/edit_mesh_mode.h
index bb1794a5ed3..9eee473917b 100644
--- a/source/blender/draw/modes/edit_mesh_mode.h
+++ b/source/blender/draw/modes/edit_mesh_mode.h
@@ -34,4 +34,6 @@ void EDIT_MESH_cache_finish(void);
 
 void EDIT_MESH_draw(void);
 
+void EDIT_MESH_engine_free(void);
+
 #endif /* __EDIT_MESH_MODE_H__ */
\ No newline at end of file
diff --git a/source/blender/draw/modes/shaders/edit_overlay_facedot_frag.glsl b/source/blender/draw/modes/shaders/edit_overlay_facedot_frag.glsl
new file mode 100644
index 00000000000..9b99247efec
--- /dev/null
+++ b/source/blender/draw/modes/shaders/edit_overlay_facedot_frag.glsl
@@ -0,0 +1,55 @@
+
+/* keep in sync with GlobalsUboStorage */
+layout(std140) uniform globalsBlock {
+	vec4 colorWire;
+	vec4 colorWireEdit;
+	vec4 colorActive;
+	vec4 colorSelect;
+	vec4 colorTransform;
+	vec4 colorGroupActive;
+	vec4 colorGroup;
+	vec4 colorLamp;
+	vec4 colorSpeaker;
+	vec4 colorCamera;
+	vec4 colorEmpty;
+	vec4 colorVertex;
+	vec4 colorVertexSelect;
+	vec4 colorEditMeshActive;
+	vec4 colorEdgeSelect;
+	vec4 colorEdgeSeam;
+	vec4 colorEdgeSharp;
+	vec4 colorEdgeCrease;
+	vec4 colorEdgeBWeight;
+	vec4 colorEdgeFaceSelect;
+	vec4 colorFace;
+	vec4 colorFaceSelect;
+	vec4 colorNormal;
+	vec4 colorVNormal;
+	vec4 colorLNormal;
+	vec4 colorFaceDot;
+
+	vec4 colorDeselect;
+	vec4 colorOutline;
+	vec4 colorLampNoAlpha;
+
+	float sizeLampCenter;
+	float sizeLampCircle;
+	float sizeLampCircleShadow;
+	float sizeVertex;
+	float sizeEdge;
+	float sizeEdgeFix;
+	float sizeNormal;
+	float sizeFaceDot;
+};
+
+flat in int isSelected;
+
+out vec4 FragColor;
+
+void main()
+{
+	if (isSelected != 0)
+		FragColor = vec4(colorFaceDot.rgb, 1.0);
+	else
+		FragColor = vec4(colorWireEdit.rgb, 1.0);
+}
diff --git a/source/blender/draw/modes/shaders/edit_overlay_facedot_vert.glsl b/source/blender/draw/modes/shaders/edit_overlay_facedot_vert.glsl
new file mode 100644
index 00000000000..ab7f760d8a1
--- /dev/null
+++ b/source/blender/draw/modes/shaders/edit_overlay_facedot_vert.glsl
@@ -0,0 +1,57 @@
+
+/* keep in sync with GlobalsUboStorage */
+layout(std140) uniform globalsBlock {
+	vec4 colorWire;
+	vec4 colorWireEdit;
+	vec4 colorActive;
+	vec4 colorSelect;
+	vec4 colorTransform;
+	vec4 colorGroupActive;
+	vec4 colorGroup;
+	vec4 colorLamp;
+	vec4 colorSpeaker;
+	vec4 colorCamera;
+	vec4 colorEmpty;
+	vec4 colorVertex;
+	vec4 colorVertexSelect;
+	vec4 colorEditMeshActive;
+	vec4 colorEdgeSelect;
+	vec4 colorEdgeSeam;
+	vec4 colorEdgeSharp;
+	vec4 colorEdgeCrease;
+	vec4 colorEdgeBWeight;
+	vec4 colorEdgeFaceSelect;
+	vec4 colorFace;
+	vec4 colorFaceSelect;
+	vec4 colorNormal;
+	vec4 colorVNormal;
+	vec4 colorLNormal;
+	vec4 colorFaceDot;
+
+	vec4 colorDeselect;
+	vec4 colorOutline;
+	vec4 colorLampNoAlpha;
+
+	float sizeLampCenter;
+	float sizeLampCircle;
+	float sizeLampCircleShadow;
+	float sizeVertex;
+	float sizeEdge;
+	float sizeEdgeFix;
+	float sizeNormal;
+	float sizeFaceDot;
+};
+
+uniform mat4 ModelViewProjectionMatrix;
+
+in vec3 pos;
+in int data;
+
+flat out int isSelected;
+
+void main()
+{
+	gl_Position = ModelViewProjectionMatrix * vec4(pos, 1.0);
+	gl_PointSize = sizeFaceDot;
+	isSelected = data;
+}
diff --git a/source/blender/gpu/shaders/gpu_shader_edit_overlay_frag.glsl b/source/blender/draw/modes/shaders/edit_overlay_frag.glsl
index 96f65bd5836..a3deaa237ee 100644
--- a/source/blender/gpu/shaders/gpu_shader_edit_overlay_frag.glsl
+++ b/source/blender/draw/modes/shaders/edit_overlay_frag.glsl
@@ -190,20 +190,22 @@ void main()
 				colorDist(vec4(colorEdgeCrease.rgb, edgesCrease[v]), largeEdge);
 			else if ((flag[v] & EDGE_SHARP) != 0)
 				colorDist(colorEdgeSharp, largeEdge);
+#ifndef VERTEX_SELECTION
 			else
-#ifdef VERTEX_SELECTION
-				colorDist(vertexColor, innerEdge);
-#else
 				colorDist(colorWireEdit, innerEdge);
+
 			if ((flag[v] & EDGE_ACTIVE) != 0)
 				colorDist(vec4(colorEditMeshActive.xyz, 1.0), innerEdge);
 			else if ((flag[v] & EDGE_SELECTED) != 0)
 				colorDist(colorEdgeSelect, innerEdge);
+#else
+			colorDist(vec4(vertexColor, 1.0), innerEdge);
 #endif
 		}
 	}
 
 	/* Points */
+#ifdef VERTEX_SELECTION
 	for (int v = 0; v < 3; ++v) {
 		float size = p[v] - sizeVertex;
 
@@ -214,6 +216,7 @@ void main()
 		else
 			colorDist(colorVertex, size);
 	}
+#endif
 
 	/* don't write depth if not opaque */
 	if (FragColor.a == 0.0)	discard;
diff --git a/source/blender/gpu/shaders/gpu_shader_edit_overlay_geom_edge.glsl b/source/blender/draw/modes/shaders/edit_overlay_geom_edge.glsl
index 7ebaea59133..f376969d083 100644
--- a/source/blender/gpu/shaders/gpu_shader_edit_overlay_geom_edge.glsl
+++ b/source/blender/draw/modes/shaders/edit_overlay_geom_edge.glsl
@@ -110,12 +110,10 @@ float dist(vec2 pos[3], vec2 vpos, int v)
 
 vec3 getVertexColor(int v)
 {
-	if ((vData[v].x & VERTEX_ACTIVE) != 0)
-		return colorEditMeshActive;
-	else if ((vData[v].x & VERTEX_SELECTED) != 0)
-		return colorEdgeSelect;
+	if ((vData[v].x & (VERTEX_ACTIVE | VERTEX_SELECTED)) != 0)
+		return colorEdgeSelect.rgb;
 	else
-		return colorWireEdit;
+		return colorWireEdit.rgb;
 }
 
 void doVertex(int v, vec4 pos)
diff --git a/source/blender/gpu/shaders/gpu_shader_edit_overlay_geom_tri.glsl b/source/blender/draw/modes/shaders/edit_overlay_geom_tri.glsl
index 0f847c28ded..59d7971f944 100644
--- a/source/blender/gpu/shaders/gpu_shader_edit_overlay_geom_tri.glsl
+++ b/source/blender/draw/modes/shaders/edit_overlay_geom_tri.glsl
@@ -122,12 +122,10 @@ float dist(vec2 pos[3], vec2 vpos, int v)
 
 vec3 getVertexColor(int v)
 {
-	if ((vData[v].x & VERTEX_ACTIVE) != 0)
-		return colorEditMeshActive;
-	else if ((vData[v].x & VERTEX_SELECTED) != 0)
-		return colorEdgeSelect;
+	if ((vData[v].x & (VERTEX_ACTIVE | VERTEX_SELECTED)) != 0)
+		return colorEdgeSelect.rgb;
 	else
-		return colorWireEdit;
+		return colorWireEdit.rgb;
 }
 
 vec4 getClipData(vec2 pos[3], ivec2 vidx)
@@ -268,12 +266,11 @@ void main()
 			int vaf = (i + 1) % 3;
 			int v = i % 3;
 
-			/* Position of the "hidden" thrid vertex
-			 * we set it early because it has*/
+			/* Position of the "hidden" thrid vertex */
 			eData1.zw = pos[vbe];
 
-			doVertex(vaf, pPos[v]);
-			doVertex(vaf, pPos[v] + vec4(fixvec[v], 0.0, 0.0));
+			doVertex(v, pPos[v]);
+			doVertex(v, pPos[v] + vec4(fixvec[v], 0.0, 0.0));
 
 			/* Now one triangle only shade one edge
 			 * so we use the edge distance calculated
@@ -288,18 +285,18 @@ void main()
 			edgesCrease[2] = ecrease[vbe];
 			edgesSharp[2] = esharp[vbe];
 
-			doVertex(v, pPos[vaf]);
-			doVertex(v, pPos[vaf] + vec4(fixvecaf[v], 0.0, 0.0));
+			doVertex(vaf, pPos[vaf]);
+			doVertex(vaf, pPos[vaf] + vec4(fixvecaf[v], 0.0, 0.0));
 
 			/* corner vertices should not drax edges but draw point only */
 			flag[2] = (vData[vbe].x << 8);
-			doVertex(v, pPos[vaf]);
-			doVertex(v, pPos[vaf] + vec4(cornervec[vaf], 0.0, 0.0));
+			doVertex(vaf, pPos[vaf]);
+			doVertex(vaf, pPos[vaf] + vec4(cornervec[vaf], 0.0, 0.0));
 		}
 
 		/* finish the loop strip */
-		doVertex(0, pPos[2]);
-		doVertex(0, pPos[2] + vec4(fixvec[2], 0.0, 0.0));
+		doVertex(2, pPos[2]);
+		doVertex(2, pPos[2] + vec4(fixvec[2], 0.0, 0.0));
 #endif
 	}
 	/* Harder case : compute visible edges vectors */
diff --git a/source/blender/gpu/shaders/gpu_shader_edit_overlay_geom_vert.glsl b/source/blender/draw/modes/shaders/edit_overlay_loosevert_vert.glsl
index 1dc7f7aa389..a046676b6e3 100644
--- a/source/blender/gpu/shaders/gpu_shader_edit_overlay_geom_vert.glsl
+++ b/source/blender/draw/modes/shaders/edit_overlay_loosevert_vert.glsl
@@ -48,15 +48,11 @@ layout(std140) uniform globalsBlock {
 	float sizeFaceDot;
 };
 
-layout(points) in;
-layout(triangle_strip, max_vertices=4) out;
-
-uniform mat4 ProjectionMatrix;
+uniform mat4 ModelViewProjectionMatrix;
 uniform vec2 viewportSize;
 
-in vec4 vPos[];
-in vec4 pPos[];
-in ivec4 vData[];
+in vec3 pos;
+in ivec4 data;
 
 /* these are the same for all vertices
  * and does not need interpolation */
@@ -74,40 +70,22 @@ vec2 proj(vec4 pos)
 	return (0.5 * (pos.xy / pos.w) + 0.5) * viewportSize;
 }
 
-void doVertex(vec4 pos)
-{
-	gl_Position = pos;
-	EmitVertex();
-}
-
 void main()
 {
 	clipCase = 0;
 
+	vec4 pPos = ModelViewProjectionMatrix * vec4(pos, 1.0);
+
 	/* there is no face */
 	faceColor = vec4(0.0);
 
 	/* only verterx position 0 is used */
 	eData1 = eData2 = vec4(1e10);
-	flag = ivec3(0);
+	eData2.zw = proj(pPos);
 
-	vec2 dir = vec2(1.0) * sizeEdgeFix;
-	/* Make it view independant */
-	dir /= viewportSize;
-
-	if (ProjectionMatrix[3][3] == 0.0) {
-		dir *= -vPos[0].z;
-	}
-
-	eData2.zw = proj(pPos[0]);
-
-	flag[0] = (vData[0].x << 8);
-
-	/* Quad */
-	doVertex(pPos[0] + vec4( dir.x,  dir.y, 0.0, 0.0));
-	doVertex(pPos[0] + vec4(-dir.x,  dir.y, 0.0, 0.0));
-	doVertex(pPos[0] + vec4( dir.x, -dir.y, 0.0, 0.0));
-	doVertex(pPos[0] + vec4(-dir.x, -dir.y, 0.0, 0.0));
+	flag = ivec3(0);
+	flag[0] = (data.x << 8);
 
-	EndPrimitive();
+	gl_PointSize = sizeEdgeFix;
+	gl_Position = pPos;
 }
diff --git a/source/blender/gpu/shaders/gpu_shader_edit_overlay_vert.glsl b/source/blender/draw/modes/shaders/edit_overlay_vert.glsl
index 5bc9a8bef85..5bc9a8bef85 100644
--- a/source/blender/gpu/shaders/gpu_shader_edit_overlay_vert.glsl
+++ b/source/blender/draw/modes/shaders/edit_overlay_vert.glsl
diff --git a/source/blender/gpu/CMakeLists.txt b/source/blender/gpu/CMakeLists.txt
index 95b15d664ab..b6ec702403a 100644
--- a/source/blender/gpu/CMakeLists.txt
+++ b/source/blender/gpu/CMakeLists.txt
@@ -191,11 +191,6 @@ data_to_c_simple(shaders/gpu_shader_edges_overlay_vert.glsl SRC)
 data_to_c_simple(shaders/gpu_shader_edges_overlay_geom.glsl SRC)
 data_to_c_simple(shaders/gpu_shader_edges_overlay_simple_geom.glsl SRC)
 data_to_c_simple(shaders/gpu_shader_edges_overlay_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_edit_overlay_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_edit_overlay_geom_tri.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_edit_overlay_geom_edge.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_edit_overlay_geom_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_edit_overlay_vert.glsl SRC)
 data_to_c_simple(shaders/gpu_shader_text_vert.glsl SRC)
 data_to_c_simple(shaders/gpu_shader_text_frag.glsl SRC)
 data_to_c_simple(shaders/gpu_shader_keyframe_diamond_vert.glsl SRC)
diff --git a/source/blender/gpu/GPU_shader.h b/source/blender/gpu/GPU_shader.h
index 2488d265834..fe29b1edc58 100644
--- a/source/blender/gpu/GPU_shader.h
+++ b/source/blender/gpu/GPU_shader.h
@@ -100,10 +100,6 @@ typedef enum GPUBuiltinShader {
 	GPU_SHADER_EDGES_FRONT_BACK_PERSP,
 	GPU_SHADER_EDGES_FRONT_BACK_ORTHO,
 	GPU_SHADER_EDGES_OVERLAY_SIMPLE,
-	GPU_SHADER_EDGES_OVERLAY_EDIT_TRI,
-	GPU_SHADER_EDGES_OVERLAY_EDIT_TRI_FAST,
-	GPU_SHADER_EDGES_OVERLAY_EDIT_VERT,
-	GPU_SHADER_EDGES_OVERLAY_EDIT_EDGE,
 	GPU_SHADER_EDGES_OVERLAY,
 	GPU_SHADER_KEYFRAME_DIAMOND,
 	GPU_SHADER_SIMPLE_LIGHTING,
diff --git a/source/blender/gpu/intern/gpu_shader.c b/source/blender/gpu/intern/gpu_shader.c
index 2e590302227..aeec2af8d0c 100644
--- a/source/blender/gpu/intern/gpu_shader.c
+++ b/source/blender/gpu/intern/gpu_shader.c
@@ -109,11 +109,6 @@ extern char datatoc_gpu_shader_edges_overlay_vert_glsl[];
 extern char datatoc_gpu_shader_edges_overlay_geom_glsl[];
 extern char datatoc_gpu_shader_edges_overlay_simple_geom_glsl[];
 extern char datatoc_gpu_shader_edges_overlay_frag_glsl[];
-extern char datatoc_gpu_shader_edit_overlay_frag_glsl[];
-extern char datatoc_gpu_shader_edit_overlay_geom_tri_glsl[];
-extern char datatoc_gpu_shader_edit_overlay_geom_edge_glsl[];
-extern char datatoc_gpu_shader_edit_overlay_geom_vert_glsl[];
-extern char datatoc_gpu_shader_edit_overlay_vert_glsl[];
 extern char datatoc_gpu_shader_text_vert_glsl[];
 extern char datatoc_gpu_shader_text_frag_glsl[];
 extern char datatoc_gpu_shader_keyframe_diamond_vert_glsl[];
@@ -672,18 +667,6 @@ GPUShader *GPU_shader_get_builtin_shader(GPUBuiltinShader shader)
 		                                        datatoc_gpu_shader_flat_color_frag_glsl },
 		[GPU_SHADER_EDGES_OVERLAY_SIMPLE] = { datatoc_gpu_shader_3D_vert_glsl, datatoc_gpu_shader_edges_overlay_frag_glsl,
 		                                      datatoc_gpu_shader_edges_overlay_simple_geom_glsl },
-		[GPU_SHADER_EDGES_OVERLAY_EDIT_TRI] = { datatoc_gpu_shader_edit_overlay_vert_glsl,
-		                                        datatoc_gpu_shader_edit_overlay_frag_glsl,
-		                                        datatoc_gpu_shader_edit_overlay_geom_tri_glsl },
-		[GPU_SHADER_EDGES_OVERLAY_EDIT_TRI_FAST] = { datatoc_gpu_shader_edit_overlay_vert_glsl,
-		                                             datatoc_gpu_shader_edit_overlay_frag_glsl,
-		                                             datatoc_gpu_shader_edit_overlay_geom_tri_glsl },
-		[GPU_SHADER_EDGES_OVERLAY_EDIT_EDGE] = { datatoc_gpu_shader_edit_overlay_vert_glsl,
-		                                         datatoc_gpu_shader_edit_overlay_frag_glsl,
-		                                         datatoc_gpu_shader_edit_overlay_geom_edge_glsl },
-		[GPU_SHADER_EDGES_OVERLAY_EDIT_VERT] = { datatoc_gpu_shader_edit_overlay_vert_glsl,
-		                                         datatoc_gpu_shader_edit_overlay_frag_glsl,
-		                                         datatoc_gpu_shader_edit_overlay_geom_vert_glsl },
 		[GPU_SHADER_EDGES_OVERLAY] = { datatoc_gpu_shader_edges_overlay_vert_glsl,
 		                               datatoc_gpu_shader_edges_overlay_frag_glsl,
 		                               datatoc_gpu_shader_edges_overlay_geom_glsl },
@@ -778,7 +761,6 @@ GPUShader *GPU_shader_get_builtin_shader(GPUBuiltinShader shader)
 		/* just a few special cases */
 		const char *defines = (shader == GPU_SHADER_SMOKE_COBA) ? "#define USE_COBA;\n" :
 		                      (shader == GPU_SHADER_SIMPLE_LIGHTING) ? "#define USE_NORMALS;\n" :
-		                      (shader == GPU_SHADER_EDGES_OVERLAY_EDIT_TRI) ? "#define EDGE_FIX;\n" :
 		                      (shader == GPU_SHADER_3D_OBJECTSPACE_SIMPLE_LIGHTING_VARIYING_COLOR) ? "#define USE_INSTANCE_COLOR;\n" : NULL;
 
 		const GPUShaderStages *stages = builtin_shader_stages + shader;