@genome-spy/core 0.14.0

package/src/gl/text.vertex.glsl

@@ -0,0 +1,246 @@
+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;
+flat out vec4 vColor;
+flat 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();
+}