@genome-spy/core 0.19.0 → 0.21.0

package/src/gl/includes/fp64-arithmetic.glsl

@@ -1,187 +0,0 @@
-// Adapted from luma.gl - https://github.com/uber/luma.gl
-
-// Copyright (c) 2015 - 2017 Uber Technologies, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-uniform float ONE;
-
-/*
-About LUMA_FP64_CODE_ELIMINATION_WORKAROUND
-
-The purpose of this workaround is to prevent shader compilers from
-optimizing away necessary arithmetic operations by swapping their sequences
-or transform the equation to some 'equivalent' from.
-
-The method is to multiply an artifical variable, ONE, which will be known to
-the compiler to be 1 only at runtime. The whole expression is then represented
-as a polynomial with respective to ONE. In the coefficients of all terms, only one a
-and one b should appear
-
-err = (a + b) * ONE^6 - a * ONE^5 - (a + b) * ONE^4 + a * ONE^3 - b - (a + b) * ONE^2 + a * ONE
-*/
-
-// Divide float number to high and low floats to extend fraction bits
-vec2 split(float a) {
-  const float SPLIT = 4097.0;
-  float t = a * SPLIT;
-#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float a_hi = t * ONE - (t - a);
-  float a_lo = a * ONE - a_hi;
-#else
-  float a_hi = t - (t - a);
-  float a_lo = a - a_hi;
-#endif
-  return vec2(a_hi, a_lo);
-}
-
-// Divide float number again when high float uses too many fraction bits
-vec2 split2(vec2 a) {
-  vec2 b = split(a.x);
-  b.y += a.y;
-  return b;
-}
-
-// Special sum operation when a > b
-vec2 quickTwoSum(float a, float b) {
-#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float sum = (a + b) * ONE;
-  float err = b - (sum - a) * ONE;
-#else
-  float sum = a + b;
-  float err = b - (sum - a);
-#endif
-  return vec2(sum, err);
-}
-
-// General sum operation
-vec2 twoSum(float a, float b) {
-  float s = (a + b);
-#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float v = (s * ONE - a) * ONE;
-  float err = (a - (s - v) * ONE) * ONE * ONE * ONE + (b - v);
-#else
-  float v = s - a;
-  float err = (a - (s - v)) + (b - v);
-#endif
-  return vec2(s, err);
-}
-
-vec2 twoSub(float a, float b) {
-  float s = (a - b);
-#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float v = (s * ONE - a) * ONE;
-  float err = (a - (s - v) * ONE) * ONE * ONE * ONE - (b + v);
-#else
-  float v = s - a;
-  float err = (a - (s - v)) - (b + v);
-#endif
-  return vec2(s, err);
-}
-
-vec2 twoSqr(float a) {
-  float prod = a * a;
-  vec2 a_fp64 = split(a);
-#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float err = ((a_fp64.x * a_fp64.x - prod) * ONE + 2.0 * a_fp64.x *
-    a_fp64.y * ONE * ONE) + a_fp64.y * a_fp64.y * ONE * ONE * ONE;
-#else
-  float err = ((a_fp64.x * a_fp64.x - prod) + 2.0 * a_fp64.x * a_fp64.y) + a_fp64.y * a_fp64.y;
-#endif
-  return vec2(prod, err);
-}
-
-vec2 twoProd(float a, float b) {
-  float prod = a * b;
-  vec2 a_fp64 = split(a);
-  vec2 b_fp64 = split(b);
-  float err = ((a_fp64.x * b_fp64.x - prod) + a_fp64.x * b_fp64.y +
-    a_fp64.y * b_fp64.x) + a_fp64.y * b_fp64.y;
-  return vec2(prod, err);
-}
-
-vec2 sum_fp64(vec2 a, vec2 b) {
-  vec2 s, t;
-  s = twoSum(a.x, b.x);
-  t = twoSum(a.y, b.y);
-  s.y += t.x;
-  s = quickTwoSum(s.x, s.y);
-  s.y += t.y;
-  s = quickTwoSum(s.x, s.y);
-  return s;
-}
-
-vec2 sub_fp64(vec2 a, vec2 b) {
-  vec2 s, t;
-  s = twoSub(a.x, b.x);
-  t = twoSub(a.y, b.y);
-  s.y += t.x;
-  s = quickTwoSum(s.x, s.y);
-  s.y += t.y;
-  s = quickTwoSum(s.x, s.y);
-  return s;
-}
-
-vec2 mul_fp64(vec2 a, vec2 b) {
-  vec2 prod = twoProd(a.x, b.x);
-  // y component is for the error
-  prod.y += a.x * b.y;
-#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
-  prod = split2(prod);
-#endif
-  prod = quickTwoSum(prod.x, prod.y);
-  prod.y += a.y * b.x;
-#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
-  prod = split2(prod);
-#endif
-  prod = quickTwoSum(prod.x, prod.y);
-  return prod;
-}
-
-vec2 div_fp64(vec2 a, vec2 b) {
-  float xn = 1.0 / b.x;
-#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
-  vec2 yn = mul_fp64(a, vec2(xn, 0));
-#else
-  vec2 yn = a * xn;
-#endif
-  float diff = (sub_fp64(a, mul_fp64(b, yn))).x;
-  vec2 prod = twoProd(xn, diff);
-  return sum_fp64(yn, prod);
-}
-
-vec2 sqrt_fp64(vec2 a) {
-  if (a.x == 0.0 && a.y == 0.0) return vec2(0.0, 0.0);
-  if (a.x < 0.0) return vec2(0.0 / 0.0, 0.0 / 0.0);
-
-  float x = 1.0 / sqrt(a.x);
-  float yn = a.x * x;
-#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  vec2 yn_sqr = twoSqr(yn) * ONE;
-#else
-  vec2 yn_sqr = twoSqr(yn);
-#endif
-  float diff = sub_fp64(a, yn_sqr).x;
-  vec2 prod = twoProd(x * 0.5, diff);
-#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
-  return sum_fp64(split(yn), prod);
-#else
-  return sum_fp64(vec2(yn, 0.0), prod);
-#endif
-}

package/src/gl/includes/fp64-utils.js

@@ -1,142 +0,0 @@
-// Adapted from luma.gl - https://github.com/visgl/luma.gl
-
-// Copyright (c) 2015 - 2017 Uber Technologies, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-/**
- * Calculate WebGL 64 bit float
- *
- * @param {number} a the input float number
- * @param {number[]} [out] the output array. If not supplied, a new array is created.
- * @param {number} [startIndex] the index in the output array to fill from. Default 0.
- * @returns {number[]} the fp64 representation of the input number
- */
-export function fp64ify(a, out = [], startIndex = 0) {
-    const hiPart = Math.fround(a);
-    out[startIndex] = hiPart;
-    out[startIndex + 1] = isFinite(hiPart) ? a - hiPart : 0;
-    return out;
-}
-
-/**
- * Calculate the low part of a WebGL 64 bit float
- *
- * @param {number} a the input float number
- * @returns {number} the lower 32 bit of the number
- */
-export function fp64LowPart(a) {
-    return a - Math.fround(a);
-}
-
-/**
- * @param {WebGLRenderingContext | WebGL2RenderingContext} gl
- */
-export function getPlatformShaderDefines(gl) {
-    const debugInfo = getContextInfo(gl);
-
-    switch (debugInfo.gpuVendor.toLowerCase()) {
-        case "nvidia":
-            return `\
-  #define NVIDIA_GPU
-  // Nvidia optimizes away the calculation necessary for emulated fp64
-  #define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1
-  `;
-
-        case "intel":
-            return `\
-  #define INTEL_GPU
-  // Intel optimizes away the calculation necessary for emulated fp64
-  #define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1
-  // Intel's built-in 'tan' function doesn't have acceptable precision
-  #define LUMA_FP32_TAN_PRECISION_WORKAROUND 1
-  // Intel GPU doesn't have full 32 bits precision in same cases, causes overflow
-  #define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1
-  `;
-
-        case "amd":
-            // AMD Does not eliminate fp64 code
-            return `\
-  #define AMD_GPU
-  `;
-
-        default:
-            // We don't know what GPU it is, could be that the GPU driver or
-            // browser is not implementing UNMASKED_RENDERER constant and not
-            // reporting a correct name
-            return `\
-  #define DEFAULT_GPU
-  // Prevent driver from optimizing away the calculation necessary for emulated fp64
-  #define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1
-  // Intel's built-in 'tan' function doesn't have acceptable precision
-  #define LUMA_FP32_TAN_PRECISION_WORKAROUND 1
-  // Intel GPU doesn't have full 32 bits precision in same cases, causes overflow
-  #define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1
-  `;
-    }
-}
-
-const GL_VENDOR = 0x1f00;
-const GL_RENDERER = 0x1f01;
-const GL_VERSION = 0x1f02;
-const GL_SHADING_LANGUAGE_VERSION = 0x8b8c;
-
-/**
- * @param {WebGLRenderingContext | WebGL2RenderingContext} gl
- */
-export function getContextInfo(gl) {
-    const info = gl.getExtension("WEBGL_debug_renderer_info");
-    const vendor = gl.getParameter(
-        (info && info.UNMASKED_VENDOR_WEBGL) || GL_VENDOR
-    );
-    const renderer = gl.getParameter(
-        (info && info.UNMASKED_RENDERER_WEBGL) || GL_RENDERER
-    );
-    const gpuVendor = identifyGPUVendor(vendor, renderer);
-    const gpuInfo = {
-        gpuVendor,
-        vendor,
-        renderer,
-        version: gl.getParameter(GL_VERSION),
-        shadingLanguageVersion: gl.getParameter(GL_SHADING_LANGUAGE_VERSION),
-    };
-    return gpuInfo;
-}
-
-/**
- * @param {string} vendor
- * @param {string} renderer
- */
-function identifyGPUVendor(vendor, renderer) {
-    if (vendor.match(/NVIDIA/i) || renderer.match(/NVIDIA/i)) {
-        return "NVIDIA";
-    }
-    if (vendor.match(/INTEL/i) || renderer.match(/INTEL/i)) {
-        return "INTEL";
-    }
-    if (
-        vendor.match(/AMD/i) ||
-        renderer.match(/AMD/i) ||
-        vendor.match(/ATI/i) ||
-        renderer.match(/ATI/i)
-    ) {
-        return "AMD";
-    }
-    return "UNKNOWN GPU";
-}

package/src/gl/includes/scales_fp64.glsl

@@ -1,30 +0,0 @@
-float scaleIdentityFp64(vec2 value) {
-    return value[0];
-}
-
-float scaleLinearFp64(vec2 value, vec4 domain, vec2 range) {
-    vec2 domainSpan = sub_fp64(domain.zw, domain.xy);
-    float rangeSpan = range[1] - range[0];
-
-    float unitValue = div_fp64(sub_fp64(value, domain.xy), domainSpan).x;
-    return unitValue * rangeSpan + range[0];
-}
-
-float scaleBandFp64(vec2 value, vec4 domainExtent, vec2 range,
-                float paddingInner, float paddingOuter,
-                float align, float band) {
-
-    // TODO: reverse
-    float start = range[0];
-    float stop = range[1];
-
-    vec2 domainSpan = sub_fp64(domainExtent.zw, domainExtent.xy);
-    float n = domainSpan.x;
-
-    // Based on: https://github.com/d3/d3-scale/blob/master/src/band.js
-    float step = (stop - start) / max(1.0, n - paddingInner + paddingOuter * 2.0);
-    start += (stop - start - step * (n - paddingInner)) * align;
-    float bandwidth = step * (1.0 - paddingInner);
-
-    return start + sub_fp64(value, domainExtent.xy).x * step + bandwidth * band;
-}

package/src/utils/binnedRangeIndex.js

@@ -1,83 +0,0 @@
-import clamp from "./clamp";
-
-const MAX_INTEGER = 2 ** 31 - 1;
-
-/**
- * @callback Lookup
- * @param {number} start
- * @param {number} end
- * @returns {[number, number]}
- */
-
-/**
- * A binned index for (overlapping) ranges that are sorted by their start position.
- * Allows for indexing vertices of mark instances.
- *
- * @param {number} size Number of bins
- * @param {[number, number]} domain
- */
-export default function createBinningRangeIndexer(size, domain) {
-    const startIndices = new Int32Array(size);
-    startIndices.fill(MAX_INTEGER);
-
-    const endIndices = new Int32Array(size);
-
-    const start = domain[0];
-    const domainLength = domain[1] - domain[0];
-    const divisor = domainLength / size;
-
-    /** @param {number} pos */
-    const getBin = (pos) =>
-        clamp(Math.floor((pos - start) / divisor), 0, size - 1);
-
-    /**
-     *
-     * @param {number} start
-     * @param {number} end
-     * @param {number} startIndex
-     * @param {number} endIndex
-     */
-    const indexer = (start, end, startIndex, endIndex) => {
-        const startBin = getBin(start);
-        const endBin = getBin(end);
-
-        // TODO: This loop could probably be done as a more efficient post processing
-        // step.
-        for (let bin = startBin; bin <= endBin; bin++) {
-            if (startIndices[bin] > startIndex) {
-                startIndices[bin] = startIndex;
-            }
-
-            if (endIndices[bin] < endIndex) {
-                endIndices[bin] = endIndex;
-            }
-        }
-    };
-
-    /**
-     * @type {Lookup}
-     */
-    const lookup = (start, end) => [
-        startIndices[getBin(start)],
-        endIndices[getBin(end)],
-    ];
-
-    const getIndex = () => {
-        for (let i = 1; i < endIndices.length; i++) {
-            if (endIndices[i] < endIndices[i - 1]) {
-                endIndices[i] = endIndices[i - 1];
-            }
-        }
-        for (let i = endIndices.length - 1; i > 0; i--) {
-            if (endIndices[i - 1] > endIndices[i]) {
-                endIndices[i - 1] = endIndices[i];
-            }
-        }
-
-        return lookup;
-    };
-
-    indexer.getIndex = getIndex;
-
-    return indexer;
-}