molstar 4.2.0 → 4.3.0

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

@@ -6,42 +6,42 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.points_vert = void 0;
-exports.points_vert = `
-precision highp float;
-precision highp int;
-
-#include common
-#include read_from_texture
-#include common_vert_params
-#include color_vert_params
-#include size_vert_params
-#include common_clip
-
-uniform float uPixelRatio;
-uniform vec4 uViewport;
-
-attribute vec3 aPosition;
-attribute mat4 aTransform;
-attribute float aInstance;
-attribute float aGroup;
-
-void main(){
-    #include assign_group
-    #include assign_color_varying
-    #include assign_marker_varying
-    #include assign_clipping_varying
-    #include assign_position
-    #include assign_size
-
-    #ifdef dPointSizeAttenuation
-        gl_PointSize = size * uPixelRatio * ((uViewport.w / 2.0) / -mvPosition.z) * 5.0;
-    #else
-        gl_PointSize = size * uPixelRatio;
-    #endif
-    gl_PointSize = max(1.0, gl_PointSize);
-
-    gl_Position = uProjection * mvPosition;
-
-    #include clip_instance
-}
+exports.points_vert = `
+precision highp float;
+precision highp int;
+
+#include common
+#include read_from_texture
+#include common_vert_params
+#include color_vert_params
+#include size_vert_params
+#include common_clip
+
+uniform float uPixelRatio;
+uniform vec4 uViewport;
+
+attribute vec3 aPosition;
+attribute mat4 aTransform;
+attribute float aInstance;
+attribute float aGroup;
+
+void main(){
+    #include assign_group
+    #include assign_color_varying
+    #include assign_marker_varying
+    #include assign_clipping_varying
+    #include assign_position
+    #include assign_size
+
+    #ifdef dPointSizeAttenuation
+        gl_PointSize = size * uPixelRatio * ((uViewport.w / 2.0) / -mvPosition.z) * 5.0;
+    #else
+        gl_PointSize = size * uPixelRatio;
+    #endif
+    gl_PointSize = max(1.0, gl_PointSize);
+
+    gl_Position = uProjection * mvPosition;
+
+    #include clip_instance
+}
 `;

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

@@ -7,154 +7,154 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.postprocessing_frag = void 0;
-exports.postprocessing_frag = `
-precision highp float;
-precision highp int;
-precision highp sampler2D;
-
-uniform sampler2D tSsaoDepth;
-uniform sampler2D tColor;
-uniform sampler2D tDepthOpaque;
-uniform sampler2D tDepthTransparent;
-uniform sampler2D tShadows;
-uniform sampler2D tOutlines;
-uniform vec2 uTexSize;
-
-uniform float uNear;
-uniform float uFar;
-uniform float uFogNear;
-uniform float uFogFar;
-uniform vec3 uFogColor;
-uniform vec3 uOutlineColor;
-uniform vec3 uOcclusionColor;
-uniform bool uTransparentBackground;
-uniform vec2 uOcclusionOffset;
-
-#include common
-
-float getViewZ(const in float depth) {
-    #if dOrthographic == 1
-        return orthographicDepthToViewZ(depth, uNear, uFar);
-    #else
-        return perspectiveDepthToViewZ(depth, uNear, uFar);
-    #endif
-}
-
-float getDepthOpaque(const in vec2 coords) {
-    #ifdef depthTextureSupport
-        return texture2D(tDepthOpaque, coords).r;
-    #else
-        return unpackRGBAToDepth(texture2D(tDepthOpaque, coords));
-    #endif
-}
-
-float getDepthTransparent(const in vec2 coords) {
-    #ifdef dTransparentOutline
-        return unpackRGBAToDepth(texture2D(tDepthTransparent, coords));
-    #else
-        return 1.0;
-    #endif
-}
-
-bool isBackground(const in float depth) {
-    return depth == 1.0;
-}
-
-float getOutline(const in vec2 coords, const in float opaqueDepth, out float closestTexel) {
-    float backgroundViewZ = 2.0 * uFar;
-    vec2 invTexSize = 1.0 / uTexSize;
-
-    float transparentDepth = getDepthTransparent(coords);
-    float opaqueSelfViewZ = isBackground(opaqueDepth) ? backgroundViewZ : getViewZ(opaqueDepth);
-    float transparentSelfViewZ = isBackground(transparentDepth) ? backgroundViewZ : getViewZ(transparentDepth);
-    float selfDepth = min(opaqueDepth, transparentDepth);
-
-    float outline = 1.0;
-    closestTexel = 1.0;
-    for (int y = -dOutlineScale; y <= dOutlineScale; y++) {
-        for (int x = -dOutlineScale; x <= dOutlineScale; x++) {
-            if (x * x + y * y > dOutlineScale * dOutlineScale) {
-                continue;
-            }
-
-            vec2 sampleCoords = coords + vec2(float(x), float(y)) * invTexSize;
-
-            vec4 sampleOutlineCombined = texture2D(tOutlines, sampleCoords);
-            float sampleOutline = sampleOutlineCombined.r;
-            float sampleOutlineDepth = unpackRGToUnitInterval(sampleOutlineCombined.gb);
-            float sampleOutlineViewZ = isBackground(sampleOutlineDepth) ? backgroundViewZ : getViewZ(sampleOutlineDepth);
-
-            float selfViewZ = sampleOutlineCombined.a == 0.0 ? opaqueSelfViewZ : transparentSelfViewZ;
-            if (sampleOutline == 0.0 && sampleOutlineDepth < closestTexel) {
-                outline = 0.0;
-                closestTexel = sampleOutlineDepth;
-            }
-        }
-    }
-    return closestTexel < opaqueDepth ? outline : 1.0;
-}
-
-float getSsao(vec2 coords) {
-    float rawSsao = unpackRGToUnitInterval(texture2D(tSsaoDepth, coords).xy);
-    if (rawSsao > 0.999) {
-        return 1.0;
-    } else if (rawSsao > 0.001) {
-        return rawSsao;
-    }
-    // treat values close to 0.0 as errors and return no occlusion
-    return 1.0;
-}
-
-void main(void) {
-    vec2 coords = gl_FragCoord.xy / uTexSize;
-    vec4 color = texture2D(tColor, coords);
-
-    float viewDist;
-    float fogFactor;
-    float opaqueDepth = getDepthOpaque(coords);
-
-    #ifdef dOcclusionEnable
-        if (!isBackground(opaqueDepth)) {
-            viewDist = abs(getViewZ(opaqueDepth));
-            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);
-            float occlusionFactor = getSsao(coords + uOcclusionOffset);
-            if (!uTransparentBackground) {
-                color.rgb = mix(mix(uOcclusionColor, uFogColor, fogFactor), color.rgb, occlusionFactor);
-            } else {
-                color.rgb = mix(uOcclusionColor * (1.0 - fogFactor), color.rgb, occlusionFactor);
-            }
-        }
-    #endif
-
-    #ifdef dShadowEnable
-        if (!isBackground(opaqueDepth)) {
-            viewDist = abs(getViewZ(opaqueDepth));
-            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);
-            vec4 shadow = texture2D(tShadows, coords);
-            if (!uTransparentBackground) {
-                color.rgb = mix(mix(vec3(0), uFogColor, fogFactor), color.rgb, shadow.a);
-            } else {
-                color.rgb = mix(vec3(0) * (1.0 - fogFactor), color.rgb, shadow.a);
-            }
-        }
-    #endif
-
-    // outline needs to be handled after occlusion and shadow to keep them clean
-    #ifdef dOutlineEnable
-        float closestTexel;
-        float outline = getOutline(coords, opaqueDepth, closestTexel);
-        if (outline == 0.0) {
-            viewDist = abs(getViewZ(closestTexel));
-            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);
-            if (!uTransparentBackground) {
-                color.rgb = mix(uOutlineColor, uFogColor, fogFactor);
-            } else {
-                color.a = 1.0 - fogFactor;
-                color.rgb = mix(uOutlineColor, color.rgb, fogFactor);
-            }
-        }
-    #endif
-
-    gl_FragColor = color;
-}
+exports.postprocessing_frag = `
+precision highp float;
+precision highp int;
+precision highp sampler2D;
+
+uniform sampler2D tSsaoDepth;
+uniform sampler2D tColor;
+uniform sampler2D tDepthOpaque;
+uniform sampler2D tDepthTransparent;
+uniform sampler2D tShadows;
+uniform sampler2D tOutlines;
+uniform vec2 uTexSize;
+
+uniform float uNear;
+uniform float uFar;
+uniform float uFogNear;
+uniform float uFogFar;
+uniform vec3 uFogColor;
+uniform vec3 uOutlineColor;
+uniform vec3 uOcclusionColor;
+uniform bool uTransparentBackground;
+uniform vec2 uOcclusionOffset;
+
+#include common
+
+float getViewZ(const in float depth) {
+    #if dOrthographic == 1
+        return orthographicDepthToViewZ(depth, uNear, uFar);
+    #else
+        return perspectiveDepthToViewZ(depth, uNear, uFar);
+    #endif
+}
+
+float getDepthOpaque(const in vec2 coords) {
+    #ifdef depthTextureSupport
+        return texture2D(tDepthOpaque, coords).r;
+    #else
+        return unpackRGBAToDepth(texture2D(tDepthOpaque, coords));
+    #endif
+}
+
+float getDepthTransparent(const in vec2 coords) {
+    #ifdef dTransparentOutline
+        return unpackRGBAToDepth(texture2D(tDepthTransparent, coords));
+    #else
+        return 1.0;
+    #endif
+}
+
+bool isBackground(const in float depth) {
+    return depth == 1.0;
+}
+
+float getOutline(const in vec2 coords, const in float opaqueDepth, out float closestTexel) {
+    float backgroundViewZ = 2.0 * uFar;
+    vec2 invTexSize = 1.0 / uTexSize;
+
+    float transparentDepth = getDepthTransparent(coords);
+    float opaqueSelfViewZ = isBackground(opaqueDepth) ? backgroundViewZ : getViewZ(opaqueDepth);
+    float transparentSelfViewZ = isBackground(transparentDepth) ? backgroundViewZ : getViewZ(transparentDepth);
+    float selfDepth = min(opaqueDepth, transparentDepth);
+
+    float outline = 1.0;
+    closestTexel = 1.0;
+    for (int y = -dOutlineScale; y <= dOutlineScale; y++) {
+        for (int x = -dOutlineScale; x <= dOutlineScale; x++) {
+            if (x * x + y * y > dOutlineScale * dOutlineScale) {
+                continue;
+            }
+
+            vec2 sampleCoords = coords + vec2(float(x), float(y)) * invTexSize;
+
+            vec4 sampleOutlineCombined = texture2D(tOutlines, sampleCoords);
+            float sampleOutline = sampleOutlineCombined.r;
+            float sampleOutlineDepth = unpackRGToUnitInterval(sampleOutlineCombined.gb);
+            float sampleOutlineViewZ = isBackground(sampleOutlineDepth) ? backgroundViewZ : getViewZ(sampleOutlineDepth);
+
+            float selfViewZ = sampleOutlineCombined.a == 0.0 ? opaqueSelfViewZ : transparentSelfViewZ;
+            if (sampleOutline == 0.0 && sampleOutlineDepth < closestTexel) {
+                outline = 0.0;
+                closestTexel = sampleOutlineDepth;
+            }
+        }
+    }
+    return closestTexel < opaqueDepth ? outline : 1.0;
+}
+
+float getSsao(vec2 coords) {
+    float rawSsao = unpackRGToUnitInterval(texture2D(tSsaoDepth, coords).xy);
+    if (rawSsao > 0.999) {
+        return 1.0;
+    } else if (rawSsao > 0.001) {
+        return rawSsao;
+    }
+    // treat values close to 0.0 as errors and return no occlusion
+    return 1.0;
+}
+
+void main(void) {
+    vec2 coords = gl_FragCoord.xy / uTexSize;
+    vec4 color = texture2D(tColor, coords);
+
+    float viewDist;
+    float fogFactor;
+    float opaqueDepth = getDepthOpaque(coords);
+
+    #ifdef dOcclusionEnable
+        if (!isBackground(opaqueDepth)) {
+            viewDist = abs(getViewZ(opaqueDepth));
+            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);
+            float occlusionFactor = getSsao(coords + uOcclusionOffset);
+            if (!uTransparentBackground) {
+                color.rgb = mix(mix(uOcclusionColor, uFogColor, fogFactor), color.rgb, occlusionFactor);
+            } else {
+                color.rgb = mix(uOcclusionColor * (1.0 - fogFactor), color.rgb, occlusionFactor);
+            }
+        }
+    #endif
+
+    #ifdef dShadowEnable
+        if (!isBackground(opaqueDepth)) {
+            viewDist = abs(getViewZ(opaqueDepth));
+            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);
+            vec4 shadow = texture2D(tShadows, coords);
+            if (!uTransparentBackground) {
+                color.rgb = mix(mix(vec3(0), uFogColor, fogFactor), color.rgb, shadow.a);
+            } else {
+                color.rgb = mix(vec3(0) * (1.0 - fogFactor), color.rgb, shadow.a);
+            }
+        }
+    #endif
+
+    // outline needs to be handled after occlusion and shadow to keep them clean
+    #ifdef dOutlineEnable
+        float closestTexel;
+        float outline = getOutline(coords, opaqueDepth, closestTexel);
+        if (outline == 0.0) {
+            viewDist = abs(getViewZ(closestTexel));
+            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);
+            if (!uTransparentBackground) {
+                color.rgb = mix(uOutlineColor, uFogColor, fogFactor);
+            } else {
+                color.a = 1.0 - fogFactor;
+                color.rgb = mix(uOutlineColor, color.rgb, fogFactor);
+            }
+        }
+    #endif
+
+    gl_FragColor = color;
+}
 `;

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

@@ -6,14 +6,14 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.quad_vert = void 0;
-exports.quad_vert = `
-precision highp float;
-
-attribute vec2 aPosition;
-uniform vec2 uQuadScale;
-
-void main(void) {
-    vec2 position = aPosition * uQuadScale - vec2(1.0, 1.0) + uQuadScale;
-    gl_Position = vec4(position, 0.0, 1.0);
-}
+exports.quad_vert = `
+precision highp float;
+
+attribute vec2 aPosition;
+uniform vec2 uQuadScale;
+
+void main(void) {
+    vec2 position = aPosition * uQuadScale - vec2(1.0, 1.0) + uQuadScale;
+    gl_Position = vec4(position, 0.0, 1.0);
+}
 `;

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

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