@genome-spy/core 0.71.0 → 0.73.0

package/dist/src/gl/canvasSizeHelper.js

@@ -0,0 +1,203 @@
+/**
+ * Handles logical/physical canvas size calculations and optional
+ * device-pixel-content-box observation.
+ */
+export default class CanvasSizeHelper {
+    /**
+     * @param {HTMLElement} container
+     * @param {HTMLCanvasElement} canvas
+     * @param {() => {width: number, height: number}} sizeSource
+     * @param {() => void} [onPhysicalSizeChange]
+     */
+    constructor(container, canvas, sizeSource, onPhysicalSizeChange) {
+        this._container = container;
+        this._canvas = canvas;
+        this._sizeSource = sizeSource;
+        this._onPhysicalSizeChange = onPhysicalSizeChange ?? (() => {});
+
+        /**
+         * @type {{ width: number, height: number } | undefined}
+         */
+        this._logicalCanvasSize = undefined;
+
+        /**
+         * @type {{ width: number, height: number } | undefined}
+         */
+        this._devicePixelContentBoxSize = undefined;
+
+        /**
+         * @type {ResizeObserver | undefined}
+         */
+        this._devicePixelContentBoxObserver = undefined;
+
+        this._observeDevicePixelContentBox();
+    }
+
+    invalidate() {
+        this._logicalCanvasSize = undefined;
+        this._devicePixelContentBoxSize = undefined;
+    }
+
+    finalize() {
+        if (this._devicePixelContentBoxObserver) {
+            this._devicePixelContentBoxObserver.disconnect();
+        }
+    }
+
+    /**
+     * Returns the canvas size in true display pixels
+     *
+     * @param {{ width: number, height: number }} [logicalSize]
+     */
+    getPhysicalCanvasSize(logicalSize) {
+        // devicePixelContentBox gives the actual backing-store pixel size.
+        // Prefer it whenever available to avoid fractional DPR drift.
+        // https://web.dev/articles/device-pixel-content-box
+        if (this._devicePixelContentBoxSize) {
+            return this._devicePixelContentBoxSize;
+        }
+
+        const dpr = window.devicePixelRatio ?? 1;
+        logicalSize = logicalSize || this.getLogicalCanvasSize();
+        return {
+            width: Math.round(logicalSize.width * dpr),
+            height: Math.round(logicalSize.height * dpr),
+        };
+    }
+
+    /**
+     * Returns the ratio between true display pixels and logical pixels.
+     *
+     * @param {{ width: number, height: number }} [logicalSize]
+     */
+    getDevicePixelRatio(logicalSize) {
+        logicalSize = logicalSize || this.getLogicalCanvasSize();
+        const physicalSize = this.getPhysicalCanvasSize(logicalSize);
+        const widthRatio =
+            logicalSize.width > 0
+                ? physicalSize.width / logicalSize.width
+                : undefined;
+        const heightRatio =
+            logicalSize.height > 0
+                ? physicalSize.height / logicalSize.height
+                : undefined;
+
+        if (widthRatio !== undefined && heightRatio !== undefined) {
+            // Width and height can differ slightly because backing-store dimensions
+            // are integers. Averaging keeps snapping stable in both directions.
+            return (widthRatio + heightRatio) / 2;
+        } else if (widthRatio !== undefined) {
+            // During transient layout states one logical dimension may be zero.
+            // Use the non-zero dimension instead of falling back to window DPR.
+            return widthRatio;
+        } else if (heightRatio !== undefined) {
+            return heightRatio;
+        } else {
+            return window.devicePixelRatio ?? 1;
+        }
+    }
+
+    /**
+     * Returns the size of the canvas canvas container size in logical pixels,
+     * without devicePixelRatio correction.
+     */
+    getLogicalCanvasSize() {
+        if (this._logicalCanvasSize) {
+            return this._logicalCanvasSize;
+        }
+
+        // TODO: The size should never be smaller than the minimum content size!
+        const contentSize = this._sizeSource();
+
+        const cs = window.getComputedStyle(this._container, null);
+        // clientWidth/clientHeight are integer CSS pixels, which causes subtle
+        // blur at fractional DPR. getBoundingClientRect preserves fractions.
+        const containerRect = this._container.getBoundingClientRect();
+
+        const paddingLeft = parseFloat(cs.paddingLeft);
+        const paddingRight = parseFloat(cs.paddingRight);
+        const paddingTop = parseFloat(cs.paddingTop);
+        const paddingBottom = parseFloat(cs.paddingBottom);
+
+        const borderLeft = parseFloat(cs.borderLeftWidth);
+        const borderRight = parseFloat(cs.borderRightWidth);
+        const borderTop = parseFloat(cs.borderTopWidth);
+        const borderBottom = parseFloat(cs.borderBottomWidth);
+
+        const width =
+            contentSize.width ??
+            containerRect.width -
+                paddingLeft -
+                paddingRight -
+                borderLeft -
+                borderRight;
+
+        const height =
+            contentSize.height ??
+            containerRect.height -
+                paddingTop -
+                paddingBottom -
+                borderTop -
+                borderBottom;
+
+        this._logicalCanvasSize = { width, height };
+        return this._logicalCanvasSize;
+    }
+
+    _observeDevicePixelContentBox() {
+        if (typeof ResizeObserver != "function") {
+            return;
+        }
+
+        const observer = new ResizeObserver((entries) => {
+            const entry = entries.find(
+                (candidate) => candidate.target == this._canvas
+            );
+            if (!entry) {
+                return;
+            }
+
+            const boxSize = entry.devicePixelContentBoxSize;
+            if (!boxSize) {
+                return;
+            }
+
+            const contentBoxSize = Array.isArray(boxSize)
+                ? boxSize[0]
+                : boxSize;
+            if (!contentBoxSize) {
+                return;
+            }
+
+            // ResizeObserver reports device pixels directly, which is exactly what
+            // canvas width/height expect.
+            const nextPhysicalSize = {
+                width: contentBoxSize.inlineSize,
+                height: contentBoxSize.blockSize,
+            };
+
+            if (
+                this._devicePixelContentBoxSize &&
+                this._devicePixelContentBoxSize.width ==
+                    nextPhysicalSize.width &&
+                this._devicePixelContentBoxSize.height ==
+                    nextPhysicalSize.height
+            ) {
+                return;
+            }
+
+            this._devicePixelContentBoxSize = nextPhysicalSize;
+            this._onPhysicalSizeChange();
+        });
+
+        try {
+            // Fails in browsers that do not support device-pixel-content-box.
+            observer.observe(this._canvas, {
+                box: "device-pixel-content-box",
+            });
+            this._devicePixelContentBoxObserver = observer;
+        } catch {
+            observer.disconnect();
+        }
+    }
+}

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

@@ -0,0 +1,78 @@
+/**
+ * Build-time options for sizing the hash table.
+ *
+ * @typedef {object} HashTableBuildOptions
+ * @property {number} [capacity] Power-of-two table size override.
+ * @property {number} [maxLoadFactor] Maximum load factor before resizing.
+ */
+/**
+ * Packed table payload ready for WebGL texture upload.
+ *
+ * @typedef {object} HashTableBuildResult
+ * @property {Uint32Array} table Hash table slots that contain keys.
+ * @property {number} capacity Table capacity (number of slots).
+ * @property {number} size Number of stored keys.
+ */
+/**
+ * 32-bit integer hash for u32 keys. Keep in sync with GLSL hash32.
+ *
+ * @param {number} value
+ * @returns {number}
+ */
+export function hash32(value: number): number;
+/**
+ * Build a hash table for set membership checks.
+ *
+ * @param {Iterable<number>} keys
+ * @param {HashTableBuildOptions} [options]
+ * @returns {HashTableBuildResult}
+ */
+export function buildHashTableSet(keys: Iterable<number>, options?: HashTableBuildOptions): HashTableBuildResult;
+/**
+ * Computes a 2D texture layout for a power-of-two hash table capacity.
+ *
+ * The returned dimensions satisfy `width * height === capacity`.
+ *
+ * @param {number} capacity
+ * @param {number} maxTextureSize
+ * @returns {{ width: number, height: number }}
+ */
+export function computeHashTextureDimensions(capacity: number, maxTextureSize: number): {
+    width: number;
+    height: number;
+};
+/** Sentinel key that marks an empty hash slot. */
+export const HASH_EMPTY_KEY: 4294967295;
+/** Default maximum load factor for table sizing. */
+export const DEFAULT_MAX_LOAD_FACTOR: 0.6;
+/**
+ * Build-time options for sizing the hash table.
+ */
+export type HashTableBuildOptions = {
+    /**
+     * Power-of-two table size override.
+     */
+    capacity?: number;
+    /**
+     * Maximum load factor before resizing.
+     */
+    maxLoadFactor?: number;
+};
+/**
+ * Packed table payload ready for WebGL texture upload.
+ */
+export type HashTableBuildResult = {
+    /**
+     * Hash table slots that contain keys.
+     */
+    table: Uint32Array;
+    /**
+     * Table capacity (number of slots).
+     */
+    capacity: number;
+    /**
+     * Number of stored keys.
+     */
+    size: number;
+};
+//# sourceMappingURL=hashTable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hashTable.d.ts","sourceRoot":"","sources":["../../../src/gl/hashTable.js"],"names":[],"mappings":"AAQA;;;;;;GAMG;AAEH;;;;;;;GAOG;AAEH;;;;;GAKG;AACH,8BAHW,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;;GAMG;AACH,wCAJW,QAAQ,CAAC,MAAM,CAAC,YAChB,qBAAqB,GACnB,oBAAoB,CAkDhC;AAED;;;;;;;;GAQG;AACH,uDAJW,MAAM,kBACN,MAAM,GACJ;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CA+B7C;AAxID,kDAAkD;AAClD,6BAA8B,UAAW,CAAC;AAE1C,oDAAoD;AACpD,sCAAuC,GAAG,CAAC;;;;;;;;eAQ7B,MAAM;;;;oBACN,MAAM;;;;;;;;;WAON,WAAW;;;;cACX,MAAM;;;;UACN,MAAM"}

package/dist/src/gl/hashTable.js

@@ -0,0 +1,164 @@
+/** Sentinel key that marks an empty hash slot. */
+export const HASH_EMPTY_KEY = 0xffff_ffff;
+
+/** Default maximum load factor for table sizing. */
+export const DEFAULT_MAX_LOAD_FACTOR = 0.6;
+
+const MAX_U32 = 0xffff_ffff;
+
+/**
+ * Build-time options for sizing the hash table.
+ *
+ * @typedef {object} HashTableBuildOptions
+ * @property {number} [capacity] Power-of-two table size override.
+ * @property {number} [maxLoadFactor] Maximum load factor before resizing.
+ */
+
+/**
+ * Packed table payload ready for WebGL texture upload.
+ *
+ * @typedef {object} HashTableBuildResult
+ * @property {Uint32Array} table Hash table slots that contain keys.
+ * @property {number} capacity Table capacity (number of slots).
+ * @property {number} size Number of stored keys.
+ */
+
+/**
+ * 32-bit integer hash for u32 keys. Keep in sync with GLSL hash32.
+ *
+ * @param {number} value
+ * @returns {number}
+ */
+export function hash32(value) {
+    let v = value >>> 0;
+    v ^= v >>> 16;
+    v = Math.imul(v, 0x7feb352d);
+    v ^= v >>> 15;
+    v = Math.imul(v, 0x846ca68b);
+    v ^= v >>> 16;
+    return v >>> 0;
+}
+
+/**
+ * Build a hash table for set membership checks.
+ *
+ * @param {Iterable<number>} keys
+ * @param {HashTableBuildOptions} [options]
+ * @returns {HashTableBuildResult}
+ */
+export function buildHashTableSet(keys, options = {}) {
+    const normalized = Array.from(keys, (key) => normalizeU32(key, "key"));
+    const size = normalized.length;
+    const maxLoadFactor = options.maxLoadFactor ?? DEFAULT_MAX_LOAD_FACTOR;
+    if (!(maxLoadFactor > 0 && maxLoadFactor < 1)) {
+        throw new Error("maxLoadFactor must be between 0 and 1.");
+    }
+
+    const capacity =
+        options.capacity ?? nextPow2(Math.ceil(size / maxLoadFactor));
+    if (!Number.isSafeInteger(capacity) || capacity < 1) {
+        throw new Error("capacity must be a positive power of two.");
+    }
+    if ((capacity & (capacity - 1)) !== 0) {
+        throw new Error("capacity must be a power of two.");
+    }
+
+    const table = new Uint32Array(capacity);
+    table.fill(HASH_EMPTY_KEY);
+
+    const mask = capacity - 1;
+    for (const key of normalized) {
+        if (key === HASH_EMPTY_KEY) {
+            throw new Error(
+                "Hash table keys must not equal the empty sentinel (0xffffffff)."
+            );
+        }
+        let index = hash32(key) & mask;
+        let inserted = false;
+
+        for (let probe = 0; probe < capacity; probe += 1) {
+            const existingKey = table[index];
+            if (existingKey === HASH_EMPTY_KEY || existingKey === key) {
+                table[index] = key;
+                inserted = true;
+                break;
+            }
+            index = (index + 1) & mask;
+        }
+
+        if (!inserted) {
+            throw new Error(
+                "Hash table insertion failed. Increase capacity or lower load factor."
+            );
+        }
+    }
+
+    return { table, capacity, size };
+}
+
+/**
+ * Computes a 2D texture layout for a power-of-two hash table capacity.
+ *
+ * The returned dimensions satisfy `width * height === capacity`.
+ *
+ * @param {number} capacity
+ * @param {number} maxTextureSize
+ * @returns {{ width: number, height: number }}
+ */
+export function computeHashTextureDimensions(capacity, maxTextureSize) {
+    if (!Number.isSafeInteger(capacity) || capacity < 1) {
+        throw new Error("capacity must be a positive integer.");
+    }
+    if ((capacity & (capacity - 1)) !== 0) {
+        throw new Error("capacity must be a power of two.");
+    }
+    if (!Number.isSafeInteger(maxTextureSize) || maxTextureSize < 1) {
+        throw new Error("maxTextureSize must be a positive integer.");
+    }
+
+    const maxSlots = maxTextureSize * maxTextureSize;
+    if (capacity > maxSlots) {
+        throw new Error(
+            "Selection hash table exceeds maximum texture capacity."
+        );
+    }
+
+    const maxPow2Width = 1 << Math.floor(Math.log2(maxTextureSize));
+    const width = Math.min(capacity, maxPow2Width);
+    const height = capacity / width;
+
+    if (height > maxTextureSize) {
+        throw new Error(
+            "Selection hash table dimensions exceed maximum texture size."
+        );
+    }
+
+    return { width, height };
+}
+
+/**
+ * @param {number} value
+ * @param {string} label
+ * @returns {number}
+ */
+function normalizeU32(value, label) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > MAX_U32) {
+        throw new Error(label + " must be a non-negative u32.");
+    }
+    return value >>> 0;
+}
+
+/**
+ * @param {number} value
+ * @returns {number}
+ */
+function nextPow2(value) {
+    let v = Math.max(1, value);
+    v -= 1;
+    v |= v >>> 1;
+    v |= v >>> 2;
+    v |= v >>> 4;
+    v |= v >>> 8;
+    v |= v >>> 16;
+    return v + 1;
+}

package/dist/src/gl/includes/common.glsl.js

@@ -1,2 +1,2 @@
-const shader = "#define PI 3.141593\nuniform View{mediump vec2 uViewOffset;mediump vec2 uViewScale;mediump vec2 uViewportSize;lowp float uDevicePixelRatio;lowp float uViewOpacity;bool uPickingEnabled;};/***Maps a coordinate on the unit scale to a normalized device coordinate.*(0,0)is at the bottom left corner.*/vec4 unitToNdc(vec2 coord){return vec4((coord*uViewScale+uViewOffset)*2.0-1.0,0.0,1.0);}vec4 unitToNdc(float x,float y){return unitToNdc(vec2(x,y));}vec4 pixelsToNdc(vec2 coord){return unitToNdc(coord/uViewportSize);}vec4 pixelsToNdc(float x,float y){return pixelsToNdc(vec2(x,y));}float linearstep(float edge0,float edge1,float x){return clamp((x-edge0)/(edge1-edge0),0.0,1.0);}bool isEmptyBinarySearchTexture(highp usampler2D s){return textureSize(s,0).x==1&&texelFetch(s,ivec2(0,0),0).r==0u;}bool binarySearchTexture(highp usampler2D s,uint value){int texSize=textureSize(s,0).x;if(texSize==1&&texelFetch(s,ivec2(0,0),0).r==0u){return false;}int left=0;int right=texSize-1;while(left<=right){int mid=left+(right-left)/2;uint midValue=texelFetch(s,ivec2(mid,0),0).r;if(midValue==value){return true;}if(midValue<value){left=mid+1;}else{right=mid-1;}}return false;}/***Calculates a gamma for antialiasing opacity based on the color.*/float getGammaForColor(vec3 rgb){return mix(1.25,0.75,smoothstep(0.0,1.0,dot(rgb,vec3(0.299,0.587,0.114))));}/***Specialized linearstep for doing antialiasing*/float distanceToRatio(float d){return clamp(d*uDevicePixelRatio+0.5,0.0,1.0);}vec4 distanceToColor(float d,vec4 fill,vec4 stroke,vec4 background,float halfStrokeWidth){if(halfStrokeWidth>0.0){float sd=abs(d)-halfStrokeWidth;return mix(stroke,d<=0.0 ? fill : background,distanceToRatio(sd));}else{return mix(background,fill,distanceToRatio(-d));}}";
+const shader = "#define PI 3.141593\nuniform View{mediump vec2 uViewOffset;mediump vec2 uViewScale;mediump vec2 uViewportSize;lowp float uDevicePixelRatio;lowp float uViewOpacity;bool uPickingEnabled;};/***Maps a coordinate on the unit scale to a normalized device coordinate.*(0,0)is at the bottom left corner.*/vec4 unitToNdc(vec2 coord){return vec4((coord*uViewScale+uViewOffset)*2.0-1.0,0.0,1.0);}vec4 unitToNdc(float x,float y){return unitToNdc(vec2(x,y));}vec4 pixelsToNdc(vec2 coord){return unitToNdc(coord/uViewportSize);}vec4 pixelsToNdc(float x,float y){return pixelsToNdc(vec2(x,y));}float linearstep(float edge0,float edge1,float x){return clamp((x-edge0)/(edge1-edge0),0.0,1.0);}const highp uint HASH_EMPTY_KEY=0xffffffffu;highp uint hash32(highp uint key){highp uint v=key;v ^=v>>16u;v*=0x7feb352du;v ^=v>>15u;v*=0x846ca68bu;v ^=v>>16u;return v;}bool isEmptyHashTexture(highp usampler2D s){ivec2 texSize=textureSize(s,0);return texSize.x==1&&texSize.y==1&&texelFetch(s,ivec2(0,0),0).r==HASH_EMPTY_KEY;}bool hashContainsTexture(highp usampler2D s,highp uint value){ivec2 texSize=textureSize(s,0);highp uint width=uint(texSize.x);highp uint size=width*uint(texSize.y);highp uint mask=size-1u;highp uint index=hash32(value)&mask;for(highp uint probe=0u;probe<size;probe+=1u){ivec2 coord=ivec2(int(index % width),int(index/width));highp uint entry=texelFetch(s,coord,0).r;if(entry==value){return true;}if(entry==HASH_EMPTY_KEY){return false;}index=(index+1u)&mask;}return false;}/***Calculates a gamma for antialiasing opacity based on the color.*/float getGammaForColor(vec3 rgb){return mix(1.25,0.75,smoothstep(0.0,1.0,dot(rgb,vec3(0.299,0.587,0.114))));}/***Specialized linearstep for doing antialiasing*/float distanceToRatio(float d){return clamp(d*uDevicePixelRatio+0.5,0.0,1.0);}vec4 distanceToColor(float d,vec4 fill,vec4 stroke,vec4 background,float halfStrokeWidth){if(halfStrokeWidth>0.0){float sd=abs(d)-halfStrokeWidth;return mix(stroke,d<=0.0 ? fill : background,distanceToRatio(sd));}else{return mix(background,fill,distanceToRatio(-d));}}";
 export default shader;

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

@@ -45,11 +45,19 @@ export default class WebGLHelper {
         width: number;
         height: number;
     }, webglContextAttributes?: WebGLContextAttributes);
-    _container: HTMLElement;
-    _sizeSource: () => {
-        width: any;
-        height: any;
-    };
+    /**
+     * @type {CanvasSizeHelper}
+     */
+    _canvasSizeHelper: CanvasSizeHelper;
+    /**
+     * @type {{ logicalWidth: number, logicalHeight: number, physicalWidth: number, physicalHeight: number } | undefined}
+     */
+    _appliedCanvasSize: {
+        logicalWidth: number;
+        logicalHeight: number;
+        physicalWidth: number;
+        physicalHeight: number;
+    } | undefined;
     /** @type {Map<string, WebGLShader>} */
     _shaderCache: Map<string, WebGLShader>;
     /** @type {WeakMap<import("../types/encoder.js").VegaScale, WebGLTexture>} */
@@ -64,10 +72,6 @@ export default class WebGLHelper {
     _pickingAttachmentOptions: import("twgl.js").AttachmentOptions[];
     _pickingBufferInfo: import("twgl.js").FramebufferInfo;
     invalidateSize(): void;
-    _logicalCanvasSize: {
-        width: any;
-        height: any;
-    };
     /**
      * Compiles and caches a shader. The shader source is used as a cache key.
      *
@@ -89,13 +93,22 @@ export default class WebGLHelper {
         width: number;
         height: number;
     };
+    /**
+     * Returns the ratio between true display pixels and logical pixels.
+     *
+     * @param {{ width: number, height: number }} [logicalSize]
+     */
+    getDevicePixelRatio(logicalSize?: {
+        width: number;
+        height: number;
+    }): number;
     /**
      * Returns the size of the canvas canvas container size in logical pixels,
      * without devicePixelRatio correction.
      */
     getLogicalCanvasSize(): {
-        width: any;
-        height: any;
+        width: number;
+        height: number;
     };
     /**
      * Creates textures for color schemes and discrete/discretizing ranges.
@@ -113,4 +126,5 @@ export default class WebGLHelper {
      */
     createSelectionTexture(selection: import("../types/selectionTypes.js").MultiPointSelection, update?: boolean): void;
 }
+import CanvasSizeHelper from "./canvasSizeHelper.js";
 //# sourceMappingURL=webGLHelper.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"webGLHelper.d.ts","sourceRoot":"","sources":["../../../src/gl/webGLHelper.js"],"names":[],"mappings":"AAyZA;;;;GAIG;AACH,kCAJW,sBAAsB,gBACtB,WAAW,kBACX,WAAW;;;;;;EA8CrB;AAED;;;;;GAKG;AACH,0CALW,qBAAqB,WACrB,IAAI,CAAC,OAAO,SAAS,EAAE,cAAc,EAAE,KAAK,CAAC,OAC7C,MAAM,EAAE,GAAG,eAAe,YAC1B,YAAY,gBAYtB;AAED;;;;;;GAMG;AACH,qCALW,sBAAsB,mBACtB,OAAO,SAAS,EAAE,eAAe,KACjC,MAAM,KACN,MAAM,2BAWhB;AAED;;;;;GAKG;AACH,yCAJW,sBAAsB,mBACtB,OAAO,SAAS,EAAE,eAAe,SACjC,MAAM,UA4BhB;AAlfD;IACI;;;;;;;OAOG;IACH,uBANW,WAAW,eACX,MAAM;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,2BAGrC,sBAAsB,EAsFhC;IAnFG,wBAA2B;IAC3B;;;MAKO;IAEP,uCAAuC;IACvC,cADW,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CACN;IAE7B,6EAA6E;IAC7E,eADW,OAAO,CAAC,OAAO,qBAAqB,EAAE,SAAS,EAAE,YAAY,CAAC,CACvC;IAElC;;OAEG;IACH,mBAFU,OAAO,CAAC,OAAO,4BAA4B,EAAE,mBAAmB,EAAE,YAAY,CAAC,CAEnD;IA8CtC,0BAAoB;IACpB,2BAAY;IAGZ,oDAAoD;IACpD,2BADW,OAAO,SAAS,EAAE,iBAAiB,EAAE,CAQ/C;IACD,sDAGC;IAML,uBAGC;IAFG;;;MAAmC;IAIvC;;;;;OAKG;IACH,oBAHW,MAAM,QACN,MAAM,GAAG,MAAM,EAAE,eA2B3B;IAED,iBAcC;IAED,iBAEC;IAED;;;;OAIG;IACH,oCAFW;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;;;MAS3C;IAED;;;OAGG;IACH;;;MAuBC;IAED;;;;;;;;;OASG;IACH,+BAHW,OAAO,8BAA8B,EAAE,OAAO,WAC9C,OAAO,QA2GjB;IAED;;OAEG;IACH,kCAFW,OAAO,4BAA4B,EAAE,mBAAmB,0BA+BlE;CACJ"}
+{"version":3,"file":"webGLHelper.d.ts","sourceRoot":"","sources":["../../../src/gl/webGLHelper.js"],"names":[],"mappings":"AAybA;;;;GAIG;AACH,kCAJW,sBAAsB,gBACtB,WAAW,kBACX,WAAW;;;;;;EA8CrB;AAED;;;;;GAKG;AACH,0CALW,qBAAqB,WACrB,IAAI,CAAC,OAAO,SAAS,EAAE,cAAc,EAAE,KAAK,CAAC,OAC7C,MAAM,EAAE,GAAG,eAAe,YAC1B,YAAY,gBAYtB;AAED;;;;;;GAMG;AACH,qCALW,sBAAsB,mBACtB,OAAO,SAAS,EAAE,eAAe,KACjC,MAAM,KACN,MAAM,2BAWhB;AAED;;;;;GAKG;AACH,yCAJW,sBAAsB,mBACtB,OAAO,SAAS,EAAE,eAAe,SACjC,MAAM,UA4BhB;AA7gBD;IACI;;;;;;;OAOG;IACH,uBANW,WAAW,eACX,MAAM;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,2BAGrC,sBAAsB,EAsGhC;IA5FG;;OAEG;IACH,mBAFU,gBAAgB,CAEQ;IAElC;;OAEG;IACH,oBAFU;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAEjF;IAEnC,uCAAuC;IACvC,cADW,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CACN;IAE7B,6EAA6E;IAC7E,eADW,OAAO,CAAC,OAAO,qBAAqB,EAAE,SAAS,EAAE,YAAY,CAAC,CACvC;IAElC;;OAEG;IACH,mBAFU,OAAO,CAAC,OAAO,4BAA4B,EAAE,mBAAmB,EAAE,YAAY,CAAC,CAEnD;IA8CtC,0BAAoB;IACpB,2BAAY;IAGZ,oDAAoD;IACpD,2BADW,OAAO,SAAS,EAAE,iBAAiB,EAAE,CAQ/C;IACD,sDAGC;IAaL,uBAGC;IAED;;;;;OAKG;IACH,oBAHW,MAAM,QACN,MAAM,GAAG,MAAM,EAAE,eA2B3B;IAED,iBAgCC;IAED,iBAGC;IAED;;;;OAIG;IACH,oCAFW;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;;;MAI3C;IAED;;;;OAIG;IACH,kCAFW;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,UAI3C;IAED;;;OAGG;IACH;;;MAEC;IAED;;;;;;;;;OASG;IACH,+BAHW,OAAO,8BAA8B,EAAE,OAAO,WAC9C,OAAO,QA2GjB;IAED;;OAEG;IACH,kCAFW,OAAO,4BAA4B,EAAE,mBAAmB,0BAwClE;CACJ;6BAvX4B,uBAAuB"}