vispy 0.15.0__cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

vispy/glsl/collections/agg-fast-path.vert

@@ -0,0 +1,78 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+// Hooks:
+//  <transform> : vec4 function(position, ...)
+//
+// ----------------------------------------------------------------------------
+#include "misc/viewport-NDC.glsl"
+
+// Externs
+// ------------------------------------
+// extern vec3  prev;
+// extern vec3  curr;
+// extern vec3  next;
+// extern float id;
+// extern vec4  color;
+// extern float antialias;
+// extern float linewidth;
+// extern vec4 viewport;
+//        vec4 transform(vec3 position);
+
+// Varyings
+// ------------------------------------
+varying float v_antialias;
+varying float v_linewidth;
+varying float v_distance;
+varying vec4  v_color;
+
+
+// Main
+// ------------------------------------
+void main (void)
+{
+    // This function is externally generated
+    fetch_uniforms();
+    v_linewidth = linewidth;
+    v_antialias = antialias;
+    v_color     = color;
+
+    // transform prev/curr/next
+    vec4 prev_ = $transform(vec4(prev, 1));
+    vec4 curr_ = $transform(vec4(curr, 1));
+    vec4 next_ = $transform(vec4(next, 1));
+
+    // prev/curr/next in viewport coordinates
+    vec2 _prev = NDC_to_viewport(prev_, viewport.zw);
+    vec2 _curr = NDC_to_viewport(curr_, viewport.zw);
+    vec2 _next = NDC_to_viewport(next_, viewport.zw);
+
+    // Compute vertex final position (in viewport coordinates)
+    float w = linewidth/2.0 + 1.5*antialias;
+    float z;
+    vec2 P;
+    if( curr == prev) {
+        vec2 v = normalize(_next.xy - _curr.xy);
+        vec2 normal = normalize(vec2(-v.y,v.x));
+        P = _curr.xy + normal*w*id;
+    } else if (curr == next) {
+        vec2 v = normalize(_curr.xy - _prev.xy);
+        vec2 normal  = normalize(vec2(-v.y,v.x));
+        P = _curr.xy + normal*w*id;
+    } else {
+        vec2 v0 = normalize(_curr.xy - _prev.xy);
+        vec2 v1 = normalize(_next.xy - _curr.xy);
+        vec2 normal  = normalize(vec2(-v0.y,v0.x));
+        vec2 tangent = normalize(v0+v1);
+        vec2 miter   = vec2(-tangent.y, tangent.x);
+        float l = abs(w / dot(miter,normal));
+        P = _curr.xy + miter*l*sign(id);
+    }
+
+    if( abs(id) > 1.5 ) v_color.a = 0.0;
+
+    v_distance = w*id;
+    gl_Position = viewport_to_NDC(vec3(P, curr_.z/curr_.w), viewport.zw);
+
+}

vispy/glsl/collections/agg-glyph.frag

@@ -0,0 +1,60 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+// Uniforms
+// ------------------------------------
+uniform sampler2D atlas_data;
+uniform vec2      atlas_shape;
+
+// Varyings
+// ------------------------------------
+varying vec4  v_color;
+varying float v_offset;
+varying vec2  v_texcoord;
+
+
+// Main
+// ------------------------------------
+void main(void)
+{
+    <viewport.clipping>;
+
+    vec2 viewport = <viewport.viewport_global>.zw;
+
+    vec4 current = texture2D(atlas_data, v_texcoord);
+    vec4 previous= texture2D(atlas_data, v_texcoord+vec2(-1.0,0.0)/viewport);
+    vec4 next    = texture2D(atlas_data, v_texcoord+vec2(+1.0,0.0)/viewport);
+
+    float r = current.r;
+    float g = current.g;
+    float b = current.b;
+
+    if( v_offset < 1.0 )
+    {
+        float z = v_offset;
+        r = mix(current.r, previous.b, z);
+        g = mix(current.g, current.r,  z);
+        b = mix(current.b, current.g,  z);
+    }
+    else if( v_offset < 2.0 )
+    {
+        float z = v_offset - 1.0;
+        r = mix(previous.b, previous.g, z);
+        g = mix(current.r,  previous.b, z);
+        b = mix(current.g,  current.r,  z);
+    }
+   else //if( v_offset <= 1.0 )
+    {
+        float z = v_offset - 2.0;
+        r = mix(previous.g, previous.r, z);
+        g = mix(previous.b, previous.g, z);
+        b = mix(current.r,  previous.b, z);
+    }
+
+   float t = max(max(r,g),b);
+   vec4 color = vec4(v_color.rgb, (r+g+b)/3.0);
+   color = t*color + (1.0-t)*vec4(r,g,b, min(min(r,g),b));
+   gl_FragColor = vec4( color.rgb, v_color.a*color.a);
+}

vispy/glsl/collections/agg-glyph.vert

@@ -0,0 +1,33 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+// Externs
+// ------------------------------------
+// vec2 origin;
+// vec2 position;
+// vec2 texcoord;
+// vec4 color;
+
+// Varyings
+// ------------------------------------
+varying vec4  v_color;
+varying float v_offset;
+varying vec2  v_texcoord;
+
+// Main
+// ------------------------------------
+void main()
+{
+    fetch_uniforms();
+
+    gl_Position = <transform(origin)>;
+    v_color = color;
+    v_texcoord = texcoord;
+    <viewport.transform>;
+
+    // We set actual position after transform
+    v_offset = 3.0*(offset + origin.x - int(origin.x));
+    gl_Position = gl_Position + vec4(2.0*position/<viewport.viewport_global>.zw,0,0);
+}

vispy/glsl/collections/agg-marker.frag

@@ -0,0 +1,35 @@
+// ----------------------------------------------------------------------------
+// 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.h"
+#include "markers/markers.glsl"
+#include "antialias/antialias.h"
+
+// 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_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 = SQRT_2*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);
+}

vispy/glsl/collections/agg-marker.vert

@@ -0,0 +1,48 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+// Hooks:
+//  <transform> : vec4 function(position, ...)
+//
+// ----------------------------------------------------------------------------
+#version 120
+#include "math/constants.glsl"
+
+// Collection externs
+// ------------------------------------
+// extern vec2  position;
+// extern float size;
+// extern vec4  fg_color;
+// extern vec4  bg_color;
+// extern float orientation;
+// extern float antialias;
+// extern float linewidth;
+
+
+// Varyings
+// ------------------------------------
+varying float v_size;
+varying vec4  v_fg_color;
+varying vec4  v_bg_color;
+varying vec2  v_orientation;
+varying float v_antialias;
+varying float v_linewidth;
+
+
+// Main (hooked)
+// ------------------------------------
+void main (void)
+{
+    fetch_uniforms();
+
+    v_size        = size;
+    v_linewidth   = linewidth;
+    v_antialias   = antialias;
+    v_fg_color    = fg_color;
+    v_bg_color    = bg_color;
+    v_orientation = vec2(cos(orientation), sin(orientation));
+
+    gl_Position = <transform>;
+    gl_PointSize = M_SQRT2 * size + 2.0 * (linewidth + 1.5*antialias);
+}

vispy/glsl/collections/agg-path.frag

@@ -0,0 +1,55 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "antialias/antialias.glsl"
+#include "antialias/caps.glsl"
+
+// Varyings
+// ------------------------------------
+varying vec2  v_caps;
+varying vec4  v_color;
+varying float v_length;
+varying vec2  v_texcoord;
+varying float v_linewidth;
+varying float v_antialias;
+varying float v_miter_limit;
+varying vec2  v_bevel_distance;
+
+void main()
+{
+    float distance = v_texcoord.y;
+
+    if (v_caps.x < 0.0)
+    {
+        gl_FragColor = cap(1, v_texcoord.x, v_texcoord.y,
+                           v_linewidth, v_antialias, v_color);
+        // Do not return here or clipping won't be enforced
+        // return;
+    }
+    else if (v_caps.y > v_length)
+    {
+        gl_FragColor = cap(1, v_texcoord.x-v_length, v_texcoord.y,
+                           v_linewidth, v_antialias, v_color);
+        // Do not return here or clipping won't be enforced
+        // return;
+    }
+
+    // Round join (instead of miter)
+    // if (v_texcoord.x < 0.0)          { distance = length(v_texcoord); }
+    // else if(v_texcoord.x > v_length) { distance = length(v_texcoord - vec2(v_length, 0.0)); }
+
+    else {
+        // Miter limit
+        float t = (v_miter_limit-1.0)*(v_linewidth/2.0) + v_antialias;
+        if( (v_texcoord.x < 0.0) && (v_bevel_distance.x > (abs(distance) + t)) )
+        {
+            distance = v_bevel_distance.x - t;
+        }
+        else if( (v_texcoord.x > v_length) && (v_bevel_distance.y > (abs(distance) + t)) )
+        {
+            distance = v_bevel_distance.y - t;
+        }
+        gl_FragColor = stroke(distance, v_linewidth, v_antialias, v_color);
+    }
+}

vispy/glsl/collections/agg-path.vert

@@ -0,0 +1,166 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+// Hooks:
+//  <transform> : vec4 function(position, ...)
+//
+// ----------------------------------------------------------------------------
+#include "misc/viewport-NDC.glsl"
+#include "math/point-to-line-distance.glsl"
+#include "math/point-to-line-projection.glsl"
+
+// Externs
+// ------------------------------------
+// extern vec3  p0;
+// extern vec3  p1;
+// extern vec3  p2;
+// extern vec3  p3;
+// extern vec2  uv;
+// extern vec2  caps;
+// extern vec4  color;
+// extern float antialias;
+// extern float linewidth;
+// extern float miter_limit;
+// extern vec4 viewport;
+// vec4 transform(vec3 position);
+
+
+// Varyings
+// ------------------------------------
+varying vec2  v_caps;
+varying vec4  v_color;
+
+varying float v_antialias;
+varying float v_linewidth;
+
+varying float v_length;
+varying vec2  v_texcoord;
+varying float v_miter_limit;
+varying vec2  v_bevel_distance;
+
+
+// Main
+// ------------------------------------
+void main (void)
+{
+    // This function is externally generated
+    fetch_uniforms();
+
+    v_color = color;
+    v_caps = caps;
+    v_linewidth = linewidth;
+    v_antialias = antialias;
+    v_miter_limit = miter_limit;
+
+    // transform prev/curr/next
+    vec4 p0_ = $transform(vec4(p0, 1));
+    vec4 p1_ = $transform(vec4(p1, 1));
+    vec4 p2_ = $transform(vec4(p2, 1));
+    vec4 p3_ = $transform(vec4(p3, 1));
+
+    // prev/curr/next in viewport coordinates
+    vec2 _p0 = NDC_to_viewport(p0_, viewport.zw);
+    vec2 _p1 = NDC_to_viewport(p1_, viewport.zw);
+    vec2 _p2 = NDC_to_viewport(p2_, viewport.zw);
+    vec2 _p3 = NDC_to_viewport(p3_, viewport.zw);
+
+    v_antialias = antialias;
+    v_linewidth = linewidth;
+    v_miter_limit = miter_limit;
+
+    // Determine the direction of each of the 3 segments (previous, current, next)
+    vec2 v0 = normalize(_p1 - _p0);
+    vec2 v1 = normalize(_p2 - _p1);
+    vec2 v2 = normalize(_p3 - _p2);
+
+
+    // Determine the normal of each of the 3 segments (previous, current, next)
+    vec2 n0 = vec2(-v0.y, v0.x);
+    vec2 n1 = vec2(-v1.y, v1.x);
+    vec2 n2 = vec2(-v2.y, v2.x);
+
+    // Determine miter lines by averaging the normals of the 2 segments
+    vec2 miter_a;
+    vec2 miter_b;
+    const float epsilon = 0.1;
+
+    // WARN: Here we test if v0 = -v1 relatively to epsilon
+    if( length(v0+v1) < epsilon ) {
+        miter_a = n1;
+    } else {
+        miter_a = normalize(n0 + n1); // miter at start of current segment
+    }
+
+    // WARN: Here we test if v1 = -v2 relatively to epsilon
+    if( length(v1+v2) < epsilon ) {
+        miter_b = n1;
+    } else {
+        miter_b = normalize(n1 + n2); // miter at end of current segment
+    }
+
+    // Determine the length of the miter by projecting it onto normal
+    vec2 p,v;
+    float d, z;
+    float w = linewidth/2.0 + 1.5*antialias;
+    v_length = length(_p2-_p1);
+    float m = miter_limit*linewidth/2.0;
+    float length_a = w / dot(miter_a, n1);
+    float length_b = w / dot(miter_b, n1);
+
+
+    // Angle between prev and current segment (sign only)
+    float d0 = +1.0;
+    if( (v0.x*v1.y - v0.y*v1.x) > 0. ) { d0 = -1.0;}
+
+    // Angle between current and next segment (sign only)
+    float d1 = +1.0;
+    if( (v1.x*v2.y - v1.y*v2.x) > 0. ) { d1 = -1.0; }
+
+    // Adjust vertex position
+    if (uv.x == -1.) {
+        z = p1_.z / p1_.w;
+
+        // Cap at start
+        if( p0 == p1 ) {
+            p = _p1 - w*v1 + uv.y* w*n1;
+            v_texcoord = vec2(-w, uv.y*w);
+            v_caps.x = v_texcoord.x;
+            // Regular join
+        } else {
+            p = _p1 + uv.y * length_a * miter_a;
+            v_texcoord = vec2(point_to_line_projection(_p1,_p2,p), uv.y*w);
+            v_caps.x = 1.0;
+        }
+        if( p2 == p3 ) {
+            v_caps.y = v_texcoord.x;
+        } else {
+            v_caps.y = 1.0;
+        }
+        v_bevel_distance.x = uv.y*d0*point_to_line_distance(_p1+d0*n0*w, _p1+d0*n1*w, p);
+        v_bevel_distance.y =        -point_to_line_distance(_p2+d1*n1*w, _p2+d1*n2*w, p);
+    } else {
+        z = p2_.z / p2_.w;
+
+        // Cap at end
+        if( p2 == p3 ) {
+            p = _p2 + w*v1 + uv.y*w*n1;
+            v_texcoord = vec2(v_length+w, uv.y*w);
+            v_caps.y = v_texcoord.x;
+        // Regular join
+        } else {
+            p = _p2 + uv.y*length_b * miter_b;
+            v_texcoord = vec2(point_to_line_projection(_p1,_p2,p), uv.y*w);
+            v_caps.y = 1.0;
+        }
+        if( p0 == p1 ) {
+            v_caps.x = v_texcoord.x;
+        } else {
+            v_caps.x = 1.0;
+        }
+        v_bevel_distance.x =        -point_to_line_distance(_p1+d0*n0*w, _p1+d0*n1*w, p);
+        v_bevel_distance.y = uv.y*d1*point_to_line_distance(_p2+d1*n1*w, _p2+d1*n2*w, p);
+    }
+
+    gl_Position = viewport_to_NDC(vec3(p,z), viewport.zw);
+}

vispy/glsl/collections/agg-point.frag

@@ -0,0 +1,21 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "markers/disc.glsl"
+#include "antialias/filled.glsl"
+
+// Varyings
+// ------------------------------------
+varying float v_size;
+varying vec4  v_color;
+
+// Main
+// ------------------------------------
+void main()
+{
+    vec2 P = gl_PointCoord.xy - vec2(0.5,0.5);
+    float point_size = v_size  + 2. * (1.0 + 1.5*1.0);
+    float distance = marker_disc(P*point_size, v_size);
+    gl_FragColor = filled(distance, 1.0, 1.0, v_color);
+}

vispy/glsl/collections/agg-point.vert

@@ -0,0 +1,35 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+// Externs
+// ------------------------------------
+// extern vec3 position;
+// extern float size;
+// extern vec4 fg_color;
+// extern vec4 bg_color;
+// extern float orientation;
+// extern float antialias;
+// extern float linewidth;
+// extern vec4 transform(vec3);
+
+// Varyings
+// ------------------------------------
+varying float v_size;
+varying vec4  v_color;
+varying float v_linewidth;
+varying float v_antialias;
+
+// Main (hooked)
+// ------------------------------------
+void main (void)
+{
+    fetch_uniforms();
+
+    v_size = size;
+    v_color = color;
+
+    gl_Position = $transform(vec4(position, 1));
+    gl_PointSize = size + 2.0 * (1.0 + 1.5*1.0);
+}

vispy/glsl/collections/agg-segment.frag

@@ -0,0 +1,32 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "antialias/caps.glsl"
+#include "antialias/antialias.glsl"
+
+// Varyings
+// ------------------------------------
+varying float v_length;
+varying float v_linewidth;
+varying float v_antialias;
+varying vec2  v_texcoord;
+varying vec4  v_color;
+
+
+// Main
+// ------------------------------------
+void main (void)
+{
+    if (v_texcoord.x < 0.0) {
+        gl_FragColor = cap( CAP_ROUND,
+                            v_texcoord.x, v_texcoord.y,
+                            v_linewidth, v_antialias, v_color);
+    } else if(v_texcoord.x > v_length) {
+        gl_FragColor = cap( CAP_ROUND,
+                            v_texcoord.x-v_length, v_texcoord.y,
+                            v_linewidth, v_antialias, v_color);
+    } else {
+        gl_FragColor = stroke(v_texcoord.y, v_linewidth, v_antialias, v_color);
+    }
+}

vispy/glsl/collections/agg-segment.vert

@@ -0,0 +1,75 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+// Hooks:
+//  <transform> : vec4 function(position, ...)
+//
+// ----------------------------------------------------------------------------
+#include "misc/viewport-NDC.glsl"
+
+// Externs
+// ------------------------------------
+// extern vec3  P0;
+// extern vec3  P1;
+// extern float index;
+// extern vec4  color;
+// extern float antialias;
+// extern float linewidth;
+// extern vec4  viewport;
+// vec4 transform(vec3 position);
+
+// Varyings
+// ------------------------------------
+varying float v_length;
+varying float v_antialias;
+varying float v_linewidth;
+varying vec2  v_texcoord;
+varying vec4  v_color;
+
+
+
+// Main
+// ------------------------------------
+void main (void)
+{
+    // This function is externally generated
+    fetch_uniforms();
+    v_linewidth = linewidth;
+    v_antialias = antialias;
+    v_color     = color;
+
+    vec4 P0_ = $transform(vec4(P0, 1));
+    vec4 P1_ = $transform(vec4(P1, 1));
+
+    // p0/p1 in viewport coordinates
+    vec2 p0 = NDC_to_viewport(P0_, viewport.zw);
+    vec2 p1 = NDC_to_viewport(P1_, viewport.zw);
+
+    //
+    vec2 position;
+    vec2 T = p1 - p0;
+    v_length = length(T);
+    float w = v_linewidth/2.0 + 1.5*v_antialias;
+    T = w*normalize(T);
+    float z;
+    if( index < 0.5 ) {
+       position = vec2( p0.x-T.y-T.x, p0.y+T.x-T.y);
+       v_texcoord = vec2(-w, +w);
+       z = P0.z;
+    } else if( index < 1.5 ) {
+       position = vec2(p0.x+T.y-T.x, p0.y-T.x-T.y);
+       v_texcoord= vec2(-w, -w);
+       z = P0.z;
+    } else if( index < 2.5 ) {
+       position = vec2( p1.x+T.y+T.x, p1.y-T.x+T.y);
+       v_texcoord= vec2(v_length+w, -w);
+       z = P1.z;
+    } else {
+       position = vec2( p1.x-T.y+T.x, p1.y+T.x+T.y);
+       v_texcoord = vec2(v_length+w, +w);
+       z = P1.z;
+    }
+
+    gl_Position = viewport_to_NDC(vec3(position,z), viewport.zw);
+}

vispy/glsl/collections/marker.frag

@@ -0,0 +1,38 @@
+// ----------------------------------------------------------------------------
+// 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()
+{
+    <viewport.clipping>;
+
+    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);
+}