@genome-spy/core 0.30.0 → 0.30.2

package/src/gl/rect.vertex.glsl

@@ -1,114 +0,0 @@
-/**
- * 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;
-
-out lowp vec4 vFillColor;
-out lowp vec4 vStrokeColor;
-out float vHalfStrokeWidth;
-out vec4 vCornerRadii;
-
-
-#if defined(ROUNDED_CORNERS) || defined(STROKED)
-/** Position for SDF-strokes */
-out vec2 vPosInPixels;
-#endif
-
-/** Size of the rect in pixels */
-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

@@ -1,52 +0,0 @@
-// 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;
-
-in vec4 vColor;
-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

@@ -1,89 +0,0 @@
-// 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 mediump float uDashTextureSize;
-uniform lowp int uStrokeCap;
-
-out vec4 vColor;
-
-/** Stroke width */
-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

@@ -1,31 +0,0 @@
-uniform sampler2D uTexture;
-
-in vec2 vTexCoord;
-in float vEdgeFadeOpacity;
-in vec4 vColor;
-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;
-    }
-}

package/src/gl/text.vertex.glsl

@@ -1,246 +0,0 @@
-uniform float uSdfNumerator;
-
-uniform vec2 uD; // dx & dy
-
-in mediump vec2 vertexCoord;
-in lowp vec2 textureCoord;
-
-uniform vec4 uViewportEdgeFadeWidth;
-uniform vec4 uViewportEdgeFadeDistance;
-    
-uniform bool uSqueeze;
-uniform bool uLogoLetter;
-
-// Width of the text (all letters)
-in float width;
-
-// x: -1, 0, 1 = left, center, right
-// y: -1, 0, 1 = top, middle, bottom 
-uniform ivec2 uAlign;
-
-#ifdef x2_DEFINED
-uniform float uPaddingX;
-uniform bool uFlushX;
-#endif
-
-#ifdef y2_DEFINED
-uniform float uPaddingY;
-uniform bool uFlushY;
-#endif
-
-out vec2 vTexCoord;
-out vec4 vColor;
-out float vSlope;
-out float vEdgeFadeOpacity;
-
-struct RangeResult {
-    float pos;
-    float scale;
-};
-
-float minValue(vec4 v) {
-    return min(min(v.x, v.y), min(v.z, v.w));
-}
-
-float maxValue(vec4 v) {
-    return max(max(v.x, v.y), max(v.z, v.w));
-}
-
-/**
- * All measures are in [0, 1]
- */
-RangeResult positionInsideRange(float a, float b, float width, float padding,
-                                int align, bool flush) {
-    float span = b - a;
-    float paddedWidth = width + 2.0 * padding;
-
-    // Is the text clearly outside the viewport
-    if (a > 1.0 || b < 0.0) {
-        return RangeResult(0.0, 0.0);
-    }
-
-    // How much extra space we have for adjusting the position so that the
-    // text stays inside the range.
-    float extra = max(0.0, span - paddedWidth);
-
-    float pos;
-
-    // Align the text and try to keep it inside the range and the viewport
-    if (align == 0) {
-        float centre = a + b;
-
-        if (flush) {
-            float leftOver = max(0.0, paddedWidth - centre);
-            centre += min(leftOver, extra);
-
-            float rightOver = max(0.0, paddedWidth + centre - 2.0);
-            centre -= min(rightOver, extra);
-        }
-
-        pos = centre / 2.0;
-
-    } else if (align < 0) {
-        float edge = a;
-
-        if (flush) {
-            float over = max(0.0, -edge);
-            edge += min(over, extra);
-        }
-
-        pos = edge + padding;
-
-    } else {
-        float edge = b;
-
-        if (flush) {
-            float over = max(0.0, edge - 1.0);
-            edge -= min(over, extra);
-        }
-
-		// TODO: If the text spans the whole viewport, try to keep it centered if possible.
-
-        pos = edge - padding;
-    }
-
-    // How the text should be scaled to make it fit inside the range (if it didn't fit).
-    float scale = clamp((span - padding) / paddedWidth, 0.0, 1.0);
-
-    // TODO: Fix padding in scale factor. Padding should stay constant
-    return RangeResult(pos, scale);
-}
-
-vec2 calculateRotatedDimensions(float width, mat2 rotationMatrix) {
-    vec2 a = abs(rotationMatrix * vec2(width / 2.0, 0.5));
-    vec2 b = abs(rotationMatrix * vec2(width / 2.0, -0.5));
-    return vec2(max(a.x, b.x), max(a.y, b.y)) * 2.0;
-}
-
-/** Needed when using ranged text */
-ivec2 fixAlignForAngle(ivec2 align, float angleInDegrees) {
-    float a = mod(angleInDegrees + 45.0, 360.0);
-    int x = align.x;
-    int y = -align.y;
-
-    // TODO: Optimize by avoiding branching
-    if (a < 90.0) {
-        return ivec2(x, y);
-    } else if (a < 180.0) {
-        return ivec2(y, -x);
-    } else if (a < 270.0) {
-        return ivec2(-x, y);
-    } else {
-        return ivec2(-y, x);
-    }
-}
-
-void main(void) {
-    float opacity = getScaled_opacity() * uViewOpacity;
-    vec2 size = vec2(getScaled_size());
-    float x = getScaled_x();
-    float y = getScaled_y();
-
-    float scale = 1.0;
-
-	float angleInDegrees = getScaled_angle();
-	float angle = -angleInDegrees * PI / 180.0;
-	
-    float sinTheta = sin(angle);
-    float cosTheta = cos(angle);
-    mat2 rotationMatrix = mat2(cosTheta, sinTheta, -sinTheta, cosTheta);
-
-    vec2 flushSize = calculateRotatedDimensions(width, rotationMatrix);
-
-#if defined(x2_DEFINED) || defined(y2_DEFINED)
-    ivec2 align = fixAlignForAngle(uAlign, angleInDegrees);
-#else
-    ivec2 align = uAlign;
-#endif
-
-#ifdef x2_DEFINED
-    float x2 = getScaled_x2();
-
-    if (uLogoLetter) {
-        size.x = (x2 - x) * uViewportSize.x;
-        x += (x2 - x) / 2.0;
-
-    } else {
-        float x2 = getScaled_x2();
-        RangeResult result = positionInsideRange(
-            min(x, x2), max(x, x2),
-            size.x * scale * flushSize.x / uViewportSize.x, uPaddingX / uViewportSize.x,
-            align.x, uFlushX);
-        
-        x = result.pos;
-        scale *= result.scale;
-    }
-#endif
-
-    // Position of the text origo 
-    vec2 pos = applySampleFacet(vec2(x, y));
-
-#ifdef y2_DEFINED
-    float y2 = getScaled_y2();
-    vec2 pos2 = applySampleFacet(vec2(x, y2));
-
-    if (uLogoLetter) {
-        size.y = (pos2.y - pos.y) * uViewportSize.y;
-        pos.y += (pos2.y - pos.y) / 2.0;
-
-    } else {
-        RangeResult result = positionInsideRange(
-            min(pos.y, pos2.y), max(pos.y, pos2.y),
-            size.y * scale * flushSize.y / uViewportSize.y, uPaddingY / uViewportSize.y,
-            align.y, uFlushY);
-        
-        pos.y = result.pos;
-        scale *= result.scale;
-    }
-#endif
-
-    if (scale < 1.0) {
-        if (uSqueeze) {
-            vec2 scaleFadeExtent = vec2(3.0, 6.0) / size;
-
-            if (scale  < scaleFadeExtent[0]) {
-                gl_Position = vec4(0.0);
-                return;
-            }
-
-            size *= scale;
-            opacity *= linearstep(scaleFadeExtent[0], scaleFadeExtent[1], scale);
-
-        } else if (scale < 1.0) {
-            // Eliminate the text
-            gl_Position = vec4(0.0);
-            return;
-        }
-    }
-
-    // Position of the character vertex in relation to the text origo
-    vec2 charPos = rotationMatrix * (vertexCoord * size + uD);
-
-    // Position of the character vertex inside the unit viewport
-    vec2 unitPos = pos + charPos / uViewportSize;
-
-    gl_Position = unitToNdc(unitPos);
-
-    // Controls antialiasing of the SDF
-    vSlope = max(1.0, min(size.x, size.y) / uSdfNumerator);
-
-    vColor = vec4(getScaled_color() * opacity, opacity);
-
-    vTexCoord = textureCoord;
-
-    // Edge fading. The implementation is simplistic and fails with primitives that
-    // span the whole viewport. However, it works just fine with reasonable font sizes.
-    // x: top, y: right, z: bottom, w: left
-    if (maxValue(uViewportEdgeFadeDistance) > -pow(10.0, 10.0)) { // -Infinity would be nice
-        vEdgeFadeOpacity = minValue(
-            ((vec4(1.0, 1.0, 0.0, 0.0) + vec4(-1.0, -1.0, 1.0, 1.0) * unitPos.yxyx) *
-                uViewportSize.yxyx - uViewportEdgeFadeDistance) / uViewportEdgeFadeWidth);
-    } else {
-        vEdgeFadeOpacity = 1.0;
-    }
-
-    setupPicking();
-}