npm - molstar - Versions diffs - 3.0.2 → 3.3.0 - Mend

molstar 3.0.2 → 3.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2351) hide show

package/lib/mol-gl/shader/direct-volume.frag.d.ts CHANGED Viewed

@@ -1,7 +1,7 @@
 /**
- * Copyright (c) 2017-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2017-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  * @author Michael Krone <michael.krone@uni-tuebingen.de>
  */
-export declare const directVolume_frag = "\nprecision highp float;\nprecision highp int;\n\n#include common\n#include light_frag_params\n\n#if dClipObjectCount != 0\n    uniform int uClipObjectType[dClipObjectCount];\n    uniform bool uClipObjectInvert[dClipObjectCount];\n    uniform vec3 uClipObjectPosition[dClipObjectCount];\n    uniform vec4 uClipObjectRotation[dClipObjectCount];\n    uniform vec3 uClipObjectScale[dClipObjectCount];\n#endif\n#include common_clip\n\n#include read_from_texture\n#include texture3d_from_1d_trilinear\n#include texture3d_from_2d_nearest\n#include texture3d_from_2d_linear\n\nuniform mat4 uProjection, uTransform, uModelView, uModel, uView;\nuniform vec3 uCameraDir;\n\nuniform sampler2D tDepth;\nuniform vec2 uDrawingBufferSize;\n\nvarying vec3 vOrigPos;\nvarying float vInstance;\nvarying vec4 vBoundingSphere;\nvarying mat4 vTransform;\n\nuniform mat4 uInvView;\nuniform vec3 uGridDim;\nuniform vec3 uBboxSize;\nuniform sampler2D tTransferTex;\nuniform float uTransferScale;\nuniform float uStepScale;\nuniform float uJumpLength;\n\nuniform int uObjectId;\nuniform int uVertexCount;\nuniform int uInstanceCount;\nuniform int uGroupCount;\n\nuniform vec3 uHighlightColor;\nuniform vec3 uSelectColor;\nuniform float uHighlightStrength;\nuniform float uSelectStrength;\nuniform int uMarkerPriority;\n\nuniform float uMarker;\nuniform vec2 uMarkerTexDim;\nuniform sampler2D tMarker;\n\nuniform float uMetalness;\nuniform float uRoughness;\n\nuniform float uFogNear;\nuniform float uFogFar;\nuniform vec3 uFogColor;\n\nuniform float uAlpha;\nuniform float uPickingAlphaThreshold;\nuniform bool uTransparentBackground;\nuniform float uXrayEdgeFalloff;\n\nuniform float uInteriorDarkening;\nuniform bool uInteriorColorFlag;\nuniform vec3 uInteriorColor;\n\nuniform bool uRenderWboit;\nuniform bool uDoubleSided;\n\nuniform float uNear;\nuniform float uFar;\nuniform float uIsOrtho;\n\nuniform vec3 uCellDim;\nuniform vec3 uCameraPosition;\nuniform mat4 uCartnToUnit;\n\n#if __VERSION__ != 100\n    // for webgl1 this is given as a 'define'\n    uniform int uMaxSteps;\n#endif\n\n#if defined(dGridTexType_2d)\n    precision highp sampler2D;\n    uniform sampler2D tGridTex;\n    uniform vec3 uGridTexDim;\n#elif defined(dGridTexType_3d)\n    precision highp sampler3D;\n    uniform sampler3D tGridTex;\n#endif\n\n#if defined(dColorType_uniform)\n    uniform vec3 uColor;\n#elif defined(dColorType_texture)\n    uniform vec2 uColorTexDim;\n    uniform sampler2D tColor;\n#endif\n\n#ifdef dOverpaint\n    #if defined(dOverpaintType_groupInstance) || defined(dOverpaintType_vertexInstance)\n        uniform vec2 uOverpaintTexDim;\n        uniform sampler2D tOverpaint;\n    #endif\n#endif\n\n#ifdef dUsePalette\n    uniform sampler2D tPalette;\n#endif\n\n#if defined(dGridTexType_2d)\n    vec4 textureVal(vec3 pos) {\n        return texture3dFrom2dLinear(tGridTex, pos + (vec3(0.5, 0.5, 0.0) / uGridDim), uGridDim, uGridTexDim.xy);\n    }\n    vec4 textureGroup(vec3 pos) {\n        return texture3dFrom2dNearest(tGridTex, pos + (vec3(0.5, 0.5, 0.0) / uGridDim), uGridDim, uGridTexDim.xy);\n    }\n#elif defined(dGridTexType_3d)\n    vec4 textureVal(vec3 pos) {\n        return texture(tGridTex, pos + (vec3(0.5) / uGridDim));\n    }\n    vec4 textureGroup(vec3 pos) {\n        return texelFetch(tGridTex, ivec3(pos * uGridDim), 0);\n    }\n#endif\n\nfloat calcDepth(const in vec3 pos) {\n    vec2 clipZW = pos.z * uProjection[2].zw + uProjection[3].zw;\n    return 0.5 + 0.5 * clipZW.x / clipZW.y;\n}\n\nfloat transferFunction(float value) {\n    return texture2D(tTransferTex, vec2(value, 0.0)).a;\n}\n\nfloat getDepth(const in vec2 coords) {\n    #ifdef depthTextureSupport\n        if (!uRenderWboit) {\n            // in case of opaque volumes (and depth texture support)\n            return texture2D(tDepth, coords).r;\n        } else {\n            return unpackRGBAToDepth(texture2D(tDepth, coords));\n        }\n    #else\n        return unpackRGBAToDepth(texture2D(tDepth, coords));\n    #endif\n}\n\nconst float gradOffset = 0.5;\n\nvec3 v3m4(vec3 p, mat4 m) {\n    return (m * vec4(p, 1.0)).xyz;\n}\n\nfloat preFogAlphaBlended = 0.0;\n\nvec4 raymarch(vec3 startLoc, vec3 step, vec3 rayDir) {\n    #if !defined(dIgnoreLight)\n        mat3 normalMatrix = transpose3(inverse3(mat3(uModelView * vTransform)));\n    #endif\n    mat4 cartnToUnit = uCartnToUnit * inverse4(vTransform);\n    #if defined(dClipVariant_pixel) && dClipObjectCount != 0\n        mat4 modelTransform = uModel * vTransform * uTransform;\n    #endif\n    mat4 modelViewTransform = uModelView * vTransform * uTransform;\n\n    vec3 scaleVol = vec3(1.0) / uGridDim;\n    vec3 pos = startLoc;\n    vec4 cell;\n    float prevValue = -1.0;\n    float value = 0.0;\n    vec4 src = vec4(0.0);\n    vec4 dst = vec4(0.0);\n    float fragmentDepth;\n\n    vec3 posMin = vec3(0.0);\n    vec3 posMax = vec3(1.0) - vec3(1.0) / uGridDim;\n\n    vec3 unitPos;\n\n    vec3 nextPos;\n    float nextValue;\n\n    vec4 material;\n    vec4 overpaint;\n    float metalness = uMetalness;\n    float roughness = uRoughness;\n\n    vec3 gradient = vec3(1.0);\n    vec3 dx = vec3(gradOffset * scaleVol.x, 0.0, 0.0);\n    vec3 dy = vec3(0.0, gradOffset * scaleVol.y, 0.0);\n    vec3 dz = vec3(0.0, 0.0, gradOffset * scaleVol.z);\n\n    float maxDist = min(vBoundingSphere.w * 2.0, uFar - uNear);\n    float maxDistSq = maxDist * maxDist;\n\n    for (int i = 0; i < uMaxSteps; ++i) {\n        // break when beyond bounding-sphere or far-plane\n        vec3 distVec = startLoc - pos;\n        if (dot(distVec, distVec) > maxDistSq) break;\n\n        unitPos = v3m4(pos, cartnToUnit);\n\n        // continue when outside of grid\n        if (unitPos.x > posMax.x || unitPos.y > posMax.y || unitPos.z > posMax.z ||\n            unitPos.x < posMin.x || unitPos.y < posMin.y || unitPos.z < posMin.z\n        ) {\n            prevValue = value;\n            pos += step;\n            continue;\n        }\n\n        cell = textureVal(unitPos);\n        value = cell.a; // current voxel value\n\n        if (uJumpLength > 0.0 && value < 0.01) {\n            nextPos = pos + rayDir * uJumpLength;\n            nextValue = textureVal(v3m4(nextPos, cartnToUnit)).a;\n            if (nextValue < 0.01) {\n                prevValue = nextValue;\n                pos = nextPos;\n                continue;\n            }\n        }\n\n        vec4 mvPosition = modelViewTransform * vec4(unitPos * uGridDim, 1.0);\n        if (calcDepth(mvPosition.xyz) > getDepth(gl_FragCoord.xy / uDrawingBufferSize))\n            break;\n\n        #if defined(dClipVariant_pixel) && dClipObjectCount != 0\n            vec3 vModelPosition = v3m4(unitPos * uGridDim, modelTransform);\n            if (clipTest(vec4(vModelPosition, 0.0), 0)) {\n                prevValue = value;\n                pos += step;\n                continue;\n            }\n        #endif\n\n        vec3 vViewPosition = mvPosition.xyz;\n        material.a = transferFunction(value);\n\n        #ifdef dPackedGroup\n            float group = unpackRGBToInt(textureGroup(floor(unitPos * uGridDim + 0.5) / uGridDim).rgb);\n        #else\n            vec3 g = floor(unitPos * uGridDim + 0.5);\n            // note that we swap x and z because the texture is flipped around y\n            #if defined(dAxisOrder_012)\n                float group = g.z + g.y * uGridDim.z + g.x * uGridDim.z * uGridDim.y; // 210\n            #elif defined(dAxisOrder_021)\n                float group = g.y + g.z * uGridDim.y + g.x * uGridDim.y * uGridDim.z; // 120\n            #elif defined(dAxisOrder_102)\n                float group = g.z + g.x * uGridDim.z + g.y * uGridDim.z * uGridDim.x; // 201\n            #elif defined(dAxisOrder_120)\n                float group = g.x + g.z * uGridDim.x + g.y * uGridDim.x * uGridDim.z; // 021\n            #elif defined(dAxisOrder_201)\n                float group = g.y + g.x * uGridDim.y + g.z * uGridDim.y * uGridDim.x; // 102\n            #elif defined(dAxisOrder_210)\n                float group = g.x + g.y * uGridDim.x + g.z * uGridDim.x * uGridDim.y; // 012\n            #endif\n        #endif\n\n        #if defined(dColorType_direct) && defined(dUsePalette)\n            material.rgb = texture2D(tPalette, vec2(value, 0.0)).rgb;\n        #elif defined(dColorType_uniform)\n            material.rgb = uColor;\n        #elif defined(dColorType_instance)\n            material.rgb = readFromTexture(tColor, vInstance, uColorTexDim).rgb;\n        #elif defined(dColorType_group)\n            material.rgb = readFromTexture(tColor, group, uColorTexDim).rgb;\n        #elif defined(dColorType_groupInstance)\n            material.rgb = readFromTexture(tColor, vInstance * float(uGroupCount) + group, uColorTexDim).rgb;\n        #elif defined(dColorType_vertex)\n            material.rgb = texture3dFrom1dTrilinear(tColor, isoPos, uGridDim, uColorTexDim, 0.0).rgb;\n        #elif defined(dColorType_vertexInstance)\n            material.rgb = texture3dFrom1dTrilinear(tColor, isoPos, uGridDim, uColorTexDim, vInstance * float(uVertexCount)).rgb;\n        #endif\n\n        #ifdef dOverpaint\n            #if defined(dOverpaintType_groupInstance)\n                overpaint = readFromTexture(tOverpaint, vInstance * float(uGroupCount) + group, uOverpaintTexDim);\n            #elif defined(dOverpaintType_vertexInstance)\n                overpaint = texture3dFrom1dTrilinear(tOverpaint, isoPos, uGridDim, uOverpaintTexDim, vInstance * float(uVertexCount));\n            #endif\n\n            material.rgb = mix(material.rgb, overpaint.rgb, overpaint.a);\n        #endif\n\n        #ifdef dIgnoreLight\n            gl_FragColor.rgb = material.rgb;\n        #else\n            if (material.a >= 0.01) {\n                #ifdef dPackedGroup\n                    // compute gradient by central differences\n                    gradient.x = textureVal(unitPos - dx).a - textureVal(unitPos + dx).a;\n                    gradient.y = textureVal(unitPos - dy).a - textureVal(unitPos + dy).a;\n                    gradient.z = textureVal(unitPos - dz).a - textureVal(unitPos + dz).a;\n                #else\n                    gradient = cell.xyz * 2.0 - 1.0;\n                #endif\n                vec3 normal = -normalize(normalMatrix * normalize(gradient));\n                #include apply_light_color\n            } else {\n                gl_FragColor.rgb = material.rgb;\n            }\n        #endif\n\n        gl_FragColor.a = material.a * uAlpha * uTransferScale;\n\n        float marker = uMarker;\n        if (uMarker == -1.0) {\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        #include apply_marker_color\n\n        preFogAlphaBlended = (1.0 - preFogAlphaBlended) * gl_FragColor.a + preFogAlphaBlended;\n        fragmentDepth = calcDepth(mvPosition.xyz);\n        #include apply_fog\n\n        src = gl_FragColor;\n\n        if (!uTransparentBackground) {\n            // done in 'apply_fog' otherwise\n            src.rgb *= src.a;\n        }\n        dst = (1.0 - dst.a) * src + dst; // standard blending\n\n        // break if the color is opaque enough\n        if (dst.a > 0.95)\n            break;\n\n        pos += step;\n    }\n\n    return dst;\n}\n\n// TODO: support float texture for higher precision values???\n// TODO: support clipping exclusion texture support\n\nvoid main() {\n    if (gl_FrontFacing)\n        discard;\n\n    vec3 rayDir = mix(normalize(vOrigPos - uCameraPosition), uCameraDir, uIsOrtho);\n    vec3 step = rayDir * uStepScale;\n\n    float boundingSphereNear = distance(vBoundingSphere.xyz, uCameraPosition) - vBoundingSphere.w;\n    float d = max(uNear, boundingSphereNear) - mix(0.0, distance(vOrigPos, uCameraPosition), uIsOrtho);\n    vec3 start = mix(uCameraPosition, vOrigPos, uIsOrtho) + (d * rayDir);\n    gl_FragColor = raymarch(start, step, rayDir);\n\n    float fragmentDepth = calcDepth((uModelView * vec4(start, 1.0)).xyz);\n    float preFogAlpha = clamp(preFogAlphaBlended, 0.0, 1.0);\n    bool interior = false;\n    #include wboit_write\n}\n";
+export declare const directVolume_frag = "\nprecision highp float;\nprecision highp int;\n\n#include common\n#include light_frag_params\n\n#if dClipObjectCount != 0\n    uniform int uClipObjectType[dClipObjectCount];\n    uniform bool uClipObjectInvert[dClipObjectCount];\n    uniform vec3 uClipObjectPosition[dClipObjectCount];\n    uniform vec4 uClipObjectRotation[dClipObjectCount];\n    uniform vec3 uClipObjectScale[dClipObjectCount];\n#endif\n#include common_clip\n\n#include read_from_texture\n#include texture3d_from_1d_trilinear\n#include texture3d_from_2d_nearest\n#include texture3d_from_2d_linear\n\nuniform mat4 uProjection, uTransform, uModelView, uModel, uView;\nuniform vec3 uCameraDir;\n\nuniform sampler2D tDepth;\nuniform vec2 uDrawingBufferSize;\n\nvarying vec3 vOrigPos;\nvarying float vInstance;\nvarying vec4 vBoundingSphere;\nvarying mat4 vTransform;\n\nuniform mat4 uInvView;\nuniform vec3 uGridDim;\nuniform vec3 uBboxSize;\nuniform sampler2D tTransferTex;\nuniform float uTransferScale;\nuniform float uStepScale;\nuniform float uJumpLength;\n\nuniform int uObjectId;\nuniform int uVertexCount;\nuniform int uInstanceCount;\nuniform int uGroupCount;\n\nuniform vec3 uHighlightColor;\nuniform vec3 uSelectColor;\nuniform float uHighlightStrength;\nuniform float uSelectStrength;\nuniform int uMarkerPriority;\n\nuniform float uMarker;\nuniform vec2 uMarkerTexDim;\nuniform sampler2D tMarker;\n\nuniform float uMetalness;\nuniform float uRoughness;\n\nuniform float uFogNear;\nuniform float uFogFar;\nuniform vec3 uFogColor;\n\nuniform float uAlpha;\nuniform float uPickingAlphaThreshold;\nuniform bool uTransparentBackground;\nuniform float uXrayEdgeFalloff;\n\nuniform float uInteriorDarkening;\nuniform bool uInteriorColorFlag;\nuniform vec3 uInteriorColor;\n\nuniform bool uRenderWboit;\nuniform bool uDoubleSided;\n\nuniform float uNear;\nuniform float uFar;\nuniform float uIsOrtho;\n\nuniform vec3 uCellDim;\nuniform vec3 uCameraPosition;\nuniform mat4 uCartnToUnit;\n\n#if __VERSION__ != 100\n    // for webgl1 this is given as a 'define'\n    uniform int uMaxSteps;\n#endif\n\n#if defined(dGridTexType_2d)\n    precision highp sampler2D;\n    uniform sampler2D tGridTex;\n    uniform vec3 uGridTexDim;\n#elif defined(dGridTexType_3d)\n    precision highp sampler3D;\n    uniform sampler3D tGridTex;\n#endif\n\n#if defined(dColorType_uniform)\n    uniform vec3 uColor;\n#elif defined(dColorType_texture)\n    uniform vec2 uColorTexDim;\n    uniform sampler2D tColor;\n#endif\n\n#ifdef dOverpaint\n    #if defined(dOverpaintType_groupInstance) || defined(dOverpaintType_vertexInstance)\n        uniform vec2 uOverpaintTexDim;\n        uniform sampler2D tOverpaint;\n    #endif\n#endif\n\n#ifdef dUsePalette\n    uniform sampler2D tPalette;\n#endif\n\n#if defined(dGridTexType_2d)\n    vec4 textureVal(vec3 pos) {\n        return texture3dFrom2dLinear(tGridTex, pos + (vec3(0.5, 0.5, 0.0) / uGridDim), uGridDim, uGridTexDim.xy);\n    }\n    vec4 textureGroup(vec3 pos) {\n        return texture3dFrom2dNearest(tGridTex, pos + (vec3(0.5, 0.5, 0.0) / uGridDim), uGridDim, uGridTexDim.xy);\n    }\n#elif defined(dGridTexType_3d)\n    vec4 textureVal(vec3 pos) {\n        return texture(tGridTex, pos + (vec3(0.5) / uGridDim));\n    }\n    vec4 textureGroup(vec3 pos) {\n        return texelFetch(tGridTex, ivec3(pos * uGridDim), 0);\n    }\n#endif\n\nfloat calcDepth(const in vec3 pos) {\n    vec2 clipZW = pos.z * uProjection[2].zw + uProjection[3].zw;\n    return 0.5 + 0.5 * clipZW.x / clipZW.y;\n}\n\nfloat transferFunction(float value) {\n    return texture2D(tTransferTex, vec2(value, 0.0)).a;\n}\n\nfloat getDepth(const in vec2 coords) {\n    #ifdef depthTextureSupport\n        if (!uRenderWboit) {\n            // in case of opaque volumes (and depth texture support)\n            return texture2D(tDepth, coords).r;\n        } else {\n            return unpackRGBAToDepth(texture2D(tDepth, coords));\n        }\n    #else\n        return unpackRGBAToDepth(texture2D(tDepth, coords));\n    #endif\n}\n\nconst float gradOffset = 0.5;\n\nvec3 v3m4(vec3 p, mat4 m) {\n    return (m * vec4(p, 1.0)).xyz;\n}\n\nfloat preFogAlphaBlended = 0.0;\n\nvec4 raymarch(vec3 startLoc, vec3 step, vec3 rayDir) {\n    mat3 normalMatrix = transpose3(inverse3(mat3(uModelView * vTransform)));\n    mat4 cartnToUnit = uCartnToUnit * inverse4(vTransform);\n    #if defined(dClipVariant_pixel) && dClipObjectCount != 0\n        mat4 modelTransform = uModel * vTransform * uTransform;\n    #endif\n    mat4 modelViewTransform = uModelView * vTransform * uTransform;\n\n    vec3 scaleVol = vec3(1.0) / uGridDim;\n    vec3 pos = startLoc;\n    vec4 cell;\n    float prevValue = -1.0;\n    float value = 0.0;\n    vec4 src = vec4(0.0);\n    vec4 dst = vec4(0.0);\n    float fragmentDepth;\n\n    vec3 posMin = vec3(0.0);\n    vec3 posMax = vec3(1.0) - vec3(1.0) / uGridDim;\n\n    vec3 unitPos;\n\n    vec3 nextPos;\n    float nextValue;\n\n    vec4 material;\n    vec4 overpaint;\n    float metalness = uMetalness;\n    float roughness = uRoughness;\n\n    vec3 gradient = vec3(1.0);\n    vec3 dx = vec3(gradOffset * scaleVol.x, 0.0, 0.0);\n    vec3 dy = vec3(0.0, gradOffset * scaleVol.y, 0.0);\n    vec3 dz = vec3(0.0, 0.0, gradOffset * scaleVol.z);\n\n    float maxDist = min(vBoundingSphere.w * 2.0, uFar - uNear);\n    float maxDistSq = maxDist * maxDist;\n\n    for (int i = 0; i < uMaxSteps; ++i) {\n        // break when beyond bounding-sphere or far-plane\n        vec3 distVec = startLoc - pos;\n        if (dot(distVec, distVec) > maxDistSq) break;\n\n        unitPos = v3m4(pos, cartnToUnit);\n\n        // continue when outside of grid\n        if (unitPos.x > posMax.x || unitPos.y > posMax.y || unitPos.z > posMax.z ||\n            unitPos.x < posMin.x || unitPos.y < posMin.y || unitPos.z < posMin.z\n        ) {\n            prevValue = value;\n            pos += step;\n            continue;\n        }\n\n        cell = textureVal(unitPos);\n        value = cell.a; // current voxel value\n\n        if (uJumpLength > 0.0 && value < 0.01) {\n            nextPos = pos + rayDir * uJumpLength;\n            nextValue = textureVal(v3m4(nextPos, cartnToUnit)).a;\n            if (nextValue < 0.01) {\n                prevValue = nextValue;\n                pos = nextPos;\n                continue;\n            }\n        }\n\n        vec4 mvPosition = modelViewTransform * vec4(unitPos * uGridDim, 1.0);\n        if (calcDepth(mvPosition.xyz) > getDepth(gl_FragCoord.xy / uDrawingBufferSize))\n            break;\n\n        #if defined(dClipVariant_pixel) && dClipObjectCount != 0\n            vec3 vModelPosition = v3m4(unitPos * uGridDim, modelTransform);\n            if (clipTest(vec4(vModelPosition, 0.0), 0)) {\n                prevValue = value;\n                pos += step;\n                continue;\n            }\n        #endif\n\n        vec3 vViewPosition = mvPosition.xyz;\n        material.a = transferFunction(value);\n\n        #ifdef dPackedGroup\n            float group = unpackRGBToInt(textureGroup(floor(unitPos * uGridDim + 0.5) / uGridDim).rgb);\n        #else\n            vec3 g = floor(unitPos * uGridDim + 0.5);\n            // note that we swap x and z because the texture is flipped around y\n            #if defined(dAxisOrder_012)\n                float group = g.z + g.y * uGridDim.z + g.x * uGridDim.z * uGridDim.y; // 210\n            #elif defined(dAxisOrder_021)\n                float group = g.y + g.z * uGridDim.y + g.x * uGridDim.y * uGridDim.z; // 120\n            #elif defined(dAxisOrder_102)\n                float group = g.z + g.x * uGridDim.z + g.y * uGridDim.z * uGridDim.x; // 201\n            #elif defined(dAxisOrder_120)\n                float group = g.x + g.z * uGridDim.x + g.y * uGridDim.x * uGridDim.z; // 021\n            #elif defined(dAxisOrder_201)\n                float group = g.y + g.x * uGridDim.y + g.z * uGridDim.y * uGridDim.x; // 102\n            #elif defined(dAxisOrder_210)\n                float group = g.x + g.y * uGridDim.x + g.z * uGridDim.x * uGridDim.y; // 012\n            #endif\n        #endif\n\n        #if defined(dColorType_direct) && defined(dUsePalette)\n            material.rgb = texture2D(tPalette, vec2(value, 0.0)).rgb;\n        #elif defined(dColorType_uniform)\n            material.rgb = uColor;\n        #elif defined(dColorType_instance)\n            material.rgb = readFromTexture(tColor, vInstance, uColorTexDim).rgb;\n        #elif defined(dColorType_group)\n            material.rgb = readFromTexture(tColor, group, uColorTexDim).rgb;\n        #elif defined(dColorType_groupInstance)\n            material.rgb = readFromTexture(tColor, vInstance * float(uGroupCount) + group, uColorTexDim).rgb;\n        #elif defined(dColorType_vertex)\n            material.rgb = texture3dFrom1dTrilinear(tColor, isoPos, uGridDim, uColorTexDim, 0.0).rgb;\n        #elif defined(dColorType_vertexInstance)\n            material.rgb = texture3dFrom1dTrilinear(tColor, isoPos, uGridDim, uColorTexDim, vInstance * float(uVertexCount)).rgb;\n        #endif\n\n        #ifdef dOverpaint\n            #if defined(dOverpaintType_groupInstance)\n                overpaint = readFromTexture(tOverpaint, vInstance * float(uGroupCount) + group, uOverpaintTexDim);\n            #elif defined(dOverpaintType_vertexInstance)\n                overpaint = texture3dFrom1dTrilinear(tOverpaint, isoPos, uGridDim, uOverpaintTexDim, vInstance * float(uVertexCount));\n            #endif\n\n            material.rgb = mix(material.rgb, overpaint.rgb, overpaint.a);\n        #endif\n\n        if (material.a >= 0.01) {\n            #ifdef dPackedGroup\n                // compute gradient by central differences\n                gradient.x = textureVal(unitPos - dx).a - textureVal(unitPos + dx).a;\n                gradient.y = textureVal(unitPos - dy).a - textureVal(unitPos + dy).a;\n                gradient.z = textureVal(unitPos - dz).a - textureVal(unitPos + dz).a;\n            #else\n                gradient = cell.xyz * 2.0 - 1.0;\n            #endif\n            vec3 normal = -normalize(normalMatrix * normalize(gradient));\n            #include apply_light_color\n        } else {\n            gl_FragColor.rgb = material.rgb;\n        }\n\n        gl_FragColor.a = material.a * uAlpha * uTransferScale;\n\n        float marker = uMarker;\n        if (uMarker == -1.0) {\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        #include apply_marker_color\n\n        preFogAlphaBlended = (1.0 - preFogAlphaBlended) * gl_FragColor.a + preFogAlphaBlended;\n        fragmentDepth = calcDepth(mvPosition.xyz);\n        #include apply_fog\n\n        src = gl_FragColor;\n\n        if (!uTransparentBackground) {\n            // done in 'apply_fog' otherwise\n            src.rgb *= src.a;\n        }\n        dst = (1.0 - dst.a) * src + dst; // standard blending\n\n        // break if the color is opaque enough\n        if (dst.a > 0.95)\n            break;\n\n        pos += step;\n    }\n\n    return dst;\n}\n\n// TODO: support float texture for higher precision values???\n// TODO: support clipping exclusion texture support\n\nvoid main() {\n    if (gl_FrontFacing)\n        discard;\n\n    vec3 rayDir = mix(normalize(vOrigPos - uCameraPosition), uCameraDir, uIsOrtho);\n    vec3 step = rayDir * uStepScale;\n\n    float boundingSphereNear = distance(vBoundingSphere.xyz, uCameraPosition) - vBoundingSphere.w;\n    float d = max(uNear, boundingSphereNear) - mix(0.0, distance(vOrigPos, uCameraPosition), uIsOrtho);\n    vec3 start = mix(uCameraPosition, vOrigPos, uIsOrtho) + (d * rayDir);\n    gl_FragColor = raymarch(start, step, rayDir);\n\n    float fragmentDepth = calcDepth((uModelView * vec4(start, 1.0)).xyz);\n    float preFogAlpha = clamp(preFogAlphaBlended, 0.0, 1.0);\n    bool interior = false;\n    #include wboit_write\n}\n";

package/lib/mol-gl/shader/direct-volume.frag.js CHANGED Viewed

@@ -1,8 +1,7 @@
 /**
- * Copyright (c) 2017-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2017-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  * @author Michael Krone <michael.krone@uni-tuebingen.de>
  */
-export var directVolume_frag = "\nprecision highp float;\nprecision highp int;\n\n#include common\n#include light_frag_params\n\n#if dClipObjectCount != 0\n    uniform int uClipObjectType[dClipObjectCount];\n    uniform bool uClipObjectInvert[dClipObjectCount];\n    uniform vec3 uClipObjectPosition[dClipObjectCount];\n    uniform vec4 uClipObjectRotation[dClipObjectCount];\n    uniform vec3 uClipObjectScale[dClipObjectCount];\n#endif\n#include common_clip\n\n#include read_from_texture\n#include texture3d_from_1d_trilinear\n#include texture3d_from_2d_nearest\n#include texture3d_from_2d_linear\n\nuniform mat4 uProjection, uTransform, uModelView, uModel, uView;\nuniform vec3 uCameraDir;\n\nuniform sampler2D tDepth;\nuniform vec2 uDrawingBufferSize;\n\nvarying vec3 vOrigPos;\nvarying float vInstance;\nvarying vec4 vBoundingSphere;\nvarying mat4 vTransform;\n\nuniform mat4 uInvView;\nuniform vec3 uGridDim;\nuniform vec3 uBboxSize;\nuniform sampler2D tTransferTex;\nuniform float uTransferScale;\nuniform float uStepScale;\nuniform float uJumpLength;\n\nuniform int uObjectId;\nuniform int uVertexCount;\nuniform int uInstanceCount;\nuniform int uGroupCount;\n\nuniform vec3 uHighlightColor;\nuniform vec3 uSelectColor;\nuniform float uHighlightStrength;\nuniform float uSelectStrength;\nuniform int uMarkerPriority;\n\nuniform float uMarker;\nuniform vec2 uMarkerTexDim;\nuniform sampler2D tMarker;\n\nuniform float uMetalness;\nuniform float uRoughness;\n\nuniform float uFogNear;\nuniform float uFogFar;\nuniform vec3 uFogColor;\n\nuniform float uAlpha;\nuniform float uPickingAlphaThreshold;\nuniform bool uTransparentBackground;\nuniform float uXrayEdgeFalloff;\n\nuniform float uInteriorDarkening;\nuniform bool uInteriorColorFlag;\nuniform vec3 uInteriorColor;\n\nuniform bool uRenderWboit;\nuniform bool uDoubleSided;\n\nuniform float uNear;\nuniform float uFar;\nuniform float uIsOrtho;\n\nuniform vec3 uCellDim;\nuniform vec3 uCameraPosition;\nuniform mat4 uCartnToUnit;\n\n#if __VERSION__ != 100\n    // for webgl1 this is given as a 'define'\n    uniform int uMaxSteps;\n#endif\n\n#if defined(dGridTexType_2d)\n    precision highp sampler2D;\n    uniform sampler2D tGridTex;\n    uniform vec3 uGridTexDim;\n#elif defined(dGridTexType_3d)\n    precision highp sampler3D;\n    uniform sampler3D tGridTex;\n#endif\n\n#if defined(dColorType_uniform)\n    uniform vec3 uColor;\n#elif defined(dColorType_texture)\n    uniform vec2 uColorTexDim;\n    uniform sampler2D tColor;\n#endif\n\n#ifdef dOverpaint\n    #if defined(dOverpaintType_groupInstance) || defined(dOverpaintType_vertexInstance)\n        uniform vec2 uOverpaintTexDim;\n        uniform sampler2D tOverpaint;\n    #endif\n#endif\n\n#ifdef dUsePalette\n    uniform sampler2D tPalette;\n#endif\n\n#if defined(dGridTexType_2d)\n    vec4 textureVal(vec3 pos) {\n        return texture3dFrom2dLinear(tGridTex, pos + (vec3(0.5, 0.5, 0.0) / uGridDim), uGridDim, uGridTexDim.xy);\n    }\n    vec4 textureGroup(vec3 pos) {\n        return texture3dFrom2dNearest(tGridTex, pos + (vec3(0.5, 0.5, 0.0) / uGridDim), uGridDim, uGridTexDim.xy);\n    }\n#elif defined(dGridTexType_3d)\n    vec4 textureVal(vec3 pos) {\n        return texture(tGridTex, pos + (vec3(0.5) / uGridDim));\n    }\n    vec4 textureGroup(vec3 pos) {\n        return texelFetch(tGridTex, ivec3(pos * uGridDim), 0);\n    }\n#endif\n\nfloat calcDepth(const in vec3 pos) {\n    vec2 clipZW = pos.z * uProjection[2].zw + uProjection[3].zw;\n    return 0.5 + 0.5 * clipZW.x / clipZW.y;\n}\n\nfloat transferFunction(float value) {\n    return texture2D(tTransferTex, vec2(value, 0.0)).a;\n}\n\nfloat getDepth(const in vec2 coords) {\n    #ifdef depthTextureSupport\n        if (!uRenderWboit) {\n            // in case of opaque volumes (and depth texture support)\n            return texture2D(tDepth, coords).r;\n        } else {\n            return unpackRGBAToDepth(texture2D(tDepth, coords));\n        }\n    #else\n        return unpackRGBAToDepth(texture2D(tDepth, coords));\n    #endif\n}\n\nconst float gradOffset = 0.5;\n\nvec3 v3m4(vec3 p, mat4 m) {\n    return (m * vec4(p, 1.0)).xyz;\n}\n\nfloat preFogAlphaBlended = 0.0;\n\nvec4 raymarch(vec3 startLoc, vec3 step, vec3 rayDir) {\n    #if !defined(dIgnoreLight)\n        mat3 normalMatrix = transpose3(inverse3(mat3(uModelView * vTransform)));\n    #endif\n    mat4 cartnToUnit = uCartnToUnit * inverse4(vTransform);\n    #if defined(dClipVariant_pixel) && dClipObjectCount != 0\n        mat4 modelTransform = uModel * vTransform * uTransform;\n    #endif\n    mat4 modelViewTransform = uModelView * vTransform * uTransform;\n\n    vec3 scaleVol = vec3(1.0) / uGridDim;\n    vec3 pos = startLoc;\n    vec4 cell;\n    float prevValue = -1.0;\n    float value = 0.0;\n    vec4 src = vec4(0.0);\n    vec4 dst = vec4(0.0);\n    float fragmentDepth;\n\n    vec3 posMin = vec3(0.0);\n    vec3 posMax = vec3(1.0) - vec3(1.0) / uGridDim;\n\n    vec3 unitPos;\n\n    vec3 nextPos;\n    float nextValue;\n\n    vec4 material;\n    vec4 overpaint;\n    float metalness = uMetalness;\n    float roughness = uRoughness;\n\n    vec3 gradient = vec3(1.0);\n    vec3 dx = vec3(gradOffset * scaleVol.x, 0.0, 0.0);\n    vec3 dy = vec3(0.0, gradOffset * scaleVol.y, 0.0);\n    vec3 dz = vec3(0.0, 0.0, gradOffset * scaleVol.z);\n\n    float maxDist = min(vBoundingSphere.w * 2.0, uFar - uNear);\n    float maxDistSq = maxDist * maxDist;\n\n    for (int i = 0; i < uMaxSteps; ++i) {\n        // break when beyond bounding-sphere or far-plane\n        vec3 distVec = startLoc - pos;\n        if (dot(distVec, distVec) > maxDistSq) break;\n\n        unitPos = v3m4(pos, cartnToUnit);\n\n        // continue when outside of grid\n        if (unitPos.x > posMax.x || unitPos.y > posMax.y || unitPos.z > posMax.z ||\n            unitPos.x < posMin.x || unitPos.y < posMin.y || unitPos.z < posMin.z\n        ) {\n            prevValue = value;\n            pos += step;\n            continue;\n        }\n\n        cell = textureVal(unitPos);\n        value = cell.a; // current voxel value\n\n        if (uJumpLength > 0.0 && value < 0.01) {\n            nextPos = pos + rayDir * uJumpLength;\n            nextValue = textureVal(v3m4(nextPos, cartnToUnit)).a;\n            if (nextValue < 0.01) {\n                prevValue = nextValue;\n                pos = nextPos;\n                continue;\n            }\n        }\n\n        vec4 mvPosition = modelViewTransform * vec4(unitPos * uGridDim, 1.0);\n        if (calcDepth(mvPosition.xyz) > getDepth(gl_FragCoord.xy / uDrawingBufferSize))\n            break;\n\n        #if defined(dClipVariant_pixel) && dClipObjectCount != 0\n            vec3 vModelPosition = v3m4(unitPos * uGridDim, modelTransform);\n            if (clipTest(vec4(vModelPosition, 0.0), 0)) {\n                prevValue = value;\n                pos += step;\n                continue;\n            }\n        #endif\n\n        vec3 vViewPosition = mvPosition.xyz;\n        material.a = transferFunction(value);\n\n        #ifdef dPackedGroup\n            float group = unpackRGBToInt(textureGroup(floor(unitPos * uGridDim + 0.5) / uGridDim).rgb);\n        #else\n            vec3 g = floor(unitPos * uGridDim + 0.5);\n            // note that we swap x and z because the texture is flipped around y\n            #if defined(dAxisOrder_012)\n                float group = g.z + g.y * uGridDim.z + g.x * uGridDim.z * uGridDim.y; // 210\n            #elif defined(dAxisOrder_021)\n                float group = g.y + g.z * uGridDim.y + g.x * uGridDim.y * uGridDim.z; // 120\n            #elif defined(dAxisOrder_102)\n                float group = g.z + g.x * uGridDim.z + g.y * uGridDim.z * uGridDim.x; // 201\n            #elif defined(dAxisOrder_120)\n                float group = g.x + g.z * uGridDim.x + g.y * uGridDim.x * uGridDim.z; // 021\n            #elif defined(dAxisOrder_201)\n                float group = g.y + g.x * uGridDim.y + g.z * uGridDim.y * uGridDim.x; // 102\n            #elif defined(dAxisOrder_210)\n                float group = g.x + g.y * uGridDim.x + g.z * uGridDim.x * uGridDim.y; // 012\n            #endif\n        #endif\n\n        #if defined(dColorType_direct) && defined(dUsePalette)\n            material.rgb = texture2D(tPalette, vec2(value, 0.0)).rgb;\n        #elif defined(dColorType_uniform)\n            material.rgb = uColor;\n        #elif defined(dColorType_instance)\n            material.rgb = readFromTexture(tColor, vInstance, uColorTexDim).rgb;\n        #elif defined(dColorType_group)\n            material.rgb = readFromTexture(tColor, group, uColorTexDim).rgb;\n        #elif defined(dColorType_groupInstance)\n            material.rgb = readFromTexture(tColor, vInstance * float(uGroupCount) + group, uColorTexDim).rgb;\n        #elif defined(dColorType_vertex)\n            material.rgb = texture3dFrom1dTrilinear(tColor, isoPos, uGridDim, uColorTexDim, 0.0).rgb;\n        #elif defined(dColorType_vertexInstance)\n            material.rgb = texture3dFrom1dTrilinear(tColor, isoPos, uGridDim, uColorTexDim, vInstance * float(uVertexCount)).rgb;\n        #endif\n\n        #ifdef dOverpaint\n            #if defined(dOverpaintType_groupInstance)\n                overpaint = readFromTexture(tOverpaint, vInstance * float(uGroupCount) + group, uOverpaintTexDim);\n            #elif defined(dOverpaintType_vertexInstance)\n                overpaint = texture3dFrom1dTrilinear(tOverpaint, isoPos, uGridDim, uOverpaintTexDim, vInstance * float(uVertexCount));\n            #endif\n\n            material.rgb = mix(material.rgb, overpaint.rgb, overpaint.a);\n        #endif\n\n        #ifdef dIgnoreLight\n            gl_FragColor.rgb = material.rgb;\n        #else\n            if (material.a >= 0.01) {\n                #ifdef dPackedGroup\n                    // compute gradient by central differences\n                    gradient.x = textureVal(unitPos - dx).a - textureVal(unitPos + dx).a;\n                    gradient.y = textureVal(unitPos - dy).a - textureVal(unitPos + dy).a;\n                    gradient.z = textureVal(unitPos - dz).a - textureVal(unitPos + dz).a;\n                #else\n                    gradient = cell.xyz * 2.0 - 1.0;\n                #endif\n                vec3 normal = -normalize(normalMatrix * normalize(gradient));\n                #include apply_light_color\n            } else {\n                gl_FragColor.rgb = material.rgb;\n            }\n        #endif\n\n        gl_FragColor.a = material.a * uAlpha * uTransferScale;\n\n        float marker = uMarker;\n        if (uMarker == -1.0) {\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        #include apply_marker_color\n\n        preFogAlphaBlended = (1.0 - preFogAlphaBlended) * gl_FragColor.a + preFogAlphaBlended;\n        fragmentDepth = calcDepth(mvPosition.xyz);\n        #include apply_fog\n\n        src = gl_FragColor;\n\n        if (!uTransparentBackground) {\n            // done in 'apply_fog' otherwise\n            src.rgb *= src.a;\n        }\n        dst = (1.0 - dst.a) * src + dst; // standard blending\n\n        // break if the color is opaque enough\n        if (dst.a > 0.95)\n            break;\n\n        pos += step;\n    }\n\n    return dst;\n}\n\n// TODO: support float texture for higher precision values???\n// TODO: support clipping exclusion texture support\n\nvoid main() {\n    if (gl_FrontFacing)\n        discard;\n\n    vec3 rayDir = mix(normalize(vOrigPos - uCameraPosition), uCameraDir, uIsOrtho);\n    vec3 step = rayDir * uStepScale;\n\n    float boundingSphereNear = distance(vBoundingSphere.xyz, uCameraPosition) - vBoundingSphere.w;\n    float d = max(uNear, boundingSphereNear) - mix(0.0, distance(vOrigPos, uCameraPosition), uIsOrtho);\n    vec3 start = mix(uCameraPosition, vOrigPos, uIsOrtho) + (d * rayDir);\n    gl_FragColor = raymarch(start, step, rayDir);\n\n    float fragmentDepth = calcDepth((uModelView * vec4(start, 1.0)).xyz);\n    float preFogAlpha = clamp(preFogAlphaBlended, 0.0, 1.0);\n    bool interior = false;\n    #include wboit_write\n}\n";
-//# sourceMappingURL=direct-volume.frag.js.map
+export var directVolume_frag = "\nprecision highp float;\nprecision highp int;\n\n#include common\n#include light_frag_params\n\n#if dClipObjectCount != 0\n    uniform int uClipObjectType[dClipObjectCount];\n    uniform bool uClipObjectInvert[dClipObjectCount];\n    uniform vec3 uClipObjectPosition[dClipObjectCount];\n    uniform vec4 uClipObjectRotation[dClipObjectCount];\n    uniform vec3 uClipObjectScale[dClipObjectCount];\n#endif\n#include common_clip\n\n#include read_from_texture\n#include texture3d_from_1d_trilinear\n#include texture3d_from_2d_nearest\n#include texture3d_from_2d_linear\n\nuniform mat4 uProjection, uTransform, uModelView, uModel, uView;\nuniform vec3 uCameraDir;\n\nuniform sampler2D tDepth;\nuniform vec2 uDrawingBufferSize;\n\nvarying vec3 vOrigPos;\nvarying float vInstance;\nvarying vec4 vBoundingSphere;\nvarying mat4 vTransform;\n\nuniform mat4 uInvView;\nuniform vec3 uGridDim;\nuniform vec3 uBboxSize;\nuniform sampler2D tTransferTex;\nuniform float uTransferScale;\nuniform float uStepScale;\nuniform float uJumpLength;\n\nuniform int uObjectId;\nuniform int uVertexCount;\nuniform int uInstanceCount;\nuniform int uGroupCount;\n\nuniform vec3 uHighlightColor;\nuniform vec3 uSelectColor;\nuniform float uHighlightStrength;\nuniform float uSelectStrength;\nuniform int uMarkerPriority;\n\nuniform float uMarker;\nuniform vec2 uMarkerTexDim;\nuniform sampler2D tMarker;\n\nuniform float uMetalness;\nuniform float uRoughness;\n\nuniform float uFogNear;\nuniform float uFogFar;\nuniform vec3 uFogColor;\n\nuniform float uAlpha;\nuniform float uPickingAlphaThreshold;\nuniform bool uTransparentBackground;\nuniform float uXrayEdgeFalloff;\n\nuniform float uInteriorDarkening;\nuniform bool uInteriorColorFlag;\nuniform vec3 uInteriorColor;\n\nuniform bool uRenderWboit;\nuniform bool uDoubleSided;\n\nuniform float uNear;\nuniform float uFar;\nuniform float uIsOrtho;\n\nuniform vec3 uCellDim;\nuniform vec3 uCameraPosition;\nuniform mat4 uCartnToUnit;\n\n#if __VERSION__ != 100\n    // for webgl1 this is given as a 'define'\n    uniform int uMaxSteps;\n#endif\n\n#if defined(dGridTexType_2d)\n    precision highp sampler2D;\n    uniform sampler2D tGridTex;\n    uniform vec3 uGridTexDim;\n#elif defined(dGridTexType_3d)\n    precision highp sampler3D;\n    uniform sampler3D tGridTex;\n#endif\n\n#if defined(dColorType_uniform)\n    uniform vec3 uColor;\n#elif defined(dColorType_texture)\n    uniform vec2 uColorTexDim;\n    uniform sampler2D tColor;\n#endif\n\n#ifdef dOverpaint\n    #if defined(dOverpaintType_groupInstance) || defined(dOverpaintType_vertexInstance)\n        uniform vec2 uOverpaintTexDim;\n        uniform sampler2D tOverpaint;\n    #endif\n#endif\n\n#ifdef dUsePalette\n    uniform sampler2D tPalette;\n#endif\n\n#if defined(dGridTexType_2d)\n    vec4 textureVal(vec3 pos) {\n        return texture3dFrom2dLinear(tGridTex, pos + (vec3(0.5, 0.5, 0.0) / uGridDim), uGridDim, uGridTexDim.xy);\n    }\n    vec4 textureGroup(vec3 pos) {\n        return texture3dFrom2dNearest(tGridTex, pos + (vec3(0.5, 0.5, 0.0) / uGridDim), uGridDim, uGridTexDim.xy);\n    }\n#elif defined(dGridTexType_3d)\n    vec4 textureVal(vec3 pos) {\n        return texture(tGridTex, pos + (vec3(0.5) / uGridDim));\n    }\n    vec4 textureGroup(vec3 pos) {\n        return texelFetch(tGridTex, ivec3(pos * uGridDim), 0);\n    }\n#endif\n\nfloat calcDepth(const in vec3 pos) {\n    vec2 clipZW = pos.z * uProjection[2].zw + uProjection[3].zw;\n    return 0.5 + 0.5 * clipZW.x / clipZW.y;\n}\n\nfloat transferFunction(float value) {\n    return texture2D(tTransferTex, vec2(value, 0.0)).a;\n}\n\nfloat getDepth(const in vec2 coords) {\n    #ifdef depthTextureSupport\n        if (!uRenderWboit) {\n            // in case of opaque volumes (and depth texture support)\n            return texture2D(tDepth, coords).r;\n        } else {\n            return unpackRGBAToDepth(texture2D(tDepth, coords));\n        }\n    #else\n        return unpackRGBAToDepth(texture2D(tDepth, coords));\n    #endif\n}\n\nconst float gradOffset = 0.5;\n\nvec3 v3m4(vec3 p, mat4 m) {\n    return (m * vec4(p, 1.0)).xyz;\n}\n\nfloat preFogAlphaBlended = 0.0;\n\nvec4 raymarch(vec3 startLoc, vec3 step, vec3 rayDir) {\n    mat3 normalMatrix = transpose3(inverse3(mat3(uModelView * vTransform)));\n    mat4 cartnToUnit = uCartnToUnit * inverse4(vTransform);\n    #if defined(dClipVariant_pixel) && dClipObjectCount != 0\n        mat4 modelTransform = uModel * vTransform * uTransform;\n    #endif\n    mat4 modelViewTransform = uModelView * vTransform * uTransform;\n\n    vec3 scaleVol = vec3(1.0) / uGridDim;\n    vec3 pos = startLoc;\n    vec4 cell;\n    float prevValue = -1.0;\n    float value = 0.0;\n    vec4 src = vec4(0.0);\n    vec4 dst = vec4(0.0);\n    float fragmentDepth;\n\n    vec3 posMin = vec3(0.0);\n    vec3 posMax = vec3(1.0) - vec3(1.0) / uGridDim;\n\n    vec3 unitPos;\n\n    vec3 nextPos;\n    float nextValue;\n\n    vec4 material;\n    vec4 overpaint;\n    float metalness = uMetalness;\n    float roughness = uRoughness;\n\n    vec3 gradient = vec3(1.0);\n    vec3 dx = vec3(gradOffset * scaleVol.x, 0.0, 0.0);\n    vec3 dy = vec3(0.0, gradOffset * scaleVol.y, 0.0);\n    vec3 dz = vec3(0.0, 0.0, gradOffset * scaleVol.z);\n\n    float maxDist = min(vBoundingSphere.w * 2.0, uFar - uNear);\n    float maxDistSq = maxDist * maxDist;\n\n    for (int i = 0; i < uMaxSteps; ++i) {\n        // break when beyond bounding-sphere or far-plane\n        vec3 distVec = startLoc - pos;\n        if (dot(distVec, distVec) > maxDistSq) break;\n\n        unitPos = v3m4(pos, cartnToUnit);\n\n        // continue when outside of grid\n        if (unitPos.x > posMax.x || unitPos.y > posMax.y || unitPos.z > posMax.z ||\n            unitPos.x < posMin.x || unitPos.y < posMin.y || unitPos.z < posMin.z\n        ) {\n            prevValue = value;\n            pos += step;\n            continue;\n        }\n\n        cell = textureVal(unitPos);\n        value = cell.a; // current voxel value\n\n        if (uJumpLength > 0.0 && value < 0.01) {\n            nextPos = pos + rayDir * uJumpLength;\n            nextValue = textureVal(v3m4(nextPos, cartnToUnit)).a;\n            if (nextValue < 0.01) {\n                prevValue = nextValue;\n                pos = nextPos;\n                continue;\n            }\n        }\n\n        vec4 mvPosition = modelViewTransform * vec4(unitPos * uGridDim, 1.0);\n        if (calcDepth(mvPosition.xyz) > getDepth(gl_FragCoord.xy / uDrawingBufferSize))\n            break;\n\n        #if defined(dClipVariant_pixel) && dClipObjectCount != 0\n            vec3 vModelPosition = v3m4(unitPos * uGridDim, modelTransform);\n            if (clipTest(vec4(vModelPosition, 0.0), 0)) {\n                prevValue = value;\n                pos += step;\n                continue;\n            }\n        #endif\n\n        vec3 vViewPosition = mvPosition.xyz;\n        material.a = transferFunction(value);\n\n        #ifdef dPackedGroup\n            float group = unpackRGBToInt(textureGroup(floor(unitPos * uGridDim + 0.5) / uGridDim).rgb);\n        #else\n            vec3 g = floor(unitPos * uGridDim + 0.5);\n            // note that we swap x and z because the texture is flipped around y\n            #if defined(dAxisOrder_012)\n                float group = g.z + g.y * uGridDim.z + g.x * uGridDim.z * uGridDim.y; // 210\n            #elif defined(dAxisOrder_021)\n                float group = g.y + g.z * uGridDim.y + g.x * uGridDim.y * uGridDim.z; // 120\n            #elif defined(dAxisOrder_102)\n                float group = g.z + g.x * uGridDim.z + g.y * uGridDim.z * uGridDim.x; // 201\n            #elif defined(dAxisOrder_120)\n                float group = g.x + g.z * uGridDim.x + g.y * uGridDim.x * uGridDim.z; // 021\n            #elif defined(dAxisOrder_201)\n                float group = g.y + g.x * uGridDim.y + g.z * uGridDim.y * uGridDim.x; // 102\n            #elif defined(dAxisOrder_210)\n                float group = g.x + g.y * uGridDim.x + g.z * uGridDim.x * uGridDim.y; // 012\n            #endif\n        #endif\n\n        #if defined(dColorType_direct) && defined(dUsePalette)\n            material.rgb = texture2D(tPalette, vec2(value, 0.0)).rgb;\n        #elif defined(dColorType_uniform)\n            material.rgb = uColor;\n        #elif defined(dColorType_instance)\n            material.rgb = readFromTexture(tColor, vInstance, uColorTexDim).rgb;\n        #elif defined(dColorType_group)\n            material.rgb = readFromTexture(tColor, group, uColorTexDim).rgb;\n        #elif defined(dColorType_groupInstance)\n            material.rgb = readFromTexture(tColor, vInstance * float(uGroupCount) + group, uColorTexDim).rgb;\n        #elif defined(dColorType_vertex)\n            material.rgb = texture3dFrom1dTrilinear(tColor, isoPos, uGridDim, uColorTexDim, 0.0).rgb;\n        #elif defined(dColorType_vertexInstance)\n            material.rgb = texture3dFrom1dTrilinear(tColor, isoPos, uGridDim, uColorTexDim, vInstance * float(uVertexCount)).rgb;\n        #endif\n\n        #ifdef dOverpaint\n            #if defined(dOverpaintType_groupInstance)\n                overpaint = readFromTexture(tOverpaint, vInstance * float(uGroupCount) + group, uOverpaintTexDim);\n            #elif defined(dOverpaintType_vertexInstance)\n                overpaint = texture3dFrom1dTrilinear(tOverpaint, isoPos, uGridDim, uOverpaintTexDim, vInstance * float(uVertexCount));\n            #endif\n\n            material.rgb = mix(material.rgb, overpaint.rgb, overpaint.a);\n        #endif\n\n        if (material.a >= 0.01) {\n            #ifdef dPackedGroup\n                // compute gradient by central differences\n                gradient.x = textureVal(unitPos - dx).a - textureVal(unitPos + dx).a;\n                gradient.y = textureVal(unitPos - dy).a - textureVal(unitPos + dy).a;\n                gradient.z = textureVal(unitPos - dz).a - textureVal(unitPos + dz).a;\n            #else\n                gradient = cell.xyz * 2.0 - 1.0;\n            #endif\n            vec3 normal = -normalize(normalMatrix * normalize(gradient));\n            #include apply_light_color\n        } else {\n            gl_FragColor.rgb = material.rgb;\n        }\n\n        gl_FragColor.a = material.a * uAlpha * uTransferScale;\n\n        float marker = uMarker;\n        if (uMarker == -1.0) {\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        #include apply_marker_color\n\n        preFogAlphaBlended = (1.0 - preFogAlphaBlended) * gl_FragColor.a + preFogAlphaBlended;\n        fragmentDepth = calcDepth(mvPosition.xyz);\n        #include apply_fog\n\n        src = gl_FragColor;\n\n        if (!uTransparentBackground) {\n            // done in 'apply_fog' otherwise\n            src.rgb *= src.a;\n        }\n        dst = (1.0 - dst.a) * src + dst; // standard blending\n\n        // break if the color is opaque enough\n        if (dst.a > 0.95)\n            break;\n\n        pos += step;\n    }\n\n    return dst;\n}\n\n// TODO: support float texture for higher precision values???\n// TODO: support clipping exclusion texture support\n\nvoid main() {\n    if (gl_FrontFacing)\n        discard;\n\n    vec3 rayDir = mix(normalize(vOrigPos - uCameraPosition), uCameraDir, uIsOrtho);\n    vec3 step = rayDir * uStepScale;\n\n    float boundingSphereNear = distance(vBoundingSphere.xyz, uCameraPosition) - vBoundingSphere.w;\n    float d = max(uNear, boundingSphereNear) - mix(0.0, distance(vOrigPos, uCameraPosition), uIsOrtho);\n    vec3 start = mix(uCameraPosition, vOrigPos, uIsOrtho) + (d * rayDir);\n    gl_FragColor = raymarch(start, step, rayDir);\n\n    float fragmentDepth = calcDepth((uModelView * vec4(start, 1.0)).xyz);\n    float preFogAlpha = clamp(preFogAlphaBlended, 0.0, 1.0);\n    bool interior = false;\n    #include wboit_write\n}\n";

package/lib/mol-gl/shader/direct-volume.vert.js CHANGED Viewed

@@ -5,4 +5,3 @@
  * @author Michael Krone <michael.krone@uni-tuebingen.de>
  */
 export var directVolume_vert = "\nprecision highp float;\n\nattribute vec3 aPosition;\nattribute mat4 aTransform;\nattribute float aInstance;\n\nuniform mat4 uModelView;\nuniform mat4 uProjection;\nuniform vec4 uInvariantBoundingSphere;\n\nvarying vec3 vOrigPos;\nvarying float vInstance;\nvarying vec4 vBoundingSphere;\nvarying mat4 vTransform;\n\nuniform vec3 uBboxSize;\nuniform vec3 uBboxMin;\nuniform vec3 uBboxMax;\nuniform vec3 uGridDim;\nuniform mat4 uTransform;\n\nuniform mat4 uUnitToCartn;\n\nvoid main() {\n    vec4 unitCoord = vec4(aPosition + vec3(0.5), 1.0);\n    vec4 mvPosition = uModelView * aTransform * uUnitToCartn * unitCoord;\n\n    vOrigPos = (aTransform * uUnitToCartn * unitCoord).xyz;\n    vInstance = aInstance;\n    vBoundingSphere = vec4(\n        (aTransform * vec4(uInvariantBoundingSphere.xyz, 1.0)).xyz,\n        uInvariantBoundingSphere.w\n    );\n    vTransform = aTransform;\n\n    gl_Position = uProjection * mvPosition;\n\n    // move z position to near clip plane (but not too close to get precision issues)\n    gl_Position.z = gl_Position.w - 0.01;\n}\n";
-//# sourceMappingURL=direct-volume.vert.js.map

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

	@@ -1,2 +1 @@
1 1	export var 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";
2	- //# sourceMappingURL=evaluate-wboit.frag.js.map

package/lib/mol-gl/shader/fxaa.frag.js CHANGED Viewed

	@@ -1,2 +1 @@
1 1	export var 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";
2	- //# sourceMappingURL=fxaa.frag.js.map

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

@@ -5,4 +5,3 @@
  * @author Michael Krone <michael.krone@uni-tuebingen.de>
  */
 export var 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/mol-gl/shader/gaussian-density.vert.js CHANGED Viewed

@@ -5,4 +5,3 @@
  * @author Michael Krone <michael.krone@uni-tuebingen.de>
  */
 export var 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/mol-gl/shader/histogram-pyramid/reduction.frag.js CHANGED Viewed

	@@ -1,2 +1 @@
1 1	export var 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";
2	- //# sourceMappingURL=reduction.frag.js.map

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

@@ -4,4 +4,3 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 export var 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/mol-gl/shader/image.frag.js CHANGED Viewed

@@ -4,4 +4,3 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 export var 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/mol-gl/shader/image.vert.js CHANGED Viewed

@@ -4,4 +4,3 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 export var 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/mol-gl/shader/lines.frag.js CHANGED Viewed

@@ -4,4 +4,3 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 export var 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/mol-gl/shader/lines.vert.js CHANGED Viewed

@@ -6,4 +6,3 @@
  * heavily based on code by WestLangley from https://github.com/WestLangley/three.js/blob/af28b2fb706ac109771ecad0a7447fad90ab3210/examples/js/lines/LineMaterial.js
  */
 export var 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/mol-gl/shader/marching-cubes/active-voxels.frag.js CHANGED Viewed

	@@ -1,2 +1 @@
1 1	export var 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";
2	- //# sourceMappingURL=active-voxels.frag.js.map

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

	@@ -1,2 +1 @@
1 1	export var 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";
2	- //# sourceMappingURL=isosurface.frag.js.map

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

	@@ -1,2 +1 @@
1 1	export var 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";
2	- //# sourceMappingURL=edge.frag.js.map

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

	@@ -1,2 +1 @@
1 1	export var 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";
2	- //# sourceMappingURL=overlay.frag.js.map

package/lib/mol-gl/shader/mesh.frag.d.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 /**
- * 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>
  */
-export declare const 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        #ifdef dIgnoreLight\n            gl_FragColor = material;\n        #else\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        #endif\n\n        #include apply_interior_color\n        #include apply_marker_color\n        #include apply_fog\n        #include wboit_write\n    #endif\n}\n";
+export declare const 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";

package/lib/mol-gl/shader/mesh.frag.js CHANGED Viewed

@@ -1,7 +1,6 @@
 /**
- * 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>
  */
-export var 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        #ifdef dIgnoreLight\n            gl_FragColor = material;\n        #else\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        #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=mesh.frag.js.map
+export var 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";

package/lib/mol-gl/shader/mesh.vert.js CHANGED Viewed

@@ -4,4 +4,3 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 export var 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/mol-gl/shader/outlines.frag.js CHANGED Viewed

@@ -4,4 +4,3 @@
  * @author Áron Samuel Kovács <aron.kovacs@mail.muni.cz>
  */
 export var 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/mol-gl/shader/points.frag.js CHANGED Viewed

@@ -4,4 +4,3 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 export var 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/mol-gl/shader/points.vert.js CHANGED Viewed

@@ -4,4 +4,3 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 export var 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/mol-gl/shader/postprocessing.frag.d.ts CHANGED Viewed

@@ -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/mol-gl/shader/postprocessing.frag.js CHANGED Viewed

@@ -1,8 +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 var 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
+export var 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/mol-gl/shader/quad.vert.js CHANGED Viewed

@@ -4,4 +4,3 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 export var 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/mol-gl/shader/smaa/blend.frag.js CHANGED Viewed

@@ -7,4 +7,3 @@
  * https://github.com/iryoku/smaa/releases/tag/v2.8
  */
 export var 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/mol-gl/shader/smaa/blend.vert.js CHANGED Viewed

@@ -7,4 +7,3 @@
  * https://github.com/iryoku/smaa/releases/tag/v2.8
  */
 export var 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/mol-gl/shader/smaa/edges.frag.js CHANGED Viewed

@@ -7,4 +7,3 @@
  * https://github.com/iryoku/smaa/releases/tag/v2.8
  */
 export var 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/mol-gl/shader/smaa/edges.vert.js CHANGED Viewed

@@ -7,4 +7,3 @@
  * https://github.com/iryoku/smaa/releases/tag/v2.8
  */
 export var 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/mol-gl/shader/smaa/weights.frag.js CHANGED Viewed

@@ -7,4 +7,3 @@
  * https://github.com/iryoku/smaa/releases/tag/v2.8
  */
 export var 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/mol-gl/shader/smaa/weights.vert.js CHANGED Viewed

@@ -7,4 +7,3 @@
  * https://github.com/iryoku/smaa/releases/tag/v2.8
  */
 export var 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/mol-gl/shader/spheres.frag.d.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 /**
- * 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>
  */
-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";
+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        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";

package/lib/mol-gl/shader/spheres.frag.js CHANGED Viewed

@@ -1,7 +1,6 @@
 /**
- * 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>
  */
-export var 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
+export var 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";

package/lib/mol-gl/shader/spheres.vert.js CHANGED Viewed

@@ -4,4 +4,3 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 export var 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/mol-gl/shader/ssao-blur.frag.js CHANGED Viewed

@@ -5,4 +5,3 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 export var 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