molstar 3.0.1 → 3.0.2

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

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * Slightly adapted from https://github.com/mrdoob/three.js
+ * MIT License Copyright (c) 2010-2020 three.js authors
+ *
+ * WebGL port of Subpixel Morphological Antialiasing (SMAA) v2.8
+ * Preset: SMAA 1x Medium (with color edge detection)
+ * https://github.com/iryoku/smaa/releases/tag/v2.8
+ */
+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.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Slightly adapted from https://github.com/mrdoob/three.js
+ * MIT License Copyright (c) 2010-2020 three.js authors
+ *
+ * WebGL port of Subpixel Morphological Antialiasing (SMAA) v2.8
+ * Preset: SMAA 1x Medium (with color edge detection)
+ * https://github.com/iryoku/smaa/releases/tag/v2.8
+ */
+export declare const 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";

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

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * Slightly adapted from https://github.com/mrdoob/three.js
+ * MIT License Copyright (c) 2010-2020 three.js authors
+ *
+ * WebGL port of Subpixel Morphological Antialiasing (SMAA) v2.8
+ * Preset: SMAA 1x Medium (with color edge detection)
+ * https://github.com/iryoku/smaa/releases/tag/v2.8
+ */
+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.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Slightly adapted from https://github.com/mrdoob/three.js
+ * MIT License Copyright (c) 2010-2020 three.js authors
+ *
+ * WebGL port of Subpixel Morphological Antialiasing (SMAA) v2.8
+ * Preset: SMAA 1x Medium (with color edge detection)
+ * https://github.com/iryoku/smaa/releases/tag/v2.8
+ */
+export declare const 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";

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

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * Slightly adapted from https://github.com/mrdoob/three.js
+ * MIT License Copyright (c) 2010-2020 three.js authors
+ *
+ * WebGL port of Subpixel Morphological Antialiasing (SMAA) v2.8
+ * Preset: SMAA 1x Medium (with color edge detection)
+ * https://github.com/iryoku/smaa/releases/tag/v2.8
+ */
+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.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Slightly adapted from https://github.com/mrdoob/three.js
+ * MIT License Copyright (c) 2010-2020 three.js authors
+ *
+ * WebGL port of Subpixel Morphological Antialiasing (SMAA) v2.8
+ * Preset: SMAA 1x Medium (with color edge detection)
+ * https://github.com/iryoku/smaa/releases/tag/v2.8
+ */
+export declare const 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";

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

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * Slightly adapted from https://github.com/mrdoob/three.js
+ * MIT License Copyright (c) 2010-2020 three.js authors
+ *
+ * WebGL port of Subpixel Morphological Antialiasing (SMAA) v2.8
+ * Preset: SMAA 1x Medium (with color edge detection)
+ * https://github.com/iryoku/smaa/releases/tag/v2.8
+ */
+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.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Slightly adapted from https://github.com/mrdoob/three.js
+ * MIT License Copyright (c) 2010-2020 three.js authors
+ *
+ * WebGL port of Subpixel Morphological Antialiasing (SMAA) v2.8
+ * Preset: SMAA 1x Medium (with color edge detection)
+ * https://github.com/iryoku/smaa/releases/tag/v2.8
+ */
+export declare const 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";

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

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * Slightly adapted from https://github.com/mrdoob/three.js
+ * MIT License Copyright (c) 2010-2020 three.js authors
+ *
+ * WebGL port of Subpixel Morphological Antialiasing (SMAA) v2.8
+ * Preset: SMAA 1x Medium (with color edge detection)
+ * https://github.com/iryoku/smaa/releases/tag/v2.8
+ */
+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.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copyright (c) 2019-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+export declare const 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        #ifdef dIgnoreLight\n            gl_FragColor = material;\n        #else\n            vec3 normal = -cameraNormal;\n            #include apply_light_color\n        #endif\n\n        #include apply_interior_color\n        #include apply_marker_color\n        #include apply_fog\n        #include wboit_write\n    #endif\n}\n";

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

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Copyright (c) 2019-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+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        #ifdef dIgnoreLight\n            gl_FragColor = material;\n        #else\n            vec3 normal = -cameraNormal;\n            #include apply_light_color\n        #endif\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.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copyright (c) 2019-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+export declare const 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";

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

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Copyright (c) 2019-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+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.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) 2019-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Áron Samuel Kovács <aron.kovacs@mail.muni.cz>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+export declare const 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";

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

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * Copyright (c) 2019-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Áron Samuel Kovács <aron.kovacs@mail.muni.cz>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+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.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) 2019-2021 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 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";

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

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * Copyright (c) 2019-2021 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.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.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copyright (c) 2019-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+export declare const 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";

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

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Copyright (c) 2019-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+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.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copyright (c) 2019-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+export declare const 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";

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

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Copyright (c) 2019-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+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.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+export declare const 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";

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

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+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.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2018-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { ValueCell } from '../mol-util';
+import { WebGLExtensions } from './webgl/extensions';
+import { GLRenderingContext } from './webgl/compat';
+export declare type DefineKind = 'boolean' | 'string' | 'number';
+export declare type DefineType = boolean | string;
+export declare type DefineValues = {
+    [k: string]: ValueCell<DefineType>;
+};
+declare type ShaderExtensionsValue = 'required' | 'optional';
+export interface ShaderExtensions {
+    readonly fragDepth?: ShaderExtensionsValue;
+    readonly drawBuffers?: ShaderExtensionsValue;
+    readonly shaderTextureLod?: ShaderExtensionsValue;
+}
+declare type FragOutTypes = {
+    [k in number]: 'vec4' | 'ivec4';
+};
+declare type IgnoreDefine = (name: string, variant: string, defines: ShaderDefines) => boolean;
+export interface ShaderCode {
+    readonly id: number;
+    readonly name: string;
+    readonly vert: string;
+    readonly frag: string;
+    readonly extensions: ShaderExtensions;
+    /** Fragment shader output type only applicable for webgl2 */
+    readonly outTypes: FragOutTypes;
+    readonly ignoreDefine?: IgnoreDefine;
+}
+export declare function ShaderCode(name: string, vert: string, frag: string, extensions?: ShaderExtensions, outTypes?: FragOutTypes, ignoreDefine?: IgnoreDefine): ShaderCode;
+export declare const PointsShaderCode: ShaderCode;
+export declare const SpheresShaderCode: ShaderCode;
+export declare const CylindersShaderCode: ShaderCode;
+export declare const TextShaderCode: ShaderCode;
+export declare const LinesShaderCode: ShaderCode;
+export declare const MeshShaderCode: ShaderCode;
+export declare const DirectVolumeShaderCode: ShaderCode;
+export declare const ImageShaderCode: ShaderCode;
+export declare type ShaderDefines = {
+    [k: string]: ValueCell<DefineType>;
+};
+export declare function addShaderDefines(gl: GLRenderingContext, extensions: WebGLExtensions, defines: ShaderDefines, shaders: ShaderCode): ShaderCode;
+export {};