@genome-spy/core 0.36.1 → 0.37.1

package/dist/src/gl/arrayBuilder.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @typedef {Object} ConverterMetadata
+ *      A function that extracts a raw attribute from a datum (optionally) converts
+ *      it to floats or float vectors that can be stored in GPU buffers.
+ * @prop {function(object):any} f The converter
+ * @prop {number[]} [arrayReference] An optimization for fp64 mainly
+ * @prop {number} [numComponents]
+ */
+export default class ArrayBuilder {
+    /**
+     *
+     * @param {number} size Size if known, uses TypedArray
+     */
+    constructor(size: number);
+    size: number;
+    /** @type {Object.<string, {data: number[] | Float32Array, numComponents: number, divisor?: number}>} */
+    arrays: {
+        [x: string]: {
+            data: number[] | Float32Array;
+            numComponents: number;
+            divisor?: number;
+        };
+    };
+    /** @type {(function():void)[]} */
+    pushers: (() => void)[];
+    /** @type {(function(any):void)[]} */
+    dataUpdaters: ((arg0: any) => void)[];
+    vertexCount: number;
+    /**
+     *
+     * @param {string} attribute
+     * @param {ConverterMetadata} metadata
+     */
+    addConverter(attribute: string, metadata: ConverterMetadata): void;
+    /**
+     *
+     * @param {string} attributeName
+     * @param {number} numComponents
+     * @param {number[]} [arrayReference]
+     * @return {function(number|number[])}
+     */
+    createUpdater(attributeName: string, numComponents: number, arrayReference?: number[]): (arg0: number | number[]) => any;
+    _unrollPushAll(): void;
+    pushAll(): void;
+    /**
+     *
+     * @param {object} datum
+     */
+    updateFromDatum(datum: object): void;
+    /**
+     *
+     * @param {object} datum
+     */
+    pushFromDatum(datum: object): void;
+}
+/**
+ * A function that extracts a raw attribute from a datum (optionally) converts
+ * it to floats or float vectors that can be stored in GPU buffers.
+ */
+export type ConverterMetadata = {
+    /**
+     * The converter
+     */
+    f: (arg0: object) => any;
+    /**
+     * An optimization for fp64 mainly
+     */
+    arrayReference?: number[];
+    numComponents?: number;
+};
+//# sourceMappingURL=arrayBuilder.d.ts.map

package/dist/src/gl/arrayBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrayBuilder.d.ts","sourceRoot":"","sources":["../../../src/gl/arrayBuilder.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH;IAGI;;;OAGG;IACH,kBAFW,MAAM,EAehB;IAZG,aAAgB;IAEhB,wGAAwG;IACxG;YADmB,MAAM,GAAE;YAAC,IAAI,EAAE,MAAM,EAAE,GAAG,YAAY,CAAC;YAAC,aAAa,EAAE,MAAM,CAAC;YAAC,OAAO,CAAC,EAAE,MAAM,CAAA;SAAC;MACnF;IAEhB,kCAAkC;IAClC,gBADuB,IAAI,IACV;IAEjB,qCAAqC;IACrC,sBADqB,GAAG,KAAE,IAAI,IACR;IAEtB,oBAAoB;IAGxB;;;;OAIG;IACH,wBAHW,MAAM,YACN,iBAAiB,QAc3B;IAED;;;;;;OAMG;IACH,6BALW,MAAM,iBACN,MAAM,mBACN,MAAM,EAAE,UACE,MAAM,GAAC,MAAM,EAAE,SA8EnC;IAED,uBAsBC;IAED,gBAiBC;IAED;;;OAGG;IACH,uBAFW,MAAM,QAMhB;IAED;;;OAGG;IACH,qBAFW,MAAM,QAKhB;CACJ;;;;;;;;;cA/LkB,MAAM,KAAE,GAAG;;;;qBACpB,MAAM,EAAE;oBACR,MAAM"}

package/dist/src/gl/arrayBuilder.js

@@ -0,0 +1,199 @@
+import { isNumber } from "vega-util";
+import { ATTRIBUTE_PREFIX } from "../scale/glslScaleGenerator";
+
+/**
+ * @typedef {Object} ConverterMetadata
+ *      A function that extracts a raw attribute from a datum (optionally) converts
+ *      it to floats or float vectors that can be stored in GPU buffers.
+ * @prop {function(object):any} f The converter
+ * @prop {number[]} [arrayReference] An optimization for fp64 mainly
+ * @prop {number} [numComponents]
+ */
+export default class ArrayBuilder {
+    // TODO: Support strided layout. May yield better performance or not. No consensus in literature.
+
+    /**
+     *
+     * @param {number} size Size if known, uses TypedArray
+     */
+    constructor(size) {
+        this.size = size;
+
+        /** @type {Object.<string, {data: number[] | Float32Array, numComponents: number, divisor?: number}>} */
+        this.arrays = {};
+
+        /** @type {(function():void)[]} */
+        this.pushers = [];
+
+        /** @type {(function(any):void)[]} */
+        this.dataUpdaters = [];
+
+        this.vertexCount = 0;
+    }
+
+    /**
+     *
+     * @param {string} attribute
+     * @param {ConverterMetadata} metadata
+     */
+    addConverter(attribute, metadata) {
+        const updater = this.createUpdater(
+            ATTRIBUTE_PREFIX + attribute,
+            metadata.numComponents || 1,
+            metadata.arrayReference
+        );
+        const f = metadata.f;
+        this.dataUpdaters.push(
+            metadata.arrayReference
+                ? (d) => updater(f(d))
+                : (d) => updater(f(d))
+        );
+    }
+
+    /**
+     *
+     * @param {string} attributeName
+     * @param {number} numComponents
+     * @param {number[]} [arrayReference]
+     * @return {function(number|number[])}
+     */
+    createUpdater(attributeName, numComponents, arrayReference) {
+        if (!isNumber(this.size)) {
+            throw new Error("The number of vertices must be defined!");
+        }
+
+        /** @type {function():void} */
+        let pusher;
+        let updater;
+        let i = 0;
+
+        const array = new Float32Array(this.size * numComponents);
+
+        this.arrays[attributeName] = {
+            data: array,
+            numComponents: numComponents,
+        };
+
+        if (numComponents == 1) {
+            let pendingValue = 0;
+
+            /** @param {number} value */
+            const valueUpdater = (value) => {
+                pendingValue = +value;
+            };
+
+            pusher = () => {
+                array[i++] = pendingValue;
+            };
+            updater = valueUpdater;
+        } else {
+            let pendingArray = arrayReference ?? [0];
+
+            /** @type {function(number[]):void} value */
+            const arrayUpdater = arrayReference
+                ? (value) => {
+                      // Nop. Pending value is updated through the array reference.
+                  }
+                : (value) => {
+                      pendingArray = value;
+                  };
+
+            switch (numComponents) {
+                case 1:
+                    break;
+                case 2:
+                    pusher = () => {
+                        array[i++] = pendingArray[0];
+                        array[i++] = pendingArray[1];
+                    };
+                    updater = arrayUpdater;
+                    break;
+                case 3:
+                    pusher = () => {
+                        array[i++] = pendingArray[0];
+                        array[i++] = pendingArray[1];
+                        array[i++] = pendingArray[2];
+                    };
+                    updater = arrayUpdater;
+                    break;
+                case 4:
+                    pusher = () => {
+                        array[i++] = pendingArray[0];
+                        array[i++] = pendingArray[1];
+                        array[i++] = pendingArray[2];
+                        array[i++] = pendingArray[3];
+                    };
+                    updater = arrayUpdater;
+                    break;
+                default:
+                    throw new Error("Invalid numComponents: " + numComponents);
+            }
+        }
+
+        this.pushers.push(pusher);
+
+        return updater;
+    }
+
+    _unrollPushAll() {
+        let preps = "";
+        let pushs = "";
+
+        for (let i = 0; i < this.pushers.length; i++) {
+            preps += `const p${i} = that.pushers[${i}];\n`;
+            pushs += `p${i}();\n`;
+        }
+
+        // eslint-disable-next-line no-new-func
+        const createUnrolled = new Function(
+            "that",
+            `${preps}
+
+            return function unrolledPushAll() {
+                ${pushs}
+                that.vertexCount++;
+            };
+        `
+        );
+
+        this.pushAll = createUnrolled(this);
+    }
+
+    pushAll() {
+        // Unrolling appears to give a 20% performance boost on Chrome but compiling the
+        // dynamically generated code takes time and is thus not great for small dynamic data.
+        // Unrolling probably allows the JS engine to inline pusher calls.
+        const unroll = this.size > 100000;
+        if (unroll) {
+            this._unrollPushAll();
+        } else {
+            this.pushAll = () => {
+                for (let i = 0; i < this.pushers.length; i++) {
+                    this.pushers[i]();
+                }
+                this.vertexCount++;
+            };
+        }
+
+        this.pushAll();
+    }
+
+    /**
+     *
+     * @param {object} datum
+     */
+    updateFromDatum(datum) {
+        for (let i = 0; i < this.dataUpdaters.length; i++) {
+            this.dataUpdaters[i](datum);
+        }
+    }
+
+    /**
+     *
+     * @param {object} datum
+     */
+    pushFromDatum(datum) {
+        this.updateFromDatum(datum);
+        this.pushAll();
+    }
+}

package/dist/src/gl/dataToVertices.d.ts

@@ -0,0 +1,194 @@
+/**
+ * @typedef {object} RangeEntry Represents a location of a vertex subset
+ * @prop {number} offset in vertices
+ * @prop {number} count in vertices
+ * @prop {import("../utils/binnedIndex").Lookup} xIndex
+ */
+export class GeometryBuilder {
+    /**
+     * @typedef {import("./arrayBuilder").ConverterMetadata} Converter
+     * @typedef {import("../types/encoder").Encoder} Encoder
+     */
+    /**
+     * @param {object} object
+     * @param {Record<string, Encoder>} object.encoders
+     * @param {string[]} [object.attributes]
+     * @param {number} [object.numVertices] If the number of data items is known, a
+     *      preallocated TypedArray is used
+     */
+    constructor({ encoders, numVertices, attributes }: {
+        encoders: Record<string, import("../types/encoder").Encoder>;
+        attributes?: string[];
+        numVertices?: number;
+    });
+    encoders: Record<string, import("../types/encoder").Encoder>;
+    variableEncoders: {
+        [k: string]: import("../types/encoder").Encoder;
+    };
+    allocatedVertices: number;
+    variableBuilder: ArrayBuilder;
+    lastOffset: number;
+    /** @type {Map<any, RangeEntry>} keep track of facet locations within the vertex array */
+    rangeMap: Map<any, RangeEntry>;
+    /**
+     * Must be called at the end of `addBatch`
+     *
+     * @param {any} key
+     */
+    registerBatch(key: any): void;
+    /**
+     * @param {Map<any, object[]>} batches
+     */
+    addBatches(batches: Map<any, object[]>): void;
+    /**
+     * @param {any} key The facet id, for example
+     * @param {object[]} data
+     */
+    addBatch(key: any, data: object[], lo?: number, hi?: number): void;
+    /**
+     * @param {import("../data/flowNode").Data} data Domain, but specified using datums
+     * @param {number} [lo]
+     * @param {number} [hi]
+     */
+    prepareXIndexer(data: import("../data/flowNode").Data, lo?: number, hi?: number): void;
+    /**
+     * Add the datum to an index, which allows for efficient rendering of ranges
+     * on the x axis. Must be called after a datum has been pushed to the ArrayBuilder.
+     *
+     * @param {import("../data/flowNode").Datum} datum
+     */
+    addToXIndex(datum: import("../data/flowNode").Datum): void;
+    xIndexer: {
+        (datum: any, startVertexIndex: number, endVertexIndex: number): void;
+        getIndex: () => import("../utils/binnedIndex").Lookup;
+    };
+    toArrays(): {
+        /** @type {Record<string, {data: number[] | Float32Array, numComponents: number, divisor?: number}>} */
+        arrays: Record<string, {
+            data: number[] | Float32Array;
+            numComponents: number;
+            divisor?: number;
+        }>;
+        /** Number of vertices used */
+        vertexCount: number;
+        /** Number of vertices allocated in buffers */
+        allocatedVertices: number;
+        rangeMap: Map<any, RangeEntry>;
+    };
+}
+export class RectVertexBuilder extends GeometryBuilder {
+    /**
+     *
+     * @param {Object} object
+     * @param {Record<string, Encoder>} object.encoders
+     * @param {string[]} object.attributes
+     * @param {number} [object.tessellationThreshold]
+     *     If the rect is wider than the threshold, tessellate it into pieces
+     * @param {number[]} [object.visibleRange]
+     * @param {number} [object.numItems] Number of data items
+     */
+    constructor({ encoders, attributes, tessellationThreshold, visibleRange, numItems, }: {
+        encoders: Record<string, import("../types/encoder").Encoder>;
+        attributes: string[];
+        tessellationThreshold?: number;
+        visibleRange?: number[];
+        numItems?: number;
+    });
+    visibleRange: number[];
+    tessellationThreshold: number;
+    updateFrac: (arg0: number | number[]) => any;
+}
+export class RuleVertexBuilder extends GeometryBuilder {
+    /**
+     *
+     * @param {Object} object
+     * @param {Record<string, Encoder>} object.encoders
+     * @param {string[]} object.attributes
+     * @param {number} [object.tessellationThreshold]
+     *     If the rule is wider than the threshold, tessellate it into pieces
+     * @param {number[]} [object.visibleRange]
+     * @param {number} [object.numItems] Number of data items
+     */
+    constructor({ encoders, attributes, tessellationThreshold, visibleRange, numItems, }: {
+        encoders: Record<string, import("../types/encoder").Encoder>;
+        attributes: string[];
+        tessellationThreshold?: number;
+        visibleRange?: number[];
+        numItems?: number;
+    });
+    visibleRange: number[];
+    tessellationThreshold: number;
+    updateSide: (arg0: number | number[]) => any;
+    updatePos: (arg0: number | number[]) => any;
+}
+export class PointVertexBuilder extends GeometryBuilder {
+    /**
+     *
+     * @param {object} object
+     * @param {Record<string, Encoder>} object.encoders
+     * @param {string[]} object.attributes
+     * @param {number} [object.numItems] Number of points if known, uses TypedArray
+     */
+    constructor({ encoders, attributes, numItems }: {
+        encoders: Record<string, import("../types/encoder").Encoder>;
+        attributes: string[];
+        numItems?: number;
+    });
+}
+export class ConnectionVertexBuilder extends GeometryBuilder {
+    /**
+     * @param {object} object
+     * @param {Record<string, Encoder>} object.encoders
+     * @param {string[]} object.attributes
+     * @param {number} [object.numItems ] Number of points if known, uses TypedArray
+     */
+    constructor({ encoders, attributes, numItems }: {
+        encoders: Record<string, import("../types/encoder").Encoder>;
+        attributes: string[];
+        numItems?: number;
+    });
+}
+export class TextVertexBuilder extends GeometryBuilder {
+    /**
+     *
+     * @param {object} object
+     * @param {Record<string, Encoder>} object.encoders
+     * @param {string[]} object.attributes
+     * @param {import("../fonts/bmFontMetrics").BMFontMetrics} object.fontMetrics
+     * @param {Record<string, any>} object.properties
+     * @param {number} [object.numCharacters] number of characters
+     * @param {boolean} [object.logoLetters]
+     */
+    constructor({ encoders, attributes, fontMetrics, properties, numCharacters, }: {
+        encoders: Record<string, import("../types/encoder").Encoder>;
+        attributes: string[];
+        fontMetrics: import("../fonts/bmFontMetrics").BMFontMetrics;
+        properties: Record<string, any>;
+        numCharacters?: number;
+        logoLetters?: boolean;
+    });
+    metadata: import("../fonts/bmFontMetrics").BMFontMetrics;
+    metrics: import("../fonts/bmFontMetrics").BMFontMetrics;
+    properties: Record<string, any>;
+    /** @type {(value: any) => string} */
+    numberFormat: (value: any) => string;
+    updateVertexCoord: (arg0: number | number[]) => any;
+    updateTextureCoord: (arg0: number | number[]) => any;
+    updateWidth: (arg0: number | number[]) => any;
+}
+/**
+ * Represents a location of a vertex subset
+ */
+export type RangeEntry = {
+    /**
+     * in vertices
+     */
+    offset: number;
+    /**
+     * in vertices
+     */
+    count: number;
+    xIndex: import("../utils/binnedIndex").Lookup;
+};
+import ArrayBuilder from "./arrayBuilder";
+//# sourceMappingURL=dataToVertices.d.ts.map

package/dist/src/gl/dataToVertices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataToVertices.d.ts","sourceRoot":"","sources":["../../../src/gl/dataToVertices.js"],"names":[],"mappings":"AAaA;;;;;GAKG;AACH;IACI;;;OAGG;IAEH;;;;;;OAMG;IACH;;qBAJW,MAAM,EAAE;sBACR,MAAM;OAqDhB;IAjDG,6DAAwB;IAGxB;;MAKC;IAED,0BAAoC;IAEpC,8BAAoD;IAiCpD,mBAAmB;IAEnB,yFAAyF;IACzF,UADW,IAAI,GAAG,EAAE,UAAU,CAAC,CACkB;IAGrD;;;;OAIG;IACH,mBAFW,GAAG,QAcb;IAED;;OAEG;IACH,oBAFW,IAAI,GAAG,EAAE,MAAM,EAAE,CAAC,QAM5B;IAED;;;OAGG;IACH,cAHW,GAAG,QACH,MAAM,EAAE,kCAYlB;IAED;;;;OAIG;IACH,sBAJW,OAAO,kBAAkB,EAAE,IAAI,OAC/B,MAAM,OACN,MAAM,QAyDhB;IAED;;;;;OAKG;IACH,mBAFW,OAAO,kBAAkB,EAAE,KAAK,QAI1C;IAzDO;;;MAAyB;IA2DjC;QAEQ,uGAAuG;;kBAAtE,MAAM,EAAE,GAAG,YAAY;2BAAiB,MAAM;sBAAY,MAAM;;QAEjG,8BAA8B;;QAE9B,8CAA8C;;;MAIrD;CACJ;AAED;IACI;;;;;;;;;OASG;IACH;;oBANW,MAAM,EAAE;gCACR,MAAM;uBAEN,MAAM,EAAE;mBACR,MAAM;OAqBhB;IALG,uBAAgC;IAEhC,8BAA8D;IAE9D,6CAA+D;CAiFtE;AAED;IACI;;;;;;;;;OASG;IACH;;oBANW,MAAM,EAAE;gCACR,MAAM;uBAEN,MAAM,EAAE;mBACR,MAAM;OAsBhB;IANG,uBAAgC;IAEhC,8BAA8D;IAE9D,6CAA+D;IAC/D,4CAA6D;CA2CpE;AAED;IACI;;;;;;OAMG;IACH;;oBAHW,MAAM,EAAE;mBACR,MAAM;OAQhB;CACJ;AAED;IACI;;;;;OAKG;IACH;;oBAHW,MAAM,EAAE;mBACR,MAAM;OAQhB;CAYJ;AAED;IACI;;;;;;;;;OASG;IACH;;oBANW,MAAM,EAAE;qBACR,OAAO,wBAAwB,EAAE,aAAa;oBAC9C,OAAO,MAAM,EAAE,GAAG,CAAC;wBACnB,MAAM;sBACN,OAAO;OA4CjB;IA7BG,yDAA2B;IAC3B,wDAA0B;IAE1B,gCAA4B;IAQ5B,qCAAqC;IACrC,sBADmB,GAAG,KAAK,MAAM,CAMf;IAElB,oDAGC;IACD,qDAGC;IAED,8CAAiE;CA8IxE;;;;;;;;YA/mBS,MAAM;;;;WACN,MAAM;YACN,OAAO,sBAAsB,EAAE,MAAM;;yBAdtB,gBAAgB"}