molstar 4.0.1 → 4.2.0

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

@@ -1,98 +1,99 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.background_frag = void 0;
-exports.background_frag = `
-precision mediump float;
-precision mediump samplerCube;
-precision mediump sampler2D;
-
-#if defined(dVariant_skybox)
-    uniform samplerCube tSkybox;
-    uniform mat4 uViewDirectionProjectionInverse;
-    uniform float uBlur;
-    uniform float uOpacity;
-    uniform float uSaturation;
-    uniform float uLightness;
-#elif defined(dVariant_image)
-    uniform sampler2D tImage;
-    uniform vec2 uImageScale;
-    uniform vec2 uImageOffset;
-    uniform float uBlur;
-    uniform float uOpacity;
-    uniform float uSaturation;
-    uniform float uLightness;
-#elif defined(dVariant_horizontalGradient) || defined(dVariant_radialGradient)
-    uniform vec3 uGradientColorA;
-    uniform vec3 uGradientColorB;
-    uniform float uGradientRatio;
-#endif
-
-uniform vec2 uTexSize;
-uniform vec4 uViewport;
-uniform bool uViewportAdjusted;
-varying vec4 vPosition;
-
-// TODO: add as general pp option to remove banding?
-// Iestyn's RGB dither from http://alex.vlachos.com/graphics/Alex_Vlachos_Advanced_VR_Rendering_GDC2015.pdf
-vec3 ScreenSpaceDither(vec2 vScreenPos) {
-    vec3 vDither = vec3(dot(vec2(171.0, 231.0), vScreenPos.xy));
-    vDither.rgb = fract(vDither.rgb / vec3(103.0, 71.0, 97.0));
-    return vDither.rgb / 255.0;
-}
-
-vec3 saturateColor(vec3 c, float amount) {
-    // https://www.w3.org/TR/WCAG21/#dfn-relative-luminance
-    const vec3 W = vec3(0.2125, 0.7154, 0.0721);
-    vec3 intensity = vec3(dot(c, W));
-    return mix(intensity, c, 1.0 + amount);
-}
-
-vec3 lightenColor(vec3 c, float amount) {
-    return c + amount;
-}
-
-void main() {
-    #if defined(dVariant_skybox)
-        vec4 t = uViewDirectionProjectionInverse * vPosition;
-        #ifdef enabledShaderTextureLod
-            gl_FragColor = textureCubeLodEXT(tSkybox, normalize(t.xyz / t.w), uBlur * 8.0);
-        #else
-            gl_FragColor = textureCube(tSkybox, normalize(t.xyz / t.w));
-        #endif
-        gl_FragColor.a = uOpacity;
-        gl_FragColor.rgb = lightenColor(saturateColor(gl_FragColor.rgb, uSaturation), uLightness);
-    #elif defined(dVariant_image)
-        vec2 coords;
-        if (uViewportAdjusted) {
-            coords = ((gl_FragCoord.xy - uViewport.xy) * (uTexSize / uViewport.zw) / uImageScale) + uImageOffset;
-        } else {
-            coords = (gl_FragCoord.xy / uImageScale) + uImageOffset;
-        }
-        #ifdef enabledShaderTextureLod
-            gl_FragColor = texture2DLodEXT(tImage, vec2(coords.x, 1.0 - coords.y), uBlur * 8.0);
-        #else
-            gl_FragColor = texture2D(tImage, vec2(coords.x, 1.0 - coords.y));
-        #endif
-        gl_FragColor.a = uOpacity;
-        gl_FragColor.rgb = lightenColor(saturateColor(gl_FragColor.rgb, uSaturation), uLightness);
-    #elif defined(dVariant_horizontalGradient)
-        float d;
-        if (uViewportAdjusted) {
-            d = ((gl_FragCoord.y - uViewport.y) * (uTexSize.y / uViewport.w) / uTexSize.y) + 1.0 - (uGradientRatio * 2.0);
-        } else {
-            d = (gl_FragCoord.y / uTexSize.y) + 1.0 - (uGradientRatio * 2.0);
-        }
-        gl_FragColor = vec4(mix(uGradientColorB, uGradientColorA, clamp(d, 0.0, 1.0)), 1.0);
-        gl_FragColor.rgb += ScreenSpaceDither(gl_FragCoord.xy);
-    #elif defined(dVariant_radialGradient)
-        float d;
-        if (uViewportAdjusted) {
-            d = distance(vec2(0.5), (gl_FragCoord.xy - uViewport.xy) * (uTexSize / uViewport.zw) / uTexSize) + uGradientRatio - 0.5;
-        } else {
-            d = distance(vec2(0.5), gl_FragCoord.xy / uTexSize) + uGradientRatio - 0.5;
-        }
-        gl_FragColor = vec4(mix(uGradientColorB, uGradientColorA, 1.0 - clamp(d, 0.0, 1.0)), 1.0);
-        gl_FragColor.rgb += ScreenSpaceDither(gl_FragCoord.xy);
-    #endif
-}
+exports.background_frag = `
+precision mediump float;
+precision mediump samplerCube;
+precision mediump sampler2D;
+
+#if defined(dVariant_skybox)
+    uniform samplerCube tSkybox;
+    uniform mat4 uViewDirectionProjectionInverse;
+    uniform float uBlur;
+    uniform float uOpacity;
+    uniform float uSaturation;
+    uniform float uLightness;
+    uniform mat3 uRotation;
+#elif defined(dVariant_image)
+    uniform sampler2D tImage;
+    uniform vec2 uImageScale;
+    uniform vec2 uImageOffset;
+    uniform float uBlur;
+    uniform float uOpacity;
+    uniform float uSaturation;
+    uniform float uLightness;
+#elif defined(dVariant_horizontalGradient) || defined(dVariant_radialGradient)
+    uniform vec3 uGradientColorA;
+    uniform vec3 uGradientColorB;
+    uniform float uGradientRatio;
+#endif
+
+uniform vec2 uTexSize;
+uniform vec4 uViewport;
+uniform bool uViewportAdjusted;
+varying vec4 vPosition;
+
+// TODO: add as general pp option to remove banding?
+// Iestyn's RGB dither from http://alex.vlachos.com/graphics/Alex_Vlachos_Advanced_VR_Rendering_GDC2015.pdf
+vec3 ScreenSpaceDither(vec2 vScreenPos) {
+    vec3 vDither = vec3(dot(vec2(171.0, 231.0), vScreenPos.xy));
+    vDither.rgb = fract(vDither.rgb / vec3(103.0, 71.0, 97.0));
+    return vDither.rgb / 255.0;
+}
+
+vec3 saturateColor(vec3 c, float amount) {
+    // https://www.w3.org/TR/WCAG21/#dfn-relative-luminance
+    const vec3 W = vec3(0.2125, 0.7154, 0.0721);
+    vec3 intensity = vec3(dot(c, W));
+    return mix(intensity, c, 1.0 + amount);
+}
+
+vec3 lightenColor(vec3 c, float amount) {
+    return c + amount;
+}
+
+void main() {
+    #if defined(dVariant_skybox)
+        vec4 t = uViewDirectionProjectionInverse * vPosition;
+        #ifdef enabledShaderTextureLod
+            gl_FragColor = textureCubeLodEXT(tSkybox, uRotation * normalize(t.xyz / t.w), uBlur * 8.0);
+        #else
+            gl_FragColor = textureCube(tSkybox, uRotation * normalize(t.xyz / t.w));
+        #endif
+        gl_FragColor.a = uOpacity;
+        gl_FragColor.rgb = lightenColor(saturateColor(gl_FragColor.rgb, uSaturation), uLightness);
+    #elif defined(dVariant_image)
+        vec2 coords;
+        if (uViewportAdjusted) {
+            coords = ((gl_FragCoord.xy - uViewport.xy) * (uTexSize / uViewport.zw) / uImageScale) + uImageOffset;
+        } else {
+            coords = (gl_FragCoord.xy / uImageScale) + uImageOffset;
+        }
+        #ifdef enabledShaderTextureLod
+            gl_FragColor = texture2DLodEXT(tImage, vec2(coords.x, 1.0 - coords.y), uBlur * 8.0);
+        #else
+            gl_FragColor = texture2D(tImage, vec2(coords.x, 1.0 - coords.y));
+        #endif
+        gl_FragColor.a = uOpacity;
+        gl_FragColor.rgb = lightenColor(saturateColor(gl_FragColor.rgb, uSaturation), uLightness);
+    #elif defined(dVariant_horizontalGradient)
+        float d;
+        if (uViewportAdjusted) {
+            d = ((gl_FragCoord.y - uViewport.y) * (uTexSize.y / uViewport.w) / uTexSize.y) + 1.0 - (uGradientRatio * 2.0);
+        } else {
+            d = (gl_FragCoord.y / uTexSize.y) + 1.0 - (uGradientRatio * 2.0);
+        }
+        gl_FragColor = vec4(mix(uGradientColorB, uGradientColorA, clamp(d, 0.0, 1.0)), 1.0);
+        gl_FragColor.rgb += ScreenSpaceDither(gl_FragCoord.xy);
+    #elif defined(dVariant_radialGradient)
+        float d;
+        if (uViewportAdjusted) {
+            d = distance(vec2(0.5), (gl_FragCoord.xy - uViewport.xy) * (uTexSize / uViewport.zw) / uTexSize) + uGradientRatio - 0.5;
+        } else {
+            d = distance(vec2(0.5), gl_FragCoord.xy / uTexSize) + uGradientRatio - 0.5;
+        }
+        gl_FragColor = vec4(mix(uGradientColorB, uGradientColorA, 1.0 - clamp(d, 0.0, 1.0)), 1.0);
+        gl_FragColor.rgb += ScreenSpaceDither(gl_FragCoord.xy);
+    #endif
+}
 `;

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

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.background_vert = void 0;
-exports.background_vert = `
-precision mediump float;
-
-attribute vec2 aPosition;
-
-varying vec4 vPosition;
-
-void main() {
-    vPosition = vec4(aPosition, 1.0, 1.0);
-    gl_Position = vec4(aPosition, 1.0, 1.0);
-}
+exports.background_vert = `
+precision mediump float;
+
+attribute vec2 aPosition;
+
+varying vec4 vPosition;
+
+void main() {
+    vPosition = vec4(aPosition, 1.0, 1.0);
+    gl_Position = vec4(aPosition, 1.0, 1.0);
+}
 `;

package/lib/commonjs/mol-gl/shader/blend-back-dpoit.frag.js

@@ -6,17 +6,17 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.blendBackDpoit_frag = void 0;
-exports.blendBackDpoit_frag = `
-    precision highp float;
-
-    uniform sampler2D tDpoitBackColor;
-    uniform vec2 uTexSize;
-
-    void main() {
-        vec2 coords = gl_FragCoord.xy / uTexSize;
-        gl_FragColor = texture2D(tDpoitBackColor, coords);
-        if (gl_FragColor.a == 0.0) {
-            discard;
-        }
-    }
+exports.blendBackDpoit_frag = `
+    precision highp float;
+
+    uniform sampler2D tDpoitBackColor;
+    uniform vec2 uTexSize;
+
+    void main() {
+        vec2 coords = gl_FragCoord.xy / uTexSize;
+        gl_FragColor = texture2D(tDpoitBackColor, coords);
+        if (gl_FragColor.a == 0.0) {
+            discard;
+        }
+    }
 `;

package/lib/commonjs/mol-gl/shader/bloom/blur.frag.d.ts

@@ -0,0 +1 @@
+export declare const blur_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform sampler2D tInput;\nuniform vec2 uTexSizeInv;\n\nuniform vec2 uDirection;\nuniform float uGaussianCoefficients[dKernelRadius];\n\nvoid main(void) {\n    vec2 coords = gl_FragCoord.xy * uTexSizeInv;\n    float weightSum = uGaussianCoefficients[0];\n    vec4 diffuseSum = texture2D(tInput, coords) * weightSum;\n\n    for(int i = 1; i < dKernelRadius; ++i) {\n        float x = float(i);\n        float w = uGaussianCoefficients[i];\n        vec2 offset = uDirection * uTexSizeInv * x;\n        vec4 sample1 = texture2D(tInput, coords + offset);\n        vec4 sample2 = texture2D(tInput, coords - offset);\n        diffuseSum += (sample1 + sample2) * w;\n        weightSum += 2.0 * w;\n    }\n\n    gl_FragColor = diffuseSum / weightSum;\n}\n";

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blur_frag = void 0;
+exports.blur_frag = `
+precision highp float;
+precision highp int;
+precision highp sampler2D;
+
+uniform sampler2D tInput;
+uniform vec2 uTexSizeInv;
+
+uniform vec2 uDirection;
+uniform float uGaussianCoefficients[dKernelRadius];
+
+void main(void) {
+    vec2 coords = gl_FragCoord.xy * uTexSizeInv;
+    float weightSum = uGaussianCoefficients[0];
+    vec4 diffuseSum = texture2D(tInput, coords) * weightSum;
+
+    for(int i = 1; i < dKernelRadius; ++i) {
+        float x = float(i);
+        float w = uGaussianCoefficients[i];
+        vec2 offset = uDirection * uTexSizeInv * x;
+        vec4 sample1 = texture2D(tInput, coords + offset);
+        vec4 sample2 = texture2D(tInput, coords - offset);
+        diffuseSum += (sample1 + sample2) * w;
+        weightSum += 2.0 * w;
+    }
+
+    gl_FragColor = diffuseSum / weightSum;
+}
+`;

package/lib/commonjs/mol-gl/shader/bloom/composite.frag.d.ts

@@ -0,0 +1 @@
+export declare const composite_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform vec2 uTexSizeInv;\n\nuniform sampler2D tBlur1;\nuniform sampler2D tBlur2;\nuniform sampler2D tBlur3;\nuniform sampler2D tBlur4;\nuniform sampler2D tBlur5;\nuniform float uBloomStrength;\nuniform float uBloomRadius;\nuniform float uBloomFactors[5];\nuniform vec3 uBloomTints[5];\n\nfloat lerpBloomFactor(const in float factor) {\n    float mirrorFactor = 1.2 - factor;\n    return mix(factor, mirrorFactor, uBloomRadius);\n}\n\nvoid main(void) {\n    vec2 coords = gl_FragCoord.xy * uTexSizeInv;\n\n    gl_FragColor = uBloomStrength * (\n        lerpBloomFactor(uBloomFactors[0]) * vec4(uBloomTints[0], 1.0) * texture2D(tBlur1, coords) +\n        lerpBloomFactor(uBloomFactors[1]) * vec4(uBloomTints[1], 1.0) * texture2D(tBlur2, coords) +\n        lerpBloomFactor(uBloomFactors[2]) * vec4(uBloomTints[2], 1.0) * texture2D(tBlur3, coords) +\n        lerpBloomFactor(uBloomFactors[3]) * vec4(uBloomTints[3], 1.0) * texture2D(tBlur4, coords) +\n        lerpBloomFactor(uBloomFactors[4]) * vec4(uBloomTints[4], 1.0) * texture2D(tBlur5, coords)\n    );\n}\n";

package/lib/commonjs/mol-gl/shader/bloom/composite.frag.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composite_frag = void 0;
+exports.composite_frag = `
+precision highp float;
+precision highp int;
+precision highp sampler2D;
+
+uniform vec2 uTexSizeInv;
+
+uniform sampler2D tBlur1;
+uniform sampler2D tBlur2;
+uniform sampler2D tBlur3;
+uniform sampler2D tBlur4;
+uniform sampler2D tBlur5;
+uniform float uBloomStrength;
+uniform float uBloomRadius;
+uniform float uBloomFactors[5];
+uniform vec3 uBloomTints[5];
+
+float lerpBloomFactor(const in float factor) {
+    float mirrorFactor = 1.2 - factor;
+    return mix(factor, mirrorFactor, uBloomRadius);
+}
+
+void main(void) {
+    vec2 coords = gl_FragCoord.xy * uTexSizeInv;
+
+    gl_FragColor = uBloomStrength * (
+        lerpBloomFactor(uBloomFactors[0]) * vec4(uBloomTints[0], 1.0) * texture2D(tBlur1, coords) +
+        lerpBloomFactor(uBloomFactors[1]) * vec4(uBloomTints[1], 1.0) * texture2D(tBlur2, coords) +
+        lerpBloomFactor(uBloomFactors[2]) * vec4(uBloomTints[2], 1.0) * texture2D(tBlur3, coords) +
+        lerpBloomFactor(uBloomFactors[3]) * vec4(uBloomTints[3], 1.0) * texture2D(tBlur4, coords) +
+        lerpBloomFactor(uBloomFactors[4]) * vec4(uBloomTints[4], 1.0) * texture2D(tBlur5, coords)
+    );
+}
+`;

package/lib/commonjs/mol-gl/shader/bloom/luminosity.frag.d.ts

@@ -0,0 +1 @@
+export declare const luminosity_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform sampler2D tColor;\nuniform sampler2D tEmissive;\nuniform sampler2D tDepth;\nuniform vec2 uTexSizeInv;\n\nuniform vec3 uDefaultColor;\nuniform float uDefaultOpacity;\nuniform float uLuminosityThreshold;\nuniform float uSmoothWidth;\n\n#include common\n\nfloat getDepth(const in vec2 coords) {\n    #ifdef depthTextureSupport\n        return texture2D(tDepth, coords).r;\n    #else\n        return unpackRGBAToDepth(texture2D(tDepth, coords));\n    #endif\n}\n\nbool isBackground(const in float depth) {\n    return depth == 1.0;\n}\n\nvoid main(void) {\n    vec2 coords = gl_FragCoord.xy * uTexSizeInv;\n    vec4 texel = texture2D(tColor, coords);\n    float emissive = texture2D(tEmissive, coords).a;\n    float depth = getDepth(coords);\n\n    if (isBackground(depth)) {\n        gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);\n        return;\n    }\n\n    vec4 outputColor = vec4(uDefaultColor.rgb, uDefaultOpacity);\n\n    #if defined(dMode_luminosity)\n        vec3 luma = vec3(0.299, 0.587, 0.114);\n        float v = dot(texel.xyz, luma);\n        float alpha = smoothstep(uLuminosityThreshold, uLuminosityThreshold + uSmoothWidth, v);\n\n        gl_FragColor = mix(outputColor, texel, alpha);\n    #elif defined(dMode_emissive)\n        gl_FragColor = mix(outputColor, texel, emissive);\n    #endif\n}\n";

package/lib/commonjs/mol-gl/shader/bloom/luminosity.frag.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.luminosity_frag = void 0;
+exports.luminosity_frag = `
+precision highp float;
+precision highp int;
+precision highp sampler2D;
+
+uniform sampler2D tColor;
+uniform sampler2D tEmissive;
+uniform sampler2D tDepth;
+uniform vec2 uTexSizeInv;
+
+uniform vec3 uDefaultColor;
+uniform float uDefaultOpacity;
+uniform float uLuminosityThreshold;
+uniform float uSmoothWidth;
+
+#include common
+
+float getDepth(const in vec2 coords) {
+    #ifdef depthTextureSupport
+        return texture2D(tDepth, coords).r;
+    #else
+        return unpackRGBAToDepth(texture2D(tDepth, coords));
+    #endif
+}
+
+bool isBackground(const in float depth) {
+    return depth == 1.0;
+}
+
+void main(void) {
+    vec2 coords = gl_FragCoord.xy * uTexSizeInv;
+    vec4 texel = texture2D(tColor, coords);
+    float emissive = texture2D(tEmissive, coords).a;
+    float depth = getDepth(coords);
+
+    if (isBackground(depth)) {
+        gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+        return;
+    }
+
+    vec4 outputColor = vec4(uDefaultColor.rgb, uDefaultOpacity);
+
+    #if defined(dMode_luminosity)
+        vec3 luma = vec3(0.299, 0.587, 0.114);
+        float v = dot(texel.xyz, luma);
+        float alpha = smoothstep(uLuminosityThreshold, uLuminosityThreshold + uSmoothWidth, v);
+
+        gl_FragColor = mix(outputColor, texel, alpha);
+    #elif defined(dMode_emissive)
+        gl_FragColor = mix(outputColor, texel, emissive);
+    #endif
+}
+`;