molstar 4.0.1 → 4.2.0

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

@@ -1,106 +1,105 @@
 /**
- * Copyright (c) 2019-2023 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2019-2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Áron Samuel Kovács <aron.kovacs@mail.muni.cz>
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ * @author Ludovic Autin <ludovic.autin@gmail.com>
  */
-export const ssaoBlur_frag = `
-precision highp float;
-precision highp int;
-precision highp sampler2D;
-
-uniform sampler2D tSsaoDepth;
-uniform vec2 uTexSize;
-uniform vec4 uBounds;
-
-uniform float uKernel[dOcclusionKernelSize];
-
-uniform float uBlurDirectionX;
-uniform float uBlurDirectionY;
-
-uniform mat4 uInvProjection;
-uniform float uNear;
-uniform float uFar;
-
-#include common
-
-float getViewZ(const in float depth) {
-    #if dOrthographic == 1
-        return orthographicDepthToViewZ(depth, uNear, uFar);
-    #else
-        return perspectiveDepthToViewZ(depth, uNear, uFar);
-    #endif
-}
-
-bool isBackground(const in float depth) {
-    return depth == 1.0;
-}
-
-bool outsideBounds(const in vec2 p) {
-    return p.x < uBounds.x || p.y < uBounds.y || p.x > uBounds.z || p.y > uBounds.w;
-}
-
-float getPixelSize(const in vec2 coords, const in float depth) {
-    vec3 viewPos0 = screenSpaceToViewSpace(vec3(coords, depth), uInvProjection);
-    vec3 viewPos1 = screenSpaceToViewSpace(vec3(coords + vec2(1.0, 0.0) / uTexSize, depth), uInvProjection);
-    return distance(viewPos0, viewPos1);
-}
-
-void main(void) {
-    vec2 coords = gl_FragCoord.xy / uTexSize;
-
-    vec2 packedDepth = texture2D(tSsaoDepth, coords).zw;
-
-    if (outsideBounds(coords)) {
-        gl_FragColor = vec4(packUnitIntervalToRG(1.0), packedDepth);
-        return;
-    }
-
-    float selfDepth = unpackRGToUnitInterval(packedDepth);
-    // if background and if second pass
-    if (isBackground(selfDepth) && uBlurDirectionY != 0.0) {
-        gl_FragColor = vec4(packUnitIntervalToRG(1.0), packedDepth);
-        return;
-    }
-
-    float selfViewZ = getViewZ(selfDepth);
-    float pixelSize = getPixelSize(coords, selfDepth);
-    float maxDiffViewZ = pixelSize * 10.0;
-
-    vec2 offset = vec2(uBlurDirectionX, uBlurDirectionY) / uTexSize;
-
-    float sum = 0.0;
-    float kernelSum = 0.0;
-    // only if kernelSize is odd
-    for (int i = -dOcclusionKernelSize / 2; i <= dOcclusionKernelSize / 2; i++) {
-        if (abs(float(i)) > 1.0 && abs(float(i)) * pixelSize > 0.8) continue;
-
-        vec2 sampleCoords = coords + float(i) * offset;
-        if (outsideBounds(sampleCoords)) {
-            continue;
-        }
-
-        vec4 sampleSsaoDepth = texture2D(tSsaoDepth, sampleCoords);
-
-        float sampleDepth = unpackRGToUnitInterval(sampleSsaoDepth.zw);
-        if (isBackground(sampleDepth)) {
-            continue;
-        }
-
-        if (abs(float(i)) > 1.0) {
-            float sampleViewZ = getViewZ(sampleDepth);
-            if (abs(selfViewZ - sampleViewZ) > maxDiffViewZ) {
-                continue;
-            }
-        }
-
-        float kernel = uKernel[int(abs(float(i)))]; // abs is not defined for int in webgl1
-        float sampleValue = unpackRGToUnitInterval(sampleSsaoDepth.xy);
-
-        sum += kernel * sampleValue;
-        kernelSum += kernel;
-    }
-
-    gl_FragColor = vec4(packUnitIntervalToRG(sum / kernelSum), packedDepth);
-}
+export const ssaoBlur_frag = `
+precision highp float;
+precision highp int;
+precision highp sampler2D;
+
+uniform sampler2D tSsaoDepth;
+uniform vec2 uTexSize;
+uniform vec4 uBounds;
+
+uniform float uKernel[dOcclusionKernelSize];
+
+uniform float uBlurDirectionX;
+uniform float uBlurDirectionY;
+
+uniform mat4 uInvProjection;
+uniform float uNear;
+uniform float uFar;
+
+#include common
+
+float getViewZ(const in float depth) {
+    #if dOrthographic == 1
+        return orthographicDepthToViewZ(depth, uNear, uFar);
+    #else
+        return perspectiveDepthToViewZ(depth, uNear, uFar);
+    #endif
+}
+
+bool isBackground(const in float depth) {
+    return depth == 1.0;
+}
+
+bool outsideBounds(const in vec2 p) {
+    return p.x < uBounds.x || p.y < uBounds.y || p.x > uBounds.z || p.y > uBounds.w;
+}
+
+float getPixelSize(const in vec2 coords, const in float depth) {
+    vec3 viewPos0 = screenSpaceToViewSpace(vec3(coords, depth), uInvProjection);
+    vec3 viewPos1 = screenSpaceToViewSpace(vec3(coords + vec2(1.0, 0.0) / uTexSize, depth), uInvProjection);
+    return distance(viewPos0, viewPos1);
+}
+
+void main(void) {
+    vec2 coords = gl_FragCoord.xy / uTexSize;
+
+    vec2 packedDepth = texture2D(tSsaoDepth, coords).zw;
+
+    if (outsideBounds(coords)) {
+        gl_FragColor = vec4(packUnitIntervalToRG(1.0), packedDepth);
+        return;
+    }
+
+    float selfDepth = unpackRGToUnitInterval(packedDepth);
+    // if background and if second pass
+    if (isBackground(selfDepth) && uBlurDirectionY != 0.0) {
+        gl_FragColor = vec4(packUnitIntervalToRG(1.0), packedDepth);
+        return;
+    }
+
+    float selfViewZ = getViewZ(selfDepth);
+    float pixelSize = getPixelSize(coords, selfDepth);
+    // max diff depth between two pixels
+    float maxDiffViewZ = 1.0;
+
+    vec2 offset = vec2(uBlurDirectionX, uBlurDirectionY) / uTexSize;
+
+    float sum = 0.0;
+    float kernelSum = 0.0;
+    // only if kernelSize is odd
+    for (int i = -dOcclusionKernelSize / 2; i <= dOcclusionKernelSize / 2; i++) {
+        if (abs(float(i)) > 1.0 && abs(float(i)) * pixelSize > 0.8) continue;
+
+        vec2 sampleCoords = coords + float(i) * offset;
+        if (outsideBounds(sampleCoords)) {
+            continue;
+        }
+
+        vec4 sampleSsaoDepth = texture2D(tSsaoDepth, sampleCoords);
+
+        float sampleDepth = unpackRGToUnitInterval(sampleSsaoDepth.zw);
+        if (isBackground(sampleDepth)) {
+            continue;
+        }
+
+        float sampleViewZ = getViewZ(sampleDepth);
+        if (abs(selfViewZ - sampleViewZ) > maxDiffViewZ) {
+            continue;
+        }
+
+        float kernel = uKernel[int(abs(float(i)))]; // abs is not defined for int in webgl1
+        float sampleValue = unpackRGToUnitInterval(sampleSsaoDepth.xy);
+
+        sum += kernel * sampleValue;
+        kernelSum += kernel;
+    }
+    gl_FragColor = vec4(packUnitIntervalToRG(sum / kernelSum), packedDepth);
+}
 `;

package/lib/mol-gl/shader/ssao.frag.d.ts

@@ -1,7 +1,8 @@
 /**
- * Copyright (c) 2019-2023 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2019-2024 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>
+ * @author Ludovic Autin <ludovic.autin@gmail.com>
  */
-export declare const ssao_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\n#include common\n\nuniform sampler2D tDepth;\nuniform sampler2D tDepthHalf;\nuniform sampler2D tDepthQuarter;\nuniform vec2 uTexSize;\nuniform vec4 uBounds;\n\nuniform vec3 uSamples[dNSamples];\n\nuniform mat4 uProjection;\nuniform mat4 uInvProjection;\n\n#ifdef dMultiScale\n    uniform float uLevelRadius[dLevels];\n    uniform float uLevelBias[dLevels];\n    uniform float uNearThreshold;\n    uniform float uFarThreshold;\n#else\n    uniform float uRadius;\n#endif\nuniform float uBias;\n\nfloat smootherstep(float edge0, float edge1, float x) {\n    x = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);\n    return x * x * x * (x * (x * 6.0 - 15.0) + 10.0);\n}\n\nfloat noise(const in vec2 coords) {\n    float a = 12.9898;\n    float b = 78.233;\n    float c = 43758.5453;\n    float dt = dot(coords, vec2(a,b));\n    float sn = mod(dt, PI);\n    return abs(fract(sin(sn) * c)); // is abs necessary?\n}\n\nvec2 getNoiseVec2(const in vec2 coords) {\n    return vec2(noise(coords), noise(coords + vec2(PI, 2.71828)));\n}\n\nbool isBackground(const in float depth) {\n    return depth == 1.0;\n}\n\nfloat getDepth(const in vec2 coords) {\n    vec2 c = vec2(clamp(coords.x, uBounds.x, uBounds.z), clamp(coords.y, uBounds.y, uBounds.w));\n    #ifdef depthTextureSupport\n        return texture2D(tDepth, c).r;\n    #else\n        return unpackRGBAToDepth(texture2D(tDepth, c));\n    #endif\n}\n\n#define dQuarterThreshold 0.1\n#define dHalfThreshold 0.05\n\nfloat getMappedDepth(const in vec2 coords, const in vec2 selfCoords) {\n    vec2 c = vec2(clamp(coords.x, uBounds.x, uBounds.z), clamp(coords.y, uBounds.y, uBounds.w));\n    float d = distance(coords, selfCoords);\n    #ifdef depthTextureSupport\n        if (d > dQuarterThreshold) {\n            return texture2D(tDepthQuarter, c).r;\n        } else if (d > dHalfThreshold) {\n            return texture2D(tDepthHalf, c).r;\n        } else {\n            return texture2D(tDepth, c).r;\n        }\n    #else\n        if (d > dQuarterThreshold) {\n            return unpackRGBAToDepth(texture2D(tDepthQuarter, c));\n        } else if (d > dHalfThreshold) {\n            return unpackRGBAToDepth(texture2D(tDepthHalf, c));\n        } else {\n            return unpackRGBAToDepth(texture2D(tDepth, c));\n        }\n    #endif\n}\n\nvec3 normalFromDepth(const in float depth, const in float depth1, const in float depth2, vec2 offset1, vec2 offset2) {\n    vec3 p1 = vec3(offset1, depth1 - depth);\n    vec3 p2 = vec3(offset2, depth2 - depth);\n\n    vec3 normal = cross(p1, p2);\n    normal.z = -normal.z;\n\n    return normalize(normal);\n}\n\nfloat getPixelSize(const in vec2 coords, const in float depth) {\n    vec3 viewPos0 = screenSpaceToViewSpace(vec3(coords, depth), uInvProjection);\n    vec3 viewPos1 = screenSpaceToViewSpace(vec3(coords + vec2(1.0, 0.0) / uTexSize, depth), uInvProjection);\n    return distance(viewPos0, viewPos1);\n}\n\n// StarCraft II Ambient Occlusion by [Filion and McNaughton 2008]\nvoid main(void) {\n    vec2 invTexSize = 1.0 / uTexSize;\n    vec2 selfCoords = gl_FragCoord.xy * invTexSize;\n\n    float selfDepth = getDepth(selfCoords);\n    vec2 selfPackedDepth = packUnitIntervalToRG(selfDepth);\n\n    if (isBackground(selfDepth)) {\n        gl_FragColor = vec4(packUnitIntervalToRG(1.0), selfPackedDepth);\n        return;\n    }\n\n    vec2 offset1 = vec2(0.0, invTexSize.y);\n    vec2 offset2 = vec2(invTexSize.x, 0.0);\n\n    float selfDepth1 = getDepth(selfCoords + offset1);\n    float selfDepth2 = getDepth(selfCoords + offset2);\n\n    vec3 selfViewNormal = normalFromDepth(selfDepth, selfDepth1, selfDepth2, offset1, offset2);\n    vec3 selfViewPos = screenSpaceToViewSpace(vec3(selfCoords, selfDepth), uInvProjection);\n\n    vec3 randomVec = normalize(vec3(getNoiseVec2(selfCoords) * 2.0 - 1.0, 0.0));\n    vec3 tangent = normalize(randomVec - selfViewNormal * dot(randomVec, selfViewNormal));\n    vec3 bitangent = cross(selfViewNormal, tangent);\n    mat3 TBN = mat3(tangent, bitangent, selfViewNormal);\n\n    float occlusion = 0.0;\n    #ifdef dMultiScale\n        float pixelSize = getPixelSize(selfCoords, selfDepth);\n\n        for(int l = 0; l < dLevels; l++) {\n            // TODO: smooth transition\n            if (pixelSize * uNearThreshold > uLevelRadius[l]) continue;\n            if (pixelSize * uFarThreshold < uLevelRadius[l]) continue;\n\n            float levelOcclusion = 0.0;\n            for(int i = 0; i < dNSamples; i++) {\n                vec3 sampleViewPos = TBN * uSamples[i];\n                sampleViewPos = selfViewPos + sampleViewPos * uLevelRadius[l];\n\n                vec4 offset = vec4(sampleViewPos, 1.0);\n                offset = uProjection * offset;\n                offset.xyz = (offset.xyz / offset.w) * 0.5 + 0.5;\n\n                float sampleDepth = getMappedDepth(offset.xy, selfCoords);\n                float sampleViewZ = screenSpaceToViewSpace(vec3(offset.xy, sampleDepth), uInvProjection).z;\n\n                levelOcclusion += step(sampleViewPos.z + 0.025, sampleViewZ) * smootherstep(0.0, 1.0, uLevelRadius[l] / abs(selfViewPos.z - sampleViewZ)) * uLevelBias[l];\n            }\n            occlusion = max(occlusion, levelOcclusion);\n        }\n    #else\n        for(int i = 0; i < dNSamples; i++) {\n            vec3 sampleViewPos = TBN * uSamples[i];\n            sampleViewPos = selfViewPos + sampleViewPos * uRadius;\n\n            vec4 offset = vec4(sampleViewPos, 1.0);\n            offset = uProjection * offset;\n            offset.xyz = (offset.xyz / offset.w) * 0.5 + 0.5;\n\n            float sampleDepth = getMappedDepth(offset.xy, selfCoords);\n            float sampleViewZ = screenSpaceToViewSpace(vec3(offset.xy, sampleDepth), uInvProjection).z;\n\n            occlusion += step(sampleViewPos.z + 0.025, sampleViewZ) * smootherstep(0.0, 1.0, uRadius / abs(selfViewPos.z - sampleViewZ));\n        }\n    #endif\n    occlusion = 1.0 - (uBias * occlusion / float(dNSamples));\n\n    vec2 packedOcclusion = packUnitIntervalToRG(clamp(occlusion, 0.01, 1.0));\n\n    gl_FragColor = vec4(packedOcclusion, selfPackedDepth);\n}\n";
+export declare const ssao_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\n#include common\n\nuniform sampler2D tDepth;\nuniform sampler2D tDepthHalf;\nuniform sampler2D tDepthQuarter;\nuniform vec2 uTexSize;\nuniform vec4 uBounds;\n\nuniform vec3 uSamples[dNSamples];\n\nuniform mat4 uProjection;\nuniform mat4 uInvProjection;\n\n#ifdef dMultiScale\n    uniform float uLevelRadius[dLevels];\n    uniform float uLevelBias[dLevels];\n    uniform float uNearThreshold;\n    uniform float uFarThreshold;\n#else\n    uniform float uRadius;\n#endif\nuniform float uBias;\n\nfloat smootherstep(float edge0, float edge1, float x) {\n    x = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);\n    return x * x * x * (x * (x * 6.0 - 15.0) + 10.0);\n}\n\nfloat noise(const in vec2 coords) {\n    float a = 12.9898;\n    float b = 78.233;\n    float c = 43758.5453;\n    float dt = dot(coords, vec2(a,b));\n    float sn = mod(dt, PI);\n    return abs(fract(sin(sn) * c)); // is abs necessary?\n}\n\nvec2 getNoiseVec2(const in vec2 coords) {\n    return vec2(noise(coords), noise(coords + vec2(PI, 2.71828)));\n}\n\nbool isBackground(const in float depth) {\n    return depth == 1.0;\n}\n\nfloat getDepth(const in vec2 coords) {\n    vec2 c = vec2(clamp(coords.x, uBounds.x, uBounds.z), clamp(coords.y, uBounds.y, uBounds.w));\n    #ifdef depthTextureSupport\n        return texture2D(tDepth, c).r;\n    #else\n        return unpackRGBAToDepth(texture2D(tDepth, c));\n    #endif\n}\n\n#define dQuarterThreshold 0.1\n#define dHalfThreshold 0.05\n\nfloat getMappedDepth(const in vec2 coords, const in vec2 selfCoords) {\n    vec2 c = vec2(clamp(coords.x, uBounds.x, uBounds.z), clamp(coords.y, uBounds.y, uBounds.w));\n    float d = distance(coords, selfCoords);\n    #ifdef depthTextureSupport\n        if (d > dQuarterThreshold) {\n            return texture2D(tDepthQuarter, c).r;\n        } else if (d > dHalfThreshold) {\n            return texture2D(tDepthHalf, c).r;\n        } else {\n            return texture2D(tDepth, c).r;\n        }\n    #else\n        if (d > dQuarterThreshold) {\n            return unpackRGBAToDepth(texture2D(tDepthQuarter, c));\n        } else if (d > dHalfThreshold) {\n            return unpackRGBAToDepth(texture2D(tDepthHalf, c));\n        } else {\n            return unpackRGBAToDepth(texture2D(tDepth, c));\n        }\n    #endif\n}\n\n// adapted from https://gist.github.com/bgolus/a07ed65602c009d5e2f753826e8078a0\nvec3 viewNormalAtPixelPositionAccurate(vec2 vpos) {\n    // current pixel's depth\n    float c = getDepth(vpos);\n\n    // get current pixel's view space position\n    vec3 viewSpacePos_c = screenSpaceToViewSpace(vec3(vpos, c), uInvProjection);\n\n    // get view space position at 1 pixel offsets in each major direction\n    vec3 viewSpacePos_l = screenSpaceToViewSpace(vec3(vpos + vec2(-1.0, 0.0) / uTexSize, getDepth(vpos + vec2(-1.0, 0.0) / uTexSize)), uInvProjection);\n    vec3 viewSpacePos_r = screenSpaceToViewSpace(vec3(vpos + vec2( 1.0, 0.0) / uTexSize, getDepth(vpos + vec2( 1.0, 0.0) / uTexSize)), uInvProjection);\n    vec3 viewSpacePos_d = screenSpaceToViewSpace(vec3(vpos + vec2( 0.0,-1.0) / uTexSize, getDepth(vpos + vec2( 0.0,-1.0) / uTexSize)), uInvProjection);\n    vec3 viewSpacePos_u = screenSpaceToViewSpace(vec3(vpos + vec2( 0.0, 1.0) / uTexSize, getDepth(vpos + vec2( 0.0, 1.0) / uTexSize)), uInvProjection);\n\n    // get the difference between the current and each offset position\n    vec3 l = viewSpacePos_c - viewSpacePos_l;\n    vec3 r = viewSpacePos_r - viewSpacePos_c;\n    vec3 d = viewSpacePos_c - viewSpacePos_d;\n    vec3 u = viewSpacePos_u - viewSpacePos_c;\n\n    // get depth values at 1 & 2 pixels offsets from current along the horizontal axis\n    vec4 H = vec4(\n        getDepth(vpos + vec2(-1.0, 0.0) / uTexSize),\n        getDepth(vpos + vec2( 1.0, 0.0) / uTexSize),\n        getDepth(vpos + vec2(-2.0, 0.0) / uTexSize),\n        getDepth(vpos + vec2( 2.0, 0.0) / uTexSize)\n    );\n\n    // get depth values at 1 & 2 pixels offsets from current along the vertical axis\n    vec4 V = vec4(\n        getDepth(vpos + vec2(0.0,-1.0) / uTexSize),\n        getDepth(vpos + vec2(0.0, 1.0) / uTexSize),\n        getDepth(vpos + vec2(0.0,-2.0) / uTexSize),\n        getDepth(vpos + vec2(0.0, 2.0) / uTexSize)\n    );\n\n    // current pixel's depth difference from slope of offset depth samples\n    // differs from original article because we're using non-linear depth values\n    // see article's comments\n    vec2 he = abs((2.0 * H.xy - H.zw) - c);\n    vec2 ve = abs((2.0 * V.xy - V.zw) - c);\n\n    // pick horizontal and vertical diff with the smallest depth difference from slopes\n    vec3 hDeriv = he.x < he.y ? l : r;\n    vec3 vDeriv = ve.x < ve.y ? d : u;\n\n    // get view space normal from the cross product of the best derivatives\n    vec3 viewNormal = normalize(cross(hDeriv, vDeriv));\n\n    return viewNormal;\n}\n\nfloat getPixelSize(const in vec2 coords, const in float depth) {\n    vec3 viewPos0 = screenSpaceToViewSpace(vec3(coords, depth), uInvProjection);\n    vec3 viewPos1 = screenSpaceToViewSpace(vec3(coords + vec2(1.0, 0.0) / uTexSize, depth), uInvProjection);\n    return distance(viewPos0, viewPos1);\n}\n\n// StarCraft II Ambient Occlusion by [Filion and McNaughton 2008]\nvoid main(void) {\n    vec2 invTexSize = 1.0 / uTexSize;\n    vec2 selfCoords = gl_FragCoord.xy * invTexSize;\n\n    float selfDepth = getDepth(selfCoords);\n    vec2 selfPackedDepth = packUnitIntervalToRG(selfDepth);\n\n    if (isBackground(selfDepth)) {\n        gl_FragColor = vec4(packUnitIntervalToRG(1.0), selfPackedDepth);\n        return;\n    }\n\n    vec3 selfViewNormal = viewNormalAtPixelPositionAccurate(selfCoords);\n    vec3 selfViewPos = screenSpaceToViewSpace(vec3(selfCoords, selfDepth), uInvProjection);\n\n    vec3 randomVec = normalize(vec3(getNoiseVec2(selfCoords) * 2.0 - 1.0, 0.0));\n    vec3 tangent = normalize(randomVec - selfViewNormal * dot(randomVec, selfViewNormal));\n    vec3 bitangent = cross(selfViewNormal, tangent);\n    mat3 TBN = mat3(tangent, bitangent, selfViewNormal);\n\n    float occlusion = 0.0;\n    #ifdef dMultiScale\n        float pixelSize = getPixelSize(selfCoords, selfDepth);\n\n        for(int l = 0; l < dLevels; l++) {\n            // TODO: smooth transition\n            if (pixelSize * uNearThreshold > uLevelRadius[l]) continue;\n            if (pixelSize * uFarThreshold < uLevelRadius[l]) continue;\n\n            float levelOcclusion = 0.0;\n            for(int i = 0; i < dNSamples; i++) {\n                // get sample position:\n                vec3 sampleViewPos = TBN * uSamples[i];\n                sampleViewPos = selfViewPos + sampleViewPos * uLevelRadius[l];\n\n                // project sample position:\n                vec4 offset = vec4(sampleViewPos, 1.0);\n                offset = uProjection * offset;\n                offset.xyz = (offset.xyz / offset.w) * 0.5 + 0.5;\n\n                // get sample depth:\n                float sampleDepth = getMappedDepth(offset.xy, selfCoords);\n                float sampleViewZ = screenSpaceToViewSpace(vec3(offset.xy, sampleDepth), uInvProjection).z;\n                levelOcclusion += step(sampleViewPos.z + 0.025, sampleViewZ) * smootherstep(0.0, 1.0, uLevelRadius[l] / abs(selfViewPos.z - sampleViewZ)) * uLevelBias[l];\n            }\n            occlusion = max(occlusion, levelOcclusion);\n        }\n    #else\n        for(int i = 0; i < dNSamples; i++) {\n            vec3 sampleViewPos = TBN * uSamples[i];\n            sampleViewPos = selfViewPos + sampleViewPos * uRadius;\n\n            vec4 offset = vec4(sampleViewPos, 1.0);\n            offset = uProjection * offset;\n            offset.xyz = (offset.xyz / offset.w) * 0.5 + 0.5;\n\n            float sampleDepth = getMappedDepth(offset.xy, selfCoords);\n            float sampleViewZ = screenSpaceToViewSpace(vec3(offset.xy, sampleDepth), uInvProjection).z;\n\n            occlusion += step(sampleViewPos.z + 0.025, sampleViewZ) * smootherstep(0.0, 1.0, uRadius / abs(selfViewPos.z - sampleViewZ));\n        }\n    #endif\n    occlusion = 1.0 - (uBias * occlusion / float(dNSamples));\n\n    vec2 packedOcclusion = packUnitIntervalToRG(clamp(occlusion, 0.01, 1.0));\n\n    gl_FragColor = vec4(packedOcclusion, selfPackedDepth);\n}\n";

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

@@ -1,180 +1,219 @@
 /**
- * Copyright (c) 2019-2023 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2019-2024 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>
+ * @author Ludovic Autin <ludovic.autin@gmail.com>
  */
-export const ssao_frag = `
-precision highp float;
-precision highp int;
-precision highp sampler2D;
-
-#include common
-
-uniform sampler2D tDepth;
-uniform sampler2D tDepthHalf;
-uniform sampler2D tDepthQuarter;
-uniform vec2 uTexSize;
-uniform vec4 uBounds;
-
-uniform vec3 uSamples[dNSamples];
-
-uniform mat4 uProjection;
-uniform mat4 uInvProjection;
-
-#ifdef dMultiScale
-    uniform float uLevelRadius[dLevels];
-    uniform float uLevelBias[dLevels];
-    uniform float uNearThreshold;
-    uniform float uFarThreshold;
-#else
-    uniform float uRadius;
-#endif
-uniform float uBias;
-
-float smootherstep(float edge0, float edge1, float x) {
-    x = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);
-    return x * x * x * (x * (x * 6.0 - 15.0) + 10.0);
-}
-
-float noise(const in vec2 coords) {
-    float a = 12.9898;
-    float b = 78.233;
-    float c = 43758.5453;
-    float dt = dot(coords, vec2(a,b));
-    float sn = mod(dt, PI);
-    return abs(fract(sin(sn) * c)); // is abs necessary?
-}
-
-vec2 getNoiseVec2(const in vec2 coords) {
-    return vec2(noise(coords), noise(coords + vec2(PI, 2.71828)));
-}
-
-bool isBackground(const in float depth) {
-    return depth == 1.0;
-}
-
-float getDepth(const in vec2 coords) {
-    vec2 c = vec2(clamp(coords.x, uBounds.x, uBounds.z), clamp(coords.y, uBounds.y, uBounds.w));
-    #ifdef depthTextureSupport
-        return texture2D(tDepth, c).r;
-    #else
-        return unpackRGBAToDepth(texture2D(tDepth, c));
-    #endif
-}
-
-#define dQuarterThreshold 0.1
-#define dHalfThreshold 0.05
-
-float getMappedDepth(const in vec2 coords, const in vec2 selfCoords) {
-    vec2 c = vec2(clamp(coords.x, uBounds.x, uBounds.z), clamp(coords.y, uBounds.y, uBounds.w));
-    float d = distance(coords, selfCoords);
-    #ifdef depthTextureSupport
-        if (d > dQuarterThreshold) {
-            return texture2D(tDepthQuarter, c).r;
-        } else if (d > dHalfThreshold) {
-            return texture2D(tDepthHalf, c).r;
-        } else {
-            return texture2D(tDepth, c).r;
-        }
-    #else
-        if (d > dQuarterThreshold) {
-            return unpackRGBAToDepth(texture2D(tDepthQuarter, c));
-        } else if (d > dHalfThreshold) {
-            return unpackRGBAToDepth(texture2D(tDepthHalf, c));
-        } else {
-            return unpackRGBAToDepth(texture2D(tDepth, c));
-        }
-    #endif
-}
-
-vec3 normalFromDepth(const in float depth, const in float depth1, const in float depth2, vec2 offset1, vec2 offset2) {
-    vec3 p1 = vec3(offset1, depth1 - depth);
-    vec3 p2 = vec3(offset2, depth2 - depth);
-
-    vec3 normal = cross(p1, p2);
-    normal.z = -normal.z;
-
-    return normalize(normal);
-}
-
-float getPixelSize(const in vec2 coords, const in float depth) {
-    vec3 viewPos0 = screenSpaceToViewSpace(vec3(coords, depth), uInvProjection);
-    vec3 viewPos1 = screenSpaceToViewSpace(vec3(coords + vec2(1.0, 0.0) / uTexSize, depth), uInvProjection);
-    return distance(viewPos0, viewPos1);
-}
-
-// StarCraft II Ambient Occlusion by [Filion and McNaughton 2008]
-void main(void) {
-    vec2 invTexSize = 1.0 / uTexSize;
-    vec2 selfCoords = gl_FragCoord.xy * invTexSize;
-
-    float selfDepth = getDepth(selfCoords);
-    vec2 selfPackedDepth = packUnitIntervalToRG(selfDepth);
-
-    if (isBackground(selfDepth)) {
-        gl_FragColor = vec4(packUnitIntervalToRG(1.0), selfPackedDepth);
-        return;
-    }
-
-    vec2 offset1 = vec2(0.0, invTexSize.y);
-    vec2 offset2 = vec2(invTexSize.x, 0.0);
-
-    float selfDepth1 = getDepth(selfCoords + offset1);
-    float selfDepth2 = getDepth(selfCoords + offset2);
-
-    vec3 selfViewNormal = normalFromDepth(selfDepth, selfDepth1, selfDepth2, offset1, offset2);
-    vec3 selfViewPos = screenSpaceToViewSpace(vec3(selfCoords, selfDepth), uInvProjection);
-
-    vec3 randomVec = normalize(vec3(getNoiseVec2(selfCoords) * 2.0 - 1.0, 0.0));
-    vec3 tangent = normalize(randomVec - selfViewNormal * dot(randomVec, selfViewNormal));
-    vec3 bitangent = cross(selfViewNormal, tangent);
-    mat3 TBN = mat3(tangent, bitangent, selfViewNormal);
-
-    float occlusion = 0.0;
-    #ifdef dMultiScale
-        float pixelSize = getPixelSize(selfCoords, selfDepth);
-
-        for(int l = 0; l < dLevels; l++) {
-            // TODO: smooth transition
-            if (pixelSize * uNearThreshold > uLevelRadius[l]) continue;
-            if (pixelSize * uFarThreshold < uLevelRadius[l]) continue;
-
-            float levelOcclusion = 0.0;
-            for(int i = 0; i < dNSamples; i++) {
-                vec3 sampleViewPos = TBN * uSamples[i];
-                sampleViewPos = selfViewPos + sampleViewPos * uLevelRadius[l];
-
-                vec4 offset = vec4(sampleViewPos, 1.0);
-                offset = uProjection * offset;
-                offset.xyz = (offset.xyz / offset.w) * 0.5 + 0.5;
-
-                float sampleDepth = getMappedDepth(offset.xy, selfCoords);
-                float sampleViewZ = screenSpaceToViewSpace(vec3(offset.xy, sampleDepth), uInvProjection).z;
-
-                levelOcclusion += step(sampleViewPos.z + 0.025, sampleViewZ) * smootherstep(0.0, 1.0, uLevelRadius[l] / abs(selfViewPos.z - sampleViewZ)) * uLevelBias[l];
-            }
-            occlusion = max(occlusion, levelOcclusion);
-        }
-    #else
-        for(int i = 0; i < dNSamples; i++) {
-            vec3 sampleViewPos = TBN * uSamples[i];
-            sampleViewPos = selfViewPos + sampleViewPos * uRadius;
-
-            vec4 offset = vec4(sampleViewPos, 1.0);
-            offset = uProjection * offset;
-            offset.xyz = (offset.xyz / offset.w) * 0.5 + 0.5;
-
-            float sampleDepth = getMappedDepth(offset.xy, selfCoords);
-            float sampleViewZ = screenSpaceToViewSpace(vec3(offset.xy, sampleDepth), uInvProjection).z;
-
-            occlusion += step(sampleViewPos.z + 0.025, sampleViewZ) * smootherstep(0.0, 1.0, uRadius / abs(selfViewPos.z - sampleViewZ));
-        }
-    #endif
-    occlusion = 1.0 - (uBias * occlusion / float(dNSamples));
-
-    vec2 packedOcclusion = packUnitIntervalToRG(clamp(occlusion, 0.01, 1.0));
-
-    gl_FragColor = vec4(packedOcclusion, selfPackedDepth);
-}
+export const ssao_frag = `
+precision highp float;
+precision highp int;
+precision highp sampler2D;
+
+#include common
+
+uniform sampler2D tDepth;
+uniform sampler2D tDepthHalf;
+uniform sampler2D tDepthQuarter;
+uniform vec2 uTexSize;
+uniform vec4 uBounds;
+
+uniform vec3 uSamples[dNSamples];
+
+uniform mat4 uProjection;
+uniform mat4 uInvProjection;
+
+#ifdef dMultiScale
+    uniform float uLevelRadius[dLevels];
+    uniform float uLevelBias[dLevels];
+    uniform float uNearThreshold;
+    uniform float uFarThreshold;
+#else
+    uniform float uRadius;
+#endif
+uniform float uBias;
+
+float smootherstep(float edge0, float edge1, float x) {
+    x = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);
+    return x * x * x * (x * (x * 6.0 - 15.0) + 10.0);
+}
+
+float noise(const in vec2 coords) {
+    float a = 12.9898;
+    float b = 78.233;
+    float c = 43758.5453;
+    float dt = dot(coords, vec2(a,b));
+    float sn = mod(dt, PI);
+    return abs(fract(sin(sn) * c)); // is abs necessary?
+}
+
+vec2 getNoiseVec2(const in vec2 coords) {
+    return vec2(noise(coords), noise(coords + vec2(PI, 2.71828)));
+}
+
+bool isBackground(const in float depth) {
+    return depth == 1.0;
+}
+
+float getDepth(const in vec2 coords) {
+    vec2 c = vec2(clamp(coords.x, uBounds.x, uBounds.z), clamp(coords.y, uBounds.y, uBounds.w));
+    #ifdef depthTextureSupport
+        return texture2D(tDepth, c).r;
+    #else
+        return unpackRGBAToDepth(texture2D(tDepth, c));
+    #endif
+}
+
+#define dQuarterThreshold 0.1
+#define dHalfThreshold 0.05
+
+float getMappedDepth(const in vec2 coords, const in vec2 selfCoords) {
+    vec2 c = vec2(clamp(coords.x, uBounds.x, uBounds.z), clamp(coords.y, uBounds.y, uBounds.w));
+    float d = distance(coords, selfCoords);
+    #ifdef depthTextureSupport
+        if (d > dQuarterThreshold) {
+            return texture2D(tDepthQuarter, c).r;
+        } else if (d > dHalfThreshold) {
+            return texture2D(tDepthHalf, c).r;
+        } else {
+            return texture2D(tDepth, c).r;
+        }
+    #else
+        if (d > dQuarterThreshold) {
+            return unpackRGBAToDepth(texture2D(tDepthQuarter, c));
+        } else if (d > dHalfThreshold) {
+            return unpackRGBAToDepth(texture2D(tDepthHalf, c));
+        } else {
+            return unpackRGBAToDepth(texture2D(tDepth, c));
+        }
+    #endif
+}
+
+// adapted from https://gist.github.com/bgolus/a07ed65602c009d5e2f753826e8078a0
+vec3 viewNormalAtPixelPositionAccurate(vec2 vpos) {
+    // current pixel's depth
+    float c = getDepth(vpos);
+
+    // get current pixel's view space position
+    vec3 viewSpacePos_c = screenSpaceToViewSpace(vec3(vpos, c), uInvProjection);
+
+    // get view space position at 1 pixel offsets in each major direction
+    vec3 viewSpacePos_l = screenSpaceToViewSpace(vec3(vpos + vec2(-1.0, 0.0) / uTexSize, getDepth(vpos + vec2(-1.0, 0.0) / uTexSize)), uInvProjection);
+    vec3 viewSpacePos_r = screenSpaceToViewSpace(vec3(vpos + vec2( 1.0, 0.0) / uTexSize, getDepth(vpos + vec2( 1.0, 0.0) / uTexSize)), uInvProjection);
+    vec3 viewSpacePos_d = screenSpaceToViewSpace(vec3(vpos + vec2( 0.0,-1.0) / uTexSize, getDepth(vpos + vec2( 0.0,-1.0) / uTexSize)), uInvProjection);
+    vec3 viewSpacePos_u = screenSpaceToViewSpace(vec3(vpos + vec2( 0.0, 1.0) / uTexSize, getDepth(vpos + vec2( 0.0, 1.0) / uTexSize)), uInvProjection);
+
+    // get the difference between the current and each offset position
+    vec3 l = viewSpacePos_c - viewSpacePos_l;
+    vec3 r = viewSpacePos_r - viewSpacePos_c;
+    vec3 d = viewSpacePos_c - viewSpacePos_d;
+    vec3 u = viewSpacePos_u - viewSpacePos_c;
+
+    // get depth values at 1 & 2 pixels offsets from current along the horizontal axis
+    vec4 H = vec4(
+        getDepth(vpos + vec2(-1.0, 0.0) / uTexSize),
+        getDepth(vpos + vec2( 1.0, 0.0) / uTexSize),
+        getDepth(vpos + vec2(-2.0, 0.0) / uTexSize),
+        getDepth(vpos + vec2( 2.0, 0.0) / uTexSize)
+    );
+
+    // get depth values at 1 & 2 pixels offsets from current along the vertical axis
+    vec4 V = vec4(
+        getDepth(vpos + vec2(0.0,-1.0) / uTexSize),
+        getDepth(vpos + vec2(0.0, 1.0) / uTexSize),
+        getDepth(vpos + vec2(0.0,-2.0) / uTexSize),
+        getDepth(vpos + vec2(0.0, 2.0) / uTexSize)
+    );
+
+    // current pixel's depth difference from slope of offset depth samples
+    // differs from original article because we're using non-linear depth values
+    // see article's comments
+    vec2 he = abs((2.0 * H.xy - H.zw) - c);
+    vec2 ve = abs((2.0 * V.xy - V.zw) - c);
+
+    // pick horizontal and vertical diff with the smallest depth difference from slopes
+    vec3 hDeriv = he.x < he.y ? l : r;
+    vec3 vDeriv = ve.x < ve.y ? d : u;
+
+    // get view space normal from the cross product of the best derivatives
+    vec3 viewNormal = normalize(cross(hDeriv, vDeriv));
+
+    return viewNormal;
+}
+
+float getPixelSize(const in vec2 coords, const in float depth) {
+    vec3 viewPos0 = screenSpaceToViewSpace(vec3(coords, depth), uInvProjection);
+    vec3 viewPos1 = screenSpaceToViewSpace(vec3(coords + vec2(1.0, 0.0) / uTexSize, depth), uInvProjection);
+    return distance(viewPos0, viewPos1);
+}
+
+// StarCraft II Ambient Occlusion by [Filion and McNaughton 2008]
+void main(void) {
+    vec2 invTexSize = 1.0 / uTexSize;
+    vec2 selfCoords = gl_FragCoord.xy * invTexSize;
+
+    float selfDepth = getDepth(selfCoords);
+    vec2 selfPackedDepth = packUnitIntervalToRG(selfDepth);
+
+    if (isBackground(selfDepth)) {
+        gl_FragColor = vec4(packUnitIntervalToRG(1.0), selfPackedDepth);
+        return;
+    }
+
+    vec3 selfViewNormal = viewNormalAtPixelPositionAccurate(selfCoords);
+    vec3 selfViewPos = screenSpaceToViewSpace(vec3(selfCoords, selfDepth), uInvProjection);
+
+    vec3 randomVec = normalize(vec3(getNoiseVec2(selfCoords) * 2.0 - 1.0, 0.0));
+    vec3 tangent = normalize(randomVec - selfViewNormal * dot(randomVec, selfViewNormal));
+    vec3 bitangent = cross(selfViewNormal, tangent);
+    mat3 TBN = mat3(tangent, bitangent, selfViewNormal);
+
+    float occlusion = 0.0;
+    #ifdef dMultiScale
+        float pixelSize = getPixelSize(selfCoords, selfDepth);
+
+        for(int l = 0; l < dLevels; l++) {
+            // TODO: smooth transition
+            if (pixelSize * uNearThreshold > uLevelRadius[l]) continue;
+            if (pixelSize * uFarThreshold < uLevelRadius[l]) continue;
+
+            float levelOcclusion = 0.0;
+            for(int i = 0; i < dNSamples; i++) {
+                // get sample position:
+                vec3 sampleViewPos = TBN * uSamples[i];
+                sampleViewPos = selfViewPos + sampleViewPos * uLevelRadius[l];
+
+                // project sample position:
+                vec4 offset = vec4(sampleViewPos, 1.0);
+                offset = uProjection * offset;
+                offset.xyz = (offset.xyz / offset.w) * 0.5 + 0.5;
+
+                // get sample depth:
+                float sampleDepth = getMappedDepth(offset.xy, selfCoords);
+                float sampleViewZ = screenSpaceToViewSpace(vec3(offset.xy, sampleDepth), uInvProjection).z;
+                levelOcclusion += step(sampleViewPos.z + 0.025, sampleViewZ) * smootherstep(0.0, 1.0, uLevelRadius[l] / abs(selfViewPos.z - sampleViewZ)) * uLevelBias[l];
+            }
+            occlusion = max(occlusion, levelOcclusion);
+        }
+    #else
+        for(int i = 0; i < dNSamples; i++) {
+            vec3 sampleViewPos = TBN * uSamples[i];
+            sampleViewPos = selfViewPos + sampleViewPos * uRadius;
+
+            vec4 offset = vec4(sampleViewPos, 1.0);
+            offset = uProjection * offset;
+            offset.xyz = (offset.xyz / offset.w) * 0.5 + 0.5;
+
+            float sampleDepth = getMappedDepth(offset.xy, selfCoords);
+            float sampleViewZ = screenSpaceToViewSpace(vec3(offset.xy, sampleDepth), uInvProjection).z;
+
+            occlusion += step(sampleViewPos.z + 0.025, sampleViewZ) * smootherstep(0.0, 1.0, uRadius / abs(selfViewPos.z - sampleViewZ));
+        }
+    #endif
+    occlusion = 1.0 - (uBias * occlusion / float(dNSamples));
+
+    vec2 packedOcclusion = packUnitIntervalToRG(clamp(occlusion, 0.01, 1.0));
+
+    gl_FragColor = vec4(packedOcclusion, selfPackedDepth);
+}
 `;