molstar 4.2.0 → 4.3.0

package/lib/commonjs/mol-canvas3d/passes/draw.d.ts

@@ -18,6 +18,7 @@ import { DpoitPass } from './dpoit';
 import { AntialiasingPass, PostprocessingPass, PostprocessingProps } from './postprocessing';
 import { MarkingPass, MarkingProps } from './marking';
 import { AssetManager } from '../../mol-util/assets';
+import { DofPass } from './dof';
 import { BloomPass } from './bloom';
 type Props = {
     postprocessing: PostprocessingProps;
@@ -49,6 +50,7 @@ export declare class DrawPass {
     readonly postprocessing: PostprocessingPass;
     readonly antialiasing: AntialiasingPass;
     readonly bloom: BloomPass;
+    readonly dof: DofPass;
     private transparencyMode;
     setTransparency(transparency: 'wboit' | 'dpoit' | 'blended'): void;
     get transparency(): TransparencyMode;

package/lib/commonjs/mol-canvas3d/passes/draw.js

@@ -18,6 +18,7 @@ const postprocessing_1 = require("./postprocessing");
 const marking_1 = require("./marking");
 const util_1 = require("../../mol-gl/compute/util");
 const debug_1 = require("../../mol-util/debug");
+const dof_1 = require("./dof");
 const bloom_1 = require("./bloom");
 class DrawPass {
     setTransparency(transparency) {
@@ -61,6 +62,7 @@ class DrawPass {
         this.postprocessing = new postprocessing_1.PostprocessingPass(webgl, assetManager, this);
         this.antialiasing = new postprocessing_1.AntialiasingPass(webgl, width, height);
         this.bloom = new bloom_1.BloomPass(webgl, width, height);
+        this.dof = new dof_1.DofPass(webgl, width, height);
         this.copyFboTarget = (0, util_1.createCopyRenderable)(webgl, this.colorTarget.texture);
         this.copyFboPostprocessing = (0, util_1.createCopyRenderable)(webgl, this.postprocessing.target.texture);
         this.setTransparency(transparency);
@@ -93,6 +95,7 @@ class DrawPass {
         this.marking.setSize(width, height);
         this.postprocessing.setSize(width, height);
         this.antialiasing.setSize(width, height);
+        this.dof.setSize(width, height);
         this.bloom.setSize(width, height);
     }
     _renderDpoit(renderer, camera, scene, iterations, transparentBackground, postprocessingProps) {
@@ -105,7 +108,7 @@ class DrawPass {
             renderer.renderDpoitOpaque(scene.primitives, camera, null);
         }
         if (postprocessing_1.PostprocessingPass.isEnabled(postprocessingProps)) {
-            if (postprocessing_1.PostprocessingPass.isTransparentOutlineEnabled(postprocessingProps)) {
+            if (postprocessing_1.PostprocessingPass.isTransparentOutlineEnabled(postprocessingProps) || dof_1.DofPass.isEnabled(postprocessingProps)) {
                 this.depthTargetTransparent.bind();
                 renderer.clearDepth(true);
                 if (scene.opacityAverage < 1) {
@@ -150,7 +153,7 @@ class DrawPass {
             renderer.renderWboitOpaque(scene.primitives, camera, null);
         }
         if (postprocessing_1.PostprocessingPass.isEnabled(postprocessingProps)) {
-            if (postprocessing_1.PostprocessingPass.isTransparentOutlineEnabled(postprocessingProps)) {
+            if (postprocessing_1.PostprocessingPass.isTransparentOutlineEnabled(postprocessingProps) || dof_1.DofPass.isEnabled(postprocessingProps)) {
                 this.depthTargetTransparent.bind();
                 renderer.clearDepth(true);
                 if (scene.opacityAverage < 1) {
@@ -211,7 +214,7 @@ class DrawPass {
                 else {
                     (_a = this.colorTarget.depthRenderbuffer) === null || _a === void 0 ? void 0 : _a.detachFramebuffer(this.postprocessing.target.framebuffer);
                 }
-                if (postprocessing_1.PostprocessingPass.isTransparentOutlineEnabled(postprocessingProps)) {
+                if (postprocessing_1.PostprocessingPass.isTransparentOutlineEnabled(postprocessingProps) || dof_1.DofPass.isEnabled(postprocessingProps)) {
                     this.depthTargetTransparent.bind();
                     renderer.clearDepth(true);
                     if (scene.opacityAverage < 1) {
@@ -251,11 +254,12 @@ class DrawPass {
         }
     }
     _render(renderer, camera, scene, helper, toDrawingBuffer, transparentBackground, props) {
-        var _a;
+        var _a, _b;
         const volumeRendering = scene.volumes.renderables.length > 0;
         const postprocessingEnabled = postprocessing_1.PostprocessingPass.isEnabled(props.postprocessing);
         const antialiasingEnabled = postprocessing_1.AntialiasingPass.isEnabled(props.postprocessing);
         const markingEnabled = marking_1.MarkingPass.isEnabled(props.marking);
+        const dofEnabled = dof_1.DofPass.isEnabled(props.postprocessing);
         const { x, y, width, height } = camera.viewport;
         renderer.setViewport(x, y, width, height);
         renderer.update(camera, scene);
@@ -308,13 +312,29 @@ class DrawPass {
             renderer.update(helper.camera.camera, helper.camera.scene);
             renderer.renderBlended(helper.camera.scene, helper.camera.camera);
         }
+        let needsTargetCopy = false;
         if (antialiasingEnabled) {
             const input = postprocessing_1.PostprocessingPass.isEnabled(props.postprocessing)
                 ? this.postprocessing.target.texture
                 : this.colorTarget.texture;
-            this.antialiasing.render(camera, input, toDrawingBuffer, props.postprocessing);
+            this.antialiasing.render(camera, input, toDrawingBuffer && !dofEnabled, props.postprocessing);
         }
-        else if (toDrawingBuffer) {
+        else if (toDrawingBuffer && !dof_1.DofPass.isEnabled(props.postprocessing)) {
+            needsTargetCopy = true;
+        }
+        if (props.postprocessing.dof.name === 'on') {
+            const input = postprocessing_1.AntialiasingPass.isEnabled(props.postprocessing)
+                ? this.antialiasing.target.texture
+                : postprocessing_1.PostprocessingPass.isEnabled(props.postprocessing)
+                    ? this.postprocessing.target.texture
+                    : this.colorTarget.texture;
+            this.dof.update(camera, input, ((_a = this.depthTargetOpaque) === null || _a === void 0 ? void 0 : _a.texture) || this.depthTextureOpaque, this.depthTextureTransparent, props.postprocessing.dof.params, scene.boundingSphereVisible);
+            this.dof.render(camera.viewport, toDrawingBuffer ? undefined : this.getColorTarget(props.postprocessing));
+        }
+        else if (toDrawingBuffer && !postprocessing_1.AntialiasingPass.isEnabled(props.postprocessing)) {
+            needsTargetCopy = true;
+        }
+        if (needsTargetCopy) {
             this.drawTarget.bind();
             this.webgl.state.disable(this.webgl.gl.DEPTH_TEST);
             if (postprocessingEnabled) {
@@ -333,7 +353,7 @@ class DrawPass {
                 renderer.renderEmissive(scene.primitives, camera, null);
             }
             if (!emissiveBloom || scene.emissiveAverage > 0) {
-                this.bloom.update(this.colorTarget.texture, this.bloom.emissiveTarget.texture, ((_a = this.depthTargetOpaque) === null || _a === void 0 ? void 0 : _a.texture) || this.depthTextureOpaque, props.postprocessing.bloom.params);
+                this.bloom.update(this.colorTarget.texture, this.bloom.emissiveTarget.texture, ((_b = this.depthTargetOpaque) === null || _b === void 0 ? void 0 : _b.texture) || this.depthTextureOpaque, props.postprocessing.bloom.params);
                 this.bloom.render(camera.viewport, toDrawingBuffer ? undefined : this.getColorTarget(props.postprocessing));
             }
         }
@@ -367,7 +387,10 @@ class DrawPass {
             this.webgl.timer.markEnd('DrawPass.render');
     }
     getColorTarget(postprocessingProps) {
-        if (postprocessing_1.AntialiasingPass.isEnabled(postprocessingProps)) {
+        if (dof_1.DofPass.isEnabled(postprocessingProps)) {
+            return this.dof.target;
+        }
+        else if (postprocessing_1.AntialiasingPass.isEnabled(postprocessingProps)) {
             return this.antialiasing.target;
         }
         else if (postprocessing_1.PostprocessingPass.isEnabled(postprocessingProps)) {

package/lib/commonjs/mol-canvas3d/passes/image.d.ts

@@ -42,6 +42,14 @@ export declare const ImageParams: {
             color: any;
             includeTransparent: any;
         }>, "on">;
+        dof: PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
+            blurSize: any;
+            blurSpread: any;
+            inFocus: any;
+            PPM: any;
+            center: any;
+            mode: any;
+        }>, "on">;
         antialiasing: PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
             edgeThreshold: any;
             maxSearchSteps: any;

package/lib/commonjs/mol-canvas3d/passes/postprocessing.d.ts

@@ -60,6 +60,14 @@ export declare const PostprocessingParams: {
         color: Color;
         includeTransparent: boolean;
     }>, "on">>;
+    dof: PD.Mapped<PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
+        blurSize: number;
+        blurSpread: number;
+        inFocus: number;
+        PPM: number;
+        center: string;
+        mode: string;
+    }>, "on">>;
     antialiasing: PD.Mapped<PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
         edgeThreshold: number;
         maxSearchSteps: number;

package/lib/commonjs/mol-canvas3d/passes/postprocessing.js

@@ -28,6 +28,7 @@ const debug_1 = require("../../mol-util/debug");
 const background_1 = require("./background");
 const shadows_frag_1 = require("../../mol-gl/shader/shadows.frag");
 const cas_1 = require("./cas");
+const dof_1 = require("./dof");
 const bloom_1 = require("./bloom");
 exports.OutlinesSchema = {
     ...util_1.QuadSchema,
@@ -318,6 +319,10 @@ exports.PostprocessingParams = {
         }),
         off: param_definition_1.ParamDefinition.Group({})
     }, { cycle: true, description: 'Draw outline around 3D objects' }),
+    dof: param_definition_1.ParamDefinition.MappedStatic('off', {
+        on: param_definition_1.ParamDefinition.Group(dof_1.DofParams),
+        off: param_definition_1.ParamDefinition.Group({})
+    }, { cycle: true, description: 'DOF' }),
     antialiasing: param_definition_1.ParamDefinition.MappedStatic('smaa', {
         fxaa: param_definition_1.ParamDefinition.Group(fxaa_1.FxaaParams),
         smaa: param_definition_1.ParamDefinition.Group(smaa_1.SmaaParams),

package/lib/commonjs/mol-geo/geometry/lines/lines.d.ts

@@ -42,7 +42,6 @@ export declare namespace Lines {
         alpha: PD.Numeric;
         quality: PD.Select<"auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest">;
         material: PD.Group<PD.Normalize<{
-            /** Wide line */
             metalness: number;
             roughness: number;
             bumpiness: number;

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

@@ -1,99 +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;
-    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
-}
+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.js

@@ -1,32 +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;
-}
+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.js

@@ -1,37 +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)
-    );
-}
+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)
+    );
+}
 `;