vispy 0.15.0__cp313-cp313-win_amd64.whl

vispy/glsl/collections/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)
+//
+// ----------------------------------------------------------------------------
+#include "math/constants.glsl"
+
+
+// Externs
+// ------------------------------------
+// attribute vec3  position;
+// attribute float size;
+// attribute vec4  fg_color;
+// attribute vec4  bg_color;
+// attribute float orientation;
+// attribute 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)
+{
+    // From collection
+    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(position)>;
+    gl_PointSize = M_SQRT2 * size + 2.0 * (linewidth + 1.5*antialias);
+
+    <viewport.transform>;
+}

vispy/glsl/collections/raw-path.frag

@@ -0,0 +1,15 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+// Varyings
+// ------------------------------------
+varying vec4  v_color;
+
+// Main
+// ------------------------------------
+void main()
+{
+    gl_FragColor = v_color;
+}

vispy/glsl/collections/raw-path.vert

@@ -0,0 +1,24 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+// Externs
+// ------------------------------------
+// extern vec3  position;
+// extern float id;
+// extern vec4  color;
+// vec4 transform(vec3 position);
+
+// Varyings
+// ------------------------------------
+varying vec4 v_color;
+
+// Main
+// ------------------------------------
+void main (void)
+{
+    fetch_uniforms();
+    v_color = vec4(color.rgb, color.a*id);
+    gl_Position = $transform(vec4(position, 1));
+}

vispy/glsl/collections/raw-point.frag

@@ -0,0 +1,14 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+// Varyings
+// ------------------------------------
+varying float v_size;
+varying vec4  v_color;
+
+void main(void)
+{
+    gl_FragColor = v_color;
+}

vispy/glsl/collections/raw-point.vert

@@ -0,0 +1,31 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+// Externs
+// ------------------------------------
+// extern vec3 position;
+// extern float size;
+// extern vec4 color;
+// vec4 transform(vec3 position);
+
+
+// Varyings
+// ------------------------------------
+varying float v_size;
+varying vec4  v_color;
+
+
+// Main (hooked)
+// ------------------------------------
+void main()
+{
+    fetch_uniforms();
+
+    v_size = size;
+    v_color = color;
+
+    gl_Position = $transform(vec4(position, 1));
+    gl_PointSize = size;
+}

vispy/glsl/collections/raw-segment.frag

@@ -0,0 +1,18 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+// Varyings
+// ------------------------------------
+varying vec4  v_color;
+
+
+// Main
+// ------------------------------------
+void main (void)
+{
+    <viewport.clipping>;
+
+    gl_FragColor = v_color;
+}

vispy/glsl/collections/raw-segment.vert

@@ -0,0 +1,26 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+// Externs
+// ------------------------------------
+// extern vec3 position;
+// extern vec4 color;
+// extern vec4 viewport;
+// vec4 transform(vec3 position);
+
+// Varyings
+// ------------------------------------
+varying vec4 v_color;
+
+// Main
+// ------------------------------------
+void main (void)
+{
+    // This function is externally generated
+    fetch_uniforms();
+    v_color = color;
+
+    gl_Position = $transform(vec4(position, 1));
+}

vispy/glsl/collections/raw-triangle.frag

@@ -0,0 +1,13 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+// Varyings
+// ------------------------------------
+varying vec4 v_color;
+
+void main(void)
+{
+    gl_FragColor = v_color;
+}

vispy/glsl/collections/raw-triangle.vert

@@ -0,0 +1,26 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+// Externs
+// ------------------------------------
+// extern vec3 position;
+// extern float size;
+// extern vec4 color;
+// vec4 transform(vec3 position);
+
+
+// Varyings
+// ------------------------------------
+varying vec4  v_color;
+
+// Main
+// ------------------------------------
+void main()
+{
+    fetch_uniforms();
+    v_color = color;
+
+    gl_Position = $transform(vec4(position, 1));
+}

vispy/glsl/collections/sdf-glyph-ticks.vert

@@ -0,0 +1,69 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "math/constants.glsl"
+#include "misc/viewport-NDC.glsl"
+
+// Externs
+// ------------------------------------
+// vec2 position;
+// vec2 texcoord;
+// float scale;
+// vec3 origin;
+// vec3 direction
+// vec4 color;
+
+// Varyings
+// ------------------------------------
+varying float v_scale;
+varying vec2  v_texcoord;
+varying vec4  v_color;
+
+
+// Main
+// ------------------------------------
+void main()
+{
+    fetch_uniforms();
+
+    vec3 up = vec3(0,0,-1);
+
+    // Untransformed normalized tangent and orhogonal directions
+    vec3 tangent = normalize(direction.xyz);
+    vec3 ortho   = normalize(cross(tangent, up));
+
+    vec4 T = <transform((origin + scale*tangent))> - <transform(origin)>;
+    T = scale*normalize(T);
+
+    vec4 O = <transform((origin + scale*ortho))>   - <transform(origin)>;
+    O = scale*normalize(O);
+
+    vec4 P1_ = <transform(origin)> + ( position.x*T + position.y*O);
+    vec2 p1 = NDC_to_viewport(P1_, <viewport.viewport_global>.zw);
+/*
+    vec3 P1 = origin + scale*(tangent*position.x + ortho*position.y);
+    vec4 P1_ = <transform(P1)>;
+    vec2 p1 = NDC_to_viewport(P1_, <viewport.viewport_global>.zw);
+*/
+
+    // This compute an estimation of the actual size of the glyph
+    vec3 P2 = origin + scale*(tangent*(position.x+64.0) + ortho*(position.y));
+    vec4 P2_ = <transform(P2)>;
+    vec2 p2 = NDC_to_viewport(P2_, <viewport.viewport_global>.zw);
+
+    vec3 P3 = origin + scale*(tangent*(position.x) + ortho*(position.y+64.0));
+    vec4 P3_ = <transform(P3)>;
+    vec2 p3 = NDC_to_viewport(P3_, <viewport.viewport_global>.zw);
+
+    float d2 = length(p2 - p1);
+    float d3 = length(p3 - p1);
+    v_scale = min(d2,d3);
+
+
+    gl_Position = P1_;
+    v_texcoord = texcoord;
+    v_color = color;
+
+    <viewport.transform>;
+}

vispy/glsl/collections/sdf-glyph.frag

@@ -0,0 +1,80 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+// Ref: http://www.java-gaming.org/index.php?topic=33612.0
+//      http://www.reddit.com/
+//       -> r/gamedev/comments/2879jd/just_found_out_about_signed_distance_field_text/
+#include "math/constants.glsl"
+#include "misc/spatial-filters.frag"
+
+// Uniforms
+// ------------------------------------
+uniform sampler2D atlas_data;
+uniform vec2      atlas_shape;
+
+// Varyings
+// ------------------------------------
+varying float v_scale;
+varying vec2 v_texcoord;
+varying vec4 v_color;
+
+
+float contour(in float d, in float w)
+{
+    return smoothstep(0.5 - w, 0.5 + w, d);
+}
+float sample(sampler2D texture, vec2 uv, float w)
+{
+    return contour(texture2D(texture, uv).r, w);
+}
+
+
+// Main
+// ------------------------------------
+void main(void)
+{
+    <viewport.clipping>;
+
+    vec4 color = v_color;
+
+    // Retrieve distance from texture
+    float dist;
+    if(v_scale > 50.) {
+        dist = Bicubic(atlas_data, atlas_shape, v_texcoord).r;
+        // Debug
+        // color = vec4(0,0,1,1);
+    } else {
+        dist = texture2D(atlas_data, v_texcoord).r;
+    }
+
+
+    // fwidth helps keep outlines a constant width irrespective of scaling
+    // GLSL's fwidth = abs(dFdx(uv)) + abs(dFdy(uv))
+    float width = fwidth(dist);
+
+    // Regular SDF
+    float alpha = contour( dist, width );
+
+    // Supersampled version (when scale is small)
+    if (v_scale < 30.)
+    {
+        // Debug
+        // color = vec4(1,0,0,1);
+
+        // Supersample, 4 extra points
+        // Half of 1/sqrt2; you can play with this
+        float dscale = 0.5 * M_SQRT1_2;
+        vec2 duv = dscale * (dFdx(v_texcoord) + dFdy(v_texcoord));
+        vec4 box = vec4(v_texcoord-duv, v_texcoord+duv);
+        float asum = sample(atlas_data, box.xy, width)
+                   + sample(atlas_data, box.zw, width)
+                   + sample(atlas_data, box.xw, width)
+                   + sample(atlas_data, box.zy, width);
+
+        // weighted average, with 4 extra points having 0.5 weight each,
+        // so 1 + 0.5*4 = 3 is the divisor
+        alpha = (alpha + 0.5 * asum) / 3.0;
+    }
+    gl_FragColor = vec4(color.rgb, alpha*color.a);
+}

vispy/glsl/collections/sdf-glyph.vert

@@ -0,0 +1,59 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "math/constants.glsl"
+#include "misc/viewport-NDC.glsl"
+
+// Externs
+// ------------------------------------
+// vec2 position;
+// vec2 texcoord;
+// float scale;
+// vec3 origin;
+// vec3 direction
+// vec4 color;
+
+// Varyings
+// ------------------------------------
+varying float v_scale;
+varying vec2  v_texcoord;
+varying vec4  v_color;
+
+
+// Main
+// ------------------------------------
+void main()
+{
+    fetch_uniforms();
+
+    vec3 up = vec3(0,0,-1);
+
+    // Untransformed normalized tangent and orhogonal directions
+    vec3 tangent = normalize(direction.xyz);
+    vec3 ortho   = normalize(cross(tangent, up));
+
+    vec3 P1 = origin + scale*(tangent*position.x + ortho*position.y);
+    vec4 P1_ = <transform(P1)>;
+    vec2 p1 = NDC_to_viewport(P1_, <viewport.viewport_global>.zw);
+
+    // This compute an estimation of the actual size of the glyph
+    vec3 P2 = origin + scale*(tangent*(position.x+64.0) + ortho*(position.y));
+    vec4 P2_ = <transform(P2)>;
+    vec2 p2 = NDC_to_viewport(P2_, <viewport.viewport_global>.zw);
+
+    vec3 P3 = origin + scale*(tangent*(position.x) + ortho*(position.y+64.0));
+    vec4 P3_ = <transform(P3)>;
+    vec2 p3 = NDC_to_viewport(P3_, <viewport.viewport_global>.zw);
+
+    float d2 = length(p2 - p1);
+    float d3 = length(p3 - p1);
+    v_scale = min(d2,d3);
+
+
+    gl_Position = P1_;
+    v_texcoord = texcoord;
+    v_color = color;
+
+    <viewport.transform>;
+}

vispy/glsl/collections/tick-labels.vert

@@ -0,0 +1,71 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "math/constants.glsl"
+#include "misc/viewport-NDC.glsl"
+
+// Externs
+// ------------------------------------
+// vec2 position;
+// vec2 texcoord;
+// float scale;
+// vec3 origin;
+// vec3 direction
+// vec4 color;
+
+// Varyings
+// ------------------------------------
+varying float v_scale;
+varying vec2  v_texcoord;
+varying vec4  v_color;
+
+
+// This works because we know the matplotlib API and how a transform is built
+float xscale(float x)        { return <transform.xscale.forward!(x)>; }
+float yscale(float y)        { return <transform.yscale.forward!(y)>; }
+float zscale(float z)        { return <transform.zscale.forward!(z)>; }
+vec3 data_projection(vec3 P) { return <transform.data_projection.forward!(P)>.xyz; }
+vec4 view_projection(vec3 P) { return <transform.view_projection.transform!(vec4(P,1))>; }
+
+vec3 data_scale(vec3 P)      { return vec3(xscale(P.x), yscale(P.y), zscale(P.z)); }
+vec4 transform(vec3 P)       { return view_projection(data_projection(data_scale(P))); }
+
+
+// Main
+// ------------------------------------
+void main()
+{
+    fetch_uniforms();
+
+    vec3 up = vec3(0,0,-1);
+
+    vec3 O = data_projection(data_scale(origin));
+
+    vec3 tangent = normalize(data_projection(data_scale(origin+scale*direction)) - O);
+    vec3 ortho = normalize(cross(tangent, up));
+
+    vec3 P1 = O + scale*(position.x*tangent + position.y*ortho);
+    vec4 P1_ = view_projection(P1);
+    vec2 p1 = NDC_to_viewport(P1_, <viewport.viewport_global>.zw);
+
+    // This compute an estimation of the actual size of the glyph
+    vec3 P2 = O + scale*(tangent*(position.x+64.0) + ortho*(position.y));
+    vec4 P2_ = view_projection(P2);
+    vec2 p2 = NDC_to_viewport(P2_, <viewport.viewport_global>.zw);
+
+    vec3 P3 = O + scale*(tangent*(position.x) + ortho*(position.y+64.0));
+    vec4 P3_ = view_projection(P3);
+    vec2 p3 = NDC_to_viewport(P3_, <viewport.viewport_global>.zw);
+
+    float d2 = length(p2 - p1);
+    float d3 = length(p3 - p1);
+    v_scale = min(d2,d3);
+
+
+    gl_Position = P1_;
+    v_texcoord = texcoord;
+    v_color = color;
+
+    <viewport.transform>;
+}

vispy/glsl/colormaps/autumn.glsl

@@ -0,0 +1,20 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "colormaps/util.glsl"
+
+vec3 colormap_autumn(float t)
+{
+    return mix(vec3(1.0,0.0,0.0), vec3(1.0,1.0,0.0), t);
+}
+
+vec3 colormap_autumn(float t, vec3 under, vec3 over)
+{
+    return colormap_underover(t, colormap_autumn(t), under, over);
+}
+
+vec4 colormap_autumn(float t, vec4 under, vec4 over)
+{
+    return colormap_underover(t, vec4(colormap_autumn(t),1.0), under, over);
+}

vispy/glsl/colormaps/blues.glsl

@@ -0,0 +1,20 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "colormaps/util.glsl"
+
+vec3 colormap_blues(float t)
+{
+    return mix(vec3(1,1,1), vec3(0,0,1), t);
+}
+
+vec3 colormap_blues(float t, vec3 under, vec3 over)
+{
+    return colormap_underover(t, colormap_blues(t), under, over);
+}
+
+vec4 colormap_blues(float t, vec4 under, vec4 over)
+{
+    return colormap_underover(t, vec4(colormap_blues(t),1.0), under, over);
+}

vispy/glsl/colormaps/color-space.glsl

@@ -0,0 +1,17 @@
+vec3 hsv_to_rgb(vec3 c)
+{
+    vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+    vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
+    return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
+}
+
+vec3 rgb_to_hsv(vec3 c)
+{
+    vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
+    vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
+    vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
+
+    float d = q.x - min(q.w, q.y);
+    float e = 1.0e-10;
+    return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
+}

vispy/glsl/colormaps/colormaps.glsl

@@ -0,0 +1,24 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "colormaps/util.glsl"
+#include "colormaps/user.glsl"
+
+#include "colormaps/hot.glsl"
+#include "colormaps/gray.glsl"
+#include "colormaps/cool.glsl"
+#include "colormaps/wheel.glsl"
+
+#include "colormaps/autumn.glsl"
+#include "colormaps/winter.glsl"
+#include "colormaps/spring.glsl"
+#include "colormaps/summer.glsl"
+
+#include "colormaps/ice.glsl"
+#include "colormaps/fire.glsl"
+#include "colormaps/icefire.glsl"
+
+#include "colormaps/reds.glsl"
+#include "colormaps/blues.glsl"
+#include "colormaps/greens.glsl"

vispy/glsl/colormaps/cool.glsl

@@ -0,0 +1,20 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "colormaps/util.glsl"
+
+vec3 colormap_cool(float t)
+{
+    return mix(vec3(0.0,1.0,1.0), vec3(1.0,0.0,1.0), t);
+}
+
+vec3 colormap_cool(float t, vec3 under, vec3 over)
+{
+    return colormap_underover(t, colormap_cool(t), under, over);
+}
+
+vec4 colormap_cool(float t, vec4 under, vec4 over)
+{
+    return colormap_underover(t, vec4(colormap_cool(t),1.0), under, over);
+}

vispy/glsl/colormaps/fire.glsl

@@ -0,0 +1,21 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "colormaps/util.glsl"
+
+vec3 colormap_fire(float t)
+{
+    return mix(mix(vec3(1,1,1), vec3(1,1,0), t),
+               mix(vec3(1,1,0), vec3(1,0,0), t*t), t);
+}
+
+vec3 colormap_fire(float t, vec3 under, vec3 over)
+{
+    return colormap_underover(t, colormap_fire(t), under, over);
+}
+
+vec4 colormap_fire(float t, vec4 under, vec4 over)
+{
+    return colormap_underover(t, vec4(colormap_fire(t),1.0), under, over);
+}

vispy/glsl/colormaps/gray.glsl

@@ -0,0 +1,20 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "colormaps/util.glsl"
+
+vec3 colormap_gray(float t)
+{
+    return vec3(t);
+}
+
+vec3 colormap_gray(float t, vec3 under, vec3 over)
+{
+    return colormap_underover(t, colormap_gray(t), under, over);
+}
+
+vec4 colormap_gray(float t, vec4 under, vec4 over)
+{
+    return colormap_underover(t, vec4(colormap_gray(t),1.0), under, over);
+}

vispy/glsl/colormaps/greens.glsl

@@ -0,0 +1,20 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "colormaps/util.glsl"
+
+vec3 colormap_greens(float t)
+{
+    return mix(vec3(1,1,1), vec3(0,1,0), t);
+}
+
+vec3 colormap_greens(float t, vec3 under, vec3 over)
+{
+    return colormap_underover(t, colormap_greens(t), under, over);
+}
+
+vec4 colormap_greens(float t, vec4 under, vec4 over)
+{
+    return colormap_underover(t, vec4(colormap_greens(t),1.0), under, over);
+}