@genome-spy/core 0.42.0 → 0.42.2

package/dist/src/encoder/encoder.d.ts

@@ -45,7 +45,12 @@ export function isChannelDefWithScale(channelDef: import("../spec/channel.js").C
  * @param {import("../view/unitView.js").default} view
  * @param {import("../spec/channel.js").Channel} channel
  */
-export function getChannelDefWithScale(view: import("../view/unitView.js").default, channel: import("../spec/channel.js").Channel): import("../spec/channel.js").ChromPosDef | import("../spec/channel.js").PositionDatumDef | import("../spec/channel.js").MarkPropExprDef<import("../spec/channel.js").Type> | import("../spec/channel.js").MarkPropDatumDef<import("../spec/channel.js").Type> | import("../spec/channel.js").MarkPropDatumDef<import("../spec/channel.js").TypeForShape> | import("../spec/channel.js").PositionFieldDef<string> | import("../spec/channel.js").MarkPropFieldDef<string, import("../spec/channel.js").Type> | import("../spec/channel.js").MarkPropFieldDef<string, import("../spec/channel.js").TypeForShape>;
+export function getChannelDefWithScale(view: import("../view/unitView.js").default, channel: import("../spec/channel.js").Channel): import("../spec/channel.js").MarkPropExprDef<import("../spec/channel.js").Type> | import("../spec/channel.js").MarkPropDatumDef<import("../spec/channel.js").Type> | import("../spec/channel.js").ChromPosDef | import("../spec/channel.js").PositionDatumDef | import("../spec/channel.js").MarkPropDatumDef<import("../spec/channel.js").TypeForShape> | import("../spec/channel.js").MarkPropFieldDef<string, import("../spec/channel.js").Type> | import("../spec/channel.js").PositionFieldDef<string> | import("../spec/channel.js").MarkPropFieldDef<string, import("../spec/channel.js").TypeForShape>;
+/**
+ * @param {import("../spec/channel.js").ChannelDef} channelDef
+ * @returns {channelDef is import("../spec/channel.js").TypeMixins<import("../spec/channel.js").Type>}
+ */
+export function isChannelDefWithType(channelDef: import("../spec/channel.js").ChannelDef): channelDef is import("../spec/channel.js").TypeMixins<import("../spec/channel.js").Type>;
 /**
  * @param {import("../spec/channel.js").ChannelDef} channelDef
  * @returns {channelDef is import("../spec/channel.js").ChromPosDef}

package/dist/src/encoder/encoder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encoder.d.ts","sourceRoot":"","sources":["../../../src/encoder/encoder.js"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AACH,6CAJW,OAAO,kBAAkB,EAAE,OAAO,aAClC,OAAO,oBAAoB,EAAE,QAAQ,gGAsC/C;AAED;;;;;;;GAOG;AACH,0CANW,OAAO,oBAAoB,EAAE,UAAU,SACvC,GAAG,0IAyFb;AAED;;;;;GAKG;AACH,uCAHW,OAAO,oBAAoB,EAAE,UAAU,4FAKjD;AAED;;;GAGG;AACH,uCAHW,OAAO,oBAAoB,EAAE,UAAU,mEAKjD;AAED;;;GAGG;AACH,uCAHW,OAAO,oBAAoB,EAAE,UAAU,uDAKjD;AAED;;;GAGG;AACH,kDAHW,OAAO,oBAAoB,EAAE,UAAU,kEAWjD;AAED;;;GAGG;AACH,6CAHW,OAAO,qBAAqB,EAAE,OAAO,WACrC,OAAO,oBAAoB,EAAE,OAAO,klBAS9C;AAED;;;GAGG;AACH,0CAHW,OAAO,oBAAoB,EAAE,UAAU,0DAKjD;AAED;;;GAGG;AACH,sCAHW,OAAO,oBAAoB,EAAE,UAAU,sDAKjD;AAoBD;;;GAGG;AACH,oDAHW,OAAO,oBAAoB,EAAE,OAAO,oEAM9C;AAED;;;GAGG;AACH,6CAHW,OAAO,oBAAoB,EAAE,OAAO,6DAM9C;AAqBD;;;GAGG;AACH,4CAFW,MAAM,WAIhB;AAED;;;;GAIG;AACH,oDAFW,OAAO,oBAAoB,EAAE,OAAO,2DAS9C;AAED;;;;;GAKG;AACH,2CAFW,OAAO,oBAAoB,EAAE,OAAO,wCAI9C;AAED;;;;GAIG;AACH,kDAFW,OAAO,oBAAoB,EAAE,OAAO,0CAM9C;AAED;;GAEG;AACH,wCAFW,OAAO,oBAAoB,EAAE,OAAO,WAI9C;AAED;;;;GAIG;AACH,2CAFW,OAAO,oBAAoB,EAAE,OAAO,WAI9C;AAED;;;GAGG;AACH,4CAHW,OAAO,oBAAoB,EAAE,OAAO,4DAuB9C;AAED;;;;;GAKG;AACH,0CAHW,OAAO,oBAAoB,EAAE,OAAO,GAClC,GAAG,EAAE,CAsBjB;AAED;;;GAGG;AACH,gDAHW,OAAO,oBAAoB,EAAE,OAAO,UACzB,GAAG,KAAE,MAAM,CAmBhC;AA7LD;;GAEG;AACH,wCAFU,OAAO,oBAAoB,EAAE,wBAAwB,EAAE,CAEb;AAEpD;;GAEG;AACH,0CAFU,OAAO,oBAAoB,EAAE,0BAA0B,EAAE,CAEX;AAExD;;GAEG;AACH,iCAFU,OAAO,oBAAoB,EAAE,iBAAiB,EAAE,CAKxD;AAoBF;;;;GAIG;AACH,gCAFU,QAAQ,OAAO,OAAO,oBAAoB,EAAE,OAAO,EAAE,OAAO,oBAAoB,EAAE,0BAA0B,CAAC,CAAC,CAKtH;AAEF;;;;GAIG;AACH,8BAFU,QAAQ,OAAO,OAAO,oBAAoB,EAAE,OAAO,EAAE,OAAO,oBAAoB,EAAE,OAAO,CAAC,CAAC,CAInG"}
+{"version":3,"file":"encoder.d.ts","sourceRoot":"","sources":["../../../src/encoder/encoder.js"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AACH,6CAJW,OAAO,kBAAkB,EAAE,OAAO,aAClC,OAAO,oBAAoB,EAAE,QAAQ,gGAsC/C;AAED;;;;;;;GAOG;AACH,0CANW,OAAO,oBAAoB,EAAE,UAAU,SACvC,GAAG,0IA2Fb;AAED;;;;;GAKG;AACH,uCAHW,OAAO,oBAAoB,EAAE,UAAU,4FAKjD;AAED;;;GAGG;AACH,uCAHW,OAAO,oBAAoB,EAAE,UAAU,mEAKjD;AAED;;;GAGG;AACH,uCAHW,OAAO,oBAAoB,EAAE,UAAU,uDAKjD;AAED;;;GAGG;AACH,kDAHW,OAAO,oBAAoB,EAAE,UAAU,kEAWjD;AAED;;;GAGG;AACH,6CAHW,OAAO,qBAAqB,EAAE,OAAO,WACrC,OAAO,oBAAoB,EAAE,OAAO,klBAS9C;AAED;;;GAGG;AACH,iDAHW,OAAO,oBAAoB,EAAE,UAAU,4FAKjD;AAED;;;GAGG;AACH,0CAHW,OAAO,oBAAoB,EAAE,UAAU,0DAKjD;AAED;;;GAGG;AACH,sCAHW,OAAO,oBAAoB,EAAE,UAAU,sDAKjD;AAoBD;;;GAGG;AACH,oDAHW,OAAO,oBAAoB,EAAE,OAAO,oEAM9C;AAED;;;GAGG;AACH,6CAHW,OAAO,oBAAoB,EAAE,OAAO,6DAM9C;AAqBD;;;GAGG;AACH,4CAFW,MAAM,WAIhB;AAED;;;;GAIG;AACH,oDAFW,OAAO,oBAAoB,EAAE,OAAO,2DAS9C;AAED;;;;;GAKG;AACH,2CAFW,OAAO,oBAAoB,EAAE,OAAO,wCAI9C;AAED;;;;GAIG;AACH,kDAFW,OAAO,oBAAoB,EAAE,OAAO,0CAM9C;AAED;;GAEG;AACH,wCAFW,OAAO,oBAAoB,EAAE,OAAO,WAI9C;AAED;;;;GAIG;AACH,2CAFW,OAAO,oBAAoB,EAAE,OAAO,WAI9C;AAED;;;GAGG;AACH,4CAHW,OAAO,oBAAoB,EAAE,OAAO,4DAuB9C;AAED;;;;;GAKG;AACH,0CAHW,OAAO,oBAAoB,EAAE,OAAO,GAClC,GAAG,EAAE,CAsBjB;AAED;;;GAGG;AACH,gDAHW,OAAO,oBAAoB,EAAE,OAAO,UACzB,GAAG,KAAE,MAAM,CAmBhC;AA7LD;;GAEG;AACH,wCAFU,OAAO,oBAAoB,EAAE,wBAAwB,EAAE,CAEb;AAEpD;;GAEG;AACH,0CAFU,OAAO,oBAAoB,EAAE,0BAA0B,EAAE,CAEX;AAExD;;GAEG;AACH,iCAFU,OAAO,oBAAoB,EAAE,iBAAiB,EAAE,CAKxD;AAoBF;;;;GAIG;AACH,gCAFU,QAAQ,OAAO,OAAO,oBAAoB,EAAE,OAAO,EAAE,OAAO,oBAAoB,EAAE,0BAA0B,CAAC,CAAC,CAKtH;AAEF;;;;GAIG;AACH,8BAFU,QAAQ,OAAO,OAAO,oBAAoB,EAAE,OAAO,EAAE,OAAO,oBAAoB,EAAE,OAAO,CAAC,CAAC,CAInG"}

package/dist/src/encoder/encoder.js

@@ -101,6 +101,8 @@ export function createEncoder(channelDef, scale, accessor, channel) {
             if (isDiscrete(scale.type)) {
                 // TODO: pass the found values back to the scale/resolution
                 const indexer = createIndexer();
+                // Warning: There's a chance that the domain and indexer get out of sync.
+                // TODO: Make this more robust
                 indexer.addAll(scale.domain());
                 encoder.indexer = indexer;
             }
@@ -197,6 +199,14 @@ export function getChannelDefWithScale(view, channel) {
     }
 }
 
+/**
+ * @param {import("../spec/channel.js").ChannelDef} channelDef
+ * @returns {channelDef is import("../spec/channel.js").TypeMixins<import("../spec/channel.js").Type>}
+ */
+export function isChannelDefWithType(channelDef) {
+    return channelDef && "type" in channelDef;
+}
+
 /**
  * @param {import("../spec/channel.js").ChannelDef} channelDef
  * @returns {channelDef is import("../spec/channel.js").ChromPosDef}

package/dist/src/gl/arrayBuilder.js

@@ -1,5 +1,5 @@
 import { isNumber } from "vega-util";
-import { ATTRIBUTE_PREFIX } from "../scale/glslScaleGenerator.js";
+import { ATTRIBUTE_PREFIX } from "./glslScaleGenerator.js";
 
 /**
  * @typedef {Object} ConverterMetadata

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

@@ -0,0 +1 @@
+{"version":3,"file":"colorUtils.d.ts","sourceRoot":"","sources":["../../../src/gl/colorUtils.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,kDALW,MAAM,GAAG,OAAO,kBAAkB,EAAE,YAAY,MAChD,sBAAsB,UACtB,MAAM,oBACN,YAAY,gBAqCtB;AAED;;;;;GAKG;AACH,uDALW,MAAM,EAAE,qBACR,OAAO,kBAAkB,EAAE,gBAAgB,GAAG,OAAO,kBAAkB,EAAE,sBAAsB,MAC/F,sBAAsB,oBACtB,YAAY,gBA6BtB;AAED;;;;;;;;GAQG;AACH,6CALW,MAAM,EAAE,MACR,sBAAsB,UACtB,MAAM,oBACN,YAAY,gBAqBtB;AAED;;;;;;;GAOG;AACH,mDALW,MAAM,EAAE,MACR,sBAAsB,UACtB,MAAM,oBACN,YAAY,gBActB"}

package/dist/src/{scale → gl}/colorUtils.js

@@ -3,7 +3,7 @@ import { range } from "d3-array";
 import { scheme as vegaScheme, interpolateColors } from "vega-scale";
 import { isString, isArray, isFunction } from "vega-util";
 import { peek } from "../utils/arrayUtils.js";
-import { createOrUpdateTexture } from "../gl/webGLHelper.js";
+import { createOrUpdateTexture } from "./webGLHelper.js";
 
 /**
  * @param {string | import("../spec/scale.js").SchemeParams} schemeParams

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

@@ -82,21 +82,13 @@ 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, }: {
+    constructor({ encoders, attributes, numItems }: {
         encoders: Record<string, import("../types/encoder.js").Encoder>;
         attributes: string[];
-        tessellationThreshold?: number;
-        visibleRange?: number[];
         numItems?: number;
     });
-    visibleRange: number[];
-    tessellationThreshold: number;
-    updateFrac: (arg0: number | number[]) => any;
 }
 export class RuleVertexBuilder extends GeometryBuilder {
     /**

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

@@ -1 +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,gEAAwB;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,qBAAqB,EAAE,IAAI,OAClC,MAAM,OACN,MAAM,QAyDhB;IAED;;;;;OAKG;IACH,mBAFW,OAAO,qBAAqB,EAAE,KAAK,QAI7C;IAzDO;;;MAAyB;IA2DjC;QAEQ,uGAAuG;gBAA5F,OAAO,MAAM,EAAE;YAAC,IAAI,EAAE,MAAM,EAAE,GAAG,YAAY,CAAC;YAAC,aAAa,EAAE,MAAM,CAAC;YAAC,OAAO,CAAC,EAAE,MAAM,CAAA;SAAC,CAAC;QAEnG,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,2BAA2B,EAAE,aAAa;oBACjD,OAAO,MAAM,EAAE,GAAG,CAAC;wBACnB,MAAM;sBACN,OAAO;OA4CjB;IA7BG,4DAA2B;IAC3B,2DAA0B;IAE1B,gCAA4B;IAQ5B,qCAAqC;IACrC,sBADmB,GAAG,KAAK,MAAM,CAMf;IAElB,oDAGC;IACD,qDAGC;IAED,8CAAiE;CA8IxE;;;;;;;;YA/mBS,MAAM;;;;WACN,MAAM;YACN,OAAO,yBAAyB,EAAE,MAAM;;yBAdzB,mBAAmB"}
+{"version":3,"file":"dataToVertices.d.ts","sourceRoot":"","sources":["../../../src/gl/dataToVertices.js"],"names":[],"mappings":"AAeA;;;;;GAKG;AACH;IACI;;;OAGG;IAEH;;;;;;OAMG;IACH;;qBAJW,MAAM,EAAE;sBACR,MAAM;OAyEhB;IArEG,gEAAwB;IAGxB;;MAKC;IAQD,0BAAoC;IAEpC,8BAAoD;IA+CpD,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,qBAAqB,EAAE,IAAI,OAClC,MAAM,OACN,MAAM,QAyDhB;IAED;;;;;OAKG;IACH,mBAFW,OAAO,qBAAqB,EAAE,KAAK,QAI7C;IAzDO;;;MAAyB;IA2DjC;QAEQ,uGAAuG;gBAA5F,OAAO,MAAM,EAAE;YAAC,IAAI,EAAE,MAAM,EAAE,GAAG,YAAY,CAAC;YAAC,aAAa,EAAE,MAAM,CAAC;YAAC,OAAO,CAAC,EAAE,MAAM,CAAA;SAAC,CAAC;QAEnG,8BAA8B;;QAE9B,8CAA8C;;;MAIrD;CACJ;AAED;IACI;;;;;;OAMG;IACH;;oBAHW,MAAM,EAAE;mBACR,MAAM;OAQhB;CAkCJ;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,2BAA2B,EAAE,aAAa;oBACjD,OAAO,MAAM,EAAE,GAAG,CAAC;wBACnB,MAAM;sBACN,OAAO;OA4CjB;IA7BG,4DAA2B;IAC3B,2DAA0B;IAE1B,gCAA4B;IAQ5B,qCAAqC;IACrC,sBADmB,GAAG,KAAK,MAAM,CAMf;IAElB,oDAGC;IACD,qDAGC;IAED,8CAAiE;CA8IxE;;;;;;;;YArkBS,MAAM;;;;WACN,MAAM;YACN,OAAO,yBAAyB,EAAE,MAAM;;yBAhBzB,mBAAmB"}

package/dist/src/gl/dataToVertices.js

@@ -6,9 +6,11 @@ import { SDF_PADDING } from "../fonts/bmFontMetrics.js";
 import { createBinningRangeIndexer } from "../utils/binnedIndex.js";
 import { isValueDef } from "../encoder/encoder.js";
 import {
+    dedupeEncodingFields,
     isHighPrecisionScale,
+    makeAttributeName,
     splitHighPrecision,
-} from "../scale/glslScaleGenerator.js";
+} from "./glslScaleGenerator.js";
 import { isContinuous } from "vega-scale";
 
 /**
@@ -41,6 +43,12 @@ export class GeometryBuilder {
             )
         );
 
+        const dedupedEncodingFields = [
+            ...dedupeEncodingFields(encoders).entries(),
+        ]
+            .filter(([key, channels]) => key[1] && channels.length > 1)
+            .map(([_key, channels]) => channels);
+
         this.allocatedVertices = numVertices;
 
         this.variableBuilder = new ArrayBuilder(numVertices);
@@ -49,6 +57,16 @@ export class GeometryBuilder {
         // TODO: If more than one channels use the same field with the same data type, convert the field only once.
 
         for (const [channel, ce] of Object.entries(this.variableEncoders)) {
+            // Only add the first of the shared channels as all the rest are same
+            // For example, if both x and x2 are using the same field, only x is
+            // added to the array builder with the name "x_x2".
+            const sharedChannels = dedupedEncodingFields.find((channels) =>
+                channels.find((c) => c == channel)
+            );
+            if (sharedChannels && channel != sharedChannels[0]) {
+                continue;
+            }
+
             const accessor = ce.accessor;
 
             const doubleArray = [0, 0];
@@ -69,7 +87,11 @@ export class GeometryBuilder {
                 ? (d) => splitHighPrecision(accessor(d), doubleArray)
                 : accessor;
 
-            this.variableBuilder.addConverter(channel, {
+            const attributeName = sharedChannels
+                ? makeAttributeName(sharedChannels)
+                : channel;
+
+            this.variableBuilder.addConverter(attributeName, {
                 f,
                 numComponents: hp ? 2 : 1,
                 arrayReference: hp ? doubleArray : undefined,
@@ -217,30 +239,14 @@ 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 = Infinity,
-        visibleRange = [-Infinity, Infinity],
-        numItems,
-    }) {
+    constructor({ encoders, attributes, numItems }) {
         super({
             encoders,
             attributes,
-            numVertices:
-                tessellationThreshold == Infinity ? numItems * 6 : undefined,
+            numVertices: numItems * 6,
         });
-
-        this.visibleRange = visibleRange;
-
-        this.tessellationThreshold = tessellationThreshold || Infinity;
-
-        this.updateFrac = this.variableBuilder.createUpdater("frac", 2);
     }
 
     /**
@@ -253,69 +259,23 @@ export class RectVertexBuilder extends GeometryBuilder {
             return;
         }
 
-        const e =
-            /** @type {Object.<string, import("../types/encoder.js").NumberEncoder>} */ (
-                this.encoders
-            );
-        const [lower, upper] = this.visibleRange;
-
-        /**
-         * @param {import("../types/encoder.js").Encoder} encoder
-         */
-        const a = (encoder) => encoder.accessor || ((x) => 0);
-
-        const xAccessor = a(e.x);
-        const x2Accessor = a(e.x2);
-
         this.prepareXIndexer(data, lo, hi);
 
-        const frac = [0, 0];
-        this.updateFrac(frac);
-
         for (let i = lo; i < hi; i++) {
             const d = data[i];
 
-            let x = xAccessor(d),
-                x2 = x2Accessor(d);
-
-            if (x > x2) {
-                [x, x2] = [x2, x];
-            }
-
-            // Skip rects that fall outside the visible range. TODO: Optimize by using binary search / interval tree
-            if (x2 < lower || x > upper) {
-                continue;
-            }
-
-            // Truncate to prevent tessellation of parts that are outside the viewport
-            if (x < lower) x = lower;
-            if (x2 > upper) x2 = upper;
-
             // Start a new segment.
             this.variableBuilder.updateFromDatum(d);
 
-            frac[0] = 0;
-            frac[1] = 0;
-
-            // Tessellate segments
-            const tileCount = 1;
-            //    width < Infinity
-            //        ? Math.ceil(width / this.tessellationThreshold)
-            //        : 1;
-
-            // Duplicate the first vertex to produce degenerate triangles
+            // Six vertices per rect. The vertex shader is using gl_VertexID to
+            // determine the vertex position within the rect.
+            this.variableBuilder.pushAll();
+            this.variableBuilder.pushAll();
             this.variableBuilder.pushAll();
-
-            for (let i = 0; i <= tileCount; i++) {
-                frac[0] = i / tileCount;
-                frac[1] = 0;
-                this.variableBuilder.pushAll();
-                frac[1] = 1;
-                this.variableBuilder.pushAll();
-            }
-
-            // Duplicate the last vertex to produce a degenerate triangle between the segments
             this.variableBuilder.pushAll();
+            this.variableBuilder.pushAll();
+            this.variableBuilder.pushAll();
+
             this.addToXIndex(d);
         }
 

package/dist/src/{scale → gl}/glslScaleGenerator.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="external-typings/internmap.js" />
 /**
  *
  * @param {Channel} channel
@@ -9,8 +10,10 @@ export function generateValueGlsl(channel: Channel, value: number | number[] | s
  * @param {Channel} channel
  * @param {any} scale TODO: typing
  * @param {import("../spec/channel.js").ChannelDef} channelDef
+ * @param {Channel[]} [sharedQuantitativeChannels] Channels that share the same quantitative field
  */
-export function generateScaleGlsl(channel: Channel, scale: any, channelDef: import("../spec/channel.js").ChannelDef): {
+export function generateScaleGlsl(channel: Channel, scale: any, channelDef: import("../spec/channel.js").ChannelDef, sharedQuantitativeChannels?: Channel[]): {
+    attributeGlsl: string;
     glsl: string;
     domainUniform: string;
 };
@@ -28,6 +31,20 @@ export function splitHighPrecision(x: number, arr?: number[]): number[];
  * @param {number[]} domain
  */
 export function toHighPrecisionDomainUniform(domain: number[]): number[];
+/**
+ * @typedef {[string, boolean]} FieldKey Tuple: [channel, isQuantitative]]
+ */
+/**
+ * Finds duplicated quantitative fields in the encoding block.
+ * They need to be uploaded to the GPU only once.
+ *
+ * @param {Partial<Record<import("../spec/channel.js").Channel, import("../types/encoder.js").Encoder>>} encoders
+ */
+export function dedupeEncodingFields(encoders: Partial<Record<import("../spec/channel.js").Channel, import("../types/encoder.js").Encoder>>): InternMap<FieldKey, import("../spec/channel.js").Channel[]>;
+/**
+ * @param {import("../spec/channel.js").Channel | import("../spec/channel.js").Channel[]} channel
+ */
+export function makeAttributeName(channel: import("../spec/channel.js").Channel | import("../spec/channel.js").Channel[]): string;
 export const ATTRIBUTE_PREFIX: "attr_";
 export const DOMAIN_PREFIX: "uDomain_";
 export const RANGE_PREFIX: "range_";
@@ -42,4 +59,9 @@ export type VectorizedValue = string & {
     type: string;
     numComponents: number;
 };
+/**
+ * Tuple: [channel, isQuantitative]]
+ */
+export type FieldKey = [string, boolean];
+import { InternMap } from "internmap";
 //# sourceMappingURL=glslScaleGenerator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"glslScaleGenerator.d.ts","sourceRoot":"","sources":["../../../src/gl/glslScaleGenerator.js"],"names":[],"mappings":";AAmDA;;;;GAIG;AACH,2CAHW,OAAO,SACP,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,GAAG,OAAO,UAsC9C;AAED;;;;;;GAMG;AAEH,2CANW,OAAO,SACP,GAAG,cACH,OAAO,oBAAoB,EAAE,UAAU,+BACvC,OAAO,EAAE;;;;EAmRnB;AA+FD;;;GAGG;AACH,2CAFW,MAAM,WAIhB;AAOD;;;GAGG;AACH,sCAHW,MAAM,QACN,MAAM,EAAE,YAYlB;AAYD;;GAEG;AACH,qDAFW,MAAM,EAAE,YAIlB;AAED;;GAEG;AAEH;;;;;GAKG;AACH,+CAFW,QAAQ,OAAO,OAAO,oBAAoB,EAAE,OAAO,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAC,CAAC,+DA4BtG;AAED;;GAEG;AACH,2CAFW,OAAO,oBAAoB,EAAE,OAAO,GAAG,OAAO,oBAAoB,EAAE,OAAO,EAAE,UAIvF;AAzhBD,uCAAwC;AACxC,uCAAwC;AACxC,oCAAqC;AACrC,6CAA8C;AAC9C,kDAAmD;AACnD,oDAAqD;sBAMxC,OAAO,oBAAoB,EAAE,OAAO;;;;8BAsXpC,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE;;;;uBA8GhD,CAAC,MAAM,EAAE,OAAO,CAAC;0BAjfJ,WAAW"}

package/dist/src/{scale → gl}/glslScaleGenerator.js

@@ -14,8 +14,10 @@ import {
     isDiscreteChannel,
     getPrimaryChannel,
     isValueDef,
+    isFieldDef,
 } from "../encoder/encoder.js";
-import { peek } from "../utils/arrayUtils.js";
+import { asArray, peek } from "../utils/arrayUtils.js";
+import { InternMap } from "internmap";
 
 export const ATTRIBUTE_PREFIX = "attr_";
 export const DOMAIN_PREFIX = "uDomain_";
@@ -95,9 +97,15 @@ ${vec.type} ${SCALED_FUNCTION_PREFIX}${channel}() {
  * @param {Channel} channel
  * @param {any} scale TODO: typing
  * @param {import("../spec/channel.js").ChannelDef} channelDef
+ * @param {Channel[]} [sharedQuantitativeChannels] Channels that share the same quantitative field
  */
 // eslint-disable-next-line complexity
-export function generateScaleGlsl(channel, scale, channelDef) {
+export function generateScaleGlsl(
+    channel,
+    scale,
+    channelDef,
+    sharedQuantitativeChannels = [channel]
+) {
     if (isValueDef(channelDef)) {
         throw new Error(
             `Cannot create scale for "value": ${JSON.stringify(channelDef)}`
@@ -109,7 +117,8 @@ export function generateScaleGlsl(channel, scale, channelDef) {
     }
 
     const primary = getPrimaryChannel(channel);
-    const attributeName = ATTRIBUTE_PREFIX + channel;
+    const attributeName =
+        ATTRIBUTE_PREFIX + makeAttributeName(sharedQuantitativeChannels);
     const domainUniformName = DOMAIN_PREFIX + primary;
     const rangeName = RANGE_PREFIX + primary;
 
@@ -270,11 +279,9 @@ export function generateScaleGlsl(channel, scale, channelDef) {
         interpolate = `getDiscreteColor(${textureUniformName}, int(transformed)).r`;
     }
 
-    if (isDatumDef(channelDef)) {
-        glsl.push(`uniform highp ${attributeType} ${attributeName};`);
-    } else {
-        glsl.push(`in highp ${attributeType} ${attributeName};`);
-    }
+    const attributeGlsl = isDatumDef(channelDef)
+        ? `uniform highp ${attributeType} ${attributeName};`
+        : `in highp ${attributeType} ${attributeName};`;
 
     /** @type {string[]} Channel's scale function*/
     const scaleBody = [];
@@ -361,6 +368,7 @@ ${returnType} ${SCALED_FUNCTION_PREFIX}${channel}() {
     }
 
     return {
+        attributeGlsl,
         glsl: concatenated,
         domainUniform,
     };
@@ -504,3 +512,48 @@ function exactSplitHighPrecision(x) {
 export function toHighPrecisionDomainUniform(domain) {
     return [...exactSplitHighPrecision(domain[0]), domain[1] - domain[0]];
 }
+
+/**
+ * @typedef {[string, boolean]} FieldKey Tuple: [channel, isQuantitative]]
+ */
+
+/**
+ * Finds duplicated quantitative fields in the encoding block.
+ * They need to be uploaded to the GPU only once.
+ *
+ * @param {Partial<Record<import("../spec/channel.js").Channel, import("../types/encoder.js").Encoder>>} encoders
+ */
+export function dedupeEncodingFields(encoders) {
+    /**
+     * Value: an array of channels
+     * @type {InternMap<FieldKey, import("../spec/channel.js").Channel[]>}
+     */
+    const deduped = new InternMap([], JSON.stringify);
+
+    for (const [channel, encoder] of Object.entries(encoders)) {
+        const channelDef = encoder.channelDef;
+        if (isFieldDef(channelDef)) {
+            const field = channelDef.field;
+
+            /** @type {[string, boolean]} */
+            const key = [
+                field,
+                encoder.scale
+                    ? (isContinuous(encoder.scale.type) ||
+                          isDiscretizing(encoder.scale.type)) ??
+                      false
+                    : false,
+            ];
+
+            deduped.set(key, [...(deduped.get(key) ?? []), channel]);
+        }
+    }
+    return deduped;
+}
+
+/**
+ * @param {import("../spec/channel.js").Channel | import("../spec/channel.js").Channel[]} channel
+ */
+export function makeAttributeName(channel) {
+    return asArray(channel).join("_");
+}

package/dist/src/gl/webGLHelper.js

@@ -20,7 +20,7 @@ import {
     createDiscreteTexture,
     createInterpolatedColorTexture,
     createSchemeTexture,
-} from "../scale/colorUtils.js";
+} from "./colorUtils.js";
 import {
     getDiscreteRangeMapper,
     isColorChannel,

package/dist/src/marks/link.js

@@ -1,6 +1,6 @@
 import { setBuffersAndAttributes } from "twgl.js";
-import VERTEX_SHADER from "../gl/link.vertex.glsl.js";
-import FRAGMENT_SHADER from "../gl/link.fragment.glsl.js";
+import VERTEX_SHADER from "./link.vertex.glsl.js";
+import FRAGMENT_SHADER from "./link.fragment.glsl.js";
 import { LinkVertexBuilder } from "../gl/dataToVertices.js";
 
 import Mark from "./mark.js";

package/dist/src/marks/mark.d.ts

@@ -125,8 +125,9 @@ export default class Mark {
      * @param {string} vertexShader
      * @param {string} fragmentShader
      * @param {string[]} [extraHeaders]
+     * @protected
      */
-    createAndLinkShaders(vertexShader: string, fragmentShader: string, extraHeaders?: string[]): void;
+    protected createAndLinkShaders(vertexShader: string, fragmentShader: string, extraHeaders?: string[]): void;
     /** @type {string[]} */
     domainUniforms: string[];
     programStatus: {

package/dist/src/marks/mark.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mark.d.ts","sourceRoot":"","sources":["../../../src/marks/mark.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"mark.d.ts","sourceRoot":"","sources":["../../../src/marks/mark.js"],"names":[],"mappings":"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"}

package/dist/src/marks/mark.js

@@ -14,6 +14,7 @@ import createEncoders, {
     isChannelDefWithScale,
     isChannelWithScale,
     isDatumDef,
+    isFieldDef,
     isValueDef,
 } from "../encoder/encoder.js";
 import {
@@ -25,7 +26,8 @@ import {
     isHighPrecisionScale,
     toHighPrecisionDomainUniform,
     splitHighPrecision,
-} from "../scale/glslScaleGenerator.js";
+    dedupeEncodingFields,
+} from "../gl/glslScaleGenerator.js";
 import GLSL_COMMON from "../gl/includes/common.glsl.js";
 import GLSL_SCALES from "../gl/includes/scales.glsl.js";
 import GLSL_SAMPLE_FACET from "../gl/includes/sampleFacet.glsl.js";
@@ -316,6 +318,7 @@ export default class Mark {
      * @param {string} vertexShader
      * @param {string} fragmentShader
      * @param {string[]} [extraHeaders]
+     * @protected
      */
     createAndLinkShaders(vertexShader, fragmentShader, extraHeaders = []) {
         const attributes = this.getAttributes();
@@ -330,6 +333,15 @@ export default class Mark {
         /** @type {string[]} */
         let scaleCode = [];
 
+        /**
+         * Attribute definitions. Using set to prevent duplicates caused by
+         * multiple channels using the same shared quantitative field.
+         * @type {Set<string>}
+         */
+        const attributeCode = new Set();
+
+        const dedupedEncodingFields = dedupeEncodingFields(this.encoders);
+
         const sampleFacetMode = this.getSampleFacetMode();
         if (sampleFacetMode) {
             extraHeaders.push(`#define ${sampleFacetMode}`);
@@ -364,12 +376,27 @@ export default class Mark {
                           .getScale()
                     : scaleNull();
 
-                const generated = generateScaleGlsl(channel, scale, channelDef);
+                // Channels that share the same quantitative field
+                // TODO: It should be ok to share a categorical field if the channels
+                // share the same scale, e.g., primary and secondary positional channels
+                const sharedChannels = isFieldDef(channelDef)
+                    ? dedupedEncodingFields.get([channelDef.field, true])
+                    : [channel];
+
+                const generated = generateScaleGlsl(
+                    channel,
+                    scale,
+                    channelDef,
+                    sharedChannels
+                );
 
                 scaleCode.push(generated.glsl);
                 if (generated.domainUniform) {
                     this.domainUniforms.push(generated.domainUniform);
                 }
+                if (generated.attributeGlsl) {
+                    attributeCode.add(generated.attributeGlsl);
+                }
             }
         }
 
@@ -388,6 +415,7 @@ export default class Mark {
             GLSL_COMMON,
             GLSL_SCALES,
             domainUniformBlock,
+            [...attributeCode].join("\n"),
             ...scaleCode,
             GLSL_SAMPLE_FACET,
             GLSL_PICKING_VERTEX,

package/dist/src/marks/{pointMark.d.ts → point.d.ts}

@@ -8,4 +8,4 @@ export default class PointMark extends Mark {
     getSemanticThreshold(): number;
 }
 import Mark from "./mark.js";
-//# sourceMappingURL=pointMark.d.ts.map
+//# sourceMappingURL=point.d.ts.map

package/dist/src/marks/point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/marks/point.js"],"names":[],"mappings":"AAkBA;IAsGY,oCAMC;IA2CT,mCAQC;IAED;;OAEG;IACH,wDASC;IAED,+BAoBC;CAiDJ;iBA3PgB,WAAW"}

package/dist/src/marks/{pointMark.js → point.js}

@@ -5,9 +5,9 @@ import {
 } from "twgl.js";
 import { quantileSorted } from "d3-array";
 import { PointVertexBuilder } from "../gl/dataToVertices.js";
-import VERTEX_SHADER from "../gl/point.vertex.glsl.js";
-import FRAGMENT_SHADER from "../gl/point.fragment.glsl.js";
-import COMMON_SHADER from "../gl/point.common.glsl.js";
+import VERTEX_SHADER from "./point.vertex.glsl.js";
+import FRAGMENT_SHADER from "./point.fragment.glsl.js";
+import COMMON_SHADER from "./point.common.glsl.js";
 
 import Mark from "./mark.js";
 import { sampleIterable } from "../data/transforms/sample.js";

package/dist/src/marks/{rectMark.d.ts → rect.d.ts}

@@ -14,4 +14,4 @@ export default class RectMark extends Mark {
     #private;
 }
 import Mark from "./mark.js";
-//# sourceMappingURL=rectMark.d.ts.map
+//# sourceMappingURL=rect.d.ts.map

package/dist/src/marks/rect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rect.d.ts","sourceRoot":"","sources":["../../../src/marks/rect.js"],"names":[],"mappings":"AAYA;IA0NI;;;;;;;;;;OAUG;IACH,8BALW,GAAG,KACH,OAAO,oBAAoB,EAAE,MAAM,GACjC,GAAG,CAyBf;;CACJ;iBAnQgB,WAAW"}

package/dist/src/marks/{rectMark.js → rect.js}

@@ -1,6 +1,6 @@
 import { drawBufferInfo, setBuffersAndAttributes } from "twgl.js";
-import VERTEX_SHADER from "../gl/rect.vertex.glsl.js";
-import FRAGMENT_SHADER from "../gl/rect.fragment.glsl.js";
+import VERTEX_SHADER from "./rect.vertex.glsl.js";
+import FRAGMENT_SHADER from "./rect.fragment.glsl.js";
 import { RectVertexBuilder } from "../gl/dataToVertices.js";
 
 import Mark from "./mark.js";
@@ -179,7 +179,6 @@ export default class RectMark extends Mark {
         const collector = this.unitView.getCollector();
         const numItems = collector.getItemCount();
 
-        // TODO: Disable tessellation on SimpleTrack - no need for it
         const builder = new RectVertexBuilder({
             encoders: this.encoders,
             attributes: this.getAttributes(),

package/dist/src/marks/rect.vertex.glsl.js

@@ -0,0 +1,2 @@
+const shader = "uniform Mark{uniform float uMinWidth;uniform float uMinHeight;uniform float uMinOpacity;uniform float uCornerRadiusTopRight;uniform float uCornerRadiusBottomRight;uniform float uCornerRadiusTopLeft;uniform float uCornerRadiusBottomLeft;};out lowp vec4 vFillColor;out lowp vec4 vStrokeColor;out float vHalfStrokeWidth;out vec4 vCornerRadii;\n#if defined(ROUNDED_CORNERS) || defined(STROKED)\nout vec2 vPosInPixels;\n#endif\nout 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;}}/***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.*/vec2 getVertexPos(){int index=gl_VertexID % 6;return vec2(index==0||index==1||index==3 ? 0.0 : 1.0,index==0||index==1||index==2 ? 0.0 : 1.0);}void main(void){vec2 frac=getVertexPos();vec2 normalizedMinSize=vec2(uMinWidth,uMinHeight)/uViewportSize;vec4 cornerRadii=vec4(uCornerRadiusTopRight,uCornerRadiusBottomRight,uCornerRadiusBottomLeft,uCornerRadiusTopLeft);float x=getScaled_x();float x2=getScaled_x2();float y=getScaled_y();float y2=getScaled_y2();sort(x,x2);sort(y,y2);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){gl_Position=vec4(0.0,0.0,0.0,1.0);return;}vec2 pos=pos1+frac*size;size.y*=getSampleFacetHeight(pos);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);\n#if defined(ROUNDED_CORNERS) || defined(STROKED)\nfloat 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(cornerRadii,min(vHalfSizeInPixels.x,vHalfSizeInPixels.y));vHalfStrokeWidth=strokeWidth/2.0;vStrokeColor=vec4(getScaled_stroke()*strokeOpacity,strokeOpacity);\n#endif\ngl_Position=unitToNdc(pos);float fillOpacity=getScaled_fillOpacity()*opaFactor;vFillColor=vec4(getScaled_fill()*fillOpacity,fillOpacity);setupPicking();}";
+export default shader;

package/dist/src/marks/rule.js

@@ -6,9 +6,9 @@ import {
     setBuffersAndAttributes,
     setUniforms,
 } from "twgl.js";
-import VERTEX_SHADER from "../gl/rule.vertex.glsl.js";
-import FRAGMENT_SHADER from "../gl/rule.fragment.glsl.js";
-import COMMON_SHADER from "../gl/rule.common.glsl.js";
+import VERTEX_SHADER from "./rule.vertex.glsl.js";
+import FRAGMENT_SHADER from "./rule.fragment.glsl.js";
+import COMMON_SHADER from "./rule.common.glsl.js";
 import { RuleVertexBuilder } from "../gl/dataToVertices.js";
 import { isChannelDefWithScale } from "../encoder/encoder.js";