vispy 0.14.0__cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

vispy/glsl/lines/agg.vert

@@ -0,0 +1,241 @@
+const float THETA = 15.0 * 3.14159265358979323846264/180.0;
+
+// Cross product of v1 and v2
+float cross(in vec2 v1, in vec2 v2) {
+    return v1.x*v2.y - v1.y*v2.x;
+}
+
+// Returns distance of v3 to line v1-v2
+float signed_distance(in vec2 v1, in vec2 v2, in vec2 v3) {
+    return cross(v2-v1,v1-v3) / length(v2-v1);
+}
+
+// Rotate v around origin
+void rotate( in vec2 v, in float alpha, out vec2 result ) {
+    float c = cos(alpha);
+    float s = sin(alpha);
+    result = vec2( c*v.x - s*v.y,
+                   s*v.x + c*v.y );
+}
+
+vec2 transform_vector(vec2 x, vec2 base) {
+    vec4 o = $transform(vec4(base, 0, 1));
+    return ($transform(vec4(base+x, 0, 1)) - o).xy;
+}
+
+
+// Uniforms
+//uniform mat4 u_matrix;
+//uniform mat4 u_view;
+
+attribute vec4 color;
+// uniform vec2 u_scale;
+// uniform vec2 tr_scale;
+uniform float linewidth;
+uniform float antialias;
+uniform vec2 linecaps;
+uniform float linejoin;
+uniform float miter_limit;
+attribute float alength;
+uniform float dash_phase;
+uniform float dash_period;
+uniform float dash_index;
+uniform vec2 dash_caps;
+uniform float closed;
+
+
+// Attributes
+attribute vec2 a_position; // position of each vertex
+attribute vec4 a_tangents; // vector pointing from one vertex to the next
+attribute vec2 a_segment;  // distance along path
+attribute vec2 a_angles;
+attribute vec2 a_texcoord;
+
+// Varying
+varying vec4  v_color;
+varying vec2  v_segment;
+varying vec2  v_angles;
+varying vec2  v_linecaps;
+varying vec2  v_texcoord;
+varying vec2  v_miter;
+varying float v_miter_limit;
+varying float v_length;
+varying float v_linejoin;
+varying float v_linewidth;
+varying float v_antialias;
+varying float v_dash_phase;
+varying float v_dash_period;
+varying float v_dash_index;
+varying vec2  v_dash_caps;
+varying float v_closed;
+void main()
+{
+    v_color = color;
+
+    v_linewidth = linewidth;
+    v_antialias = antialias;
+    v_linecaps  = linecaps;
+
+    v_linejoin    = linejoin;
+    v_miter_limit = miter_limit;
+    v_length      = alength;
+    v_dash_phase  = dash_phase;
+
+    v_dash_period = dash_period;
+    v_dash_index  = dash_index;
+    v_dash_caps   = dash_caps;
+
+    v_closed = closed;
+    bool closed = (v_closed > 0.0);
+
+    // Attributes to varyings
+    v_angles  = a_angles;
+    //v_segment = a_segment * u_scale.x * tr_scale.x;  // TODO: proper scaling
+    //v_length  = v_length * u_scale * tr_scale;  // TODO: proper scaling
+    v_segment = a_segment;
+
+    // Thickness below 1 pixel are represented using a 1 pixel thickness
+    // and a modified alpha
+    v_color.a = min(v_linewidth, v_color.a);
+    v_linewidth = max(v_linewidth, 1.0);
+
+    // This is the actual half width of the line
+    // TODO: take care of logical - physical pixel difference here.
+    float w = ceil(1.25*v_antialias+v_linewidth)/2.0;
+
+    vec4 doc_pos = $transform(vec4(a_position,0.,1.));
+    //vec2 position = doc_pos.xy * u_scale;
+    vec2 position = doc_pos.xy;
+    // At this point, position must be in _doc_ coordinates because the line
+    // width will be added to it.
+
+    //vec2 t1 = normalize(tr_scale*a_tangents.xy);
+    //vec2 t2 = normalize(tr_scale*a_tangents.zw);
+    vec2 t1 = normalize(transform_vector(a_tangents.xy, a_position));
+    vec2 t2 = normalize(transform_vector(a_tangents.zw, a_position));
+    float u = a_texcoord.x;
+    float v = a_texcoord.y;
+    vec2 o1 = vec2( +t1.y, -t1.x);
+    vec2 o2 = vec2( +t2.y, -t2.x);
+
+
+    // This is a join
+    // ----------------------------------------------------------------
+    if( t1 != t2 ) {
+        float angle  = atan (t1.x*t2.y-t1.y*t2.x, t1.x*t2.x+t1.y*t2.y);
+        vec2 t  = normalize(t1+t2);
+        vec2 o  = vec2( + t.y, - t.x);
+
+        if ( v_dash_index > 0.0 )
+        {
+            // Broken angle
+            // ----------------------------------------------------------------
+            if( (abs(angle) > THETA) ) {
+                position += v * w * o / cos(angle/2.0);
+                float s = sign(angle);
+                if( angle < 0.0 ) {
+                    if( u == +1.0 ) {
+                        u = v_segment.y + v * w * tan(angle/2.0);
+                        if( v == 1.0 ) {
+                            position -= 2.0 * w * t1 / sin(angle);
+                            u -= 2.0 * w / sin(angle);
+                        }
+                    } else {
+                        u = v_segment.x - v * w * tan(angle/2.0);
+                        if( v == 1.0 ) {
+                            position += 2.0 * w * t2 / sin(angle);
+                            u += 2.0*w / sin(angle);
+                        }
+                    }
+                } else {
+                    if( u == +1.0 ) {
+                        u = v_segment.y + v * w * tan(angle/2.0);
+                        if( v == -1.0 ) {
+                            position += 2.0 * w * t1 / sin(angle);
+                            u += 2.0 * w / sin(angle);
+                        }
+                    } else {
+                        u = v_segment.x - v * w * tan(angle/2.0);
+                        if( v == -1.0 ) {
+                            position -= 2.0 * w * t2 / sin(angle);
+                            u -= 2.0*w / sin(angle);
+                        }
+                    }
+                }
+                // Continuous angle
+                // ------------------------------------------------------------
+            } else {
+                position += v * w * o / cos(angle/2.0);
+                if( u == +1.0 ) u = v_segment.y;
+                else            u = v_segment.x;
+            }
+        }
+
+        // Solid line
+        // --------------------------------------------------------------------
+        else
+        {
+            position.xy += v * w * o / cos(angle/2.0);
+            if( angle < 0.0 ) {
+                if( u == +1.0 ) {
+                    u = v_segment.y + v * w * tan(angle/2.0);
+                } else {
+                    u = v_segment.x - v * w * tan(angle/2.0);
+                }
+            } else {
+                if( u == +1.0 ) {
+                    u = v_segment.y + v * w * tan(angle/2.0);
+                } else {
+                    u = v_segment.x - v * w * tan(angle/2.0);
+                }
+            }
+        }
+
+    // This is a line start or end (t1 == t2)
+    // ------------------------------------------------------------------------
+    } else {
+        position += v * w * o1;
+        if( u == -1.0 ) {
+            u = v_segment.x - w;
+            position -=  w * t1;
+        } else {
+            u = v_segment.y + w;
+            position +=  w * t2;
+        }
+    }
+
+    // Miter distance
+    // ------------------------------------------------------------------------
+    vec2 t;
+    //vec2 curr = $transform(vec4(a_position,0.,1.)).xy*u_scale;
+    vec2 curr = $transform(vec4(a_position,0.,1.)).xy;
+    if( a_texcoord.x < 0.0 ) {
+        vec2 next = curr + t2*(v_segment.y-v_segment.x);
+
+        rotate( t1, +a_angles.x/2.0, t);
+        v_miter.x = signed_distance(curr, curr+t, position);
+
+        rotate( t2, +a_angles.y/2.0, t);
+        v_miter.y = signed_distance(next, next+t, position);
+    } else {
+        vec2 prev = curr - t1*(v_segment.y-v_segment.x);
+
+        rotate( t1, -a_angles.x/2.0,t);
+        v_miter.x = signed_distance(prev, prev+t, position);
+
+        rotate( t2, -a_angles.y/2.0,t);
+        v_miter.y = signed_distance(curr, curr+t, position);
+    }
+
+    if (!closed && v_segment.x <= 0.0) {
+        v_miter.x = 1e10;
+    }
+    if (!closed && v_segment.y >= v_length)
+    {
+        v_miter.y = 1e10;
+    }
+
+    v_texcoord = vec2( u, v*w );
+
+    gl_Position = $px_ndc_transform($doc_px_transform(vec4(position, doc_pos.z, 1.0)));
+}

vispy/glsl/markers/arrow.glsl

@@ -0,0 +1,12 @@
+// -----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// -----------------------------------------------------------------------------
+
+float marker_arrow(vec2 P, float size)
+{
+    float r1 = abs(P.x) + abs(P.y) - size/2.;
+    float r2 = max(abs(P.x+size/2.), abs(P.y)) - size/2.;
+    float r3 = max(abs(P.x-size/6.)-size/4., abs(P.y)- size/4.);
+    return min(r3,max(.75*r1,r2));
+}

vispy/glsl/markers/asterisk.glsl

@@ -0,0 +1,16 @@
+// -----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// -----------------------------------------------------------------------------
+#include "math/constants.glsl"
+
+float marker_asterisk(vec2 P, float size)
+{
+    float x = M_SQRT2/2 * (P.x - P.y);
+    float y = M_SQRT2/2 * (P.x + P.y);
+    float r1 = max(abs(x)- size/2., abs(y)- size/10.);
+    float r2 = max(abs(y)- size/2., abs(x)- size/10.);
+    float r3 = max(abs(P.x)- size/2., abs(P.y)- size/10.);
+    float r4 = max(abs(P.y)- size/2., abs(P.x)- size/10.);
+    return min( min(r1,r2), min(r3,r4));
+}

vispy/glsl/markers/chevron.glsl

@@ -0,0 +1,14 @@
+// -----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// -----------------------------------------------------------------------------
+#include "math/constants.glsl"
+
+float marker_chevron(vec2 P, float size)
+{
+    float x = 1.0/M_SQRT2 * ((P.x-size/6) - P.y);
+    float y = 1.0/M_SQRT2 * ((P.x-size/6) + P.y);
+    float r1 = max(abs(x),          abs(y))          - size/3.0;
+    float r2 = max(abs(x-size/3.0), abs(y-size/3.0)) - size/3.0;
+    return max(r1,-r2);
+}

vispy/glsl/markers/clover.glsl

@@ -0,0 +1,20 @@
+// -----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// -----------------------------------------------------------------------------
+#include "math/constants.glsl"
+
+float marker_clover(vec2 P, float size)
+{
+    const float t1 = -M_PI/2;
+    const vec2  c1 = 0.25*vec2(cos(t1),sin(t1));
+    const float t2 = t1+2*M_PI/3;
+    const vec2  c2 = 0.25*vec2(cos(t2),sin(t2));
+    const float t3 = t2+2*M_PI/3;
+    const vec2  c3 = 0.25*vec2(cos(t3),sin(t3));
+
+    float r1 = length( P - c1*size) - size/3.5;
+    float r2 = length( P - c2*size) - size/3.5;
+    float r3 = length( P - c3*size) - size/3.5;
+    return min(min(r1,r2),r3);
+}

vispy/glsl/markers/club.glsl

@@ -0,0 +1,31 @@
+// -----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// -----------------------------------------------------------------------------
+#include "math/constants.glsl"
+
+float marker_club(vec2 P, float size)
+{
+    // clover (3 discs)
+    const float t1 = -M_PI/2.0;
+    const vec2  c1 = 0.225*vec2(cos(t1),sin(t1));
+    const float t2 = t1+2*M_PI/3.0;
+    const vec2  c2 = 0.225*vec2(cos(t2),sin(t2));
+    const float t3 = t2+2*M_PI/3.0;
+    const vec2  c3 = 0.225*vec2(cos(t3),sin(t3));
+    float r1 = length( P - c1*size) - size/4.25;
+    float r2 = length( P - c2*size) - size/4.25;
+    float r3 = length( P - c3*size) - size/4.25;
+    float r4 =  min(min(r1,r2),r3);
+
+    // Root (2 circles and 2 planes)
+    const vec2 c4 = vec2(+0.65, 0.125);
+    const vec2 c5 = vec2(-0.65, 0.125);
+    float r5 = length(P-c4*size) - size/1.6;
+    float r6 = length(P-c5*size) - size/1.6;
+    float r7 = P.y - 0.5*size;
+    float r8 = 0.2*size - P.y;
+    float r9 = max(-min(r5,r6), max(r7,r8));
+
+    return min(r4,r9);
+}

vispy/glsl/markers/cross.glsl

@@ -0,0 +1,17 @@
+// -----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// -----------------------------------------------------------------------------
+#include "math/constants.glsl"
+
+float marker_cross(vec2 P, float size)
+{
+    float x = M_SQRT2/2.0 * (P.x - P.y);
+    float y = M_SQRT2/2.0 * (P.x + P.y);
+    float r1 = max(abs(x - size/3.0), abs(x + size/3.0));
+    float r2 = max(abs(y - size/3.0), abs(y + size/3.0));
+    float r3 = max(abs(x), abs(y));
+    float r = max(min(r1,r2),r3);
+    r -= size/2.;
+    return r;
+}

vispy/glsl/markers/diamond.glsl

@@ -0,0 +1,12 @@
+// -----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// -----------------------------------------------------------------------------
+#include "math/constants.glsl"
+
+float marker_diamond(vec2 P, float size)
+{
+   float x = M_SQRT2/2.0 * (P.x - P.y);
+   float y = M_SQRT2/2.0 * (P.x + P.y);
+   return max(abs(x), abs(y)) - size/(2.0*M_SQRT2);
+}

vispy/glsl/markers/disc.glsl

@@ -0,0 +1,9 @@
+// -----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// -----------------------------------------------------------------------------
+
+float marker_disc(vec2 P, float size)
+{
+    return length(P) - size/2.;
+}

vispy/glsl/markers/ellipse.glsl

@@ -0,0 +1,67 @@
+// -----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// -----------------------------------------------------------------------------
+
+// --- ellipse
+// Created by Inigo Quilez - iq/2013
+// License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
+float marker_ellipse(vec2 P, float size)
+{
+    // Alternate version (approximation)
+    float a = 1.0;
+    float b = 2.0;
+    float r = 0.5*size;
+    float f = length( P*vec2(a,b) );
+    f = length( P*vec2(a,b) );
+    f = f*(f-r)/length( P*vec2(a*a,b*b) );
+    return f;
+
+/*
+    vec2 ab = vec2(size/3.0, size/2.0);
+    vec2 p = abs( P );
+    if( p.x > p.y ){
+        p = p.yx;
+        ab = ab.yx;
+    }
+    float l = ab.y*ab.y - ab.x*ab.x;
+    float m = ab.x*p.x/l;
+    float n = ab.y*p.y/l;
+    float m2 = m*m;
+    float n2 = n*n;
+
+    float c = (m2 + n2 - 1.0)/3.0;
+    float c3 = c*c*c;
+
+    float q = c3 + m2*n2*2.0;
+    float d = c3 + m2*n2;
+    float g = m + m*n2;
+
+    float co;
+
+    if(d < 0.0)
+    {
+        float p = acos(q/c3)/3.0;
+        float s = cos(p);
+        float t = sin(p)*sqrt(3.0);
+        float rx = sqrt( -c*(s + t + 2.0) + m2 );
+        float ry = sqrt( -c*(s - t + 2.0) + m2 );
+        co = ( ry + sign(l)*rx + abs(g)/(rx*ry) - m)/2.0;
+    }
+    else
+    {
+        float h = 2.0*m*n*sqrt( d );
+        float s = sign(q+h)*pow( abs(q+h), 1.0/3.0 );
+        float u = sign(q-h)*pow( abs(q-h), 1.0/3.0 );
+        float rx = -s - u - c*4.0 + 2.0*m2;
+        float ry = (s - u)*sqrt(3.0);
+        float rm = sqrt( rx*rx + ry*ry );
+        float p = ry/sqrt(rm-rx);
+        co = (p + 2.0*g/rm - m)/2.0;
+    }
+
+    float si = sqrt(1.0 - co*co);
+    vec2 closestPoint = vec2(ab.x*co, ab.y*si);
+    return length(closestPoint - p ) * sign(p.y-closestPoint.y);
+*/
+}

vispy/glsl/markers/hbar.glsl

@@ -0,0 +1,9 @@
+// -----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// -----------------------------------------------------------------------------
+
+float marker_hbar(vec2 P, float size)
+{
+    return max(abs(P.x)- size/6.0, abs(P.y)- size/2.0);
+}

vispy/glsl/markers/heart.glsl

@@ -0,0 +1,15 @@
+// -----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// -----------------------------------------------------------------------------
+#include "math/constants.glsl"
+
+float marker_heart(vec2 P, float size)
+{
+   float x = M_SQRT2/2.0 * (P.x - P.y);
+   float y = M_SQRT2/2.0 * (P.x + P.y);
+   float r1 = max(abs(x),abs(y))-size/3.5;
+   float r2 = length(P - M_SQRT2/2.0*vec2(+1.0,-1.0)*size/3.5) - size/3.5;
+   float r3 = length(P - M_SQRT2/2.0*vec2(-1.0,-1.0)*size/3.5) - size/3.5;
+   return min(min(r1,r2),r3);
+}

vispy/glsl/markers/infinity.glsl

@@ -0,0 +1,15 @@
+// -----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// -----------------------------------------------------------------------------
+
+float marker_infinity(vec2 P, float size)
+{
+    const vec2 c1 = vec2(+0.2125, 0.00);
+    const vec2 c2 = vec2(-0.2125, 0.00);
+    float r1 = length(P-c1*size) - size/3.5;
+    float r2 = length(P-c1*size) - size/7.5;
+    float r3 = length(P-c2*size) - size/3.5;
+    float r4 = length(P-c2*size) - size/7.5;
+    return min( max(r1,-r2), max(r3,-r4));
+}

vispy/glsl/markers/marker-sdf.frag

@@ -0,0 +1,74 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#version 120
+
+// Constants
+// ------------------------------------
+const float SQRT_2 = 1.4142135623730951;
+
+// Uniforms
+// ------------------------------------
+uniform sampler2D u_texture;
+uniform vec2 u_texture_shape;
+
+// Varyings
+// ------------------------------------
+varying float v_antialias;
+varying float v_linewidth;
+varying vec4  v_fg_color;
+varying vec4  v_bg_color;
+varying float v_size;
+varying vec2  v_rotation;
+
+vec4 Nearest(sampler2D u_data, vec2 u_shape, vec2 v_texcoord);
+vec4 Bilinear(sampler2D u_data, vec2 u_shape, vec2 v_texcoord);
+vec4 Hanning(sampler2D u_data, vec2 u_shape, vec2 v_texcoord);
+vec4 Hamming(sampler2D u_data, vec2 u_shape, vec2 v_texcoord);
+vec4 Hermite(sampler2D u_data, vec2 u_shape, vec2 v_texcoord);
+vec4 Kaiser(sampler2D u_data, vec2 u_shape, vec2 v_texcoord);
+vec4 Quadric(sampler2D u_data, vec2 u_shape, vec2 v_texcoord);
+vec4 Bicubic(sampler2D u_data, vec2 u_shape, vec2 v_texcoord);
+vec4 CatRom(sampler2D u_data, vec2 u_shape, vec2 v_texcoord);
+vec4 Mitchell(sampler2D u_data, vec2 u_shape, vec2 v_texcoord);
+vec4 Spline16(sampler2D u_data, vec2 u_shape, vec2 v_texcoord);
+vec4 Spline36(sampler2D u_data, vec2 u_shape, vec2 v_texcoord);
+vec4 Gaussian(sampler2D u_data, vec2 u_shape, vec2 v_texcoord);
+vec4 Bessel(sampler2D u_data, vec2 u_shape, vec2 v_texcoord);
+vec4 Sinc(sampler2D u_data, vec2 u_shape, vec2 v_texcoord);
+vec4 Lanczos(sampler2D u_data, vec2 u_shape, vec2 v_texcoord);
+vec4 Blackman(sampler2D u_data, vec2 u_shape, vec2 v_texcoord);
+
+void main()
+{
+    vec2 P = gl_PointCoord.xy - vec2(0.5,0.5);
+    P = vec2(v_rotation.x*P.x - v_rotation.y*P.y,
+             v_rotation.y*P.x + v_rotation.x*P.y);
+    P += vec2(0.5,0.5);
+
+    float r = v_size + 2*(v_linewidth + 1.5*v_antialias);
+    // float signed_distance = r * (texture2D(u_texture, P).r - 0.5);
+    float signed_distance = r * (Bicubic(u_texture, u_texture_shape, P).r - 0.5);
+    float t = v_linewidth/2.0 - v_antialias;
+    float border_distance = abs(signed_distance) - t;
+    float alpha = border_distance/v_antialias;
+    alpha = exp(-alpha*alpha);
+
+
+    // Within linestroke
+    if( border_distance < 0 )
+        gl_FragColor = v_fg_color;
+    else if( signed_distance < 0 )
+        // Inside shape
+        if( border_distance > (v_linewidth/2.0 + v_antialias) )
+            gl_FragColor = v_bg_color;
+        else // Line stroke interior border
+            gl_FragColor = mix(v_bg_color,v_fg_color,alpha);
+    else
+        // Outide shape
+        if( border_distance > (v_linewidth/2.0 + v_antialias) )
+            discard;
+        else // Line stroke exterior border
+            gl_FragColor = vec4(v_fg_color.rgb, v_fg_color.a * alpha);
+}

vispy/glsl/markers/marker-sdf.vert

@@ -0,0 +1,41 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#version 120
+
+// Uniform
+// ------------------------------------
+uniform mat4  u_projection;
+uniform float u_antialias;
+
+// Attributes
+// ------------------------------------
+attribute float a_size;
+attribute float a_orientation;
+attribute float a_linewidth;
+attribute vec3  a_position;
+attribute vec4  a_fg_color;
+attribute vec4  a_bg_color;
+
+// Varyings
+// ------------------------------------
+varying float v_antialias;
+varying float v_linewidth;
+varying float v_size;
+varying vec4  v_fg_color;
+varying vec4  v_bg_color;
+varying vec2  v_rotation;
+
+void main (void)
+{
+    v_size = a_size;
+    v_linewidth = 2.5*a_linewidth;
+    v_antialias = 3.0*u_antialias;
+    v_fg_color = a_fg_color;
+    v_bg_color = a_bg_color;
+    v_rotation = vec2(cos(a_orientation), sin(a_orientation));
+
+    gl_Position = u_projection * vec4(a_position, 1.0);
+    gl_PointSize = a_size + 2.0*(a_linewidth + 1.5*v_antialias);
+}

vispy/glsl/markers/marker.frag

@@ -0,0 +1,36 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+// Hooks:
+//  <paint>  : "stroke", "filled" or "outline"
+//  <marker> : "arrow", "asterisk", "chevron", "clover", "club",
+//             "cross", "diamond", "disc", "ellipse", "hbar",
+//             "heart", "infinity", "pin", "ring", "spade",
+//             "square", "tag", "triangle", "vbar"
+// ----------------------------------------------------------------------------
+#include "math/constants.glsl"
+#include "markers/markers.glsl"
+#include "antialias/antialias.glsl"
+
+// Varyings
+// ------------------------------------
+varying float v_antialias;
+varying float v_linewidth;
+varying float v_size;
+varying float v_texcoord;
+varying vec4  v_fg_color;
+varying vec4  v_bg_color;
+varying vec2  v_orientation;
+
+// Main (hooked)
+// ------------------------------------
+void main()
+{
+    vec2 P = gl_PointCoord.xy - vec2(0.5,0.5);
+    P = vec2(v_orientation.x*P.x - v_orientation.y*P.y,
+             v_orientation.y*P.x + v_orientation.x*P.y);
+    float point_size = M_SQRT2*v_size  + 2 * (v_linewidth + 1.5*v_antialias);
+    float distance = marker_<marker>(P*point_size, v_size);
+    gl_FragColor = <paint>(distance, v_linewidth, v_antialias, v_fg_color, v_bg_color);
+}