blender
/
blender
129
398
Fork 572
Code Issues 6.2k Pull Requests 748 Projects 19 Wiki Activity

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
This commit is contained in:
Clément Foucault 2017-03-02 01:07:03 +01:00
parent aa102283da
commit b463cd2ab8
21 changed files with 357 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
source/blender/blenkernel/BKE_mesh_render.h
View File

@ -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__ */

60
source/blender/blenkernel/intern/mesh_render.c
View File

@ -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

10
source/blender/draw/CMakeLists.txt
View File

@ -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
)

2
source/blender/draw/engines/clay/clay.c
View File

@ -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) {

2
source/blender/draw/engines/clay/clay.h
View File

@ -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__ */

11
source/blender/draw/intern/draw_cache.c
View File

@ -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);
}
return overlay_wire;
Batch *DRW_cache_face_centers_get(Object *ob)
{
BLI_assert(ob->type == OB_MESH);
Mesh *me = ob->data;
return BKE_mesh_batch_cache_get_overlay_facedots(me);
}
Batch *DRW_cache_wire_outline_get(Object *ob)

1
source/blender/draw/intern/draw_cache.h
View File

@ -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);

4
source/blender/draw/intern/draw_manager.c
View File

@ -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();

2
source/blender/draw/intern/draw_mode_pass.c
View File

@ -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 */

154
source/blender/draw/modes/edit_mesh_mode.c
View File

@ -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);
}

2
source/blender/draw/modes/edit_mesh_mode.h
View File

@ -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__ */

55
source/blender/draw/modes/shaders/edit_overlay_facedot_frag.glsl Normal file
View File

@ -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);
}

57
source/blender/draw/modes/shaders/edit_overlay_facedot_vert.glsl Normal file
View File

@ -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;
}

9
source/blender/gpu/shaders/gpu_shader_edit_overlay_frag.glsl → source/blender/draw/modes/shaders/edit_overlay_frag.glsl
View File

@ -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;

8
source/blender/gpu/shaders/gpu_shader_edit_overlay_geom_edge.glsl → source/blender/draw/modes/shaders/edit_overlay_geom_edge.glsl
View File

@ -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)

27
source/blender/gpu/shaders/gpu_shader_edit_overlay_geom_tri.glsl → source/blender/draw/modes/shaders/edit_overlay_geom_tri.glsl
View File

@ -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 */

42
source/blender/gpu/shaders/gpu_shader_edit_overlay_geom_vert.glsl → source/blender/draw/modes/shaders/edit_overlay_loosevert_vert.glsl
View File

@ -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);
eData2.zw = proj(pPos);
flag = ivec3(0);
flag[0] = (data.x << 8);
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));
EndPrimitive();
gl_PointSize = sizeEdgeFix;
gl_Position = pPos;
}

0
source/blender/gpu/shaders/gpu_shader_edit_overlay_vert.glsl → source/blender/draw/modes/shaders/edit_overlay_vert.glsl
View File

5
source/blender/gpu/CMakeLists.txt
View File

@ -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)

4
source/blender/gpu/GPU_shader.h
View File

@ -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,

18
source/blender/gpu/intern/gpu_shader.c
View File

@ -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;