molstar 3.1.0 → 3.3.1

package/lib/commonjs/mol-gl/shader/evaluate-wboit.frag.js

@@ -2,4 +2,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.evaluateWboit_frag = void 0;
 exports.evaluateWboit_frag = "\nprecision highp float;\n\nuniform sampler2D tWboitA;\nuniform sampler2D tWboitB;\nuniform vec2 uTexSize;\n\nvoid main() {\n    vec2 coords = gl_FragCoord.xy / uTexSize;\n\n    vec4 accum = texture2D(tWboitA, coords);\n    float r = 1.0 - accum.a;\n\n    accum.a = texture2D(tWboitB, coords).r;\n    // divisor needs to allow very small values for nice fading\n    gl_FragColor = vec4(accum.rgb / clamp(accum.a, 0.00000001, 50000.0), r);\n}\n";
-//# sourceMappingURL=evaluate-wboit.frag.js.map

package/lib/commonjs/mol-gl/shader/fxaa.frag.js

@@ -2,4 +2,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fxaa_frag = void 0;
 exports.fxaa_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform sampler2D tColor;\nuniform vec2 uTexSizeInv;\n\n// adapted from https://github.com/kosua20/Rendu\n// MIT License Copyright (c) 2017 Simon Rodriguez\n\n#define QUALITY(q) ((q) < 5 ? 1.0 : ((q) > 5 ? ((q) < 10 ? 2.0 : ((q) < 11 ? 4.0 : 8.0)) : 1.5))\n\nfloat rgb2luma(vec3 rgb){\n    return sqrt(dot(rgb, vec3(0.299, 0.587, 0.114)));\n}\n\nfloat sampleLuma(vec2 uv) {\n    return rgb2luma(texture2D(tColor, uv).rgb);\n}\n\nfloat sampleLuma(vec2 uv, float uOffset, float vOffset) {\n    uv += uTexSizeInv * vec2(uOffset, vOffset);\n    return sampleLuma(uv);\n}\n\nvoid main(void) {\n    vec2 coords = gl_FragCoord.xy * uTexSizeInv;\n    vec2 inverseScreenSize = uTexSizeInv;\n\n    vec4 colorCenter = texture2D(tColor, coords);\n\n    // Luma at the current fragment\n    float lumaCenter = rgb2luma(colorCenter.rgb);\n\n    // Luma at the four direct neighbours of the current fragment.\n    float lumaDown = sampleLuma(coords, 0.0, -1.0);\n    float lumaUp = sampleLuma(coords, 0.0, 1.0);\n    float lumaLeft = sampleLuma(coords, -1.0, 0.0);\n    float lumaRight = sampleLuma(coords, 1.0, 0.0);\n\n    // Find the maximum and minimum luma around the current fragment.\n    float lumaMin = min(lumaCenter, min(min(lumaDown, lumaUp), min(lumaLeft, lumaRight)));\n    float lumaMax = max(lumaCenter, max(max(lumaDown, lumaUp), max(lumaLeft, lumaRight)));\n\n    // Compute the delta.\n    float lumaRange = lumaMax - lumaMin;\n\n    // If the luma variation is lower that a threshold (or if we are in a really dark area),\n    // we are not on an edge, don't perform any AA.\n    if (lumaRange < max(dEdgeThresholdMin, lumaMax * dEdgeThresholdMax)) {\n        gl_FragColor = colorCenter;\n        return;\n    }\n\n    // Query the 4 remaining corners lumas.\n    float lumaDownLeft = sampleLuma(coords, -1.0, -1.0);\n    float lumaUpRight = sampleLuma(coords, 1.0, 1.0);\n    float lumaUpLeft = sampleLuma(coords, -1.0, 1.0);\n    float lumaDownRight = sampleLuma(coords, 1.0, -1.0);\n\n    // Combine the four edges lumas (using intermediary variables for future computations\n    // with the same values).\n    float lumaDownUp = lumaDown + lumaUp;\n    float lumaLeftRight = lumaLeft + lumaRight;\n\n    // Same for corners\n    float lumaLeftCorners = lumaDownLeft + lumaUpLeft;\n    float lumaDownCorners = lumaDownLeft + lumaDownRight;\n    float lumaRightCorners = lumaDownRight + lumaUpRight;\n    float lumaUpCorners = lumaUpRight + lumaUpLeft;\n\n    // Compute an estimation of the gradient along the horizontal and vertical axis.\n    float edgeHorizontal = abs(-2.0 * lumaLeft + lumaLeftCorners) + abs(-2.0 * lumaCenter + lumaDownUp) * 2.0 + abs(-2.0 * lumaRight + lumaRightCorners);\n    float edgeVertical = abs(-2.0 * lumaUp + lumaUpCorners) + abs(-2.0 * lumaCenter + lumaLeftRight) * 2.0 + abs(-2.0 * lumaDown + lumaDownCorners);\n\n    // Is the local edge horizontal or vertical ?\n    bool isHorizontal = (edgeHorizontal >= edgeVertical);\n\n    // Choose the step size (one pixel) accordingly.\n    float stepLength = isHorizontal ? inverseScreenSize.y : inverseScreenSize.x;\n\n    // Select the two neighboring texels lumas in the opposite direction to the local edge.\n    float luma1 = isHorizontal ? lumaDown : lumaLeft;\n    float luma2 = isHorizontal ? lumaUp : lumaRight;\n    // Compute gradients in this direction.\n    float gradient1 = luma1 - lumaCenter;\n    float gradient2 = luma2 - lumaCenter;\n\n    // Which direction is the steepest ?\n    bool is1Steepest = abs(gradient1) >= abs(gradient2);\n\n    // Gradient in the corresponding direction, normalized.\n    float gradientScaled = 0.25 * max(abs(gradient1), abs(gradient2));\n\n    // Average luma in the correct direction.\n    float lumaLocalAverage = 0.0;\n    if(is1Steepest){\n        // Switch the direction\n        stepLength = -stepLength;\n        lumaLocalAverage = 0.5 * (luma1 + lumaCenter);\n    } else {\n        lumaLocalAverage = 0.5 * (luma2 + lumaCenter);\n    }\n\n    // Shift UV in the correct direction by half a pixel.\n    vec2 currentUv = coords;\n    if(isHorizontal){\n        currentUv.y += stepLength * 0.5;\n    } else {\n        currentUv.x += stepLength * 0.5;\n    }\n\n    // Compute offset (for each iteration step) in the right direction.\n    vec2 offset = isHorizontal ? vec2(inverseScreenSize.x, 0.0) : vec2(0.0, inverseScreenSize.y);\n    // Compute UVs to explore on each side of the edge, orthogonally.\n    // The QUALITY allows us to step faster.\n    vec2 uv1 = currentUv - offset * QUALITY(0);\n    vec2 uv2 = currentUv + offset * QUALITY(0);\n\n    // Read the lumas at both current extremities of the exploration segment,\n    // and compute the delta wrt to the local average luma.\n    float lumaEnd1 = sampleLuma(uv1);\n    float lumaEnd2 = sampleLuma(uv2);\n    lumaEnd1 -= lumaLocalAverage;\n    lumaEnd2 -= lumaLocalAverage;\n\n    // If the luma deltas at the current extremities is larger than the local gradient,\n    // we have reached the side of the edge.\n    bool reached1 = abs(lumaEnd1) >= gradientScaled;\n    bool reached2 = abs(lumaEnd2) >= gradientScaled;\n    bool reachedBoth = reached1 && reached2;\n\n    // If the side is not reached, we continue to explore in this direction.\n    if(!reached1){\n        uv1 -= offset * QUALITY(1);\n    }\n    if(!reached2){\n        uv2 += offset * QUALITY(1);\n    }\n\n    // If both sides have not been reached, continue to explore.\n    if(!reachedBoth){\n        for(int i = 2; i < dIterations; i++){\n            // If needed, read luma in 1st direction, compute delta.\n            if(!reached1){\n                lumaEnd1 = sampleLuma(uv1);\n                lumaEnd1 = lumaEnd1 - lumaLocalAverage;\n            }\n            // If needed, read luma in opposite direction, compute delta.\n            if(!reached2){\n                lumaEnd2 = sampleLuma(uv2);\n                lumaEnd2 = lumaEnd2 - lumaLocalAverage;\n            }\n            // If the luma deltas at the current extremities is larger than the local gradient,\n            // we have reached the side of the edge.\n            reached1 = abs(lumaEnd1) >= gradientScaled;\n            reached2 = abs(lumaEnd2) >= gradientScaled;\n            reachedBoth = reached1 && reached2;\n\n            // If the side is not reached, we continue to explore in this direction,\n            // with a variable quality.\n            if(!reached1){\n                uv1 -= offset * QUALITY(i);\n            }\n            if(!reached2){\n                uv2 += offset * QUALITY(i);\n            }\n\n            // If both sides have been reached, stop the exploration.\n            if(reachedBoth){\n                break;\n            }\n        }\n    }\n\n    // Compute the distances to each side edge of the edge (!).\n    float distance1 = isHorizontal ? (coords.x - uv1.x) : (coords.y - uv1.y);\n    float distance2 = isHorizontal ? (uv2.x - coords.x) : (uv2.y - coords.y);\n\n    // In which direction is the side of the edge closer ?\n    bool isDirection1 = distance1 < distance2;\n    float distanceFinal = min(distance1, distance2);\n\n    // Thickness of the edge.\n    float edgeThickness = (distance1 + distance2);\n\n    // Is the luma at center smaller than the local average ?\n    bool isLumaCenterSmaller = lumaCenter < lumaLocalAverage;\n\n    // If the luma at center is smaller than at its neighbour,\n    // the delta luma at each end should be positive (same variation).\n    bool correctVariation1 = (lumaEnd1 < 0.0) != isLumaCenterSmaller;\n    bool correctVariation2 = (lumaEnd2 < 0.0) != isLumaCenterSmaller;\n\n    // Only keep the result in the direction of the closer side of the edge.\n    bool correctVariation = isDirection1 ? correctVariation1 : correctVariation2;\n\n    // UV offset: read in the direction of the closest side of the edge.\n    float pixelOffset = - distanceFinal / edgeThickness + 0.5;\n\n    // If the luma variation is incorrect, do not offset.\n    float finalOffset = correctVariation ? pixelOffset : 0.0;\n\n    // Sub-pixel shifting\n    // Full weighted average of the luma over the 3x3 neighborhood.\n    float lumaAverage = (1.0 / 12.0) * (2.0 * (lumaDownUp + lumaLeftRight) + lumaLeftCorners + lumaRightCorners);\n    // Ratio of the delta between the global average and the center luma,\n    // over the luma range in the 3x3 neighborhood.\n    float subPixelOffset1 = clamp(abs(lumaAverage - lumaCenter) / lumaRange, 0.0, 1.0);\n    float subPixelOffset2 = (-2.0 * subPixelOffset1 + 3.0) * subPixelOffset1 * subPixelOffset1;\n    // Compute a sub-pixel offset based on this delta.\n    float subPixelOffsetFinal = subPixelOffset2 * subPixelOffset2 * float(dSubpixelQuality);\n\n    // Pick the biggest of the two offsets.\n    finalOffset = max(finalOffset, subPixelOffsetFinal);\n\n    // Compute the final UV coordinates.\n    vec2 finalUv = coords;\n    if(isHorizontal){\n        finalUv.y += finalOffset * stepLength;\n    } else {\n        finalUv.x += finalOffset * stepLength;\n    }\n\n    // Read the color at the new UV coordinates, and use it.\n    gl_FragColor = texture2D(tColor, finalUv);\n}\n";
-//# sourceMappingURL=fxaa.frag.js.map

package/lib/commonjs/mol-gl/shader/gaussian-density.frag.js

@@ -8,4 +8,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.gaussianDensity_frag = void 0;
 exports.gaussianDensity_frag = "\nprecision highp float;\n\nvarying vec3 vPosition;\nvarying float vRadiusSqInv;\n#if defined(dCalcType_groupId)\n    #if defined(dGridTexType_2d)\n        precision highp sampler2D;\n        uniform sampler2D tMinDistanceTex;\n        uniform vec3 uGridTexDim;\n    #elif defined(dGridTexType_3d)\n        precision highp sampler3D;\n        uniform sampler3D tMinDistanceTex;\n    #endif\n    varying float vGroup;\n#endif\n\n#include common\n\nuniform vec3 uGridDim;\nuniform vec2 uGridTexScale;\nuniform float uCurrentSlice;\nuniform float uCurrentX;\nuniform float uCurrentY;\nuniform float uAlpha;\nuniform float uResolution;\nuniform float uRadiusFactorInv;\n\nvoid main() {\n    vec2 v = gl_FragCoord.xy - vec2(uCurrentX, uCurrentY) - 0.5;\n    vec3 fragPos = vec3(v.x, v.y, uCurrentSlice);\n    float dist = distance(fragPos, vPosition) * uResolution;\n\n    #if defined(dCalcType_density)\n        float density = exp(-uAlpha * ((dist * dist) * vRadiusSqInv));\n        gl_FragColor.a = density * uRadiusFactorInv;\n    #elif defined(dCalcType_minDistance)\n        gl_FragColor.a = 1.0 - dist * uRadiusFactorInv;\n    #elif defined(dCalcType_groupId)\n        #if defined(dGridTexType_2d)\n            float minDistance = 1.0 - texture2D(tMinDistanceTex, (gl_FragCoord.xy) / (uGridTexDim.xy / uGridTexScale)).a;\n        #elif defined(dGridTexType_3d)\n            float minDistance = 1.0 - texelFetch(tMinDistanceTex, ivec3(gl_FragCoord.xy, uCurrentSlice), 0).a;\n        #endif\n        if (dist * uRadiusFactorInv > minDistance + uResolution * 0.05)\n            discard;\n        gl_FragColor.rgb = packIntToRGB(vGroup);\n    #endif\n}\n";
-//# sourceMappingURL=gaussian-density.frag.js.map

package/lib/commonjs/mol-gl/shader/gaussian-density.vert.js

@@ -8,4 +8,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.gaussianDensity_vert = void 0;
 exports.gaussianDensity_vert = "\nprecision highp float;\n\nattribute vec3 aPosition;\nattribute float aRadius;\n\nvarying vec3 vPosition;\nvarying float vRadiusSqInv;\n\n#if defined(dCalcType_groupId)\n    attribute float aGroup;\n    varying float vGroup;\n#endif\n\nuniform vec3 uBboxSize;\nuniform vec3 uBboxMin;\nuniform float uResolution;\n\nvoid main() {\n    vRadiusSqInv = 1.0 / (aRadius * aRadius);\n    #if defined(dCalcType_groupId)\n        vGroup = aGroup;\n    #endif\n    gl_PointSize = ceil(((aRadius * 3.0) / uResolution) + uResolution);\n    vPosition = (aPosition - uBboxMin) / uResolution;\n    gl_Position = vec4(((aPosition - uBboxMin) / uBboxSize) * 2.0 - 1.0, 1.0);\n}\n";
-//# sourceMappingURL=gaussian-density.vert.js.map

package/lib/commonjs/mol-gl/shader/histogram-pyramid/reduction.frag.js

@@ -2,4 +2,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.reduction_frag = void 0;
 exports.reduction_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform sampler2D tInputLevel;\n\n// previous level used to evaluate the new level\n#if __VERSION__ == 100\n    uniform sampler2D tPreviousLevel;\n#else\n    precision highp isampler2D;\n    uniform isampler2D tPreviousLevel;\n#endif\n\n// inverted size of the previous level texture.\nuniform float uSize;\nuniform float uTexSize;\nuniform bool uFirst;\n\n#include common\n\nvoid main(void) {\n    float k = 0.5 * uSize;\n    vec2 position = floor((gl_FragCoord.xy / uTexSize) / uSize) * uSize;\n\n    #if __VERSION__ == 100\n        float a, b, c, d;\n\n        if (uFirst) {\n            a = texture2D(tInputLevel, position).r * 255.0;\n            b = texture2D(tInputLevel, position + vec2(k, 0.0)).r * 255.0;\n            c = texture2D(tInputLevel, position + vec2(0.0, k)).r * 255.0;\n            d = texture2D(tInputLevel, position + vec2(k, k)).r * 255.0;\n        } else {\n            a = unpackRGBToInt(texture2D(tPreviousLevel, position).rgb);\n            b = unpackRGBToInt(texture2D(tPreviousLevel, position + vec2(k, 0.0)).rgb);\n            c = unpackRGBToInt(texture2D(tPreviousLevel, position + vec2(0.0, k)).rgb);\n            d = unpackRGBToInt(texture2D(tPreviousLevel, position + vec2(k, k)).rgb);\n        }\n        gl_FragColor = vec4(packIntToRGB(a + b + c + d), 1.0);\n    #else\n        int a, b, c, d;\n\n        if (uFirst) {\n            a = int(texture2D(tInputLevel, position).r * 255.0);\n            b = int(texture2D(tInputLevel, position + vec2(k, 0.0)).r * 255.0);\n            c = int(texture2D(tInputLevel, position + vec2(0.0, k)).r * 255.0);\n            d = int(texture2D(tInputLevel, position + vec2(k, k)).r * 255.0);\n        } else {\n            a = texture2D(tPreviousLevel, position).r;\n            b = texture2D(tPreviousLevel, position + vec2(k, 0.0)).r;\n            c = texture2D(tPreviousLevel, position + vec2(0.0, k)).r;\n            d = texture2D(tPreviousLevel, position + vec2(k, k)).r;\n        }\n        gl_FragColor = ivec4(a + b + c + d);\n    #endif\n}\n";
-//# sourceMappingURL=reduction.frag.js.map

package/lib/commonjs/mol-gl/shader/histogram-pyramid/sum.frag.js

@@ -7,4 +7,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sum_frag = void 0;
 exports.sum_frag = "\nprecision highp float;\nprecision highp int;\n\n#if __VERSION__ == 100\n    precision highp sampler2D;\n    uniform sampler2D tTexture;\n#else\n    precision highp isampler2D;\n    uniform isampler2D tTexture;\n#endif\n\nvoid main(void) {\n    #if __VERSION__ == 100\n        gl_FragColor = texture2D(tTexture, vec2(0.5));\n    #else\n        gl_FragColor = ivec4(texture2D(tTexture, vec2(0.5)).r);\n    #endif\n}\n";
-//# sourceMappingURL=sum.frag.js.map

package/lib/commonjs/mol-gl/shader/image.frag.js

@@ -7,4 +7,3 @@ exports.image_frag = void 0;
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 exports.image_frag = "\nprecision highp float;\nprecision highp int;\n\n#include common\n#include read_from_texture\n#include common_frag_params\n#include common_clip\n\nuniform vec2 uImageTexDim;\nuniform sampler2D tImageTex;\nuniform sampler2D tGroupTex;\n\nuniform vec2 uMarkerTexDim;\nuniform sampler2D tMarker;\n\nvarying vec2 vUv;\nvarying float vInstance;\n\n#if defined(dInterpolation_catmulrom) || defined(dInterpolation_mitchell) || defined(dInterpolation_bspline)\n    #define dInterpolation_cubic\n#endif\n\n#if defined(dInterpolation_cubic)\n    #if defined(dInterpolation_catmulrom) || defined(dInterpolation_mitchell)\n        #if defined(dInterpolation_catmulrom)\n            const float B = 0.0;\n            const float C = 0.5;\n        #elif defined(dInterpolation_mitchell)\n            const float B = 0.333;\n            const float C = 0.333;\n        #endif\n\n        float cubicFilter(float x){\n            float f = x;\n            if (f < 0.0) {\n                f = -f;\n            }\n            if (f < 1.0) {\n                return ((12.0 - 9.0 * B - 6.0 * C) * (f * f * f) +\n                    (-18.0 + 12.0 * B + 6.0 * C) * (f * f) +\n                    (6.0 - 2.0 * B)) / 6.0;\n            }else if (f >= 1.0 && f < 2.0){\n                return ((-B - 6.0 * C) * ( f * f * f)\n                    + (6.0 * B + 30.0 * C) * (f * f) +\n                    (-(12.0 * B) - 48.0 * C) * f +\n                    8.0 * B + 24.0 * C) / 6.0;\n            }else{\n                return 0.0;\n            }\n        }\n    #elif defined(dInterpolation_bspline)\n        float cubicFilter(float x) {\n            float f = x;\n            if (f < 0.0) {\n                f = -f;\n            }\n            if (f >= 0.0 && f <= 1.0){\n                return (2.0 / 3.0) + (0.5) * (f * f * f) - (f * f);\n            } else if (f > 1.0 && f <= 2.0) {\n                return 1.0 / 6.0 * pow((2.0 - f), 3.0);\n            }\n            return 1.0;\n        }\n    #endif\n\n    vec4 biCubic(sampler2D tex, vec2 texCoord) {\n        vec2 texelSize = 1.0 / uImageTexDim;\n        texCoord -= texelSize / 2.0;\n        vec4 nSum = vec4(0.0);\n        float nDenom = 0.0;\n        vec2 cell = fract(texCoord * uImageTexDim);\n        for (float m = -1.0; m <= 2.0; ++m) {\n            for (float n = -1.0; n <= 2.0; ++n) {\n                vec4 vecData = texture2D(tex, texCoord + texelSize * vec2(m, n));\n                float c = cubicFilter(m - cell.x) * cubicFilter(-n + cell.y);\n                nSum += vecData * c;\n                nDenom += c;\n            }\n        }\n        return nSum / nDenom;\n    }\n#endif\n\nvoid main() {\n    #include clip_pixel\n\n    #if defined(dInterpolation_cubic)\n        vec4 imageData = biCubic(tImageTex, vUv);\n    #else\n        vec4 imageData = texture2D(tImageTex, vUv);\n    #endif\n    imageData.a = clamp(imageData.a, 0.0, 1.0);\n    if (imageData.a > 0.9) imageData.a = 1.0;\n\n    float fragmentDepth = gl_FragCoord.z;\n    bool interior = false;\n\n    #if defined(dRenderVariant_pick)\n        if (imageData.a < 0.3)\n            discard;\n        if (uPickType == 1) {\n            gl_FragColor = vec4(packIntToRGB(float(uObjectId)), 1.0);\n        } else if (uPickType == 2) {\n            gl_FragColor = vec4(packIntToRGB(vInstance), 1.0);\n        } else {\n            gl_FragColor = vec4(texture2D(tGroupTex, vUv).rgb, 1.0);\n        }\n    #elif defined(dRenderVariant_depth)\n        if (imageData.a < 0.05)\n            discard;\n        gl_FragColor = packDepthToRGBA(gl_FragCoord.z);\n    #elif defined(dRenderVariant_marking)\n        float marker = uMarker;\n        if (uMarker == -1.0) {\n            float group = unpackRGBToInt(texture2D(tGroupTex, vUv).rgb);\n            marker = readFromTexture(tMarker, vInstance * float(uGroupCount) + group, uMarkerTexDim).a;\n            marker = floor(marker * 255.0 + 0.5); // rounding required to work on some cards on win\n        }\n        if (uMarkingType == 1) {\n            if (marker > 0.0 || imageData.a < 0.05)\n                discard;\n            gl_FragColor = packDepthToRGBA(gl_FragCoord.z);\n        } else {\n            if (marker == 0.0 || imageData.a < 0.05)\n                discard;\n            float depthTest = 1.0;\n            if (uMarkingDepthTest) {\n                depthTest = (fragmentDepth >= getDepth(gl_FragCoord.xy / uDrawingBufferSize)) ? 1.0 : 0.0;\n            }\n            bool isHighlight = intMod(marker, 2.0) > 0.1;\n            gl_FragColor = vec4(0.0, depthTest, isHighlight ? 1.0 : 0.0, 1.0);\n        }\n    #elif defined(dRenderVariant_color)\n        if (imageData.a < 0.05)\n            discard;\n        gl_FragColor = imageData;\n        gl_FragColor.a *= uAlpha;\n\n        float marker = uMarker;\n        if (uMarker == -1.0) {\n            float group = unpackRGBToInt(texture2D(tGroupTex, vUv).rgb);\n            marker = readFromTexture(tMarker, vInstance * float(uGroupCount) + group, uMarkerTexDim).a;\n            marker = floor(marker * 255.0 + 0.5); // rounding required to work on some cards on win\n        }\n\n        #include apply_marker_color\n        #include apply_fog\n        #include wboit_write\n    #endif\n}\n";
-//# sourceMappingURL=image.frag.js.map

package/lib/commonjs/mol-gl/shader/image.vert.js

@@ -7,4 +7,3 @@ exports.image_vert = void 0;
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 exports.image_vert = "\nprecision highp float;\nprecision highp int;\n\n#include common\n#include common_vert_params\n\nattribute vec3 aPosition;\nattribute vec2 aUv;\nattribute mat4 aTransform;\nattribute float aInstance;\n\nvarying vec2 vUv;\nvarying float vInstance;\n\nvoid main() {\n    #include assign_position\n\n    vUv = aUv;\n    vInstance = aInstance;\n}\n";
-//# sourceMappingURL=image.vert.js.map

package/lib/commonjs/mol-gl/shader/lines.frag.js

@@ -7,4 +7,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.lines_frag = void 0;
 exports.lines_frag = "\nprecision highp float;\nprecision highp int;\n\n#include common\n#include common_frag_params\n#include color_frag_params\n#include common_clip\n\nvoid main(){\n    #include clip_pixel\n\n    bool interior = false;\n    float fragmentDepth = gl_FragCoord.z;\n    #include assign_material_color\n\n    #if defined(dRenderVariant_pick)\n        #include check_picking_alpha\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_depth)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_marking)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_color)\n        gl_FragColor = material;\n\n        #include apply_marker_color\n        #include apply_fog\n        #include wboit_write\n    #endif\n}\n";
-//# sourceMappingURL=lines.frag.js.map

package/lib/commonjs/mol-gl/shader/lines.vert.js

@@ -9,4 +9,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.lines_vert = void 0;
 exports.lines_vert = "\nprecision highp float;\nprecision highp int;\n\n#include common\n#include read_from_texture\n#include common_vert_params\n#include color_vert_params\n#include size_vert_params\n#include common_clip\n\nuniform float uPixelRatio;\nuniform vec4 uViewport;\n\nattribute mat4 aTransform;\nattribute float aInstance;\nattribute float aGroup;\n\nattribute vec2 aMapping;\nattribute vec3 aStart;\nattribute vec3 aEnd;\n\nvoid trimSegment(const in vec4 start, inout vec4 end) {\n    // trim end segment so it terminates between the camera plane and the near plane\n    // conservative estimate of the near plane\n    float a = uProjection[2][2];  // 3rd entry in 3rd column\n    float b = uProjection[3][2];  // 3rd entry in 4th column\n    float nearEstimate = -0.5 * b / a;\n    float alpha = (nearEstimate - start.z) / (end.z - start.z);\n    end.xyz = mix(start.xyz, end.xyz, alpha);\n}\n\nvoid main(){\n    float aspect = uViewport.z / uViewport.w;\n\n    #include assign_group\n    #include assign_color_varying\n    #include assign_marker_varying\n    #include assign_clipping_varying\n    #include assign_size\n\n    mat4 modelView = uView * uModel * aTransform;\n\n    // camera space\n    vec4 start = modelView * vec4(aStart, 1.0);\n    vec4 end = modelView * vec4(aEnd, 1.0);\n\n    // assign position\n    vec4 position4 = vec4((aMapping.y < 0.5) ? aStart : aEnd, 1.0);\n    vec4 mvPosition = modelView * position4;\n    vViewPosition = mvPosition.xyz;\n\n    vModelPosition = (uModel * aTransform * position4).xyz; // for clipping in frag shader\n\n    // special case for perspective projection, and segments that terminate either in, or behind, the camera plane\n    // clearly the gpu firmware has a way of addressing this issue when projecting into ndc space\n    // but we need to perform ndc-space calculations in the shader, so we must address this issue directly\n    // perhaps there is a more elegant solution -- WestLangley\n    bool perspective = (uProjection[2][3] == -1.0); // 4th entry in the 3rd column\n    if (perspective) {\n        if (start.z < 0.0 && end.z >= 0.0) {\n            trimSegment(start, end);\n        } else if (end.z < 0.0 && start.z >= 0.0) {\n            trimSegment(end, start);\n        }\n    }\n\n    // clip space\n    vec4 clipStart = uProjection * start;\n    vec4 clipEnd = uProjection * end;\n\n    // ndc space\n    vec2 ndcStart = clipStart.xy / clipStart.w;\n    vec2 ndcEnd = clipEnd.xy / clipEnd.w;\n\n    // direction\n    vec2 dir = ndcEnd - ndcStart;\n\n    // account for clip-space aspect ratio\n    dir.x *= aspect;\n    dir = normalize(dir);\n\n    // perpendicular to dir\n    vec2 offset = vec2(dir.y, - dir.x);\n\n    // undo aspect ratio adjustment\n    dir.x /= aspect;\n    offset.x /= aspect;\n\n    // sign flip\n    if (aMapping.x < 0.0) offset *= -1.0;\n\n    // calculate linewidth\n    float linewidth;\n    #ifdef dLineSizeAttenuation\n        linewidth = size * uPixelRatio * ((uViewport.w / 2.0) / -start.z) * 5.0;\n    #else\n        linewidth = size * uPixelRatio;\n    #endif\n    linewidth = max(1.0, linewidth);\n\n    // adjust for linewidth\n    offset *= linewidth;\n\n    // adjust for clip-space to screen-space conversion\n    offset /= uViewport.w;\n\n    // select end\n    vec4 clip = (aMapping.y < 0.5) ? clipStart : clipEnd;\n\n    // back to clip space\n    offset *= clip.w;\n    clip.xy += offset;\n    gl_Position = clip;\n\n    #include clip_instance\n}\n";
-//# sourceMappingURL=lines.vert.js.map

package/lib/commonjs/mol-gl/shader/marching-cubes/active-voxels.frag.js

@@ -2,4 +2,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.activeVoxels_frag = void 0;
 exports.activeVoxels_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform sampler2D tTriCount;\nuniform sampler2D tVolumeData;\n\nuniform float uIsoValue;\nuniform vec3 uGridDim;\nuniform vec3 uGridTexDim;\nuniform vec2 uScale;\n\n#include common\n\n// cube corners (excluding origin)\nconst vec3 c1 = vec3(1., 0., 0.);\nconst vec3 c2 = vec3(1., 1., 0.);\nconst vec3 c3 = vec3(0., 1., 0.);\nconst vec3 c4 = vec3(0., 0., 1.);\nconst vec3 c5 = vec3(1., 0., 1.);\nconst vec3 c6 = vec3(1., 1., 1.);\nconst vec3 c7 = vec3(0., 1., 1.);\n\nvec3 index3dFrom2d(vec2 coord) {\n    vec2 gridTexPos = coord * uGridTexDim.xy;\n    vec2 columnRow = ivec2Div(gridTexPos, uGridDim.xy);\n    vec2 posXY = gridTexPos - columnRow * uGridDim.xy;\n    float posZ = columnRow.y * intDiv(uGridTexDim.x, uGridDim.x) + columnRow.x;\n    return vec3(posXY, posZ);\n}\n\nvec4 texture3dFrom2dNearest(sampler2D tex, vec3 pos, vec3 gridDim, vec2 texDim) {\n    float zSlice = floor(pos.z * gridDim.z + 0.5); // round to nearest z-slice\n    float column = intDiv(intMod(zSlice * gridDim.x, texDim.x), gridDim.x);\n    float row = intDiv(zSlice * gridDim.x, texDim.x);\n    vec2 coord = (vec2(column * gridDim.x, row * gridDim.y) + (pos.xy * gridDim.xy)) / (texDim / uScale);\n    return texture2D(tex, coord);\n}\n\nvec4 voxel(vec3 pos) {\n    pos = min(max(vec3(0.0), pos), uGridDim - vec3(1.0));\n    return texture3dFrom2dNearest(tVolumeData, pos / uGridDim, uGridDim, uGridTexDim.xy);\n}\n\nvoid main(void) {\n    vec2 uv = gl_FragCoord.xy / uGridTexDim.xy;\n    vec3 posXYZ = index3dFrom2d(uv);\n\n    // get MC case as the sum of corners that are below the given iso level\n    float c = step(voxel(posXYZ).a, uIsoValue)\n        + 2. * step(voxel(posXYZ + c1).a, uIsoValue)\n        + 4. * step(voxel(posXYZ + c2).a, uIsoValue)\n        + 8. * step(voxel(posXYZ + c3).a, uIsoValue)\n        + 16. * step(voxel(posXYZ + c4).a, uIsoValue)\n        + 32. * step(voxel(posXYZ + c5).a, uIsoValue)\n        + 64. * step(voxel(posXYZ + c6).a, uIsoValue)\n        + 128. * step(voxel(posXYZ + c7).a, uIsoValue);\n    c *= step(c, 254.);\n\n    // handle out of bounds positions\n    posXYZ += 1.0;\n    posXYZ.xy += 1.0; // pixel padding (usually ok even if the texture has no padding)\n    if (posXYZ.x >= uGridDim.x || posXYZ.y >= uGridDim.y || posXYZ.z >= uGridDim.z)\n        c = 0.0;\n\n    // get total triangles to generate for calculated MC case from triCount texture\n    float totalTrianglesToGenerate = texture2D(tTriCount, vec2(intMod(c, 16.), floor(c / 16.)) / 16.).a;\n    gl_FragColor = vec4(vec3(totalTrianglesToGenerate * 3.0), c / 255.0);\n}\n";
-//# sourceMappingURL=active-voxels.frag.js.map

package/lib/commonjs/mol-gl/shader/marching-cubes/isosurface.frag.js

@@ -2,4 +2,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isosurface_frag = void 0;
 exports.isosurface_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\n#if __VERSION__ == 100\n    uniform sampler2D tActiveVoxelsPyramid;\n#else\n    precision highp isampler2D;\n    uniform isampler2D tActiveVoxelsPyramid;\n#endif\n\nuniform sampler2D tActiveVoxelsBase;\nuniform sampler2D tVolumeData;\nuniform sampler2D tTriIndices;\n\nuniform float uIsoValue;\nuniform float uLevels;\nuniform float uSize;\nuniform float uCount;\nuniform bool uInvert;\n\nuniform vec3 uGridDim;\nuniform vec3 uGridTexDim;\nuniform mat4 uGridTransform;\n\n// scale to volume data coord\nuniform vec2 uScale;\n\n#include common\n\n// cube corners (excluding origin)\nconst vec3 c1 = vec3(1., 0., 0.);\nconst vec3 c2 = vec3(1., 1., 0.);\nconst vec3 c3 = vec3(0., 1., 0.);\nconst vec3 c4 = vec3(0., 0., 1.);\nconst vec3 c5 = vec3(1., 0., 1.);\nconst vec3 c6 = vec3(1., 1., 1.);\nconst vec3 c7 = vec3(0., 1., 1.);\n\nvec3 index3dFrom2d(vec2 coord) {\n    vec2 gridTexPos = coord * uGridTexDim.xy;\n    vec2 columnRow = ivec2Div(gridTexPos, uGridDim.xy);\n    vec2 posXY = gridTexPos - columnRow * uGridDim.xy;\n    float posZ = columnRow.y * intDiv(uGridTexDim.x, uGridDim.x) + columnRow.x;\n    return vec3(posXY, posZ);\n}\n\nvec4 texture3dFrom2dNearest(sampler2D tex, vec3 pos, vec3 gridDim, vec2 texDim) {\n    float zSlice = floor(pos.z * gridDim.z + 0.5); // round to nearest z-slice\n    float column = intDiv(intMod(zSlice * gridDim.x, texDim.x), gridDim.x);\n    float row = intDiv(zSlice * gridDim.x, texDim.x);\n    vec2 coord = (vec2(column * gridDim.x, row * gridDim.y) + (pos.xy * gridDim.xy)) / (texDim / uScale);\n    return texture2D(tex, coord + 0.5 / (texDim / uScale));\n}\n\nvec4 voxel(vec3 pos) {\n    pos = min(max(vec3(0.0), pos), uGridDim - vec3(1.0));\n    return texture3dFrom2dNearest(tVolumeData, pos / uGridDim, uGridDim, uGridTexDim.xy);\n}\n\nvec4 voxelPadded(vec3 pos) {\n    pos = min(max(vec3(0.0), pos), uGridDim - vec3(vec2(2.0), 1.0)); // remove xy padding\n    return texture3dFrom2dNearest(tVolumeData, pos / uGridDim, uGridDim, uGridTexDim.xy);\n}\n\nint idot2(const in ivec2 a, const in ivec2 b) {\n    return a.x * b.x + a.y * b.y;\n}\n\nint idot4(const in ivec4 a, const in ivec4 b) {\n    return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;\n}\n\n#if __VERSION__ == 100\n    int pyramidVoxel(vec2 pos) {\n        return int(unpackRGBToInt(texture2D(tActiveVoxelsPyramid, pos / (vec2(1.0, 0.5) * uSize)).rgb));\n    }\n#else\n    int pyramidVoxel(vec2 pos) {\n        return texture2D(tActiveVoxelsPyramid, pos / (vec2(1.0, 0.5) * uSize)).r;\n    }\n#endif\n\nvec4 baseVoxel(vec2 pos) {\n    return texture2D(tActiveVoxelsBase, pos / uSize);\n}\n\nvec4 getGroup(const in vec3 p) {\n    vec3 gridDim = uGridDim - vec3(1.0, 1.0, 0.0); // remove xy padding\n    // note that we swap x and z because the texture is flipped around y\n    #if defined(dAxisOrder_012)\n        float group = p.z + p.y * gridDim.z + p.x * gridDim.z * gridDim.y; // 210\n    #elif defined(dAxisOrder_021)\n        float group = p.y + p.z * gridDim.y + p.x * gridDim.y * gridDim.z; // 120\n    #elif defined(dAxisOrder_102)\n        float group = p.z + p.x * gridDim.z + p.y * gridDim.z * gridDim.x; // 201\n    #elif defined(dAxisOrder_120)\n        float group = p.x + p.z * gridDim.x + p.y * gridDim.x * gridDim.z; // 021\n    #elif defined(dAxisOrder_201)\n        float group = p.y + p.x * gridDim.y + p.z * gridDim.y * gridDim.x; // 102\n    #elif defined(dAxisOrder_210)\n        float group = p.x + p.y * gridDim.x + p.z * gridDim.x * gridDim.y; // 012\n    #endif\n    return vec4(group > 16777215.5 ? vec3(1.0) : packIntToRGB(group), 1.0);\n}\n\nvoid main(void) {\n    // get 1D index\n    int vI = int(gl_FragCoord.x) + int(gl_FragCoord.y) * int(uSize);\n\n    // ignore 1D indices outside of the grid\n    if(vI >= int(uCount)) discard;\n\n    ivec2 offset = ivec2(int(uSize) - 2, 0);\n\n    int start = 0;\n    ivec4 starts = ivec4(0);\n    ivec4 ends = ivec4(0);\n    int diff = 2;\n    ivec4 m = ivec4(0);\n    ivec2 position = ivec2(0);\n    ivec4 vI4 = ivec4(vI);\n\n    ivec2 relativePosition = ivec2(0);\n    int end = 0;\n    ivec2 pos1 = ivec2(0);\n    ivec2 pos2 = ivec2(0);\n    ivec2 pos3 = ivec2(0);\n    ivec2 pos4 = ivec2(0);\n    ivec3 vI3 = ivec3(vI);\n    ivec3 mask = ivec3(0);\n\n    // traverse the different levels of the pyramid\n    for(int i = 1; i < 14; i++) {\n        if(float(i) >= uLevels) break;\n\n        offset.x -= diff;\n        diff *= 2;\n        relativePosition = position + offset;\n\n        end = start + pyramidVoxel(vec2(relativePosition));\n        pos1 = ivec2(relativePosition);\n        starts.x = start;\n        ends.x = end;\n        pos2 = ivec2(relativePosition + ivec2(1, 0));\n        starts.y = ends.x;\n        ends.y = ends.x + pyramidVoxel(vec2(pos2));\n        pos3 = relativePosition + ivec2(0, 1);\n        starts.z = ends.y;\n        ends.z = ends.y + pyramidVoxel(vec2(pos3));\n        pos4 = relativePosition + ivec2(1, 1);\n        starts.w = ends.z;\n        mask = ivec3(greaterThanEqual(vI3, starts.rgb)) * ivec3(lessThan(vI3, ends.rgb));\n        m = ivec4(mask, 1 - int(any(bvec3(mask))));\n\n        relativePosition = m.x * pos1 + m.y * pos2 + m.z * pos3 + m.w * pos4;\n        start = idot4(m, starts);\n        position = 2 * (relativePosition - offset);\n    }\n\n    end = start + int(baseVoxel(vec2(position)).r * 255.0);\n    pos1 = position;\n    starts.x = start;\n    ends.x = end;\n    pos2 = position + ivec2(1, 0);\n    starts.y = ends.x;\n    ends.y = ends.x + int(baseVoxel(vec2(pos2)).r * 255.0);\n    pos3 = position + ivec2(0, 1);\n    starts.z = ends.y;\n    ends.z = ends.y + int(baseVoxel(vec2(pos3)).r * 255.0);\n    pos4 = position + ivec2(1, 1);\n    starts.w = ends.z;\n    mask = ivec3(greaterThanEqual(vI3, starts.rgb)) * ivec3(lessThan(vI3, ends.rgb));\n    m = ivec4(mask, 1 - int(any(bvec3(mask))));\n    position = m.x * pos1 + m.y * pos2 + m.z * pos3 + m.w * pos4;\n\n    vec2 coord2d = (vec2(position) / uSize) / uScale;\n    vec3 coord3d = floor(index3dFrom2d(coord2d) + 0.5);\n\n    float edgeIndex = floor(baseVoxel(vec2(position)).a * 255.0 + 0.5);\n\n    // current vertex for the up to 15 MC cases\n    int currentVertex = vI - idot4(m, starts);\n\n    // ensure winding-order is the same for negative and positive iso-levels\n    if (uInvert) {\n        int v = imod(currentVertex + 1, 3);\n        if (v == 1) currentVertex += 2;\n        else if (v == 0) currentVertex -= 2;\n    }\n\n    // get index into triIndices table\n    int mcIndex = 16 * int(edgeIndex) + currentVertex;\n    vec4 mcData = texture2D(tTriIndices, vec2(imod(mcIndex, 64), mcIndex / 64) / 64.);\n\n    // bit mask to avoid conditionals (see comment below) for getting MC case corner\n    vec4 m0 = vec4(floor(mcData.a * 255.0 + 0.5));\n\n    // get edge value masks\n    vec4 m1 = vec4(equal(m0, vec4(0., 1., 2., 3.)));\n    vec4 m2 = vec4(equal(m0, vec4(4., 5., 6., 7.)));\n    vec4 m3 = vec4(equal(m0, vec4(8., 9., 10., 11.)));\n\n    // apply bit masks\n    vec3 b0 = coord3d +\n                m1.y * c1 +\n                m1.z * c2 +\n                m1.w * c3 +\n                m2.x * c4 +\n                m2.y * c5 +\n                m2.z * c6 +\n                m2.w * c7 +\n                m3.y * c1 +\n                m3.z * c2 +\n                m3.w * c3;\n    vec3 b1 = coord3d +\n                m1.x * c1 +\n                m1.y * c2 +\n                m1.z * c3 +\n                m2.x * c5 +\n                m2.y * c6 +\n                m2.z * c7 +\n                m2.w * c4 +\n                m3.x * c4 +\n                m3.y * c5 +\n                m3.z * c6 +\n                m3.w * c7;\n\n    // the conditionals that are avoided by above bitmasks\n    // vec3 b0 = coord3d;\n    // vec3 b1 = coord3d;\n    // if (mcIndex == 0.0) {\n    //     b1 += c1;\n    // } else if (mcIndex == 1.0) {\n    //     b0 += c1; b1 += c2;\n    // } else if (mcIndex == 2.0) {\n    //     b0 += c2; b1 += c3;\n    // } else if (mcIndex == 3.0) {\n    //     b0 += c3;\n    // } else if (mcIndex == 4.0) {\n    //     b0 += c4; b1 += c5;\n    // } else if (mcIndex == 5.0) {\n    //     b0 += c5; b1 += c6;\n    // } else if (mcIndex == 6.0) {\n    //     b0 += c6; b1 += c7;\n    // } else if (mcIndex == 7.0) {\n    //     b0 += c7; b1 += c4;\n    // } else if (mcIndex == 8.0) {\n    //     b1 += c4;\n    // } else if (mcIndex == 9.0) {\n    //     b0 += c1; b1 += c5;\n    // } else if (mcIndex == 10.0) {\n    //     b0 += c2; b1 += c6;\n    // } else if (mcIndex == 11.0) {\n    //     b0 += c3; b1 += c7;\n    // }\n    // b0 = floor(b0 + 0.5);\n    // b1 = floor(b1 + 0.5);\n\n    vec4 d0 = voxel(b0);\n    vec4 d1 = voxel(b1);\n\n    float v0 = d0.a;\n    float v1 = d1.a;\n\n    float t = (uIsoValue - v0) / (v0 - v1);\n    gl_FragData[0].xyz = (uGridTransform * vec4(b0 + t * (b0 - b1), 1.0)).xyz;\n\n    // group id\n    #if __VERSION__ == 100\n        // webgl1 does not support 'flat' interpolation (i.e. no interpolation)\n        // so we ensure a constant group id per triangle here\n        #ifdef dPackedGroup\n            gl_FragData[1] = vec4(voxel(coord3d).rgb, 1.0);\n        #else\n            gl_FragData[1] = getGroup(coord3d);\n        #endif\n    #else\n        #ifdef dPackedGroup\n            gl_FragData[1] = vec4(t < 0.5 ? d0.rgb : d1.rgb, 1.0);\n        #else\n            gl_FragData[1] = getGroup(t < 0.5 ? b0 : b1);\n        #endif\n    #endif\n\n    // normals from gradients\n    vec3 n0 = -normalize(vec3(\n        voxelPadded(b0 - c1).a - voxelPadded(b0 + c1).a,\n        voxelPadded(b0 - c3).a - voxelPadded(b0 + c3).a,\n        voxelPadded(b0 - c4).a - voxelPadded(b0 + c4).a\n    ));\n    vec3 n1 = -normalize(vec3(\n        voxelPadded(b1 - c1).a - voxelPadded(b1 + c1).a,\n        voxelPadded(b1 - c3).a - voxelPadded(b1 + c3).a,\n        voxelPadded(b1 - c4).a - voxelPadded(b1 + c4).a\n    ));\n    gl_FragData[2].xyz = -vec3(\n        n0.x + t * (n0.x - n1.x),\n        n0.y + t * (n0.y - n1.y),\n        n0.z + t * (n0.z - n1.z)\n    );\n\n    // ensure normal-direction is the same for negative and positive iso-levels\n    if (uInvert) {\n        gl_FragData[2].xyz *= -1.0;\n    }\n\n    // apply normal matrix\n    gl_FragData[2].xyz *= transpose3(inverse3(mat3(uGridTransform)));\n}\n";
-//# sourceMappingURL=isosurface.frag.js.map

package/lib/commonjs/mol-gl/shader/marking/edge.frag.js

@@ -2,4 +2,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.edge_frag = void 0;
 exports.edge_frag = "\nprecision highp float;\nprecision highp sampler2D;\n\nuniform sampler2D tMaskTexture;\nuniform vec2 uTexSizeInv;\n\nvoid main() {\n    vec2 coords = gl_FragCoord.xy * uTexSizeInv;\n    vec4 offset = vec4(float(dEdgeScale), 0.0, 0.0, float(dEdgeScale)) * vec4(uTexSizeInv, uTexSizeInv);\n    vec4 c0 = texture2D(tMaskTexture, coords);\n    vec4 c1 = texture2D(tMaskTexture, coords + offset.xy);\n    vec4 c2 = texture2D(tMaskTexture, coords - offset.xy);\n    vec4 c3 = texture2D(tMaskTexture, coords + offset.yw);\n    vec4 c4 = texture2D(tMaskTexture, coords - offset.yw);\n    float diff1 = (c1.r - c2.r) * 0.5;\n    float diff2 = (c3.r - c4.r) * 0.5;\n    float d = length(vec2(diff1, diff2));\n    if (d <= 0.0)\n        discard;\n    float a1 = min(c1.g, c2.g);\n    float a2 = min(c3.g, c4.g);\n    float visibility = min(a1, a2) > 0.001 ? 1.0 : 0.0;\n    float mask = c0.r;\n    float marker = min(c1.b, min(c2.b, min(c3.b, c4.b)));\n    float fogAlpha = min(c1.a, min(c2.a, min(c3.a, c4.a)));\n    gl_FragColor = vec4(visibility, mask, marker, fogAlpha);\n}\n";
-//# sourceMappingURL=edge.frag.js.map

package/lib/commonjs/mol-gl/shader/marking/overlay.frag.js

@@ -2,4 +2,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.overlay_frag = void 0;
 exports.overlay_frag = "\nprecision highp float;\nprecision highp sampler2D;\n\nuniform vec2 uTexSizeInv;\nuniform sampler2D tEdgeTexture;\nuniform vec3 uHighlightEdgeColor;\nuniform vec3 uSelectEdgeColor;\nuniform float uGhostEdgeStrength;\nuniform float uInnerEdgeFactor;\n\nvoid main() {\n    vec2 coords = gl_FragCoord.xy * uTexSizeInv;\n    vec4 edgeValue = texture2D(tEdgeTexture, coords);\n    if (edgeValue.a > 0.0) {\n        vec3 edgeColor = edgeValue.b == 1.0 ? uHighlightEdgeColor : uSelectEdgeColor;\n        gl_FragColor.rgb = edgeValue.g > 0.0 ? edgeColor : edgeColor * uInnerEdgeFactor;\n        gl_FragColor.a = (edgeValue.r == 1.0 ? uGhostEdgeStrength : 1.0) * edgeValue.a;\n    } else {\n        gl_FragColor = vec4(0.0);\n    }\n}\n";
-//# sourceMappingURL=overlay.frag.js.map

package/lib/commonjs/mol-gl/shader/mesh.frag.js

@@ -7,4 +7,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mesh_frag = void 0;
 exports.mesh_frag = "\nprecision highp float;\nprecision highp int;\n\n#define bumpEnabled\n\n#include common\n#include common_frag_params\n#include color_frag_params\n#include light_frag_params\n#include normal_frag_params\n#include common_clip\n\nvoid main() {\n    #include clip_pixel\n\n    // Workaround for buggy gl_FrontFacing (e.g. on some integrated Intel GPUs)\n    vec3 fdx = dFdx(vViewPosition);\n    vec3 fdy = dFdy(vViewPosition);\n    vec3 faceNormal = normalize(cross(fdx,fdy));\n    bool frontFacing = dot(vNormal, faceNormal) > 0.0;\n\n    #if defined(dFlipSided)\n        interior = frontFacing;\n    #else\n        interior = !frontFacing;\n    #endif\n\n    float fragmentDepth = gl_FragCoord.z;\n    #include assign_material_color\n\n    #if defined(dRenderVariant_pick)\n        #include check_picking_alpha\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_depth)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_marking)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_color)\n        #if defined(dFlatShaded)\n            vec3 normal = -faceNormal;\n        #else\n            vec3 normal = -normalize(vNormal);\n            if (uDoubleSided) normal *= float(frontFacing) * 2.0 - 1.0;\n        #endif\n        #include apply_light_color\n\n        #include apply_interior_color\n        #include apply_marker_color\n        #include apply_fog\n        #include wboit_write\n    #endif\n}\n";
-//# sourceMappingURL=mesh.frag.js.map

package/lib/commonjs/mol-gl/shader/mesh.vert.js

@@ -7,4 +7,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mesh_vert = void 0;
 exports.mesh_vert = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\n#include common\n#include read_from_texture\n#include common_vert_params\n#include color_vert_params\n#include common_clip\n#include texture3d_from_2d_linear\n\n#ifdef dGeometryType_textureMesh\n    uniform vec2 uGeoTexDim;\n    uniform sampler2D tPosition;\n    uniform sampler2D tGroup;\n    uniform sampler2D tNormal;\n#else\n    attribute vec3 aPosition;\n    attribute float aGroup;\n    attribute vec3 aNormal;\n#endif\nattribute mat4 aTransform;\nattribute float aInstance;\n\nvarying vec3 vNormal;\n\nvoid main(){\n    #include assign_group\n    #include assign_marker_varying\n    #include assign_clipping_varying\n    #include assign_position\n    #include assign_color_varying\n    #include clip_instance\n\n    #ifdef dGeometryType_textureMesh\n        vec3 normal = readFromTexture(tNormal, VertexID, uGeoTexDim).xyz;\n    #else\n        vec3 normal = aNormal;\n    #endif\n    mat3 normalMatrix = transpose3(inverse3(mat3(modelView)));\n    vec3 transformedNormal = normalize(normalMatrix * normalize(normal));\n    #if defined(dFlipSided)\n        if (!uDoubleSided) { // TODO checking uDoubleSided should not be required, ASR\n            transformedNormal = -transformedNormal;\n        }\n    #endif\n    vNormal = transformedNormal;\n}\n";
-//# sourceMappingURL=mesh.vert.js.map

package/lib/commonjs/mol-gl/shader/outlines.frag.js

@@ -7,4 +7,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.outlines_frag = void 0;
 exports.outlines_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform sampler2D tDepth;\nuniform vec2 uTexSize;\n\nuniform float uNear;\nuniform float uFar;\n\nuniform float uMaxPossibleViewZDiff;\n\n#include common\n\nfloat getViewZ(const in float depth) {\n    #if dOrthographic == 1\n        return orthographicDepthToViewZ(depth, uNear, uFar);\n    #else\n        return perspectiveDepthToViewZ(depth, uNear, uFar);\n    #endif\n}\n\nfloat getDepth(const in vec2 coords) {\n    return unpackRGBAToDepth(texture2D(tDepth, coords));\n}\n\nbool isBackground(const in float depth) {\n    return depth == 1.0;\n}\n\nvoid main(void) {\n    float backgroundViewZ = uFar + 3.0 * uMaxPossibleViewZDiff;\n\n    vec2 coords = gl_FragCoord.xy / uTexSize;\n    vec2 invTexSize = 1.0 / uTexSize;\n\n    float selfDepth = getDepth(coords);\n    float selfViewZ = isBackground(selfDepth) ? backgroundViewZ : getViewZ(getDepth(coords));\n\n    float outline = 1.0;\n    float bestDepth = 1.0;\n\n    for (int y = -1; y <= 1; y++) {\n        for (int x = -1; x <= 1; x++) {\n            vec2 sampleCoords = coords + vec2(float(x), float(y)) * invTexSize;\n            float sampleDepth = getDepth(sampleCoords);\n            float sampleViewZ = isBackground(sampleDepth) ? backgroundViewZ : getViewZ(sampleDepth);\n\n            if (abs(selfViewZ - sampleViewZ) > uMaxPossibleViewZDiff && selfDepth > sampleDepth && sampleDepth <= bestDepth) {\n                outline = 0.0;\n                bestDepth = sampleDepth;\n            }\n        }\n    }\n\n    gl_FragColor = vec4(outline, packUnitIntervalToRG(bestDepth), 0.0);\n}\n";
-//# sourceMappingURL=outlines.frag.js.map

package/lib/commonjs/mol-gl/shader/points.frag.js

@@ -7,4 +7,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.points_frag = void 0;
 exports.points_frag = "\nprecision highp float;\nprecision highp int;\n\n#include common\n#include common_frag_params\n#include color_frag_params\n#include common_clip\n\nconst vec2 center = vec2(0.5);\nconst float radius = 0.5;\n\nvoid main(){\n    #include clip_pixel\n\n    float fragmentDepth = gl_FragCoord.z;\n    bool interior = false;\n    #include assign_material_color\n\n    #if defined(dPointStyle_circle)\n        float dist = distance(gl_PointCoord, center);\n        if (dist > radius) discard;\n    #elif defined(dPointStyle_fuzzy)\n        float dist = distance(gl_PointCoord, center);\n        float fuzzyAlpha = 1.0 - smoothstep(0.0, radius, dist);\n        if (fuzzyAlpha < 0.0001) discard;\n    #endif\n\n    #if defined(dRenderVariant_pick)\n        #include check_picking_alpha\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_depth)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_marking)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_color)\n        gl_FragColor = material;\n\n        #if defined(dPointStyle_fuzzy)\n            gl_FragColor.a *= fuzzyAlpha;\n        #endif\n\n        #include apply_marker_color\n        #include apply_fog\n        #include wboit_write\n    #endif\n}\n";
-//# sourceMappingURL=points.frag.js.map

package/lib/commonjs/mol-gl/shader/points.vert.js

@@ -7,4 +7,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.points_vert = void 0;
 exports.points_vert = "\nprecision highp float;\nprecision highp int;\n\n#include common\n#include read_from_texture\n#include common_vert_params\n#include color_vert_params\n#include size_vert_params\n#include common_clip\n\nuniform float uPixelRatio;\nuniform vec4 uViewport;\n\nattribute vec3 aPosition;\nattribute mat4 aTransform;\nattribute float aInstance;\nattribute float aGroup;\n\nvoid main(){\n    #include assign_group\n    #include assign_color_varying\n    #include assign_marker_varying\n    #include assign_clipping_varying\n    #include assign_position\n    #include assign_size\n\n    #ifdef dPointSizeAttenuation\n        gl_PointSize = size * uPixelRatio * ((uViewport.w / 2.0) / -mvPosition.z) * 5.0;\n    #else\n        gl_PointSize = size * uPixelRatio;\n    #endif\n    gl_PointSize = max(1.0, gl_PointSize);\n\n    gl_Position = uProjection * mvPosition;\n\n    #include clip_instance\n}\n";
-//# sourceMappingURL=points.vert.js.map

package/lib/commonjs/mol-gl/shader/postprocessing.frag.d.ts

@@ -1,7 +1,7 @@
 /**
- * Copyright (c) 2019-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2019-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  * @author Áron Samuel Kovács <aron.kovacs@mail.muni.cz>
  */
-export declare const postprocessing_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform sampler2D tSsaoDepth;\nuniform sampler2D tColor;\nuniform sampler2D tDepth;\nuniform sampler2D tOutlines;\nuniform vec2 uTexSize;\n\nuniform float uNear;\nuniform float uFar;\nuniform float uFogNear;\nuniform float uFogFar;\nuniform vec3 uFogColor;\nuniform vec3 uOutlineColor;\nuniform bool uTransparentBackground;\n\nuniform float uOcclusionBias;\nuniform float uOcclusionRadius;\n\nuniform float uMaxPossibleViewZDiff;\n\nconst vec3 occlusionColor = vec3(0.0);\n\n#include common\n\nfloat getViewZ(const in float depth) {\n    #if dOrthographic == 1\n        return orthographicDepthToViewZ(depth, uNear, uFar);\n    #else\n        return perspectiveDepthToViewZ(depth, uNear, uFar);\n    #endif\n}\n\nfloat getDepth(const in vec2 coords) {\n    return unpackRGBAToDepth(texture2D(tDepth, coords));\n}\n\nbool isBackground(const in float depth) {\n    return depth == 1.0;\n}\n\nfloat getOutline(const in vec2 coords, out float closestTexel) {\n    float backgroundViewZ = uFar + 3.0 * uMaxPossibleViewZDiff;\n    vec2 invTexSize = 1.0 / uTexSize;\n\n    float selfDepth = getDepth(coords);\n    float selfViewZ = isBackground(selfDepth) ? backgroundViewZ : getViewZ(selfDepth);\n\n    float outline = 1.0;\n    closestTexel = 1.0;\n    for (int y = -dOutlineScale; y <= dOutlineScale; y++) {\n        for (int x = -dOutlineScale; x <= dOutlineScale; x++) {\n            if (x * x + y * y > dOutlineScale * dOutlineScale) {\n                continue;\n            }\n\n            vec2 sampleCoords = coords + vec2(float(x), float(y)) * invTexSize;\n\n            vec4 sampleOutlineCombined = texture2D(tOutlines, sampleCoords);\n            float sampleOutline = sampleOutlineCombined.r;\n            float sampleOutlineDepth = unpackRGToUnitInterval(sampleOutlineCombined.gb);\n\n            if (sampleOutline == 0.0 && sampleOutlineDepth < closestTexel && abs(selfViewZ - sampleOutlineDepth) > uMaxPossibleViewZDiff) {\n                outline = 0.0;\n                closestTexel = sampleOutlineDepth;\n            }\n        }\n    }\n    return outline;\n}\n\nfloat getSsao(vec2 coords) {\n    float rawSsao = unpackRGToUnitInterval(texture2D(tSsaoDepth, coords).xy);\n    if (rawSsao > 0.999) {\n        return 1.0;\n    } else if (rawSsao > 0.001) {\n        return rawSsao;\n    }\n    // treat values close to 0.0 as errors and return no occlusion\n    return 1.0;\n}\n\nvoid main(void) {\n    vec2 coords = gl_FragCoord.xy / uTexSize;\n    vec4 color = texture2D(tColor, coords);\n\n    float viewDist;\n    float fogFactor;\n\n    #ifdef dOcclusionEnable\n        float depth = getDepth(coords);\n        if (!isBackground(depth)) {\n            viewDist = abs(getViewZ(depth));\n            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);\n            float occlusionFactor = getSsao(coords);\n            if (!uTransparentBackground) {\n                color.rgb = mix(mix(occlusionColor, uFogColor, fogFactor), color.rgb, occlusionFactor);\n            } else {\n                color.rgb = mix(occlusionColor * (1.0 - fogFactor), color.rgb, occlusionFactor);\n            }\n        }\n    #endif\n\n    // outline needs to be handled after occlusion to keep them clean\n    #ifdef dOutlineEnable\n        float closestTexel;\n        float outline = getOutline(coords, closestTexel);\n\n        if (outline == 0.0) {\n            color.rgb = mix(uOutlineColor, color.rgb, outline);\n            viewDist = abs(getViewZ(closestTexel));\n            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);\n            if (!uTransparentBackground) {\n                color.rgb = mix(color.rgb, uFogColor, fogFactor);\n            } else {\n                color.a = 1.0 - fogFactor;\n            }\n        }\n    #endif\n\n    gl_FragColor = color;\n}\n";
+export declare const postprocessing_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform sampler2D tSsaoDepth;\nuniform sampler2D tColor;\nuniform sampler2D tDepth;\nuniform sampler2D tOutlines;\nuniform vec2 uTexSize;\n\nuniform float uNear;\nuniform float uFar;\nuniform float uFogNear;\nuniform float uFogFar;\nuniform vec3 uFogColor;\nuniform vec3 uOutlineColor;\nuniform bool uTransparentBackground;\n\nuniform vec2 uOcclusionOffset;\n\nuniform float uMaxPossibleViewZDiff;\n\nconst vec3 occlusionColor = vec3(0.0);\n\n#include common\n\nfloat getViewZ(const in float depth) {\n    #if dOrthographic == 1\n        return orthographicDepthToViewZ(depth, uNear, uFar);\n    #else\n        return perspectiveDepthToViewZ(depth, uNear, uFar);\n    #endif\n}\n\nfloat getDepth(const in vec2 coords) {\n    return unpackRGBAToDepth(texture2D(tDepth, coords));\n}\n\nbool isBackground(const in float depth) {\n    return depth == 1.0;\n}\n\nfloat getOutline(const in vec2 coords, out float closestTexel) {\n    float backgroundViewZ = uFar + 3.0 * uMaxPossibleViewZDiff;\n    vec2 invTexSize = 1.0 / uTexSize;\n\n    float selfDepth = getDepth(coords);\n    float selfViewZ = isBackground(selfDepth) ? backgroundViewZ : getViewZ(selfDepth);\n\n    float outline = 1.0;\n    closestTexel = 1.0;\n    for (int y = -dOutlineScale; y <= dOutlineScale; y++) {\n        for (int x = -dOutlineScale; x <= dOutlineScale; x++) {\n            if (x * x + y * y > dOutlineScale * dOutlineScale) {\n                continue;\n            }\n\n            vec2 sampleCoords = coords + vec2(float(x), float(y)) * invTexSize;\n\n            vec4 sampleOutlineCombined = texture2D(tOutlines, sampleCoords);\n            float sampleOutline = sampleOutlineCombined.r;\n            float sampleOutlineDepth = unpackRGToUnitInterval(sampleOutlineCombined.gb);\n\n            if (sampleOutline == 0.0 && sampleOutlineDepth < closestTexel && abs(selfViewZ - sampleOutlineDepth) > uMaxPossibleViewZDiff) {\n                outline = 0.0;\n                closestTexel = sampleOutlineDepth;\n            }\n        }\n    }\n    return outline;\n}\n\nfloat getSsao(vec2 coords) {\n    float rawSsao = unpackRGToUnitInterval(texture2D(tSsaoDepth, coords).xy);\n    if (rawSsao > 0.999) {\n        return 1.0;\n    } else if (rawSsao > 0.001) {\n        return rawSsao;\n    }\n    // treat values close to 0.0 as errors and return no occlusion\n    return 1.0;\n}\n\nvoid main(void) {\n    vec2 coords = gl_FragCoord.xy / uTexSize;\n    vec4 color = texture2D(tColor, coords);\n\n    float viewDist;\n    float fogFactor;\n\n    #ifdef dOcclusionEnable\n        float depth = getDepth(coords);\n        if (!isBackground(depth)) {\n            viewDist = abs(getViewZ(depth));\n            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);\n            float occlusionFactor = getSsao(coords + uOcclusionOffset);\n            if (!uTransparentBackground) {\n                color.rgb = mix(mix(occlusionColor, uFogColor, fogFactor), color.rgb, occlusionFactor);\n            } else {\n                color.rgb = mix(occlusionColor * (1.0 - fogFactor), color.rgb, occlusionFactor);\n            }\n        }\n    #endif\n\n    // outline needs to be handled after occlusion to keep them clean\n    #ifdef dOutlineEnable\n        float closestTexel;\n        float outline = getOutline(coords, closestTexel);\n\n        if (outline == 0.0) {\n            color.rgb = mix(uOutlineColor, color.rgb, outline);\n            viewDist = abs(getViewZ(closestTexel));\n            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);\n            if (!uTransparentBackground) {\n                color.rgb = mix(color.rgb, uFogColor, fogFactor);\n            } else {\n                color.a = 1.0 - fogFactor;\n            }\n        }\n    #endif\n\n    gl_FragColor = color;\n}\n";

package/lib/commonjs/mol-gl/shader/postprocessing.frag.js

@@ -1,11 +1,10 @@
 "use strict";
 /**
- * Copyright (c) 2019-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2019-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  * @author Áron Samuel Kovács <aron.kovacs@mail.muni.cz>
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.postprocessing_frag = void 0;
-exports.postprocessing_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform sampler2D tSsaoDepth;\nuniform sampler2D tColor;\nuniform sampler2D tDepth;\nuniform sampler2D tOutlines;\nuniform vec2 uTexSize;\n\nuniform float uNear;\nuniform float uFar;\nuniform float uFogNear;\nuniform float uFogFar;\nuniform vec3 uFogColor;\nuniform vec3 uOutlineColor;\nuniform bool uTransparentBackground;\n\nuniform float uOcclusionBias;\nuniform float uOcclusionRadius;\n\nuniform float uMaxPossibleViewZDiff;\n\nconst vec3 occlusionColor = vec3(0.0);\n\n#include common\n\nfloat getViewZ(const in float depth) {\n    #if dOrthographic == 1\n        return orthographicDepthToViewZ(depth, uNear, uFar);\n    #else\n        return perspectiveDepthToViewZ(depth, uNear, uFar);\n    #endif\n}\n\nfloat getDepth(const in vec2 coords) {\n    return unpackRGBAToDepth(texture2D(tDepth, coords));\n}\n\nbool isBackground(const in float depth) {\n    return depth == 1.0;\n}\n\nfloat getOutline(const in vec2 coords, out float closestTexel) {\n    float backgroundViewZ = uFar + 3.0 * uMaxPossibleViewZDiff;\n    vec2 invTexSize = 1.0 / uTexSize;\n\n    float selfDepth = getDepth(coords);\n    float selfViewZ = isBackground(selfDepth) ? backgroundViewZ : getViewZ(selfDepth);\n\n    float outline = 1.0;\n    closestTexel = 1.0;\n    for (int y = -dOutlineScale; y <= dOutlineScale; y++) {\n        for (int x = -dOutlineScale; x <= dOutlineScale; x++) {\n            if (x * x + y * y > dOutlineScale * dOutlineScale) {\n                continue;\n            }\n\n            vec2 sampleCoords = coords + vec2(float(x), float(y)) * invTexSize;\n\n            vec4 sampleOutlineCombined = texture2D(tOutlines, sampleCoords);\n            float sampleOutline = sampleOutlineCombined.r;\n            float sampleOutlineDepth = unpackRGToUnitInterval(sampleOutlineCombined.gb);\n\n            if (sampleOutline == 0.0 && sampleOutlineDepth < closestTexel && abs(selfViewZ - sampleOutlineDepth) > uMaxPossibleViewZDiff) {\n                outline = 0.0;\n                closestTexel = sampleOutlineDepth;\n            }\n        }\n    }\n    return outline;\n}\n\nfloat getSsao(vec2 coords) {\n    float rawSsao = unpackRGToUnitInterval(texture2D(tSsaoDepth, coords).xy);\n    if (rawSsao > 0.999) {\n        return 1.0;\n    } else if (rawSsao > 0.001) {\n        return rawSsao;\n    }\n    // treat values close to 0.0 as errors and return no occlusion\n    return 1.0;\n}\n\nvoid main(void) {\n    vec2 coords = gl_FragCoord.xy / uTexSize;\n    vec4 color = texture2D(tColor, coords);\n\n    float viewDist;\n    float fogFactor;\n\n    #ifdef dOcclusionEnable\n        float depth = getDepth(coords);\n        if (!isBackground(depth)) {\n            viewDist = abs(getViewZ(depth));\n            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);\n            float occlusionFactor = getSsao(coords);\n            if (!uTransparentBackground) {\n                color.rgb = mix(mix(occlusionColor, uFogColor, fogFactor), color.rgb, occlusionFactor);\n            } else {\n                color.rgb = mix(occlusionColor * (1.0 - fogFactor), color.rgb, occlusionFactor);\n            }\n        }\n    #endif\n\n    // outline needs to be handled after occlusion to keep them clean\n    #ifdef dOutlineEnable\n        float closestTexel;\n        float outline = getOutline(coords, closestTexel);\n\n        if (outline == 0.0) {\n            color.rgb = mix(uOutlineColor, color.rgb, outline);\n            viewDist = abs(getViewZ(closestTexel));\n            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);\n            if (!uTransparentBackground) {\n                color.rgb = mix(color.rgb, uFogColor, fogFactor);\n            } else {\n                color.a = 1.0 - fogFactor;\n            }\n        }\n    #endif\n\n    gl_FragColor = color;\n}\n";
-//# sourceMappingURL=postprocessing.frag.js.map
+exports.postprocessing_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform sampler2D tSsaoDepth;\nuniform sampler2D tColor;\nuniform sampler2D tDepth;\nuniform sampler2D tOutlines;\nuniform vec2 uTexSize;\n\nuniform float uNear;\nuniform float uFar;\nuniform float uFogNear;\nuniform float uFogFar;\nuniform vec3 uFogColor;\nuniform vec3 uOutlineColor;\nuniform bool uTransparentBackground;\n\nuniform vec2 uOcclusionOffset;\n\nuniform float uMaxPossibleViewZDiff;\n\nconst vec3 occlusionColor = vec3(0.0);\n\n#include common\n\nfloat getViewZ(const in float depth) {\n    #if dOrthographic == 1\n        return orthographicDepthToViewZ(depth, uNear, uFar);\n    #else\n        return perspectiveDepthToViewZ(depth, uNear, uFar);\n    #endif\n}\n\nfloat getDepth(const in vec2 coords) {\n    return unpackRGBAToDepth(texture2D(tDepth, coords));\n}\n\nbool isBackground(const in float depth) {\n    return depth == 1.0;\n}\n\nfloat getOutline(const in vec2 coords, out float closestTexel) {\n    float backgroundViewZ = uFar + 3.0 * uMaxPossibleViewZDiff;\n    vec2 invTexSize = 1.0 / uTexSize;\n\n    float selfDepth = getDepth(coords);\n    float selfViewZ = isBackground(selfDepth) ? backgroundViewZ : getViewZ(selfDepth);\n\n    float outline = 1.0;\n    closestTexel = 1.0;\n    for (int y = -dOutlineScale; y <= dOutlineScale; y++) {\n        for (int x = -dOutlineScale; x <= dOutlineScale; x++) {\n            if (x * x + y * y > dOutlineScale * dOutlineScale) {\n                continue;\n            }\n\n            vec2 sampleCoords = coords + vec2(float(x), float(y)) * invTexSize;\n\n            vec4 sampleOutlineCombined = texture2D(tOutlines, sampleCoords);\n            float sampleOutline = sampleOutlineCombined.r;\n            float sampleOutlineDepth = unpackRGToUnitInterval(sampleOutlineCombined.gb);\n\n            if (sampleOutline == 0.0 && sampleOutlineDepth < closestTexel && abs(selfViewZ - sampleOutlineDepth) > uMaxPossibleViewZDiff) {\n                outline = 0.0;\n                closestTexel = sampleOutlineDepth;\n            }\n        }\n    }\n    return outline;\n}\n\nfloat getSsao(vec2 coords) {\n    float rawSsao = unpackRGToUnitInterval(texture2D(tSsaoDepth, coords).xy);\n    if (rawSsao > 0.999) {\n        return 1.0;\n    } else if (rawSsao > 0.001) {\n        return rawSsao;\n    }\n    // treat values close to 0.0 as errors and return no occlusion\n    return 1.0;\n}\n\nvoid main(void) {\n    vec2 coords = gl_FragCoord.xy / uTexSize;\n    vec4 color = texture2D(tColor, coords);\n\n    float viewDist;\n    float fogFactor;\n\n    #ifdef dOcclusionEnable\n        float depth = getDepth(coords);\n        if (!isBackground(depth)) {\n            viewDist = abs(getViewZ(depth));\n            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);\n            float occlusionFactor = getSsao(coords + uOcclusionOffset);\n            if (!uTransparentBackground) {\n                color.rgb = mix(mix(occlusionColor, uFogColor, fogFactor), color.rgb, occlusionFactor);\n            } else {\n                color.rgb = mix(occlusionColor * (1.0 - fogFactor), color.rgb, occlusionFactor);\n            }\n        }\n    #endif\n\n    // outline needs to be handled after occlusion to keep them clean\n    #ifdef dOutlineEnable\n        float closestTexel;\n        float outline = getOutline(coords, closestTexel);\n\n        if (outline == 0.0) {\n            color.rgb = mix(uOutlineColor, color.rgb, outline);\n            viewDist = abs(getViewZ(closestTexel));\n            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);\n            if (!uTransparentBackground) {\n                color.rgb = mix(color.rgb, uFogColor, fogFactor);\n            } else {\n                color.a = 1.0 - fogFactor;\n            }\n        }\n    #endif\n\n    gl_FragColor = color;\n}\n";

package/lib/commonjs/mol-gl/shader/quad.vert.js

@@ -7,4 +7,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.quad_vert = void 0;
 exports.quad_vert = "\nprecision highp float;\n\nattribute vec2 aPosition;\nuniform vec2 uQuadScale;\n\nvoid main(void) {\n    vec2 position = aPosition * uQuadScale - vec2(1.0, 1.0) + uQuadScale;\n    gl_Position = vec4(position, 0.0, 1.0);\n}\n";
-//# sourceMappingURL=quad.vert.js.map

package/lib/commonjs/mol-gl/shader/smaa/blend.frag.js

@@ -10,4 +10,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.blend_frag = void 0;
 exports.blend_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform sampler2D tWeights;\nuniform sampler2D tColor;\nuniform vec2 uTexSizeInv;\n\nvarying vec2 vUv;\nvarying vec4 vOffset[2];\n\nvec4 SMAANeighborhoodBlendingPS(vec2 texCoord, vec4 offset[2], sampler2D colorTex, sampler2D blendTex) {\n    // Fetch the blending weights for current pixel:\n    vec4 a;\n    a.xz = texture2D(blendTex, texCoord).xz;\n    a.y = texture2D(blendTex, offset[1].zw).g;\n    a.w = texture2D(blendTex, offset[1].xy).a;\n\n    // Is there any blending weight with a value greater than 0.0?\n    if (dot(a, vec4(1.0, 1.0, 1.0, 1.0)) < 1e-5) {\n        return texture2D(colorTex, texCoord, 0.0);\n    } else {\n        // Up to 4 lines can be crossing a pixel (one through each edge). We\n        // favor blending by choosing the line with the maximum weight for each\n        // direction:\n        vec2 offset;\n        offset.x = a.a > a.b ? a.a : -a.b; // left vs. right\n        offset.y = a.g > a.r ? -a.g : a.r; // top vs. bottom // WebGL port note: Changed signs\n\n        // Then we go in the direction that has the maximum weight:\n        if (abs(offset.x) > abs(offset.y)) { // horizontal vs. vertical\n            offset.y = 0.0;\n        } else {\n            offset.x = 0.0;\n        }\n\n        // Fetch the opposite color and lerp by hand:\n        vec4 C = texture2D(colorTex, texCoord, 0.0);\n        texCoord += sign(offset) * uTexSizeInv;\n        vec4 Cop = texture2D(colorTex, texCoord, 0.0);\n        float s = abs(offset.x) > abs(offset.y) ? abs(offset.x) : abs(offset.y);\n\n        // WebGL port note: Added gamma correction\n        C.xyz = pow(C.xyz, vec3(2.2));\n        Cop.xyz = pow(Cop.xyz, vec3(2.2));\n        vec4 mixed = mix(C, Cop, s);\n        mixed.xyz = pow(mixed.xyz, vec3(1.0 / 2.2));\n\n        return mixed;\n    }\n}\n\nvoid main() {\n    gl_FragColor = SMAANeighborhoodBlendingPS(vUv, vOffset, tColor, tWeights);\n}\n";
-//# sourceMappingURL=blend.frag.js.map

package/lib/commonjs/mol-gl/shader/smaa/blend.vert.js

@@ -10,4 +10,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.blend_vert = void 0;
 exports.blend_vert = "\nprecision highp float;\n\nattribute vec2 aPosition;\nuniform vec2 uQuadScale;\n\nuniform vec2 uTexSizeInv;\nuniform vec4 uViewport;\n\nvarying vec2 vUv;\nvarying vec4 vOffset[2];\n\nvoid SMAANeighborhoodBlendingVS(vec2 texCoord) {\n    vOffset[0] = texCoord.xyxy + uTexSizeInv.xyxy * vec4(-1.0, 0.0, 0.0, 1.0); // WebGL port note: Changed sign in W component\n    vOffset[1] = texCoord.xyxy + uTexSizeInv.xyxy * vec4(1.0, 0.0, 0.0, -1.0); // WebGL port note: Changed sign in W component\n}\n\nvoid main() {\n    vec2 scale = uViewport.zw * uTexSizeInv;\n    vec2 shift = uViewport.xy * uTexSizeInv;\n    vUv = (aPosition + 1.0) * 0.5 * scale + shift;\n    SMAANeighborhoodBlendingVS(vUv);\n    vec2 position = aPosition * uQuadScale - vec2(1.0, 1.0) + uQuadScale;\n    gl_Position = vec4(position, 0.0, 1.0);\n}\n";
-//# sourceMappingURL=blend.vert.js.map

package/lib/commonjs/mol-gl/shader/smaa/edges.frag.js

@@ -10,4 +10,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.edges_frag = void 0;
 exports.edges_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform sampler2D tColor;\nuniform vec2 uTexSizeInv;\n\nvarying vec2 vUv;\nvarying vec4 vOffset[3];\n\nvec4 SMAAColorEdgeDetectionPS(vec2 texcoord, vec4 offset[3], sampler2D colorTex) {\n    vec2 threshold = vec2(dEdgeThreshold, dEdgeThreshold);\n\n    // Calculate color deltas:\n    vec4 delta;\n    vec3 C = texture2D(colorTex, texcoord).rgb;\n\n    vec3 Cleft = texture2D(colorTex, offset[0].xy).rgb;\n    vec3 t = abs(C - Cleft);\n    delta.x = max(max(t.r, t.g), t.b);\n\n    vec3 Ctop = texture2D(colorTex, offset[0].zw).rgb;\n    t = abs(C - Ctop);\n    delta.y = max(max(t.r, t.g), t.b);\n\n    // We do the usual threshold:\n    vec2 edges = step(threshold, delta.xy);\n\n    // Then discard if there is no edge:\n    if (dot(edges, vec2(1.0, 1.0 )) == 0.0)\n        discard;\n\n    // Calculate right and bottom deltas:\n    vec3 Cright = texture2D(colorTex, offset[1].xy).rgb;\n    t = abs( C - Cright );\n    delta.z = max(max(t.r, t.g), t.b);\n\n    vec3 Cbottom  = texture2D(colorTex, offset[1].zw).rgb;\n    t = abs(C - Cbottom);\n    delta.w = max(max(t.r, t.g), t.b);\n\n    // Calculate the maximum delta in the direct neighborhood:\n    float maxDelta = max(max(max(delta.x, delta.y), delta.z), delta.w );\n\n    // Calculate left-left and top-top deltas:\n    vec3 Cleftleft  = texture2D(colorTex, offset[2].xy).rgb;\n    t = abs( C - Cleftleft );\n    delta.z = max(max(t.r, t.g), t.b);\n\n    vec3 Ctoptop = texture2D(colorTex, offset[2].zw).rgb;\n    t = abs(C - Ctoptop);\n    delta.w = max(max(t.r, t.g), t.b);\n\n    // Calculate the final maximum delta:\n    maxDelta = max(max(maxDelta, delta.z), delta.w);\n\n    // Local contrast adaptation in action:\n    edges.xy *= step(0.5 * maxDelta, delta.xy);\n\n    return vec4(edges, 0.0, 0.0);\n}\n\nvoid main() {\n    gl_FragColor = SMAAColorEdgeDetectionPS(vUv, vOffset, tColor);\n}\n";
-//# sourceMappingURL=edges.frag.js.map

package/lib/commonjs/mol-gl/shader/smaa/edges.vert.js

@@ -10,4 +10,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.edges_vert = void 0;
 exports.edges_vert = "\nprecision highp float;\n\nattribute vec2 aPosition;\nuniform vec2 uQuadScale;\n\nuniform vec2 uTexSizeInv;\nuniform vec4 uViewport;\n\nvarying vec2 vUv;\nvarying vec4 vOffset[3];\n\nvoid SMAAEdgeDetectionVS(vec2 texCoord) {\n    vOffset[0] = texCoord.xyxy + uTexSizeInv.xyxy * vec4(-1.0, 0.0, 0.0, 1.0); // WebGL port note: Changed sign in W component\n    vOffset[1] = texCoord.xyxy + uTexSizeInv.xyxy * vec4(1.0, 0.0, 0.0, -1.0); // WebGL port note: Changed sign in W component\n    vOffset[2] = texCoord.xyxy + uTexSizeInv.xyxy * vec4(-2.0, 0.0, 0.0, 2.0); // WebGL port note: Changed sign in W component\n}\n\nvoid main() {\n    vec2 scale = uViewport.zw * uTexSizeInv;\n    vec2 shift = uViewport.xy * uTexSizeInv;\n    vUv = (aPosition + 1.0) * 0.5 * scale + shift;\n    SMAAEdgeDetectionVS(vUv);\n    vec2 position = aPosition * uQuadScale - vec2(1.0, 1.0) + uQuadScale;\n    gl_Position = vec4(position, 0.0, 1.0);\n}\n";
-//# sourceMappingURL=edges.vert.js.map

package/lib/commonjs/mol-gl/shader/smaa/weights.frag.js

@@ -10,4 +10,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.weights_frag = void 0;
 exports.weights_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\n#define SMAASampleLevelZeroOffset(tex, coord, offset) texture2D(tex, coord + float(offset) * uTexSizeInv, 0.0)\n\n#define SMAA_AREATEX_MAX_DISTANCE 16\n#define SMAA_AREATEX_PIXEL_SIZE (1.0 / vec2(160.0, 560.0))\n#define SMAA_AREATEX_SUBTEX_SIZE (1.0 / 7.0)\n\nuniform sampler2D tEdges;\nuniform sampler2D tArea;\nuniform sampler2D tSearch;\nuniform vec2 uTexSizeInv;\n\nvarying vec2 vUv;\nvarying vec4 vOffset[3];\nvarying vec2 vPixCoord;\n\n#if __VERSION__ == 100\n    vec2 round(vec2 x) {\n        return sign(x) * floor(abs(x) + 0.5);\n    }\n#endif\n\nfloat SMAASearchLength(sampler2D searchTex, vec2 e, float bias, float scale) {\n    // Not required if searchTex accesses are set to point:\n    // float2 SEARCH_TEX_PIXEL_SIZE = 1.0 / float2(66.0, 33.0);\n    // e = float2(bias, 0.0) + 0.5 * SEARCH_TEX_PIXEL_SIZE +\n    //     e * float2(scale, 1.0) * float2(64.0, 32.0) * SEARCH_TEX_PIXEL_SIZE;\n    e.r = bias + e.r * scale;\n    return 255.0 * texture2D(searchTex, e, 0.0).r;\n}\n\nfloat SMAASearchXLeft(sampler2D edgesTex, sampler2D searchTex, vec2 texCoord, float end) {\n    /**\n     * @PSEUDO_GATHER4\n     * This texCoord has been offset by (-0.25, -0.125) in the vertex shader to\n     * sample between edge, thus fetching four edges in a row.\n     * Sampling with different offsets in each direction allows to disambiguate\n     * which edges are active from the four fetched ones.\n     */\n    vec2 e = vec2(0.0, 1.0);\n\n    for (int i = 0; i < dMaxSearchSteps; i++) { // WebGL port note: Changed while to for\n        e = texture2D( edgesTex, texCoord, 0.0).rg;\n        texCoord -= vec2(2.0, 0.0) * uTexSizeInv;\n        if (!(texCoord.x > end && e.g > 0.8281 && e.r == 0.0)) break;\n    }\n\n    // We correct the previous (-0.25, -0.125) offset we applied:\n    texCoord.x += 0.25 * uTexSizeInv.x;\n\n    // The searches are bias by 1, so adjust the coords accordingly:\n    texCoord.x += uTexSizeInv.x;\n\n    // Disambiguate the length added by the last step:\n    texCoord.x += 2.0 * uTexSizeInv.x; // Undo last step\n    texCoord.x -= uTexSizeInv.x * SMAASearchLength(searchTex, e, 0.0, 0.5);\n\n    return texCoord.x;\n}\n\nfloat SMAASearchXRight(sampler2D edgesTex, sampler2D searchTex, vec2 texCoord, float end) {\n    vec2 e = vec2( 0.0, 1.0 );\n\n    for (int i = 0; i < dMaxSearchSteps; i++) { // WebGL port note: Changed while to for\n        e = texture2D(edgesTex, texCoord, 0.0).rg;\n        texCoord += vec2(2.0, 0.0) * uTexSizeInv;\n        if (!(texCoord.x < end && e.g > 0.8281 && e.r == 0.0)) break;\n    }\n\n    texCoord.x -= 0.25 * uTexSizeInv.x;\n    texCoord.x -= uTexSizeInv.x;\n    texCoord.x -= 2.0 * uTexSizeInv.x;\n    texCoord.x += uTexSizeInv.x * SMAASearchLength( searchTex, e, 0.5, 0.5 );\n\n    return texCoord.x;\n}\n\nfloat SMAASearchYUp(sampler2D edgesTex, sampler2D searchTex, vec2 texCoord, float end) {\n    vec2 e = vec2( 1.0, 0.0 );\n\n    for (int i = 0; i < dMaxSearchSteps; i++) { // WebGL port note: Changed while to for\n        e = texture2D(edgesTex, texCoord, 0.0).rg;\n        texCoord += vec2(0.0, 2.0) * uTexSizeInv; // WebGL port note: Changed sign\n        if (!(texCoord.y > end && e.r > 0.8281 && e.g == 0.0)) break;\n    }\n\n    texCoord.y -= 0.25 * uTexSizeInv.y; // WebGL port note: Changed sign\n    texCoord.y -= uTexSizeInv.y; // WebGL port note: Changed sign\n    texCoord.y -= 2.0 * uTexSizeInv.y; // WebGL port note: Changed sign\n    texCoord.y += uTexSizeInv.y * SMAASearchLength(searchTex, e.gr, 0.0, 0.5); // WebGL port note: Changed sign\n\n    return texCoord.y;\n}\n\nfloat SMAASearchYDown(sampler2D edgesTex, sampler2D searchTex, vec2 texCoord, float end) {\n    vec2 e = vec2( 1.0, 0.0 );\n\n    for (int i = 0; i < dMaxSearchSteps; i++) { // WebGL port note: Changed while to for\n        e = texture2D(edgesTex, texCoord, 0.0).rg;\n        texCoord -= vec2( 0.0, 2.0 ) * uTexSizeInv; // WebGL port note: Changed sign\n        if (!(texCoord.y < end && e.r > 0.8281 && e.g == 0.0)) break;\n    }\n\n    texCoord.y += 0.25 * uTexSizeInv.y; // WebGL port note: Changed sign\n    texCoord.y += uTexSizeInv.y; // WebGL port note: Changed sign\n    texCoord.y += 2.0 * uTexSizeInv.y; // WebGL port note: Changed sign\n    texCoord.y -= uTexSizeInv.y * SMAASearchLength(searchTex, e.gr, 0.5, 0.5); // WebGL port note: Changed sign\n\n    return texCoord.y;\n}\n\nvec2 SMAAArea(sampler2D areaTex, vec2 dist, float e1, float e2, float offset) {\n    // Rounding prevents precision errors of bilinear filtering:\n    vec2 texCoord = float(SMAA_AREATEX_MAX_DISTANCE) * round(4.0 * vec2(e1, e2)) + dist;\n\n    // We do a scale and bias for mapping to texel space:\n    texCoord = SMAA_AREATEX_PIXEL_SIZE * texCoord + (0.5 * SMAA_AREATEX_PIXEL_SIZE);\n\n    // Move to proper place, according to the subpixel offset:\n    texCoord.y += SMAA_AREATEX_SUBTEX_SIZE * offset;\n\n    return texture2D(areaTex, texCoord, 0.0).rg;\n}\n\nvec4 SMAABlendingWeightCalculationPS(vec2 texCoord, vec2 pixCoord, vec4 offset[3], sampler2D edgesTex, sampler2D areaTex, sampler2D searchTex, ivec4 subsampleIndices) {\n    vec4 weights = vec4(0.0, 0.0, 0.0, 0.0);\n\n    vec2 e = texture2D(edgesTex, texCoord).rg;\n\n    if (e.g > 0.0) { // Edge at north\n        vec2 d;\n\n        // Find the distance to the left:\n        vec2 coords;\n        coords.x = SMAASearchXLeft(edgesTex, searchTex, offset[0].xy, offset[2].x );\n        coords.y = offset[1].y; // offset[1].y = texCoord.y - 0.25 * uTexSizeInv.y (@CROSSING_OFFSET)\n        d.x = coords.x;\n\n        // Now fetch the left crossing edges, two at a time using bilinear\n        // filtering. Sampling at -0.25 (see @CROSSING_OFFSET) enables to\n        // discern what value each edge has:\n        float e1 = texture2D(edgesTex, coords, 0.0).r;\n\n        // Find the distance to the right:\n        coords.x = SMAASearchXRight(edgesTex, searchTex, offset[0].zw, offset[2].y);\n        d.y = coords.x;\n\n        // We want the distances to be in pixel units (doing this here allow to\n        // better interleave arithmetic and memory accesses):\n        d = d / uTexSizeInv.x - pixCoord.x;\n\n        // SMAAArea below needs a sqrt, as the areas texture is compressed\n        // quadratically:\n        vec2 sqrt_d = sqrt(abs(d));\n\n        // Fetch the right crossing edges:\n        coords.y -= 1.0 * uTexSizeInv.y; // WebGL port note: Added\n        float e2 = SMAASampleLevelZeroOffset(edgesTex, coords, ivec2(1, 0)).r;\n\n        // Ok, we know how this pattern looks like, now it is time for getting\n        // the actual area:\n        weights.rg = SMAAArea(areaTex, sqrt_d, e1, e2, float(subsampleIndices.y));\n    }\n\n    if (e.r > 0.0) { // Edge at west\n        vec2 d;\n\n        // Find the distance to the top:\n        vec2 coords;\n\n        coords.y = SMAASearchYUp(edgesTex, searchTex, offset[1].xy, offset[2].z );\n        coords.x = offset[0].x; // offset[1].x = texCoord.x - 0.25 * uTexSizeInv.x;\n        d.x = coords.y;\n\n        // Fetch the top crossing edges:\n        float e1 = texture2D(edgesTex, coords, 0.0).g;\n\n        // Find the distance to the bottom:\n        coords.y = SMAASearchYDown(edgesTex, searchTex, offset[1].zw, offset[2].w);\n        d.y = coords.y;\n\n        // We want the distances to be in pixel units:\n        d = d / uTexSizeInv.y - pixCoord.y;\n\n        // SMAAArea below needs a sqrt, as the areas texture is compressed\n        // quadratically:\n        vec2 sqrt_d = sqrt(abs(d));\n\n        // Fetch the bottom crossing edges:\n        coords.y -= 1.0 * uTexSizeInv.y; // WebGL port note: Added\n        float e2 = SMAASampleLevelZeroOffset(edgesTex, coords, ivec2(0, 1)).g;\n\n        // Get the area for this direction:\n        weights.ba = SMAAArea(areaTex, sqrt_d, e1, e2, float(subsampleIndices.x));\n    }\n\n    return weights;\n}\n\nvoid main() {\n    gl_FragColor = SMAABlendingWeightCalculationPS(vUv, vPixCoord, vOffset, tEdges, tArea, tSearch, ivec4(0.0));\n}\n";
-//# sourceMappingURL=weights.frag.js.map

package/lib/commonjs/mol-gl/shader/smaa/weights.vert.js

@@ -10,4 +10,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.weights_vert = void 0;
 exports.weights_vert = "\nprecision highp float;\n\nattribute vec2 aPosition;\nuniform vec2 uQuadScale;\n\nuniform vec2 uTexSizeInv;\nuniform vec4 uViewport;\n\nvarying vec2 vUv;\nvarying vec4 vOffset[3];\nvarying vec2 vPixCoord;\n\nvoid SMAABlendingWeightCalculationVS(vec2 texCoord) {\n    vPixCoord = texCoord / uTexSizeInv;\n\n    // We will use these offsets for the searches later on (see @PSEUDO_GATHER4):\n    vOffset[0] = texCoord.xyxy + uTexSizeInv.xyxy * vec4(-0.25, 0.125, 1.25, 0.125); // WebGL port note: Changed sign in Y and W components\n    vOffset[1] = texCoord.xyxy + uTexSizeInv.xyxy * vec4(-0.125, 0.25, -0.125, -1.25); // WebGL port note: Changed sign in Y and W components\n\n    // And these for the searches, they indicate the ends of the loops:\n    vOffset[2] = vec4(vOffset[0].xz, vOffset[1].yw) + vec4(-2.0, 2.0, -2.0, 2.0) * uTexSizeInv.xxyy * float(dMaxSearchSteps);\n}\n\nvoid main() {\n    vec2 scale = uViewport.zw * uTexSizeInv;\n    vec2 shift = uViewport.xy * uTexSizeInv;\n    vUv = (aPosition + 1.0) * 0.5 * scale + shift;\n    SMAABlendingWeightCalculationVS(vUv);\n    vec2 position = aPosition * uQuadScale - vec2(1.0, 1.0) + uQuadScale;\n    gl_Position = vec4(position, 0.0, 1.0);\n}\n";
-//# sourceMappingURL=weights.vert.js.map

package/lib/commonjs/mol-gl/shader/spheres.frag.js

@@ -7,4 +7,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.spheres_frag = void 0;
 exports.spheres_frag = "\nprecision highp float;\nprecision highp int;\n\n#define bumpEnabled\n\n#include common\n#include common_frag_params\n#include color_frag_params\n#include light_frag_params\n#include common_clip\n\nuniform mat4 uInvView;\n\nvarying float vRadius;\nvarying float vRadiusSq;\nvarying vec3 vPoint;\nvarying vec3 vPointViewPosition;\n\nvec3 cameraPos;\nvec3 cameraNormal;\n\nbool Impostor(out vec3 cameraPos, out vec3 cameraNormal){\n    vec3 cameraSpherePos = -vPointViewPosition;\n    cameraSpherePos.z += vRadius;\n\n    vec3 rayOrigin = mix(vec3(0.0, 0.0, 0.0), vPoint, uIsOrtho);\n    vec3 rayDirection = mix(normalize(vPoint), vec3(0.0, 0.0, 1.0), uIsOrtho);\n    vec3 cameraSphereDir = mix(cameraSpherePos, rayOrigin - cameraSpherePos, uIsOrtho);\n\n    float B = dot(rayDirection, cameraSphereDir);\n    float det = B * B + vRadiusSq - dot(cameraSphereDir, cameraSphereDir);\n\n    if (det < 0.0){\n        discard;\n        return false;\n    }\n\n    float sqrtDet = sqrt(det);\n    float posT = mix(B + sqrtDet, B + sqrtDet, uIsOrtho);\n    float negT = mix(B - sqrtDet, sqrtDet - B, uIsOrtho);\n\n    cameraPos = rayDirection * negT + rayOrigin;\n\n\n    if (calcDepth(cameraPos) <= 0.0) {\n        cameraPos = rayDirection * posT + rayOrigin;\n        interior = true;\n    } else {\n        interior = false;\n    }\n\n    cameraNormal = normalize(cameraPos - cameraSpherePos);\n    cameraNormal *= float(!interior) * 2.0 - 1.0;\n\n    return !interior;\n}\n\nvoid main(void){\n    #include clip_pixel\n\n    bool flag = Impostor(cameraPos, cameraNormal);\n    if (!uDoubleSided) {\n        if (interior) discard;\n    }\n\n    vec3 vViewPosition = cameraPos;\n    gl_FragDepthEXT = calcDepth(vViewPosition);\n    if (!flag && gl_FragDepthEXT >= 0.0) {\n        gl_FragDepthEXT = 0.0 + (0.0000001 / vRadius);\n    }\n\n    vec3 vModelPosition = (uInvView * vec4(vViewPosition, 1.0)).xyz;\n\n    if (gl_FragDepthEXT < 0.0) discard;\n    if (gl_FragDepthEXT > 1.0) discard;\n\n    float fragmentDepth = gl_FragDepthEXT;\n    #include assign_material_color\n\n    #if defined(dRenderVariant_pick)\n        #include check_picking_alpha\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_depth)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_marking)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_color)\n        vec3 normal = -cameraNormal;\n        #include apply_light_color\n\n        #include apply_interior_color\n        #include apply_marker_color\n        #include apply_fog\n        #include wboit_write\n    #endif\n}\n";
-//# sourceMappingURL=spheres.frag.js.map

package/lib/commonjs/mol-gl/shader/spheres.vert.js

@@ -7,4 +7,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.spheres_vert = void 0;
 exports.spheres_vert = "\nprecision highp float;\nprecision highp int;\n\n#include common\n#include read_from_texture\n#include common_vert_params\n#include color_vert_params\n#include size_vert_params\n#include common_clip\n\nuniform mat4 uModelView;\nuniform mat4 uInvProjection;\n\nattribute vec3 aPosition;\nattribute vec2 aMapping;\nattribute mat4 aTransform;\nattribute float aInstance;\nattribute float aGroup;\n\nvarying float vRadius;\nvarying float vRadiusSq;\nvarying vec3 vPoint;\nvarying vec3 vPointViewPosition;\n\n#include matrix_scale\n\nconst mat4 D = mat4(\n    1.0, 0.0, 0.0, 0.0,\n    0.0, 1.0, 0.0, 0.0,\n    0.0, 0.0, 1.0, 0.0,\n    0.0, 0.0, 0.0, -1.0\n);\n\n/**\n * Compute point size and center using the technique described in:\n * \"GPU-Based Ray-Casting of Quadratic Surfaces\" http://dl.acm.org/citation.cfm?id=2386396\n * by Christian Sigg, Tim Weyrich, Mario Botsch, Markus Gross.\n */\nvoid quadraticProjection(const in float radius, const in vec3 position){\n    vec2 xbc, ybc;\n\n    mat4 T = mat4(\n        radius, 0.0, 0.0, 0.0,\n        0.0, radius, 0.0, 0.0,\n        0.0, 0.0, radius, 0.0,\n        position.x, position.y, position.z, 1.0\n    );\n\n    mat4 R = transpose4(uProjection * uModelView * aTransform * T);\n    float A = dot(R[3], D * R[3]);\n    float B = -2.0 * dot(R[0], D * R[3]);\n    float C = dot(R[0], D * R[0]);\n    xbc[0] = (-B - sqrt(B * B - 4.0 * A * C)) / (2.0 * A);\n    xbc[1] = (-B + sqrt(B * B - 4.0 * A * C)) / (2.0 * A);\n    float sx = abs(xbc[0] - xbc[1]) * 0.5;\n\n    A = dot(R[3], D * R[3]);\n    B = -2.0 * dot(R[1], D * R[3]);\n    C = dot(R[1], D * R[1]);\n    ybc[0] = (-B - sqrt(B * B - 4.0 * A * C)) / (2.0 * A);\n    ybc[1] = (-B + sqrt(B * B - 4.0 * A * C)) / (2.0 * A);\n    float sy = abs(ybc[0] - ybc[1]) * 0.5;\n\n    gl_Position.xy = vec2(0.5 * (xbc.x + xbc.y), 0.5 * (ybc.x + ybc.y));\n    gl_Position.xy -= aMapping * vec2(sx, sy);\n    gl_Position.xy *= gl_Position.w;\n}\n\n\nvoid main(void){\n    #include assign_group\n    #include assign_color_varying\n    #include assign_marker_varying\n    #include assign_clipping_varying\n    #include assign_size\n\n    vRadius = size * matrixScale(uModelView);\n\n    vec4 position4 = vec4(aPosition, 1.0);\n    vec4 mvPosition = uModelView * aTransform * position4;\n    mvPosition.z -= vRadius; // avoid clipping, added again in fragment shader\n\n    gl_Position = uProjection * vec4(mvPosition.xyz, 1.0);\n    quadraticProjection(size, aPosition);\n\n    vRadiusSq = vRadius * vRadius;\n    vec4 vPoint4 = uInvProjection * gl_Position;\n    vPoint = vPoint4.xyz / vPoint4.w;\n    vPointViewPosition = -mvPosition.xyz / mvPosition.w;\n\n    vModelPosition = (uModel * aTransform * position4).xyz; // for clipping in frag shader\n\n    #include clip_instance\n}\n";
-//# sourceMappingURL=spheres.vert.js.map

package/lib/commonjs/mol-gl/shader/ssao-blur.frag.js

@@ -8,4 +8,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ssaoBlur_frag = void 0;
 exports.ssaoBlur_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform sampler2D tSsaoDepth;\nuniform vec2 uTexSize;\nuniform vec4 uBounds;\n\nuniform float uKernel[dOcclusionKernelSize];\n\nuniform float uBlurDirectionX;\nuniform float uBlurDirectionY;\n\nuniform float uMaxPossibleViewZDiff;\n\nuniform float uNear;\nuniform float uFar;\n\n#include common\n\nfloat getViewZ(const in float depth) {\n    #if dOrthographic == 1\n        return orthographicDepthToViewZ(depth, uNear, uFar);\n    #else\n        return perspectiveDepthToViewZ(depth, uNear, uFar);\n    #endif\n}\n\nbool isBackground(const in float depth) {\n    return depth == 1.0;\n}\n\nbool outsideBounds(const in vec2 p) {\n    return p.x < uBounds.x || p.y < uBounds.y || p.x > uBounds.z || p.y > uBounds.w;\n}\n\nvoid main(void) {\n    vec2 coords = gl_FragCoord.xy / uTexSize;\n\n    vec2 packedDepth = texture2D(tSsaoDepth, coords).zw;\n\n    if (outsideBounds(coords)) {\n        gl_FragColor = vec4(packUnitIntervalToRG(1.0), packedDepth);\n        return;\n    }\n\n    float selfDepth = unpackRGToUnitInterval(packedDepth);\n    // if background and if second pass\n    if (isBackground(selfDepth) && uBlurDirectionY != 0.0) {\n        gl_FragColor = vec4(packUnitIntervalToRG(1.0), packedDepth);\n        return;\n    }\n\n    float selfViewZ = getViewZ(selfDepth);\n\n    vec2 offset = vec2(uBlurDirectionX, uBlurDirectionY) / uTexSize;\n\n    float sum = 0.0;\n    float kernelSum = 0.0;\n    // only if kernelSize is odd\n    for (int i = -dOcclusionKernelSize / 2; i <= dOcclusionKernelSize / 2; i++) {\n        vec2 sampleCoords = coords + float(i) * offset;\n        if (outsideBounds(sampleCoords)) {\n            continue;\n        }\n\n        vec4 sampleSsaoDepth = texture2D(tSsaoDepth, sampleCoords);\n\n        float sampleDepth = unpackRGToUnitInterval(sampleSsaoDepth.zw);\n        if (isBackground(sampleDepth)) {\n            continue;\n        }\n\n        if (abs(float(i)) > 1.0) { // abs is not defined for int in webgl1\n            float sampleViewZ = getViewZ(sampleDepth);\n            if (abs(selfViewZ - sampleViewZ) > uMaxPossibleViewZDiff) {\n                continue;\n            }\n        }\n\n        float kernel = uKernel[int(abs(float(i)))]; // abs is not defined for int in webgl1\n        float sampleValue = unpackRGToUnitInterval(sampleSsaoDepth.xy);\n\n        sum += kernel * sampleValue;\n        kernelSum += kernel;\n    }\n\n    gl_FragColor = vec4(packUnitIntervalToRG(sum / kernelSum), packedDepth);\n}\n";
-//# sourceMappingURL=ssao-blur.frag.js.map

package/lib/commonjs/mol-gl/shader/ssao.frag.js

@@ -8,4 +8,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ssao_frag = void 0;
 exports.ssao_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\n#include common\n\nuniform sampler2D tDepth;\nuniform vec2 uTexSize;\nuniform vec4 uBounds;\n\nuniform vec3 uSamples[dNSamples];\n\nuniform mat4 uProjection;\nuniform mat4 uInvProjection;\n\nuniform float uRadius;\nuniform float uBias;\n\nfloat smootherstep(float edge0, float edge1, float x) {\n    x = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);\n    return x * x * x * (x * (x * 6.0 - 15.0) + 10.0);\n}\n\nfloat noise(const in vec2 coords) {\n    float a = 12.9898;\n    float b = 78.233;\n    float c = 43758.5453;\n    float dt = dot(coords, vec2(a,b));\n    float sn = mod(dt, PI);\n    return abs(fract(sin(sn) * c)); // is abs necessary?\n}\n\nvec2 getNoiseVec2(const in vec2 coords) {\n    return vec2(noise(coords), noise(coords + vec2(PI, 2.71828)));\n}\n\nbool isBackground(const in float depth) {\n    return depth == 1.0;\n}\n\nbool outsideBounds(const in vec2 p) {\n    return p.x < uBounds.x || p.y < uBounds.y || p.x > uBounds.z || p.y > uBounds.w;\n}\n\nfloat getDepth(const in vec2 coords) {\n    return outsideBounds(coords) ? 1.0 : unpackRGBAToDepth(texture2D(tDepth, coords));\n}\n\nvec3 normalFromDepth(const in float depth, const in float depth1, const in float depth2, vec2 offset1, vec2 offset2) {\n    vec3 p1 = vec3(offset1, depth1 - depth);\n    vec3 p2 = vec3(offset2, depth2 - depth);\n\n    vec3 normal = cross(p1, p2);\n    normal.z = -normal.z;\n\n    return normalize(normal);\n}\n\n// StarCraft II Ambient Occlusion by [Filion and McNaughton 2008]\nvoid main(void) {\n    vec2 invTexSize = 1.0 / uTexSize;\n    vec2 selfCoords = gl_FragCoord.xy * invTexSize;\n\n    float selfDepth = getDepth(selfCoords);\n    vec2 selfPackedDepth = packUnitIntervalToRG(selfDepth);\n\n    if (isBackground(selfDepth)) {\n        gl_FragColor = vec4(packUnitIntervalToRG(0.0), selfPackedDepth);\n        return;\n    }\n\n    vec2 offset1 = vec2(0.0, invTexSize.y);\n    vec2 offset2 = vec2(invTexSize.x, 0.0);\n\n    float selfDepth1 = getDepth(selfCoords + offset1);\n    float selfDepth2 = getDepth(selfCoords + offset2);\n\n    vec3 selfViewNormal = normalFromDepth(selfDepth, selfDepth1, selfDepth2, offset1, offset2);\n    vec3 selfViewPos = screenSpaceToViewSpace(vec3(selfCoords, selfDepth), uInvProjection);\n\n    vec3 randomVec = normalize(vec3(getNoiseVec2(selfCoords) * 2.0 - 1.0, 0.0));\n\n    vec3 tangent = normalize(randomVec - selfViewNormal * dot(randomVec, selfViewNormal));\n    vec3 bitangent = cross(selfViewNormal, tangent);\n    mat3 TBN = mat3(tangent, bitangent, selfViewNormal);\n\n    float occlusion = 0.0;\n    for(int i = 0; i < dNSamples; i++){\n        vec3 sampleViewPos = TBN * uSamples[i];\n        sampleViewPos = selfViewPos + sampleViewPos * uRadius;\n\n        vec4 offset = vec4(sampleViewPos, 1.0);\n        offset = uProjection * offset;\n        offset.xyz = (offset.xyz / offset.w) * 0.5 + 0.5;\n\n        float sampleViewZ = screenSpaceToViewSpace(vec3(offset.xy, getDepth(offset.xy)), uInvProjection).z;\n\n        occlusion += step(sampleViewPos.z + 0.025, sampleViewZ) * smootherstep(0.0, 1.0, uRadius / abs(selfViewPos.z - sampleViewZ));\n    }\n    occlusion = 1.0 - (uBias * occlusion / float(dNSamples));\n\n    vec2 packedOcclusion = packUnitIntervalToRG(occlusion);\n\n    gl_FragColor = vec4(packedOcclusion, selfPackedDepth);\n}\n";
-//# sourceMappingURL=ssao.frag.js.map

package/lib/commonjs/mol-gl/shader/text.frag.js

@@ -7,4 +7,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.text_frag = void 0;
 exports.text_frag = "\nprecision highp float;\nprecision highp int;\n\n#include common\n#include common_frag_params\n#include color_frag_params\n#include common_clip\n\nuniform sampler2D tFont;\n\nuniform vec3 uBorderColor;\nuniform float uBorderWidth;\nuniform vec3 uBackgroundColor;\nuniform float uBackgroundOpacity;\n\nvarying vec2 vTexCoord;\n\nconst float smoothness = 32.0;\nconst float gamma = 2.2;\n\nvoid main2(){\n    gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);\n}\n\nvoid main(){\n    #include clip_pixel\n\n    float fragmentDepth = gl_FragCoord.z;\n    bool interior = false;\n    #include assign_material_color\n\n    if (vTexCoord.x > 1.0) {\n        gl_FragColor = vec4(uBackgroundColor, uBackgroundOpacity * material.a);\n    } else {\n        // retrieve signed distance\n        float sdf = texture2D(tFont, vTexCoord).a + uBorderWidth;\n\n        // perform adaptive anti-aliasing of the edges\n        float w = clamp(smoothness * (abs(dFdx(vTexCoord.x)) + abs(dFdy(vTexCoord.y))), 0.0, 0.5);\n        float a = smoothstep(0.5 - w, 0.5 + w, sdf);\n\n        // gamma correction for linear attenuation\n        a = pow(a, 1.0 / gamma);\n\n        if (a < 0.5) discard;\n        material.a *= a;\n\n        // add border\n        float t = 0.5 + uBorderWidth;\n        if (uBorderWidth > 0.0 && sdf < t) {\n            material.xyz = mix(uBorderColor, material.xyz, smoothstep(t - w, t, sdf));\n        }\n\n        gl_FragColor = material;\n    }\n\n    #if defined(dRenderVariant_pick)\n        #include check_picking_alpha\n    #elif defined(dRenderVariant_depth)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_marking)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_color)\n        #include apply_marker_color\n        #include apply_fog\n        #include wboit_write\n    #endif\n}\n";
-//# sourceMappingURL=text.frag.js.map

package/lib/commonjs/mol-gl/shader/text.vert.js

@@ -7,4 +7,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.text_vert = void 0;
 exports.text_vert = "\nprecision highp float;\nprecision highp int;\n\n#include common\n#include read_from_texture\n#include common_vert_params\n#include color_vert_params\n#include size_vert_params\n#include common_clip\n\nuniform mat4 uModelView;\n\nattribute vec3 aPosition;\nattribute vec2 aMapping;\nattribute float aDepth;\nattribute vec2 aTexCoord;\nattribute mat4 aTransform;\nattribute float aInstance;\nattribute float aGroup;\n\nuniform float uOffsetX;\nuniform float uOffsetY;\nuniform float uOffsetZ;\n\n// uniform bool ortho;\nuniform float uPixelRatio;\nuniform vec4 uViewport;\n\nvarying vec2 vTexCoord;\n\n#include matrix_scale\n\nvoid main(void){\n    #include assign_group\n    #include assign_color_varying\n    #include assign_marker_varying\n    #include assign_clipping_varying\n    #include assign_size\n\n    vTexCoord = aTexCoord;\n\n    float scale = matrixScale(uModelView);\n\n    float offsetX = uOffsetX * scale;\n    float offsetY = uOffsetY * scale;\n    float offsetZ = (uOffsetZ + aDepth * 0.95) * scale;\n\n    vec4 position4 = vec4(aPosition, 1.0);\n    vec4 mvPosition = uModelView * aTransform * position4;\n\n    vModelPosition = (uModel * aTransform * position4).xyz; // for clipping in frag shader\n\n    // TODO\n    // #ifdef FIXED_SIZE\n    //     if (ortho) {\n    //         scale /= pixelRatio * ((uViewport.w / 2.0) / -uCameraPosition.z) * 0.1;\n    //     } else {\n    //         scale /= pixelRatio * ((uViewport.w / 2.0) / -mvPosition.z) * 0.1;\n    //     }\n    // #endif\n\n    vec4 mvCorner = vec4(mvPosition.xyz, 1.0);\n\n    if (vTexCoord.x == 10.0) { // indicates background plane\n        // move a bit to the back, taking distance to camera into account to avoid z-fighting\n        offsetZ -= 0.001 * distance(uCameraPosition, (uProjection * mvCorner).xyz);\n    }\n\n    mvCorner.xy += aMapping * size * scale;\n    mvCorner.x += offsetX;\n    mvCorner.y += offsetY;\n\n    // TODO\n    // if(ortho){\n    //     mvCorner.xyz += normalize(-uCameraPosition) * offsetZ;\n    // } else {\n    //     mvCorner.xyz += normalize(-mvCorner.xyz) * offsetZ;\n    // }\n    mvCorner.xyz += normalize(-mvCorner.xyz) * offsetZ;\n\n    gl_Position = uProjection * mvCorner;\n\n    vViewPosition = -mvCorner.xyz;\n\n    #include clip_instance\n}\n";
-//# sourceMappingURL=text.vert.js.map

package/lib/commonjs/mol-gl/shader/util/grid3d-template.frag.js

@@ -7,4 +7,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.grid3dTemplate_frag = void 0;
 exports.grid3dTemplate_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform vec2 uQuadShift;\nuniform vec3 uDimensions;\nuniform vec3 uMin;\nuniform vec3 uDelta;\nuniform bool uLittleEndian;\nuniform float uWidth;\n\n#ifdef CUMULATIVE\n    uniform sampler2D tCumulativeSum;\n#endif\n\n{UNIFORMS}\n\n{UTILS}\n\n#include float_to_rgba\n#ifdef CUMULATIVE\n    #include rgba_to_float\n#endif\n\nfloat intDiv(float a, float b) { return float(int(a) / int(b)); }\nfloat intMod(float a, float b) { return a - b * float(int(a) / int(b)); }\n\nvoid main(void) {\n    float offset = floor(gl_FragCoord.x) + floor(gl_FragCoord.y) * uWidth;\n\n    // axis order fast to slow Z, Y, X\n    // TODO: support arbitrary axis orders?\n    float k = intMod(offset, uDimensions.z), kk = intDiv(offset, uDimensions.z);\n    float j = intMod(kk, uDimensions.y);\n    float i = intDiv(kk, uDimensions.y);\n\n    vec3 xyz = uMin + uDelta * vec3(i, j, k);\n\n    {MAIN}\n\n    #ifdef CUMULATIVE\n        float current = rgbaToFloat(texture2D(tCumulativeSum, gl_FragCoord.xy / vec2(uWidth, uWidth)), uLittleEndian);\n    #endif\n    gl_FragColor = floatToRgba({RETURN}, uLittleEndian);\n}\n";
-//# sourceMappingURL=grid3d-template.frag.js.map

package/lib/commonjs/mol-gl/shader-code.js

@@ -278,4 +278,3 @@ function addShaderDefines(gl, extensions, defines, shaders) {
     };
 }
 exports.addShaderDefines = addShaderDefines;
-//# sourceMappingURL=shader-code.js.map

package/lib/commonjs/mol-gl/webgl/buffer.js

@@ -177,4 +177,3 @@ function createElementsBuffer(gl, array, usageHint) {
         } });
 }
 exports.createElementsBuffer = createElementsBuffer;
-//# sourceMappingURL=buffer.js.map

package/lib/commonjs/mol-gl/webgl/compat.js

@@ -340,4 +340,3 @@ function testColorBuffer(gl, type) {
     return true;
 }
 exports.testColorBuffer = testColorBuffer;
-//# sourceMappingURL=compat.js.map

package/lib/commonjs/mol-gl/webgl/context.js

@@ -306,4 +306,3 @@ function createContext(gl, props) {
     };
 }
 exports.createContext = createContext;
-//# sourceMappingURL=context.js.map

package/lib/commonjs/mol-gl/webgl/extensions.js

@@ -99,4 +99,3 @@ function createExtensions(gl) {
     };
 }
 exports.createExtensions = createExtensions;
-//# sourceMappingURL=extensions.js.map

package/lib/commonjs/mol-gl/webgl/framebuffer.js

@@ -68,4 +68,3 @@ function createNullFramebuffer() {
     };
 }
 exports.createNullFramebuffer = createNullFramebuffer;
-//# sourceMappingURL=framebuffer.js.map

package/lib/commonjs/mol-gl/webgl/program.js

@@ -193,4 +193,3 @@ function createProgram(gl, state, extensions, getShader, props) {
     };
 }
 exports.createProgram = createProgram;
-//# sourceMappingURL=program.js.map

package/lib/commonjs/mol-gl/webgl/render-item.js

@@ -332,4 +332,3 @@ function createRenderItem(ctx, drawMode, shaderCode, schema, values, materialId,
     };
 }
 exports.createRenderItem = createRenderItem;
-//# sourceMappingURL=render-item.js.map

package/lib/commonjs/mol-gl/webgl/render-target.js

@@ -86,4 +86,3 @@ function createNullRenderTarget(gl) {
     };
 }
 exports.createNullRenderTarget = createNullRenderTarget;
-//# sourceMappingURL=render-target.js.map

package/lib/commonjs/mol-gl/webgl/renderbuffer.js

@@ -80,4 +80,3 @@ function createRenderbuffer(gl, format, attachment, _width, _height) {
     };
 }
 exports.createRenderbuffer = createRenderbuffer;
-//# sourceMappingURL=renderbuffer.js.map

package/lib/commonjs/mol-gl/webgl/resources.js

@@ -125,4 +125,3 @@ function createResources(gl, state, stats, extensions) {
     };
 }
 exports.createResources = createResources;
-//# sourceMappingURL=resources.js.map

package/lib/commonjs/mol-gl/webgl/shader.js

@@ -47,4 +47,3 @@ function createShader(gl, props) {
     };
 }
 exports.createShader = createShader;
-//# sourceMappingURL=shader.js.map

package/lib/commonjs/mol-gl/webgl/state.js

@@ -144,4 +144,3 @@ function createState(gl) {
     };
 }
 exports.createState = createState;
-//# sourceMappingURL=state.js.map

package/lib/commonjs/mol-gl/webgl/texture.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */

package/lib/commonjs/mol-gl/webgl/texture.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Copyright (c) 2018-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -203,6 +203,9 @@ function createTexture(gl, extensions, kind, _format, _type, _filter) {
     var loadedData;
     var destroyed = false;
     function define(_width, _height, _depth) {
+        if (_width === 0 || _height === 0 || ((0, compat_1.isWebGL2)(gl) && target === gl.TEXTURE_3D && _depth === 0)) {
+            throw new Error('empty textures are not allowed');
+        }
         if (width === _width && height === _height && depth === (_depth || 0))
             return;
         width = _width, height = _height, depth = _depth || 0;
@@ -217,14 +220,19 @@ function createTexture(gl, extensions, kind, _format, _type, _filter) {
             throw new Error('unknown texture target');
         }
     }
+    define(1, 1, (0, compat_1.isWebGL2)(gl) && target === gl.TEXTURE_3D ? 1 : 0);
     function load(data, sub) {
         if (sub === void 0) { sub = false; }
+        if (data.width === 0 || data.height === 0 || (!isImage(data) && (0, compat_1.isWebGL2)(gl) && isTexture3d(data, target, gl) && data.depth === 0)) {
+            throw new Error('empty textures are not allowed');
+        }
         gl.bindTexture(target, texture);
         // unpack alignment of 1 since we use textures only for data
         gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
         gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, gl.NONE);
         gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, 0);
         if (isImage(data)) {
+            width = data.width, height = data.height;
             gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
             gl.bindTexture(gl.TEXTURE_2D, texture);
             gl.texImage2D(gl.TEXTURE_2D, 0, internalFormat, format, type, data);
@@ -395,4 +403,3 @@ function createNullTexture(gl) {
     };
 }
 exports.createNullTexture = createNullTexture;
-//# sourceMappingURL=texture.js.map

package/lib/commonjs/mol-gl/webgl/uniform.js

@@ -109,4 +109,3 @@ function cloneUniformValues(uniformValues) {
     return clonedValues;
 }
 exports.cloneUniformValues = cloneUniformValues;
-//# sourceMappingURL=uniform.js.map

package/lib/commonjs/mol-gl/webgl/vertex-array.js

@@ -66,4 +66,3 @@ function createVertexArray(gl, extensions, program, attributeBuffers, elementsBu
     };
 }
 exports.createVertexArray = createVertexArray;
-//# sourceMappingURL=vertex-array.js.map

package/lib/commonjs/mol-io/common/ascii.js

@@ -12,4 +12,3 @@ function asciiWrite(data, str) {
     }
 }
 exports.asciiWrite = asciiWrite;
-//# sourceMappingURL=ascii.js.map