add linecaps (GLMakie, CairoMakie)

GLMakie/assets/shader/line_segment.geom

@@ -2,37 +2,54 @@
 {{GLSL_EXTENSIONS}}
 
 layout(lines) in;
-layout(triangle_strip, max_vertices = 4) out;
+layout(triangle_strip, max_vertices = 12) out;
 
 uniform vec2 resolution;
 uniform float maxlength;
-uniform float thickness;
 uniform float pattern_length;
+uniform int linecap;
 
 in vec4 g_color[];
 in uvec2 g_id[];
 in float g_thickness[];
+in float g_lastlen[];
+in float g_linecap_length[];
 
 out float f_thickness;
 out vec4 f_color;
 out vec2 f_uv;
 flat out uvec2 f_id;
+flat out int f_type;
 
-#define AA_THICKNESS 2.0
+#define AA_THICKNESS 4.0
 
 vec2 screen_space(vec4 vertex)
 {
     return vec2(vertex.xy / vertex.w)*resolution;
 }
 
-void emit_vertex(vec2 position, vec2 uv, int index)
+void emit_vertex(vec2 position, float v, float ratio, int index)
 {
     vec4 inpos = gl_in[index].gl_Position;
-    f_uv = uv;
+    f_uv = vec2(0.5 * g_lastlen[index] * ratio / pattern_length, v);
     f_color = g_color[index];
     gl_Position = vec4((position / resolution) * inpos.w, inpos.z, inpos.w);
     f_id = g_id[index];
-    f_thickness = g_thickness[index] + AA_THICKNESS;
+    f_thickness = g_thickness[index];
+    f_type = 0;
+    EmitVertex();
+}
+
+// for linecaps
+void emit_vertex(vec2 position, vec2 uv, int index, int type)
+{
+    vec4 inpos  = gl_in[index].gl_Position;
+    f_uv        = uv;
+    f_color     = g_color[index];
+    gl_Position = vec4((position/resolution)*inpos.w, inpos.z, inpos.w);
+    f_id        = g_id[index];
+    f_thickness = g_thickness[index];
+    f_type      = type; // some cap style
     EmitVertex();
 }
 
@@ -56,13 +73,58 @@ void main(void)
     vec2 v0 = normalize(vun0);
     // determine the normal of each of the 3 segments (previous, current, next)
     vec2 n0 = vec2(-v0.y, v0.x);
-    float l = length(p1-p0);
-    l /= (pattern_length*10);
-
-    float uv0 = thickness_aa0/g_thickness[0];
-    float uv1 = thickness_aa1/g_thickness[1];
-    emit_vertex(p0 + thickness_aa0 * n0, vec2(0, -uv0), 0);
-    emit_vertex(p0 - thickness_aa0 * n0, vec2(0, uv0), 0);
-    emit_vertex(p1 + thickness_aa1 * n0, vec2(l, -uv1), 1);
-    emit_vertex(p1 - thickness_aa1 * n0, vec2(l, uv1), 1);
+    float ratio = length(p1 - p0) / (g_lastlen[1] - g_lastlen[0]);
+
+    // shortens line if g_linecap_length is negative and the line terminates
+    vec2 linecap_gap0 = -min(g_linecap_length[0], 0) * v0;
+    vec2 linecap_gap1 = -min(g_linecap_length[1], 0) * v0;
+
+    emit_vertex(p0 + linecap_gap0 + thickness_aa0 * n0, -thickness_aa0, ratio, 0);
+    emit_vertex(p0 + linecap_gap0 - thickness_aa0 * n0,  thickness_aa0, ratio, 0);
+    emit_vertex(p1 - linecap_gap1 + thickness_aa1 * n0, -thickness_aa1, ratio, 1);
+    emit_vertex(p1 - linecap_gap1 - thickness_aa1 * n0,  thickness_aa1, ratio, 1);
+
+    // generate quads for line cap
+    if (linecap != 0) { // 0 doubles as no line cap
+        /*
+        Line with line caps:
+
+          cap      line      cap
+        1-----3----    ----5-----7 ^
+        |     |            |     | | off_n
+        |     p1---    ---p2     | '
+        |     |            |     |
+        2-----4----    ----6-----8
+                            ----> off_l
+
+        1 .. 8 are the emit_vertex calls below
+        */
+
+        vec2 off_n, off_l;
+        float du, dv;
+
+        // start of line segment
+        off_n = thickness_aa0 * n0;
+        off_l = sign(g_linecap_length[0]) * (abs(g_linecap_length[0]) + AA_THICKNESS) * v0;
+        du = 0.5 * AA_THICKNESS / abs(g_linecap_length[0]);
+        dv = 0.5 * AA_THICKNESS / g_thickness[0];
+
+        EndPrimitive();
+        emit_vertex(p0 + off_n - off_l, vec2(-du, -dv),  0, linecap);
+        emit_vertex(p0 - off_n - off_l, vec2(-du, 1+dv), 0, linecap);
+        emit_vertex(p0 + off_n,         vec2(0.5, -dv),  0, linecap);
+        emit_vertex(p0 - off_n,         vec2(0.5, 1+dv), 0, linecap);
+
+        // end of line segment
+        off_n = thickness_aa1 * n0;
+        off_l = sign(g_linecap_length[1]) * (abs(g_linecap_length[1]) + AA_THICKNESS) * v0;
+        du = 0.5 * AA_THICKNESS / abs(g_linecap_length[1]);
+        dv = 0.5 * AA_THICKNESS / g_thickness[1];
+
+        EndPrimitive();
+        emit_vertex(p1 + off_n,         vec2(0.5,   -dv), 1, linecap);
+        emit_vertex(p1 - off_n,         vec2(0.5,  1+dv), 1, linecap);
+        emit_vertex(p1 + off_n + off_l, vec2(1+dv,  -dv), 1, linecap);
+        emit_vertex(p1 - off_n + off_l, vec2(1+dv, 1+dv), 1, linecap);
+    }
 }

GLMakie/assets/shader/line_segment.vert

@@ -5,19 +5,24 @@ struct Nothing{ //Nothing type, to encode if some variable doesn't contain any d
     bool _; //empty structs are not allowed
 };
 
+in float lastlen;
 {{vertex_type}} vertex;
 {{thickness_type}} thickness;
+{{linecap_length_type}} linecap_length;
 
 {{color_type}} color;
 {{color_map_type}}  color_map;
 {{color_norm_type}} color_norm;
 
 uniform mat4 projectionview, model;
 uniform uint objectid;
+uniform float depth_shift;
 
 out uvec2 g_id;
 out vec4 g_color;
 out float g_thickness;
+out float g_linecap_length;
+out float g_lastlen;
 
 vec4 getindex(sampler2D tex, int index);
 vec4 getindex(sampler1D tex, int index);
@@ -34,14 +39,15 @@ vec4 to_color(float color, sampler1D color_map, vec2 color_norm, int index){
     return color_lookup(color, color_map, color_norm);
 }
 
-uniform float depth_shift;
 
 void main()
 {
     int index = gl_VertexID;
     g_id = uvec2(objectid, index+1);
     g_color = to_color(color, color_map, color_norm, index);
     g_thickness = thickness;
+    g_lastlen = lastlen;
+    g_linecap_length = linecap_length;
     gl_Position = projectionview * model * to_vec4(vertex);
     gl_Position.z += gl_Position.w * depth_shift;
 }

GLMakie/assets/shader/lines.frag

@@ -10,6 +10,7 @@ in vec4 f_color;
 in vec2 f_uv;
 in float f_thickness;
 flat in uvec2 f_id;
+flat in int f_type; // TODO bad for performance
 {{pattern_type}} pattern;
 
 uniform float pattern_length;
@@ -26,6 +27,7 @@ float aastep(float threshold1, float threshold2, float value) {
 }
 void write2framebuffer(vec4 color, uvec2 id);
 
+// Signed distance fields for lines
 // x/y pattern
 float get_sd(sampler2D pattern, vec2 uv){
     return texture(pattern, uv).x;
@@ -40,10 +42,56 @@ vec2 get_sd(Nothing _, vec2 uv){
     return vec2(0.5, uv.y);
 }
 
+// Signed distance fields for caps
+#define LINE              0
+#define CIRCLE            4
+#define RECTANGLE         5
+#define TRIANGLE          6
+#define MIRRORED_TRIANGLE 7
+
+float triangle(vec2 P){
+    // adjusted from distance shape, technically diamond shape <>
+    P -= vec2(0.5);
+    float x = P.y - P.x;
+    float y = P.y + P.x;
+    return 0.5 - max(abs(x), abs(y));
+}
+float mirrored_triangle(vec2 P){
+    // Like >< for triangle markers cutting into lines
+    P -= vec2(0.5);
+    return min(0.5, abs(P.x)) - abs(P.y);
+}
+float circle(vec2 uv){
+    // Radius 0.5 circle centered at (0.5, 0.5)
+    return 0.5-length(uv - vec2(0.5));
+}
+float rectangle(vec2 uv){
+    // fills 0..1 x 0..1
+    vec2 d = max(-uv, uv-vec2(1));
+    return -( length(max(vec2(0.0), d)) + min(0.0, max(d.x, d.y)) );
+}
+
+
 void main(){
-    vec2 xy = get_sd(pattern, f_uv);
-    float alpha = aastep(0, xy.x);
-    float alpha2 = aastep(-1, 1, xy.y);
-    vec4 color = vec4(f_color.rgb, f_color.a*alpha*alpha2);
+    vec4 color = vec4(f_color.rgb, 0.0);
+    if (f_type == CIRCLE){
+        float sd = f_thickness * circle(f_uv);
+        color = mix(color, f_color, smoothstep(-ALIASING_CONST, ALIASING_CONST, sd));
+    } else if (f_type == RECTANGLE) {
+        float sd = f_thickness * rectangle(f_uv);
+        // color = mix(color, f_color, smoothstep(-ALIASING_CONST, ALIASING_CONST, sd));
+        color = mix(color, f_color, aastep(0, sd));
+    } else if (f_type == TRIANGLE) {
+        float sd = f_thickness * triangle(f_uv);
+        color = mix(color, f_color, smoothstep(-ALIASING_CONST, ALIASING_CONST, sd));
+    } else if (f_type == MIRRORED_TRIANGLE) {
+        float sd = f_thickness * mirrored_triangle(f_uv);
+        color = mix(color, f_color, smoothstep(-ALIASING_CONST, ALIASING_CONST, sd));
+    } else {
+        vec2 xy = get_sd(pattern, f_uv);
+        float alpha = aastep(0, xy.x);
+        float alpha2 = aastep(-f_thickness, f_thickness, xy.y);
+        color = vec4(f_color.rgb, f_color.a*alpha*alpha2);
+    }
     write2framebuffer(color, f_id);
 }