@genome-spy/core 0.14.0

package/src/gl/point.fragment.glsl

@@ -0,0 +1,123 @@
+const lowp vec4 white = vec4(1.0);
+const lowp vec4 black = vec4(0.0, 0.0, 0.0, 1.0);
+
+uniform bool uInwardStroke;
+uniform float uGradientStrength;
+
+flat in float vRadius;
+flat in float vRadiusWithPadding;
+
+flat in lowp vec4 vFillColor;
+flat in lowp vec4 vStrokeColor;
+flat in lowp float vShape;
+flat in lowp float vHalfStrokeWidth;
+
+flat in mat2 vRotationMatrix;
+
+out lowp vec4 fragColor;
+
+const float CIRCLE = 0.0;
+const float SQUARE = 1.0;
+const float TRIANGLE_UP = 2.0;
+const float CROSS = 3.0;
+const float DIAMOND = 4.0;
+const float TRIANGLE_DOWN = 5.0;
+const float TRIANGLE_RIGHT = 6.0;
+const float TRIANGLE_LEFT = 7.0;
+
+
+// The distance functions are inspired by:
+// http://www.iquilezles.org/www/articles/distfunctions2d/distfunctions2d.htm
+// However, these are not true distance functions, because the corners need to be sharp.
+
+float circle(vec2 p, float r) {
+    return length(p) - r;
+}
+
+float square(vec2 p, float r) {
+    p = abs(p);
+    return max(p.x, p.y) - r;
+}
+
+float equilateralTriangle(vec2 p, float r, bool flip, bool swap) {
+    if (swap) {
+        p.xy = p.yx;
+    }
+    if (flip) {
+        p.y = -p.y;
+    }
+
+    float k = sqrt(3.0);
+    float kr = k * r;
+    //p.y -= kr * 2.0 / 3.0;
+    p.y -= kr / 2.0;
+    return max((abs(p.x) * k + p.y) / 2.0, -p.y - kr);
+}
+
+float crossShape(vec2 p, float r) {
+    p = abs(p);
+
+	vec2 b = vec2(0.4, 1.0) * r;
+    vec2 v = abs(p) - b.xy;
+    vec2 h = abs(p) - b.yx;
+    return min(max(v.x, v.y), max(h.x, h.y));
+}
+
+float diamond(vec2 p, float r) {
+    p = abs(p);
+    return (max(abs(p.x - p.y), abs(p.x + p.y)) - r) / sqrt(2.0);
+}
+
+void main() {
+    float d;
+
+	/** Normalized point coord */
+    vec2 p = vRotationMatrix * (2.0 * gl_PointCoord - 1.0) * vRadiusWithPadding;
+	float r = vRadius;
+
+    // We could also use textures here. Could even be faster, because we have plenty of branching here.
+    if (vShape == CIRCLE) {
+        d = circle(p, r);
+
+    } else if (vShape == SQUARE) {
+        d = square(p, r);
+
+    } else if (vShape == TRIANGLE_UP) {
+        d = equilateralTriangle(p, r, true, false);
+
+    } else if (vShape == CROSS) {
+        d = crossShape(p, r);
+
+    } else if (vShape == DIAMOND) {
+        d = diamond(p, r);
+
+    } else if (vShape == TRIANGLE_DOWN) {
+        d = equilateralTriangle(p, r, false, false);
+
+    } else if (vShape == TRIANGLE_RIGHT) {
+        d = equilateralTriangle(p, r, false, true);
+
+    } else if (vShape == TRIANGLE_LEFT) {
+        d = equilateralTriangle(p, r, true, true);
+
+    } else {
+        d = 0.0;
+    }
+
+	if (!uPickingEnabled) {
+		lowp vec4 fillColor = mix(vFillColor, white, -d * uGradientStrength / vRadius);
+
+		fragColor = distanceToColor(
+			d + (uInwardStroke ? vHalfStrokeWidth : 0.0),
+			fillColor,
+			vStrokeColor,
+			vHalfStrokeWidth);
+
+	} else if (d - vHalfStrokeWidth <= 0.0) {
+        fragColor = vPickingColor;
+
+	} else {
+		discard;
+    }
+}
+

package/src/gl/point.vertex.glsl

@@ -0,0 +1,128 @@
+precision mediump float;
+
+/**
+ * The stroke should only grow inwards, e.g, the diameter/outline is not affected by the stroke width.
+ * Thus, a point that has a zero size has no visible stroke. This allows strokes to be used with
+ * geometric zoom, etc.
+ */
+uniform bool uInwardStroke;
+
+/** Maximum size of the largest point as the fraction of the height of the (faceted) view */
+uniform lowp float uMaxRelativePointDiameter;
+
+/** Scale factor for geometric zoom */
+uniform float uScaleFactor;
+
+/** The size of the largest point in the data */
+uniform float uMaxPointSize;
+
+uniform float uZoomLevel;
+uniform float uSemanticThreshold;
+
+flat out float vRadius;
+flat out float vRadiusWithPadding;
+flat out lowp vec4 vFillColor;
+flat out lowp vec4 vStrokeColor;
+flat out lowp float vShape;
+flat out lowp float vHalfStrokeWidth;
+flat out mat2 vRotationMatrix;
+
+
+float computeSemanticThresholdFactor() {
+    // TODO: add smooth transition
+    return getScaled_semanticScore() >= uSemanticThreshold ? 1.0 : 0.0;
+}
+
+/**
+ * Computes a scaling factor for the points in a sample-faceted view.
+ */
+float getDownscaleFactor(vec2 pos) {
+    if (!isFacetedSamples()) {
+        return 1.0;
+    }
+
+    float sampleFacetHeight = getSampleFacetHeight(pos);
+    float maxPointDiameter = sqrt(uMaxPointSize);
+
+    float factor = sampleFacetHeight *
+        uViewportSize.y *
+        uMaxRelativePointDiameter;
+
+    return clamp(0.0, maxPointDiameter, factor) / maxPointDiameter;
+}
+
+// TODO: Move this into common.glsl or something
+vec2 getDxDy() {
+#if defined(dx_DEFINED) || defined(dy_DEFINED)
+    return vec2(getScaled_dx(), getScaled_dy()) / uViewportSize;
+#else
+    return vec2(0.0, 0.0);
+#endif
+}
+
+void main(void) {
+
+    float semanticThresholdFactor = computeSemanticThresholdFactor();
+    if (semanticThresholdFactor <= 0.0) {
+        gl_PointSize = 0.0;
+        // Exit early. MAY prevent some unnecessary calculations.
+        return;
+    }
+
+    float size = getScaled_size();
+    vec2 pos = vec2(getScaled_x(), getScaled_y()) + getDxDy();
+
+    gl_Position = unitToNdc(applySampleFacet(pos));
+
+    float strokeWidth = getScaled_strokeWidth();
+
+    float diameter = sqrt(size) *
+        uScaleFactor *
+        semanticThresholdFactor *
+        getDownscaleFactor(pos);
+
+    // Clamp minimum size and adjust opacity instead. Yields more pleasing result,
+    // no flickering etc.
+    float opacity = uViewOpacity;
+	if (strokeWidth <= 0.0 || uInwardStroke) {
+		float minDiameter = 1.0 / uDevicePixelRatio;
+		if (diameter < minDiameter) {
+			// We do some "cheap" gamma correction here. It breaks on dark background, though.
+			// First we take a square of the size and then apply "gamma" of 1.5.
+			opacity *= pow(diameter / minDiameter, 2.5);
+			diameter = minDiameter;
+		}
+	}
+
+	float fillOpa = getScaled_fillOpacity() * opacity;
+	float strokeOpa = getScaled_strokeOpacity() * opacity;
+
+    vShape = getScaled_shape();
+
+	// Circle doesn't have sharp corners. Do some special optimizations to minimize the point size.
+	bool circle = vShape == 0.0;
+
+	float angleInDegrees = getScaled_angle();
+	float angle = -angleInDegrees * PI / 180.0;
+    float sinTheta = sin(angle);
+    float cosTheta = cos(angle);
+    vRotationMatrix = mat2(cosTheta, sinTheta, -sinTheta, cosTheta);
+	float roomForRotation = circle ? 1.0 : sin(mod(angle, PI / 2.0) + PI / 4.0) / sin(PI / 4.0);
+
+	float aaPadding = 1.0 / uDevicePixelRatio;
+	float rotationPadding = (diameter * roomForRotation) - diameter;
+	// sqrt(3.0) ensures that the angles of equilateral triangles have enough room
+	float strokePadding = uInwardStroke ? 0.0 : strokeWidth * (circle ? 1.0 : sqrt(3.0));
+	float padding = rotationPadding + strokePadding + aaPadding;
+    gl_PointSize = (diameter + padding) * uDevicePixelRatio;
+
+	vRadius = diameter / 2.0;
+	vRadiusWithPadding = vRadius + padding / 2.0;
+
+    vHalfStrokeWidth = strokeWidth / 2.0;
+
+    vFillColor = vec4(getScaled_fill() * fillOpa, fillOpa);
+    vStrokeColor = vec4(getScaled_stroke() * strokeOpa, strokeOpa);
+
+    setupPicking();
+}

package/src/gl/rect.fragment.glsl

@@ -0,0 +1,51 @@
+#if defined(ROUNDED_CORNERS) || defined(STROKED)
+in vec2 vPosInPixels;
+#endif
+
+flat in vec2 vHalfSizeInPixels;
+
+flat in lowp vec4 vFillColor;
+flat in lowp vec4 vStrokeColor;
+flat in float vHalfStrokeWidth;
+flat in vec4 vCornerRadii;
+
+out lowp vec4 fragColor;
+
+// Source: https://www.iquilezles.org/www/articles/distfunctions2d/distfunctions2d.htm
+float sdRoundedBox(vec2 p, vec2 b, vec4 r) {
+    r.xy = p.x > 0.0 ? r.xy : r.zw;
+    r.x  = p.y > 0.0 ? r.x  : r.y;
+    vec2 q = abs(p) - b + r.x;
+    return min(max(q.x, q.y), 0.0) + length(max(q, 0.0)) - r.x;
+}
+
+// Not a true SDF. Makes the corners of strokes sharp and is faster.
+float sdSharpBox(vec2 p, vec2 b) {
+    vec2 q = abs(p) - b;
+    return max(q.x, q.y);
+}
+
+void main(void) {
+
+#if defined(ROUNDED_CORNERS) || defined(STROKED)
+#ifdef ROUNDED_CORNERS
+    // Distance from rectangle's edge in pixels. Negative inside the rectangle.
+    float d = sdRoundedBox(vPosInPixels, vHalfSizeInPixels, vCornerRadii);
+#else
+    float d = sdSharpBox(vPosInPixels, vHalfSizeInPixels);
+#endif
+
+    fragColor = distanceToColor(d, vFillColor, vStrokeColor, vHalfStrokeWidth);
+
+    if (fragColor.a == 0.0) {
+        discard;
+    }
+#else
+    // The trivial, non-decorated case
+    fragColor = vFillColor;
+#endif
+
+    if (uPickingEnabled) {
+        fragColor = vPickingColor;
+    }
+}

package/src/gl/rect.vertex.glsl

@@ -0,0 +1,114 @@
+/**
+ * The vertex position wrt the rectangle specified by (x, x2, y, y2).
+ * [0, 0] = [x, y], [1, 1] = [x2, y2]. 
+ * The x or y component may contain fractional values if the rectangle 
+ * have been tessellated.
+ */
+in vec2 frac;
+
+/** Minimum size (width, height) of the displayed rectangle in pixels */
+uniform vec2 uMinSize;
+
+/** Minimum opacity for the size size clamping */
+uniform float uMinOpacity;
+
+/** top-right, bottom-right, top-left, bottom-left */
+uniform vec4 uCornerRadii;
+
+flat out lowp vec4 vFillColor;
+flat out lowp vec4 vStrokeColor;
+flat out float vHalfStrokeWidth;
+flat out vec4 vCornerRadii;
+
+
+#if defined(ROUNDED_CORNERS) || defined(STROKED)
+/** Position for SDF-strokes */
+out vec2 vPosInPixels;
+#endif
+
+/** Size of the rect in pixels */
+flat out vec2 vHalfSizeInPixels;
+
+/**
+ * Clamps the minimumSize and returns an opacity that reflects the amount of clamping.
+ */
+float clampMinSize(inout float pos, float frac, float size, float minSize) {
+    if (minSize > 0.0 && abs(size) < minSize) {
+        pos += (frac - 0.5) * (minSize * sign(size) - size);
+        return abs(size) / minSize;
+    }
+
+    return 1.0;
+}
+
+void sort(inout float a, inout float b) {
+    if (a > b) {
+        float tmp = b;
+        b = a;
+        a = tmp;
+    }
+}
+
+void main(void) {
+    vec2 normalizedMinSize = uMinSize / uViewportSize;
+
+    float x = getScaled_x();
+    float x2 = getScaled_x2();
+    float y = getScaled_y();
+    float y2 = getScaled_y2();
+
+    sort(x, x2);
+    sort(y, y2);
+
+    // Clamp x to prevent precision artifacts when the scale is zoomed very close.
+	// TODO: clamp y as well
+	float clampMargin = 1.0;
+    vec2 pos1 = vec2(clamp(x, 0.0 - clampMargin, 1.0 + clampMargin), y);
+    vec2 pos2 = vec2(clamp(x2, 0.0 - clampMargin, 1.0 + clampMargin), y2);
+
+    vec2 size = pos2 - pos1;
+
+    if (size.x <= 0.0 || size.y <= 0.0) {
+        // Early exit. May increase performance or not...
+        gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
+        return;
+    }
+
+    vec2 pos = pos1 + frac * size;
+
+    size.y *= getSampleFacetHeight(pos);
+
+    // Clamp to minimum size, optionally compensate with opacity
+    float opaFactor = uViewOpacity * max(uMinOpacity,
+        clampMinSize(pos.x, frac.x, size.x, normalizedMinSize.x) *
+        clampMinSize(pos.y, frac.y, size.y, normalizedMinSize.y));
+
+    pos = applySampleFacet(pos);
+
+#if defined(ROUNDED_CORNERS) || defined(STROKED)
+    // Add an extra pixel to stroke width to accommodate edge antialiasing
+    float aaPadding = 1.0 / uDevicePixelRatio;
+    float strokeWidth = getScaled_strokeWidth();
+    float strokeOpacity = getScaled_strokeOpacity() * opaFactor;
+
+    vec2 centeredFrac = frac - 0.5;
+    vec2 expand = centeredFrac * (strokeWidth + aaPadding) / uViewportSize;
+    pos += expand;
+
+    vec2 sizeInPixels = size * uViewportSize;
+    vPosInPixels = (centeredFrac + expand / size) * sizeInPixels;
+
+    vHalfSizeInPixels = sizeInPixels / 2.0;
+
+    vCornerRadii = min(uCornerRadii, min(vHalfSizeInPixels.x, vHalfSizeInPixels.y));
+    vHalfStrokeWidth = strokeWidth / 2.0;
+    vStrokeColor = vec4(getScaled_stroke() * strokeOpacity, strokeOpacity);
+#endif
+
+    gl_Position = unitToNdc(pos);
+
+    float fillOpacity = getScaled_fillOpacity() * opaFactor;
+    vFillColor = vec4(getScaled_fill() * fillOpacity, fillOpacity);
+
+    setupPicking();
+}

package/src/gl/rule.fragment.glsl

@@ -0,0 +1,52 @@
+// Line ending
+const int BUTT = 0;
+const int SQUARE = 1;
+const int ROUND = 2;
+
+uniform sampler2D uDashTexture;
+uniform float uDashTextureSize;
+uniform float uStrokeDashOffset;
+uniform lowp int uStrokeCap;
+
+flat in vec4 vColor;
+flat in float vSize;
+
+/** Position on the rule along its length in pixels */
+in vec2 vPosInPixels;
+in float vNormalLengthInPixels;
+
+out lowp vec4 fragColor;
+
+void main(void) {
+    float dpr = uDevicePixelRatio;
+
+    float distanceFromEnd = -min(vPosInPixels[0], vPosInPixels[1]);
+    float distance; // from the rule centerline or end
+    if (distanceFromEnd > 0.0 && uStrokeCap == ROUND) {
+        // round cap
+        distance = length(vec2(distanceFromEnd, vNormalLengthInPixels));
+    } else {
+        distance = abs(vNormalLengthInPixels);
+    }
+
+    // Use a signed distance field to implement edge antialiasing
+    float opacity = clamp(((vSize / 2.0 - distance) * dpr), -0.5, 0.5) + 0.5;
+
+    if (uDashTextureSize > 0.0) {
+        float pos = (vPosInPixels[0] + uStrokeDashOffset) * dpr;
+        float floored = floor(pos);
+        vec2 texelPositions = (floored + vec2(0.5, 1.5)) / dpr / uDashTextureSize;
+      
+        // Do antialiasing
+        opacity *= mix(
+            texture(uDashTexture, vec2(texelPositions[0], 0)).r,
+            texture(uDashTexture, vec2(texelPositions[1], 0)).r,
+            clamp((pos - floored), 0.0, 1.0));
+    }
+
+    fragColor = vColor * opacity;
+
+    if (uPickingEnabled) {
+        fragColor = vPickingColor;
+    }
+}

package/src/gl/rule.vertex.glsl

@@ -0,0 +1,89 @@
+// Line caps
+const int BUTT = 0;
+const int SQUARE = 1;
+const int ROUND = 2;
+
+/** Position along the rule */
+in float pos;
+
+/** Which side of the stroke: -0.5 or 0.5 */
+in float side;
+
+/** Minimum rule length in pixels */
+uniform float uMinLength;
+
+uniform float uDashTextureSize;
+uniform lowp int uStrokeCap;
+
+flat out vec4 vColor;
+
+/** Stroke width */
+flat out float vSize;
+
+/** The distance from the line center to the direction of normal in pixels */
+out float vNormalLengthInPixels;
+
+/** Distances from the line endings. Used for rendering the round caps and dashes */
+out highp vec2 vPosInPixels;
+
+
+void main(void) {
+    float pixelSize = 1.0 / uDevicePixelRatio;
+
+    // Stroke width in pixels
+    float size = getScaled_size();
+    float opacity = getScaled_opacity() * uViewOpacity;
+
+    // Avoid artifacts in very thin lines by clamping the size and adjusting opacity respectively
+    if (size < pixelSize) {
+        opacity *= size / pixelSize;
+        size = pixelSize;
+    }
+
+    vec2 a = applySampleFacet(vec2(getScaled_x(), getScaled_y()));
+    vec2 b = applySampleFacet(vec2(getScaled_x2(), getScaled_y2()));
+
+    vec2 tangent = b - a;
+
+    float offset = 0.0;
+    float relativeDiff = 0.0;
+    if (uMinLength > 0.0 || uStrokeCap != BUTT) {
+        float len = length(tangent * uViewportSize);
+
+        // Elongate to reach the minimum length.
+        // The length difference in pixels
+        float diff = max(0.0, uMinLength - len);
+
+        // Add line caps
+        if (uStrokeCap != BUTT) {
+            diff += size;
+        }
+
+        relativeDiff = diff / len;
+        offset = relativeDiff * (pos - 0.5);
+    }
+
+    // Apply caps and minimum length by spreading the vertices along the tangent
+    vec2 p = pos < 1.0
+        ? a + tangent * (pos + offset)
+        : b + tangent * offset;
+
+    // Add an extra pixel to stroke width to accommodate edge antialiasing
+    float aaPadding = pixelSize;
+
+    // Extrude
+    vec2 normal = normalize(vec2(-tangent.y, tangent.x) / uViewportSize);
+    p += normal * side * (size + aaPadding) / uViewportSize;
+
+    gl_Position = unitToNdc(p);
+
+    vColor = vec4(getScaled_color() * opacity, opacity);
+    vSize = size;
+    vNormalLengthInPixels = side * (size + aaPadding);
+
+    // TODO: Here's a precision problem that breaks round caps when zoomed in enough
+    vPosInPixels = vec2(pos, (1.0 - pos)) * (1.0 + relativeDiff) * length(tangent * uViewportSize) -
+        vec2(uStrokeCap != BUTT ? size / 2.0 : 0.0);
+    
+    setupPicking();
+}

package/src/gl/text.fragment.glsl

@@ -0,0 +1,31 @@
+uniform sampler2D uTexture;
+
+in vec2 vTexCoord;
+in float vEdgeFadeOpacity;
+flat in vec4 vColor;
+flat in float vSlope;
+
+out lowp vec4 fragColor;
+
+float median(float r, float g, float b) {
+    return max(min(r, g), min(max(r, g), b));
+}
+
+void main() {
+    // TODO: Really small text should fall back to normal (non-SDF) texture that can be mip-mapped.
+    // Currently small text has severe aliasing artifacts.
+
+    vec3 c = texture(uTexture, vTexCoord).rgb;
+
+    float sigDist = 1.0 - median(c.r, c.g, c.b);
+    float opa = clamp((sigDist - 0.5) * vSlope + 0.5, 0.0, 1.0);
+
+    // Raise to the power of 2.2 to do some cheap gamma correction
+    opa *= pow(clamp(vEdgeFadeOpacity, 0.0, 1.0), 2.2);
+
+    fragColor = vColor * opa;
+
+    if (uPickingEnabled) {
+        fragColor = vPickingColor;
+    }
+}