archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

OpenGL: edge overlay shaders

Browse Source 
As seen at #bcon16. These were produced quickly and probably need further work.

SIMPLE variant draws triangle mesh edges. Based on this research:
http://www2.imm.dtu.dk/pubdb/views/edoc_download.php/4884/pdf/imm4884.pdf
http://developer.download.nvidia.com/SDK/10/direct3d/Source/SolidWireframe/Doc/SolidWireframe.pdf

Non-SIMPLE variant can adjust thickness per edge. This can be used to draw only some edges, or accentuate some edges. Given the right inputs this is a general n-gon perimeter shader.

Part of T49165
This commit is contained in:
Mike Erwin
2016-11-05 19:26:13 +01:00
parent a85f68e9c7
commit 5b26c36008
7 changed files with 192 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -162,6 +162,10 @@ data_to_c_simple(shaders/gpu_shader_edges_front_back_persp_vert.glsl SRC)
data_to_c_simple(shaders/gpu_shader_edges_front_back_persp_geom.glsl SRC)
data_to_c_simple(shaders/gpu_shader_edges_front_back_persp_legacy_vert.glsl SRC)
data_to_c_simple(shaders/gpu_shader_edges_front_back_ortho_vert.glsl SRC)
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_text_vert.glsl SRC)
data_to_c_simple(shaders/gpu_shader_text_frag.glsl SRC)

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

@@ -95,7 +95,8 @@ typedef enum GPUBuiltinShader {
GPU_SHADER_TEXT,
GPU_SHADER_EDGES_FRONT_BACK_PERSP,
GPU_SHADER_EDGES_FRONT_BACK_ORTHO,
GPU_SHADER_EDGES_OVERLAY_SIMPLE,
GPU_SHADER_EDGES_OVERLAY,
/* for simple 2D drawing */
GPU_SHADER_2D_UNIFORM_COLOR,
GPU_SHADER_2D_FLAT_COLOR,

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

@@ -82,6 +82,10 @@ extern char datatoc_gpu_shader_edges_front_back_persp_vert_glsl[];
extern char datatoc_gpu_shader_edges_front_back_persp_geom_glsl[];
extern char datatoc_gpu_shader_edges_front_back_persp_legacy_vert_glsl[];
extern char datatoc_gpu_shader_edges_front_back_ortho_vert_glsl[];
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_text_vert_glsl[];
extern char datatoc_gpu_shader_text_frag_glsl[];
@@ -115,6 +119,8 @@ static struct GPUShadersGlobal {
GPUShader *text;
GPUShader *edges_front_back_persp;
GPUShader *edges_front_back_ortho;
GPUShader *edges_overlay_simple;
GPUShader *edges_overlay;
/* for drawing images */
GPUShader *image_modulate_alpha_3D;
GPUShader *image_rect_modulate_alpha_3D;
@@ -697,6 +703,24 @@ GPUShader *GPU_shader_get_builtin_shader(GPUBuiltinShader shader)
NULL, NULL, NULL, 0, 0, 0);
retval = GG.shaders.edges_front_back_ortho;
break;
case GPU_SHADER_EDGES_OVERLAY_SIMPLE:
if (!GG.shaders.edges_overlay_simple)
GG.shaders.edges_overlay_simple = GPU_shader_create(
datatoc_gpu_shader_3D_vert_glsl,
datatoc_gpu_shader_edges_overlay_frag_glsl,
datatoc_gpu_shader_edges_overlay_simple_geom_glsl,
NULL, NULL, 0, 0, 0);
retval = GG.shaders.edges_overlay_simple;
break;
case GPU_SHADER_EDGES_OVERLAY:
if (!GG.shaders.edges_overlay)
GG.shaders.edges_overlay = GPU_shader_create(
datatoc_gpu_shader_edges_overlay_vert_glsl,
datatoc_gpu_shader_edges_overlay_frag_glsl,
datatoc_gpu_shader_edges_overlay_geom_glsl,
NULL, NULL, 0, 0, 0);
retval = GG.shaders.edges_overlay;
break;
case GPU_SHADER_3D_IMAGE_MODULATE_ALPHA:
if (!GG.shaders.image_modulate_alpha_3D)
GG.shaders.image_modulate_alpha_3D = GPU_shader_create(
@@ -994,6 +1018,16 @@ void GPU_shader_free_builtin_shaders(void)
GG.shaders.edges_front_back_ortho = NULL;
}
if (GG.shaders.edges_overlay_simple) {
GPU_shader_free(GG.shaders.edges_overlay_simple);
GG.shaders.edges_overlay_simple = NULL;
}
if (GG.shaders.edges_overlay) {
GPU_shader_free(GG.shaders.edges_overlay);
GG.shaders.edges_overlay = NULL;
}
if (GG.shaders.image_modulate_alpha_3D) {
GPU_shader_free(GG.shaders.image_modulate_alpha_3D);
GG.shaders.image_modulate_alpha_3D = NULL;

20
source/blender/gpu/shaders/gpu_shader_edges_overlay_frag.glsl Normal file
View File

@@ -0,0 +1,20 @@
#define SMOOTH 1
const float transitionWidth = 1.0;
uniform vec4 fillColor = vec4(0);
uniform vec4 outlineColor = vec4(0,0,0,1);
noperspective in vec3 distanceToOutline;
out vec4 FragColor;
void main() {
float edgeness = min(min(distanceToOutline.x, distanceToOutline.y), distanceToOutline.z);
#if SMOOTH
FragColor = mix(outlineColor, fillColor, smoothstep(0, transitionWidth, edgeness));
#else
FragColor = (edgeness <= 0) ? outlineColor : fillColor;
#endif
}

67
source/blender/gpu/shaders/gpu_shader_edges_overlay_geom.glsl Normal file
View File

@@ -0,0 +1,67 @@
layout(triangles) in;
layout(triangle_strip, max_vertices=3) out;
uniform float outlineWidth = 1.0;
uniform vec2 viewportSize;
in vec4 pos_xformed[];
in float widthModulator[];
noperspective out vec3 distanceToOutline;
// project to screen space
vec2 proj(int axis) {
vec4 pos = pos_xformed[axis];
return (0.5 * (pos.xy / pos.w) + 0.5) * viewportSize;
}
float dist(vec2 pos[3], int v) {
// current vertex position
vec2 vpos = pos[v];
// endpoints of opposite edge
vec2 e1 = pos[(v + 1) % 3];
vec2 e2 = pos[(v + 2) % 3];
float abs_det = length(cross(vec3(vpos - e1, 0), vec3(vpos - e2, 0))); // could simplify
return abs_det / distance(e2, e1);
}
vec3 distance[3];
void clearEdge(int v) {
float distant = 10 * outlineWidth;
for (int i = 0; i < 3; ++i)
distance[i][v] += distant;
}
void modulateEdge(int v) {
float offset = min(widthModulator[v],1) * outlineWidth;
for (int i = 0; i < 3; ++i)
distance[i][v] -= offset;
}
void main() {
vec2 pos[3] = vec2[3](proj(0), proj(1), proj(2));
for (int v = 0; v < 3; ++v)
distance[v] = vec3(0);
for (int v = 0; v < 3; ++v) {
if (widthModulator[v] > 0) {
distance[v][v] = dist(pos, v);
modulateEdge(v);
}
}
for (int v = 0; v < 3; ++v)
if (widthModulator[v] <= 0)
clearEdge(v);
for (int v = 0; v < 3; ++v) {
gl_Position = pos_xformed[v];
distanceToOutline = distance[v];
EmitVertex();
}
EndPrimitive();
}

52
source/blender/gpu/shaders/gpu_shader_edges_overlay_simple_geom.glsl Normal file
View File

@@ -0,0 +1,52 @@
layout(triangles) in;
layout(triangle_strip, max_vertices=3) out;
uniform float outlineWidth = 1.0;
uniform vec2 viewportSize;
noperspective out vec3 distanceToOutline;
// project to screen space
vec2 proj(int axis) {
vec4 pos = gl_in[axis].gl_Position;
return (0.5 * (pos.xy / pos.w) + 0.5) * viewportSize;
}
float dist(vec2 pos[3], int v) {
// current vertex position
vec2 vpos = pos[v];
// endpoints of opposite edge
vec2 e1 = pos[(v + 1) % 3];
vec2 e2 = pos[(v + 2) % 3];
float abs_det = length(cross(vec3(vpos - e1, 0), vec3(vpos - e2, 0))); // could simplify
return abs_det / distance(e2, e1);
}
vec3 distance[3];
void modulateEdge(int v) {
float offset = 0.5 * outlineWidth;
for (int i = 0; i < 3; ++i)
distance[i][v] -= offset;
}
void main() {
vec2 pos[3] = vec2[3](proj(0), proj(1), proj(2));
for (int v = 0; v < 3; ++v)
distance[v] = vec3(0);
for (int v = 0; v < 3; ++v) {
distance[v][v] = dist(pos, v);
modulateEdge(v);
}
for (int v = 0; v < 3; ++v) {
gl_Position = gl_in[v].gl_Position;
distanceToOutline = distance[v];
EmitVertex();
}
EndPrimitive();
}

13
source/blender/gpu/shaders/gpu_shader_edges_overlay_vert.glsl Normal file
View File

@@ -0,0 +1,13 @@
//mat4 ModelViewProjectionMatrix;
in vec3 pos;
in float edgeWidthModulator;
out vec4 pos_xformed;
out float widthModulator;
void main() {
pos_xformed = gl_ModelViewProjectionMatrix * vec4(pos, 1.0);
widthModulator = edgeWidthModulator;
}