Clément Foucault
de76a809f9
... display vertex even when occluded. Add back the vertex display because occluded vertex are not visible when the triangle is almost parallel to the view. The problem with the barycentric coord is that they are hard to work with and their derivatives not enough precise to compute the vertex positions. So we need to pass the vertices scree positions down to the fragment shader.
150 lines
3.4 KiB
GLSL
150 lines
3.4 KiB
GLSL
|
|
/* Solid Wirefram implementation
|
|
* Mike Erwin, Clément Foucault */
|
|
|
|
uniform float faceAlphaMod;
|
|
uniform float edgeScale;
|
|
|
|
flat in vec3 edgesCrease;
|
|
flat in vec3 edgesBweight;
|
|
flat in vec4 faceColor;
|
|
flat in ivec3 flag;
|
|
#ifdef VERTEX_SELECTION
|
|
in vec3 vertexColor;
|
|
#endif
|
|
|
|
#ifdef EDGE_FIX
|
|
flat in vec2 ssPos[3];
|
|
#else
|
|
in vec3 barycentric;
|
|
#endif
|
|
|
|
#ifdef VERTEX_FACING
|
|
in float facing;
|
|
#endif
|
|
|
|
out vec4 FragColor;
|
|
|
|
/* Vertex flag is shifted and combined with the edge flag */
|
|
#define FACE_ACTIVE_ (FACE_ACTIVE << 8)
|
|
|
|
#define LARGE_EDGE_SIZE 3.0
|
|
|
|
/* Style Parameters in pixel */
|
|
|
|
void distToEdgesAndPoints(out vec3 edges, out vec3 points)
|
|
{
|
|
#ifdef EDGE_FIX
|
|
vec2 e0 = normalize(ssPos[1] - ssPos[0] + 1e-8);
|
|
vec2 e1 = normalize(ssPos[2] - ssPos[1] + 1e-8);
|
|
vec2 e2 = normalize(ssPos[0] - ssPos[2] + 1e-8);
|
|
e0 = vec2(-e0.y, e0.x);
|
|
e1 = vec2(-e1.y, e1.x);
|
|
e2 = vec2(-e2.y, e2.x);
|
|
vec2 p0 = gl_FragCoord.xy - ssPos[0];
|
|
vec2 p1 = gl_FragCoord.xy - ssPos[1];
|
|
vec2 p2 = gl_FragCoord.xy - ssPos[2];
|
|
edges.z = abs(dot(e0, p0));
|
|
edges.x = abs(dot(e1, p1));
|
|
edges.y = abs(dot(e2, p2));
|
|
#else
|
|
vec3 dx = dFdx(barycentric);
|
|
vec3 dy = dFdy(barycentric);
|
|
/* per component derivative */
|
|
vec2 d0 = vec2(dx.x, dy.x);
|
|
vec2 d1 = vec2(dx.y, dy.y);
|
|
vec2 d2 = vec2(dx.z, dy.z);
|
|
vec3 d = vec3(length(d0), length(d1), length(d2));
|
|
|
|
edges = abs(vec3(barycentric / d));
|
|
#endif
|
|
|
|
#if defined(VERTEX_SELECTION) && defined(EDGE_FIX)
|
|
points.x = dot(p0, p0);
|
|
points.y = dot(p1, p1);
|
|
points.z = dot(p2, p2);
|
|
points = sqrt(points);
|
|
#else
|
|
points = vec3(1e10);
|
|
#endif
|
|
}
|
|
|
|
void colorDist(vec4 color, float dist)
|
|
{
|
|
FragColor = (dist < 0) ? color : FragColor;
|
|
}
|
|
|
|
#ifdef ANTI_ALIASING
|
|
void colorDistEdge(vec4 color, float dist)
|
|
{
|
|
FragColor.rgb *= FragColor.a;
|
|
FragColor = mix(color, FragColor, clamp(dist, 0.0, 1.0));
|
|
FragColor.rgb /= max(1e-8, FragColor.a);
|
|
}
|
|
#else
|
|
#define colorDistEdge colorDist
|
|
#endif
|
|
|
|
void main()
|
|
{
|
|
vec3 e, p;
|
|
distToEdgesAndPoints(e, p);
|
|
|
|
/* Face */
|
|
FragColor = faceColor;
|
|
FragColor.a *= faceAlphaMod;
|
|
|
|
/* Edges */
|
|
float sizeEdgeFinal = sizeEdge * edgeScale;
|
|
|
|
for (int v = 0; v < 3; ++v) {
|
|
if ((flag[v] & EDGE_EXISTS) != 0) {
|
|
/* Outer large edge */
|
|
float largeEdge = e[v] - sizeEdgeFinal * LARGE_EDGE_SIZE;
|
|
|
|
vec4 large_edge_color = EDIT_MESH_edge_color_outer(flag[v], (flag[0] & FACE_ACTIVE_) != 0, edgesCrease[v], edgesBweight[v]);
|
|
|
|
if (large_edge_color.a != 0.0) {
|
|
colorDistEdge(large_edge_color, largeEdge);
|
|
}
|
|
|
|
/* Inner thin edge */
|
|
float innerEdge = e[v] - sizeEdgeFinal;
|
|
#ifdef ANTI_ALIASING
|
|
innerEdge += 0.4;
|
|
#endif
|
|
|
|
#ifdef VERTEX_SELECTION
|
|
colorDistEdge(vec4(vertexColor, 1.0), innerEdge);
|
|
#else
|
|
vec4 inner_edge_color = EDIT_MESH_edge_color_inner(flag[v], (flag[0] & FACE_ACTIVE_) != 0);
|
|
colorDistEdge(inner_edge_color, innerEdge);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
#if defined(VERTEX_SELECTION) && defined(EDGE_FIX)
|
|
/* Points */
|
|
for (int v = 0; v < 3; ++v) {
|
|
if ((flag[v] & EDGE_VERTEX_EXISTS) == 0) {
|
|
/* Leave as-is, no vertex. */
|
|
}
|
|
else {
|
|
float size = p[v] - sizeVertex;
|
|
|
|
vec4 point_color = colorVertex;
|
|
point_color = ((flag[v] & EDGE_VERTEX_SELECTED) != 0) ? colorVertexSelect : point_color;
|
|
point_color = ((flag[v] & EDGE_VERTEX_ACTIVE) != 0) ? vec4(colorEditMeshActive.xyz, 1.0) : point_color;
|
|
|
|
colorDist(point_color, size);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifdef VERTEX_FACING
|
|
FragColor.a *= 1.0 - abs(facing) * 0.4;
|
|
#endif
|
|
/* don't write depth if not opaque */
|
|
if (FragColor.a == 0.0) discard;
|
|
}
|