molstar 4.2.0 → 4.3.0

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

@@ -8,101 +8,101 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ssaoBlur_frag = void 0;
-exports.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);
-}
+exports.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/commonjs/mol-gl/shader/ssao.frag.js

@@ -8,215 +8,215 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ssao_frag = void 0;
-exports.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);
-}
+exports.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);
+}
 `;