molstar 4.0.1 → 4.2.0

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

@@ -4,127 +4,127 @@
  * @author Ludovic Autin <ludovic.autin@gmail.com>
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
-export const shadows_frag = `
-precision highp float;
-precision highp int;
-precision highp sampler2D;
-
-#include common
-
-uniform sampler2D tDepth;
-uniform vec2 uTexSize;
-uniform vec4 uBounds;
-
-uniform float uNear;
-uniform float uFar;
-
-#if dLightCount != 0
-    uniform vec3 uLightDirection[dLightCount];
-    uniform vec3 uLightColor[dLightCount];
-#endif
-
-uniform mat4 uProjection;
-uniform mat4 uInvProjection;
-
-uniform float uMaxDistance;
-uniform float uTolerance;
-uniform float uBias;
-
-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 getViewZ(const in float depth) {
-    #if dOrthographic == 1
-        return orthographicDepthToViewZ(depth, uNear, uFar);
-    #else
-        return perspectiveDepthToViewZ(depth, uNear, uFar);
-    #endif
-}
-
-float getDepth(const in vec2 coords) {
-    #ifdef depthTextureSupport
-        return texture2D(tDepth, coords).r;
-    #else
-        return unpackRGBAToDepth(texture2D(tDepth, coords));
-    #endif
-}
-
-float screenFade(const in vec2 coords) {
-    vec2 c = (coords - uBounds.xy) / (uBounds.zw - uBounds.xy);
-    vec2 fade = max(12.0 * abs(c - 0.5) - 5.0, vec2(0.0));
-    return saturate(1.0 - dot(fade, fade));
-}
-
-// based on https://panoskarabelas.com/posts/screen_space_shadows/
-float screenSpaceShadow(const in vec3 position, const in vec3 lightDirection, const in float stepLength) {
-    // Ray position and direction (in view-space)
-    vec3 rayPos = position;
-    vec3 rayDir = -lightDirection;
-
-    // Compute ray step
-    vec3 rayStep = rayDir * stepLength;
-
-    // Ray march towards the light
-    float occlusion = 0.0;
-    vec4 rayCoords = vec4(0.0);
-    for (int i = 0; i < dSteps; ++i) {
-        // Step the ray
-        rayPos += rayStep;
-
-        rayCoords = uProjection * vec4(rayPos, 1.0);
-        rayCoords.xyz = (rayCoords.xyz / rayCoords.w) * 0.5 + 0.5;
-
-        if (outsideBounds(rayCoords.xy))
-            return 1.0;
-
-        // Compute the difference between the ray's and the camera's depth
-        float depth = getDepth(rayCoords.xy);
-        float viewZ = getViewZ(depth);
-        float zDelta = rayPos.z - viewZ;
-
-        if (zDelta < uTolerance) {
-            occlusion = 1.0;
-
-            // Fade out as we approach the edges of the screen
-            occlusion *= screenFade(rayCoords.xy);
-
-            break;
-        }
-    }
-
-    return 1.0 - (uBias * occlusion);
-}
-
-void main(void) {
-    vec2 invTexSize = 1.0 / uTexSize;
-    vec2 selfCoords = gl_FragCoord.xy * invTexSize;
-
-    float selfDepth = getDepth(selfCoords);
-
-    if (isBackground(selfDepth)) {
-        gl_FragColor = vec4(0.0);
-        return;
-    }
-
-    vec3 selfViewPos = screenSpaceToViewSpace(vec3(selfCoords, selfDepth), uInvProjection);
-    float stepLength = uMaxDistance / float(dSteps);
-
-    float o = 1.0;
-    #if dLightCount != 0
-        float sh[dLightCount];
-        #pragma unroll_loop_start
-        for (int i = 0; i < dLightCount; ++i) {
-            sh[i] = screenSpaceShadow(selfViewPos, uLightDirection[i], stepLength);
-            o = min(o, sh[i]);
-        }
-        #pragma unroll_loop_end
-    #endif
-
-    gl_FragColor = vec4(o);
-}
+export const shadows_frag = `
+precision highp float;
+precision highp int;
+precision highp sampler2D;
+
+#include common
+
+uniform sampler2D tDepth;
+uniform vec2 uTexSize;
+uniform vec4 uBounds;
+
+uniform float uNear;
+uniform float uFar;
+
+#if dLightCount != 0
+    uniform vec3 uLightDirection[dLightCount];
+    uniform vec3 uLightColor[dLightCount];
+#endif
+
+uniform mat4 uProjection;
+uniform mat4 uInvProjection;
+
+uniform float uMaxDistance;
+uniform float uTolerance;
+uniform float uBias;
+
+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 getViewZ(const in float depth) {
+    #if dOrthographic == 1
+        return orthographicDepthToViewZ(depth, uNear, uFar);
+    #else
+        return perspectiveDepthToViewZ(depth, uNear, uFar);
+    #endif
+}
+
+float getDepth(const in vec2 coords) {
+    #ifdef depthTextureSupport
+        return texture2D(tDepth, coords).r;
+    #else
+        return unpackRGBAToDepth(texture2D(tDepth, coords));
+    #endif
+}
+
+float screenFade(const in vec2 coords) {
+    vec2 c = (coords - uBounds.xy) / (uBounds.zw - uBounds.xy);
+    vec2 fade = max(12.0 * abs(c - 0.5) - 5.0, vec2(0.0));
+    return saturate(1.0 - dot(fade, fade));
+}
+
+// based on https://panoskarabelas.com/posts/screen_space_shadows/
+float screenSpaceShadow(const in vec3 position, const in vec3 lightDirection, const in float stepLength) {
+    // Ray position and direction (in view-space)
+    vec3 rayPos = position;
+    vec3 rayDir = -lightDirection;
+
+    // Compute ray step
+    vec3 rayStep = rayDir * stepLength;
+
+    // Ray march towards the light
+    float occlusion = 0.0;
+    vec4 rayCoords = vec4(0.0);
+    for (int i = 0; i < dSteps; ++i) {
+        // Step the ray
+        rayPos += rayStep;
+
+        rayCoords = uProjection * vec4(rayPos, 1.0);
+        rayCoords.xyz = (rayCoords.xyz / rayCoords.w) * 0.5 + 0.5;
+
+        if (outsideBounds(rayCoords.xy))
+            return 1.0;
+
+        // Compute the difference between the ray's and the camera's depth
+        float depth = getDepth(rayCoords.xy);
+        float viewZ = getViewZ(depth);
+        float zDelta = rayPos.z - viewZ;
+
+        if (zDelta < uTolerance) {
+            occlusion = 1.0;
+
+            // Fade out as we approach the edges of the screen
+            occlusion *= screenFade(rayCoords.xy);
+
+            break;
+        }
+    }
+
+    return 1.0 - (uBias * occlusion);
+}
+
+void main(void) {
+    vec2 invTexSize = 1.0 / uTexSize;
+    vec2 selfCoords = gl_FragCoord.xy * invTexSize;
+
+    float selfDepth = getDepth(selfCoords);
+
+    if (isBackground(selfDepth)) {
+        gl_FragColor = vec4(0.0);
+        return;
+    }
+
+    vec3 selfViewPos = screenSpaceToViewSpace(vec3(selfCoords, selfDepth), uInvProjection);
+    float stepLength = uMaxDistance / float(dSteps);
+
+    float o = 1.0;
+    #if dLightCount != 0
+        float sh[dLightCount];
+        #pragma unroll_loop_start
+        for (int i = 0; i < dLightCount; ++i) {
+            sh[i] = screenSpaceShadow(selfViewPos, uLightDirection[i], stepLength);
+            o = min(o, sh[i]);
+        }
+        #pragma unroll_loop_end
+    #endif
+
+    gl_FragColor = vec4(o);
+}
 `;

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

@@ -6,60 +6,60 @@
  * Preset: SMAA 1x Medium (with color edge detection)
  * https://github.com/iryoku/smaa/releases/tag/v2.8
  */
-export const blend_frag = `
-precision highp float;
-precision highp int;
-precision highp sampler2D;
-
-uniform sampler2D tWeights;
-uniform sampler2D tColor;
-uniform vec2 uTexSizeInv;
-
-varying vec2 vUv;
-varying vec4 vOffset[2];
-
-vec4 SMAANeighborhoodBlendingPS(vec2 texCoord, vec4 offset[2], sampler2D colorTex, sampler2D blendTex) {
-    // Fetch the blending weights for current pixel:
-    vec4 a;
-    a.xz = texture2D(blendTex, texCoord).xz;
-    a.y = texture2D(blendTex, offset[1].zw).g;
-    a.w = texture2D(blendTex, offset[1].xy).a;
-
-    // Is there any blending weight with a value greater than 0.0?
-    if (dot(a, vec4(1.0, 1.0, 1.0, 1.0)) < 1e-5) {
-        return texture2D(colorTex, texCoord, 0.0);
-    } else {
-        // Up to 4 lines can be crossing a pixel (one through each edge). We
-        // favor blending by choosing the line with the maximum weight for each
-        // direction:
-        vec2 offset;
-        offset.x = a.a > a.b ? a.a : -a.b; // left vs. right
-        offset.y = a.g > a.r ? -a.g : a.r; // top vs. bottom // WebGL port note: Changed signs
-
-        // Then we go in the direction that has the maximum weight:
-        if (abs(offset.x) > abs(offset.y)) { // horizontal vs. vertical
-            offset.y = 0.0;
-        } else {
-            offset.x = 0.0;
-        }
-
-        // Fetch the opposite color and lerp by hand:
-        vec4 C = texture2D(colorTex, texCoord, 0.0);
-        texCoord += sign(offset) * uTexSizeInv;
-        vec4 Cop = texture2D(colorTex, texCoord, 0.0);
-        float s = abs(offset.x) > abs(offset.y) ? abs(offset.x) : abs(offset.y);
-
-        // WebGL port note: Added gamma correction
-        C.xyz = pow(C.xyz, vec3(2.2));
-        Cop.xyz = pow(Cop.xyz, vec3(2.2));
-        vec4 mixed = mix(C, Cop, s);
-        mixed.xyz = pow(mixed.xyz, vec3(1.0 / 2.2));
-
-        return mixed;
-    }
-}
-
-void main() {
-    gl_FragColor = SMAANeighborhoodBlendingPS(vUv, vOffset, tColor, tWeights);
-}
+export const blend_frag = `
+precision highp float;
+precision highp int;
+precision highp sampler2D;
+
+uniform sampler2D tWeights;
+uniform sampler2D tColor;
+uniform vec2 uTexSizeInv;
+
+varying vec2 vUv;
+varying vec4 vOffset[2];
+
+vec4 SMAANeighborhoodBlendingPS(vec2 texCoord, vec4 offset[2], sampler2D colorTex, sampler2D blendTex) {
+    // Fetch the blending weights for current pixel:
+    vec4 a;
+    a.xz = texture2D(blendTex, texCoord).xz;
+    a.y = texture2D(blendTex, offset[1].zw).g;
+    a.w = texture2D(blendTex, offset[1].xy).a;
+
+    // Is there any blending weight with a value greater than 0.0?
+    if (dot(a, vec4(1.0, 1.0, 1.0, 1.0)) < 1e-5) {
+        return texture2D(colorTex, texCoord, 0.0);
+    } else {
+        // Up to 4 lines can be crossing a pixel (one through each edge). We
+        // favor blending by choosing the line with the maximum weight for each
+        // direction:
+        vec2 offset;
+        offset.x = a.a > a.b ? a.a : -a.b; // left vs. right
+        offset.y = a.g > a.r ? -a.g : a.r; // top vs. bottom // WebGL port note: Changed signs
+
+        // Then we go in the direction that has the maximum weight:
+        if (abs(offset.x) > abs(offset.y)) { // horizontal vs. vertical
+            offset.y = 0.0;
+        } else {
+            offset.x = 0.0;
+        }
+
+        // Fetch the opposite color and lerp by hand:
+        vec4 C = texture2D(colorTex, texCoord, 0.0);
+        texCoord += sign(offset) * uTexSizeInv;
+        vec4 Cop = texture2D(colorTex, texCoord, 0.0);
+        float s = abs(offset.x) > abs(offset.y) ? abs(offset.x) : abs(offset.y);
+
+        // WebGL port note: Added gamma correction
+        C.xyz = pow(C.xyz, vec3(2.2));
+        Cop.xyz = pow(Cop.xyz, vec3(2.2));
+        vec4 mixed = mix(C, Cop, s);
+        mixed.xyz = pow(mixed.xyz, vec3(1.0 / 2.2));
+
+        return mixed;
+    }
+}
+
+void main() {
+    gl_FragColor = SMAANeighborhoodBlendingPS(vUv, vOffset, tColor, tWeights);
+}
 `;

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

@@ -6,29 +6,29 @@
  * Preset: SMAA 1x Medium (with color edge detection)
  * https://github.com/iryoku/smaa/releases/tag/v2.8
  */
-export const blend_vert = `
-precision highp float;
-
-attribute vec2 aPosition;
-uniform vec2 uQuadScale;
-
-uniform vec2 uTexSizeInv;
-uniform vec4 uViewport;
-
-varying vec2 vUv;
-varying vec4 vOffset[2];
-
-void SMAANeighborhoodBlendingVS(vec2 texCoord) {
-    vOffset[0] = texCoord.xyxy + uTexSizeInv.xyxy * vec4(-1.0, 0.0, 0.0, 1.0); // WebGL port note: Changed sign in W component
-    vOffset[1] = texCoord.xyxy + uTexSizeInv.xyxy * vec4(1.0, 0.0, 0.0, -1.0); // WebGL port note: Changed sign in W component
-}
-
-void main() {
-    vec2 scale = uViewport.zw * uTexSizeInv;
-    vec2 shift = uViewport.xy * uTexSizeInv;
-    vUv = (aPosition + 1.0) * 0.5 * scale + shift;
-    SMAANeighborhoodBlendingVS(vUv);
-    vec2 position = aPosition * uQuadScale - vec2(1.0, 1.0) + uQuadScale;
-    gl_Position = vec4(position, 0.0, 1.0);
-}
+export const blend_vert = `
+precision highp float;
+
+attribute vec2 aPosition;
+uniform vec2 uQuadScale;
+
+uniform vec2 uTexSizeInv;
+uniform vec4 uViewport;
+
+varying vec2 vUv;
+varying vec4 vOffset[2];
+
+void SMAANeighborhoodBlendingVS(vec2 texCoord) {
+    vOffset[0] = texCoord.xyxy + uTexSizeInv.xyxy * vec4(-1.0, 0.0, 0.0, 1.0); // WebGL port note: Changed sign in W component
+    vOffset[1] = texCoord.xyxy + uTexSizeInv.xyxy * vec4(1.0, 0.0, 0.0, -1.0); // WebGL port note: Changed sign in W component
+}
+
+void main() {
+    vec2 scale = uViewport.zw * uTexSizeInv;
+    vec2 shift = uViewport.xy * uTexSizeInv;
+    vUv = (aPosition + 1.0) * 0.5 * scale + shift;
+    SMAANeighborhoodBlendingVS(vUv);
+    vec2 position = aPosition * uQuadScale - vec2(1.0, 1.0) + uQuadScale;
+    gl_Position = vec4(position, 0.0, 1.0);
+}
 `;

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

@@ -6,70 +6,70 @@
  * Preset: SMAA 1x Medium (with color edge detection)
  * https://github.com/iryoku/smaa/releases/tag/v2.8
  */
-export const edges_frag = `
-precision highp float;
-precision highp int;
-precision highp sampler2D;
-
-uniform sampler2D tColor;
-uniform vec2 uTexSizeInv;
-
-varying vec2 vUv;
-varying vec4 vOffset[3];
-
-vec4 SMAAColorEdgeDetectionPS(vec2 texcoord, vec4 offset[3], sampler2D colorTex) {
-    vec2 threshold = vec2(dEdgeThreshold, dEdgeThreshold);
-
-    // Calculate color deltas:
-    vec4 delta;
-    vec3 C = texture2D(colorTex, texcoord).rgb;
-
-    vec3 Cleft = texture2D(colorTex, offset[0].xy).rgb;
-    vec3 t = abs(C - Cleft);
-    delta.x = max(max(t.r, t.g), t.b);
-
-    vec3 Ctop = texture2D(colorTex, offset[0].zw).rgb;
-    t = abs(C - Ctop);
-    delta.y = max(max(t.r, t.g), t.b);
-
-    // We do the usual threshold:
-    vec2 edges = step(threshold, delta.xy);
-
-    // Then discard if there is no edge:
-    if (dot(edges, vec2(1.0, 1.0 )) == 0.0)
-        discard;
-
-    // Calculate right and bottom deltas:
-    vec3 Cright = texture2D(colorTex, offset[1].xy).rgb;
-    t = abs( C - Cright );
-    delta.z = max(max(t.r, t.g), t.b);
-
-    vec3 Cbottom  = texture2D(colorTex, offset[1].zw).rgb;
-    t = abs(C - Cbottom);
-    delta.w = max(max(t.r, t.g), t.b);
-
-    // Calculate the maximum delta in the direct neighborhood:
-    float maxDelta = max(max(max(delta.x, delta.y), delta.z), delta.w );
-
-    // Calculate left-left and top-top deltas:
-    vec3 Cleftleft  = texture2D(colorTex, offset[2].xy).rgb;
-    t = abs( C - Cleftleft );
-    delta.z = max(max(t.r, t.g), t.b);
-
-    vec3 Ctoptop = texture2D(colorTex, offset[2].zw).rgb;
-    t = abs(C - Ctoptop);
-    delta.w = max(max(t.r, t.g), t.b);
-
-    // Calculate the final maximum delta:
-    maxDelta = max(max(maxDelta, delta.z), delta.w);
-
-    // Local contrast adaptation in action:
-    edges.xy *= step(0.5 * maxDelta, delta.xy);
-
-    return vec4(edges, 0.0, 0.0);
-}
-
-void main() {
-    gl_FragColor = SMAAColorEdgeDetectionPS(vUv, vOffset, tColor);
-}
+export const edges_frag = `
+precision highp float;
+precision highp int;
+precision highp sampler2D;
+
+uniform sampler2D tColor;
+uniform vec2 uTexSizeInv;
+
+varying vec2 vUv;
+varying vec4 vOffset[3];
+
+vec4 SMAAColorEdgeDetectionPS(vec2 texcoord, vec4 offset[3], sampler2D colorTex) {
+    vec2 threshold = vec2(dEdgeThreshold, dEdgeThreshold);
+
+    // Calculate color deltas:
+    vec4 delta;
+    vec3 C = texture2D(colorTex, texcoord).rgb;
+
+    vec3 Cleft = texture2D(colorTex, offset[0].xy).rgb;
+    vec3 t = abs(C - Cleft);
+    delta.x = max(max(t.r, t.g), t.b);
+
+    vec3 Ctop = texture2D(colorTex, offset[0].zw).rgb;
+    t = abs(C - Ctop);
+    delta.y = max(max(t.r, t.g), t.b);
+
+    // We do the usual threshold:
+    vec2 edges = step(threshold, delta.xy);
+
+    // Then discard if there is no edge:
+    if (dot(edges, vec2(1.0, 1.0 )) == 0.0)
+        discard;
+
+    // Calculate right and bottom deltas:
+    vec3 Cright = texture2D(colorTex, offset[1].xy).rgb;
+    t = abs( C - Cright );
+    delta.z = max(max(t.r, t.g), t.b);
+
+    vec3 Cbottom  = texture2D(colorTex, offset[1].zw).rgb;
+    t = abs(C - Cbottom);
+    delta.w = max(max(t.r, t.g), t.b);
+
+    // Calculate the maximum delta in the direct neighborhood:
+    float maxDelta = max(max(max(delta.x, delta.y), delta.z), delta.w );
+
+    // Calculate left-left and top-top deltas:
+    vec3 Cleftleft  = texture2D(colorTex, offset[2].xy).rgb;
+    t = abs( C - Cleftleft );
+    delta.z = max(max(t.r, t.g), t.b);
+
+    vec3 Ctoptop = texture2D(colorTex, offset[2].zw).rgb;
+    t = abs(C - Ctoptop);
+    delta.w = max(max(t.r, t.g), t.b);
+
+    // Calculate the final maximum delta:
+    maxDelta = max(max(maxDelta, delta.z), delta.w);
+
+    // Local contrast adaptation in action:
+    edges.xy *= step(0.5 * maxDelta, delta.xy);
+
+    return vec4(edges, 0.0, 0.0);
+}
+
+void main() {
+    gl_FragColor = SMAAColorEdgeDetectionPS(vUv, vOffset, tColor);
+}
 `;

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

@@ -6,30 +6,30 @@
  * Preset: SMAA 1x Medium (with color edge detection)
  * https://github.com/iryoku/smaa/releases/tag/v2.8
  */
-export const edges_vert = `
-precision highp float;
-
-attribute vec2 aPosition;
-uniform vec2 uQuadScale;
-
-uniform vec2 uTexSizeInv;
-uniform vec4 uViewport;
-
-varying vec2 vUv;
-varying vec4 vOffset[3];
-
-void SMAAEdgeDetectionVS(vec2 texCoord) {
-    vOffset[0] = texCoord.xyxy + uTexSizeInv.xyxy * vec4(-1.0, 0.0, 0.0, 1.0); // WebGL port note: Changed sign in W component
-    vOffset[1] = texCoord.xyxy + uTexSizeInv.xyxy * vec4(1.0, 0.0, 0.0, -1.0); // WebGL port note: Changed sign in W component
-    vOffset[2] = texCoord.xyxy + uTexSizeInv.xyxy * vec4(-2.0, 0.0, 0.0, 2.0); // WebGL port note: Changed sign in W component
-}
-
-void main() {
-    vec2 scale = uViewport.zw * uTexSizeInv;
-    vec2 shift = uViewport.xy * uTexSizeInv;
-    vUv = (aPosition + 1.0) * 0.5 * scale + shift;
-    SMAAEdgeDetectionVS(vUv);
-    vec2 position = aPosition * uQuadScale - vec2(1.0, 1.0) + uQuadScale;
-    gl_Position = vec4(position, 0.0, 1.0);
-}
+export const edges_vert = `
+precision highp float;
+
+attribute vec2 aPosition;
+uniform vec2 uQuadScale;
+
+uniform vec2 uTexSizeInv;
+uniform vec4 uViewport;
+
+varying vec2 vUv;
+varying vec4 vOffset[3];
+
+void SMAAEdgeDetectionVS(vec2 texCoord) {
+    vOffset[0] = texCoord.xyxy + uTexSizeInv.xyxy * vec4(-1.0, 0.0, 0.0, 1.0); // WebGL port note: Changed sign in W component
+    vOffset[1] = texCoord.xyxy + uTexSizeInv.xyxy * vec4(1.0, 0.0, 0.0, -1.0); // WebGL port note: Changed sign in W component
+    vOffset[2] = texCoord.xyxy + uTexSizeInv.xyxy * vec4(-2.0, 0.0, 0.0, 2.0); // WebGL port note: Changed sign in W component
+}
+
+void main() {
+    vec2 scale = uViewport.zw * uTexSizeInv;
+    vec2 shift = uViewport.xy * uTexSizeInv;
+    vUv = (aPosition + 1.0) * 0.5 * scale + shift;
+    SMAAEdgeDetectionVS(vUv);
+    vec2 position = aPosition * uQuadScale - vec2(1.0, 1.0) + uQuadScale;
+    gl_Position = vec4(position, 0.0, 1.0);
+}
 `;