molstar 4.2.0 → 4.3.0

package/lib/mol-gl/shader/chunks/rgba-to-float.glsl.js

@@ -3,88 +3,88 @@
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  */
-export const rgba_to_float = `
-    // rgbaToFloat adapted from https://github.com/ihmeuw/glsl-rgba-to-float
-    // BSD 3-Clause License
-    //
-    // Copyright (c) 2019, Institute for Health Metrics and Evaluation All rights reserved.
-    // Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
-    //  - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
-    //  - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
-    //  - Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
-    //
-    // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-    // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-    // IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
-    // OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
-    // OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-    // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
-    // OF THE POSSIBILITY OF SUCH DAMAGE.
-
-    ivec4 floatsToBytes(vec4 inputFloats, bool littleEndian) {
-        ivec4 bytes = ivec4(inputFloats * 255.0);
-        return (
-            littleEndian
-                ? bytes.abgr
-                : bytes
-        );
-    }
-
-    // Break the four bytes down into an array of 32 bits.
-    void bytesToBits(const in ivec4 bytes, out bool bits[32]) {
-        for (int channelIndex = 0; channelIndex < 4; ++channelIndex) {
-            float acc = float(bytes[channelIndex]);
-            for (int indexInByte = 7; indexInByte >= 0; --indexInByte) {
-                float powerOfTwo = exp2(float(indexInByte));
-                bool bit = acc >= powerOfTwo;
-                bits[channelIndex * 8 + (7 - indexInByte)] = bit;
-                acc = mod(acc, powerOfTwo);
-            }
-        }
-    }
-
-    // Compute the exponent of the 32-bit float.
-    float getExponent(bool bits[32]) {
-        const int startIndex = 1;
-        const int bitStringLength = 8;
-        const int endBeforeIndex = startIndex + bitStringLength;
-        float acc = 0.0;
-        int pow2 = bitStringLength - 1;
-        for (int bitIndex = startIndex; bitIndex < endBeforeIndex; ++bitIndex) {
-            acc += float(bits[bitIndex]) * exp2(float(pow2--));
-        }
-        return acc;
-    }
-
-    // Compute the mantissa of the 32-bit float.
-    float getMantissa(bool bits[32], bool subnormal) {
-        const int startIndex = 9;
-        const int bitStringLength = 23;
-        const int endBeforeIndex = startIndex + bitStringLength;
-        // Leading/implicit/hidden bit convention:
-        // If the number is not subnormal (with exponent 0), we add a leading 1 digit.
-        float acc = float(!subnormal) * exp2(float(bitStringLength));
-        int pow2 = bitStringLength - 1;
-        for (int bitIndex = startIndex; bitIndex < endBeforeIndex; ++bitIndex) {
-            acc += float(bits[bitIndex]) * exp2(float(pow2--));
-        }
-        return acc;
-    }
-
-    // Parse the float from its 32 bits.
-    float bitsToFloat(bool bits[32]) {
-        float signBit = float(bits[0]) * -2.0 + 1.0;
-        float exponent = getExponent(bits);
-        bool subnormal = abs(exponent - 0.0) < 0.01;
-        float mantissa = getMantissa(bits, subnormal);
-        float exponentBias = 127.0;
-        return signBit * mantissa * exp2(exponent - exponentBias - 23.0);
-    }
-
-    float rgbaToFloat(vec4 texelRGBA, bool littleEndian) {
-        ivec4 rgbaBytes = floatsToBytes(texelRGBA, littleEndian);
-        bool bits[32];
-        bytesToBits(rgbaBytes, bits);
-        return bitsToFloat(bits);
-    }
+export const rgba_to_float = `
+    // rgbaToFloat adapted from https://github.com/ihmeuw/glsl-rgba-to-float
+    // BSD 3-Clause License
+    //
+    // Copyright (c) 2019, Institute for Health Metrics and Evaluation All rights reserved.
+    // Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+    //  - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+    //  - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+    //  - Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+    //
+    // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+    // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+    // IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+    // OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+    // OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+    // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+    // OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    ivec4 floatsToBytes(vec4 inputFloats, bool littleEndian) {
+        ivec4 bytes = ivec4(inputFloats * 255.0);
+        return (
+            littleEndian
+                ? bytes.abgr
+                : bytes
+        );
+    }
+
+    // Break the four bytes down into an array of 32 bits.
+    void bytesToBits(const in ivec4 bytes, out bool bits[32]) {
+        for (int channelIndex = 0; channelIndex < 4; ++channelIndex) {
+            float acc = float(bytes[channelIndex]);
+            for (int indexInByte = 7; indexInByte >= 0; --indexInByte) {
+                float powerOfTwo = exp2(float(indexInByte));
+                bool bit = acc >= powerOfTwo;
+                bits[channelIndex * 8 + (7 - indexInByte)] = bit;
+                acc = mod(acc, powerOfTwo);
+            }
+        }
+    }
+
+    // Compute the exponent of the 32-bit float.
+    float getExponent(bool bits[32]) {
+        const int startIndex = 1;
+        const int bitStringLength = 8;
+        const int endBeforeIndex = startIndex + bitStringLength;
+        float acc = 0.0;
+        int pow2 = bitStringLength - 1;
+        for (int bitIndex = startIndex; bitIndex < endBeforeIndex; ++bitIndex) {
+            acc += float(bits[bitIndex]) * exp2(float(pow2--));
+        }
+        return acc;
+    }
+
+    // Compute the mantissa of the 32-bit float.
+    float getMantissa(bool bits[32], bool subnormal) {
+        const int startIndex = 9;
+        const int bitStringLength = 23;
+        const int endBeforeIndex = startIndex + bitStringLength;
+        // Leading/implicit/hidden bit convention:
+        // If the number is not subnormal (with exponent 0), we add a leading 1 digit.
+        float acc = float(!subnormal) * exp2(float(bitStringLength));
+        int pow2 = bitStringLength - 1;
+        for (int bitIndex = startIndex; bitIndex < endBeforeIndex; ++bitIndex) {
+            acc += float(bits[bitIndex]) * exp2(float(pow2--));
+        }
+        return acc;
+    }
+
+    // Parse the float from its 32 bits.
+    float bitsToFloat(bool bits[32]) {
+        float signBit = float(bits[0]) * -2.0 + 1.0;
+        float exponent = getExponent(bits);
+        bool subnormal = abs(exponent - 0.0) < 0.01;
+        float mantissa = getMantissa(bits, subnormal);
+        float exponentBias = 127.0;
+        return signBit * mantissa * exp2(exponent - exponentBias - 23.0);
+    }
+
+    float rgbaToFloat(vec4 texelRGBA, bool littleEndian) {
+        ivec4 rgbaBytes = floatsToBytes(texelRGBA, littleEndian);
+        bool bits[32];
+        bytesToBits(rgbaBytes, bits);
+        return bitsToFloat(bits);
+    }
 `;

package/lib/mol-gl/shader/chunks/size-vert-params.glsl.js

@@ -1,12 +1,12 @@
-export const size_vert_params = `
-#if defined(dSizeType_uniform)
-    uniform float uSize;
-#elif defined(dSizeType_attribute)
-    attribute float aSize;
-#elif defined(dSizeType_instance) || defined(dSizeType_group) || defined(dSizeType_groupInstance)
-    uniform vec2 uSizeTexDim;
-    uniform sampler2D tSize;
-#endif
-
-uniform float uSizeFactor;
+export const size_vert_params = `
+#if defined(dSizeType_uniform)
+    uniform float uSize;
+#elif defined(dSizeType_attribute)
+    attribute float aSize;
+#elif defined(dSizeType_instance) || defined(dSizeType_group) || defined(dSizeType_groupInstance)
+    uniform vec2 uSizeTexDim;
+    uniform sampler2D tSize;
+#endif
+
+uniform float uSizeFactor;
 `;

package/lib/mol-gl/shader/chunks/texture3d-from-1d-trilinear.glsl.js

@@ -3,27 +3,27 @@
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
-export const texture3d_from_1d_trilinear = `
-vec4 texture3dFrom1dTrilinear(const in sampler2D tex, const in vec3 pos, const in vec3 gridDim, const in vec2 texDim, const in float offset) {
-    float gdYZ = gridDim.z * gridDim.y;
-    float gdZ = gridDim.z;
-    vec3 p0 = floor(pos * gridDim);
-    vec3 p1 = ceil(pos * gridDim);
-    vec3 pd = (pos * gridDim - p0) / (p1 - p0);
-    vec4 s000 = readFromTexture(tex, offset + p0.z + p0.y * gdZ + p0.x * gdYZ, texDim);
-    vec4 s100 = readFromTexture(tex, offset + p0.z + p0.y * gdZ + p1.x * gdYZ, texDim);
-    vec4 s001 = readFromTexture(tex, offset + p1.z + p0.y * gdZ + p0.x * gdYZ, texDim);
-    vec4 s101 = readFromTexture(tex, offset + p1.z + p0.y * gdZ + p1.x * gdYZ, texDim);
-    vec4 s010 = readFromTexture(tex, offset + p0.z + p1.y * gdZ + p0.x * gdYZ, texDim);
-    vec4 s110 = readFromTexture(tex, offset + p0.z + p1.y * gdZ + p1.x * gdYZ, texDim);
-    vec4 s011 = readFromTexture(tex, offset + p1.z + p1.y * gdZ + p0.x * gdYZ, texDim);
-    vec4 s111 = readFromTexture(tex, offset + p1.z + p1.y * gdZ + p1.x * gdYZ, texDim);
-    vec4 s00 = mix(s000, s100, pd.x);
-    vec4 s01 = mix(s001, s101, pd.x);
-    vec4 s10 = mix(s010, s110, pd.x);
-    vec4 s11 = mix(s011, s111, pd.x);
-    vec4 s0 = mix(s00, s10, pd.y);
-    vec4 s1 = mix(s01, s11, pd.y);
-    return mix(s0, s1, pd.z);
-}
+export const texture3d_from_1d_trilinear = `
+vec4 texture3dFrom1dTrilinear(const in sampler2D tex, const in vec3 pos, const in vec3 gridDim, const in vec2 texDim, const in float offset) {
+    float gdYZ = gridDim.z * gridDim.y;
+    float gdZ = gridDim.z;
+    vec3 p0 = floor(pos * gridDim);
+    vec3 p1 = ceil(pos * gridDim);
+    vec3 pd = (pos * gridDim - p0) / (p1 - p0);
+    vec4 s000 = readFromTexture(tex, offset + p0.z + p0.y * gdZ + p0.x * gdYZ, texDim);
+    vec4 s100 = readFromTexture(tex, offset + p0.z + p0.y * gdZ + p1.x * gdYZ, texDim);
+    vec4 s001 = readFromTexture(tex, offset + p1.z + p0.y * gdZ + p0.x * gdYZ, texDim);
+    vec4 s101 = readFromTexture(tex, offset + p1.z + p0.y * gdZ + p1.x * gdYZ, texDim);
+    vec4 s010 = readFromTexture(tex, offset + p0.z + p1.y * gdZ + p0.x * gdYZ, texDim);
+    vec4 s110 = readFromTexture(tex, offset + p0.z + p1.y * gdZ + p1.x * gdYZ, texDim);
+    vec4 s011 = readFromTexture(tex, offset + p1.z + p1.y * gdZ + p0.x * gdYZ, texDim);
+    vec4 s111 = readFromTexture(tex, offset + p1.z + p1.y * gdZ + p1.x * gdYZ, texDim);
+    vec4 s00 = mix(s000, s100, pd.x);
+    vec4 s01 = mix(s001, s101, pd.x);
+    vec4 s10 = mix(s010, s110, pd.x);
+    vec4 s11 = mix(s011, s111, pd.x);
+    vec4 s0 = mix(s00, s10, pd.y);
+    vec4 s1 = mix(s01, s11, pd.y);
+    return mix(s0, s1, pd.z);
+}
 `;

package/lib/mol-gl/shader/chunks/texture3d-from-2d-linear.glsl.js

@@ -4,21 +4,21 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  * @author Michael Krone <michael.krone@uni-tuebingen.de>
  */
-export const texture3d_from_2d_linear = `
-vec4 texture3dFrom2dLinear(sampler2D tex, vec3 pos, vec3 gridDim, vec2 texDim) {
-    float zSlice0 = floor(pos.z * gridDim.z);
-    float column0 = intMod(zSlice0 * gridDim.x, texDim.x) / gridDim.x;
-    float row0 = floor(intDiv(zSlice0 * gridDim.x, texDim.x));
-    vec2 coord0 = (vec2(column0 * gridDim.x, row0 * gridDim.y) + (pos.xy * gridDim.xy)) / texDim;
-    vec4 color0 = texture2D(tex, coord0);
-
-    float zSlice1 = zSlice0 + 1.0;
-    float column1 = intMod(zSlice1 * gridDim.x, texDim.x) / gridDim.x;
-    float row1 = floor(intDiv(zSlice1 * gridDim.x, texDim.x));
-    vec2 coord1 = (vec2(column1 * gridDim.x, row1 * gridDim.y) + (pos.xy * gridDim.xy)) / texDim;
-    vec4 color1 = texture2D(tex, coord1);
-
-    float delta0 = abs((pos.z * gridDim.z) - zSlice0);
-    return mix(color0, color1, delta0);
-}
+export const texture3d_from_2d_linear = `
+vec4 texture3dFrom2dLinear(sampler2D tex, vec3 pos, vec3 gridDim, vec2 texDim) {
+    float zSlice0 = floor(pos.z * gridDim.z);
+    float column0 = intMod(zSlice0 * gridDim.x, texDim.x) / gridDim.x;
+    float row0 = floor(intDiv(zSlice0 * gridDim.x, texDim.x));
+    vec2 coord0 = (vec2(column0 * gridDim.x, row0 * gridDim.y) + (pos.xy * gridDim.xy)) / texDim;
+    vec4 color0 = texture2D(tex, coord0);
+
+    float zSlice1 = zSlice0 + 1.0;
+    float column1 = intMod(zSlice1 * gridDim.x, texDim.x) / gridDim.x;
+    float row1 = floor(intDiv(zSlice1 * gridDim.x, texDim.x));
+    vec2 coord1 = (vec2(column1 * gridDim.x, row1 * gridDim.y) + (pos.xy * gridDim.xy)) / texDim;
+    vec4 color1 = texture2D(tex, coord1);
+
+    float delta0 = abs((pos.z * gridDim.z) - zSlice0);
+    return mix(color0, color1, delta0);
+}
 `;

package/lib/mol-gl/shader/chunks/texture3d-from-2d-nearest.glsl.js

@@ -4,12 +4,12 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  * @author Michael Krone <michael.krone@uni-tuebingen.de>
  */
-export const texture3d_from_2d_nearest = `
-vec4 texture3dFrom2dNearest(sampler2D tex, vec3 pos, vec3 gridDim, vec2 texDim) {
-    float zSlice = floor(pos.z * gridDim.z + 0.5); // round to nearest z-slice
-    float column = intMod(zSlice * gridDim.x, texDim.x) / gridDim.x;
-    float row = floor(intDiv(zSlice * gridDim.x, texDim.x));
-    vec2 coord = (vec2(column * gridDim.x, row * gridDim.y) + (pos.xy * gridDim.xy)) / texDim;
-    return texture2D(tex, coord);
-}
+export const texture3d_from_2d_nearest = `
+vec4 texture3dFrom2dNearest(sampler2D tex, vec3 pos, vec3 gridDim, vec2 texDim) {
+    float zSlice = floor(pos.z * gridDim.z + 0.5); // round to nearest z-slice
+    float column = intMod(zSlice * gridDim.x, texDim.x) / gridDim.x;
+    float row = floor(intDiv(zSlice * gridDim.x, texDim.x));
+    vec2 coord = (vec2(column * gridDim.x, row * gridDim.y) + (pos.xy * gridDim.xy)) / texDim;
+    return texture2D(tex, coord);
+}
 `;

package/lib/mol-gl/shader/chunks/wboit-write.glsl.js

@@ -4,29 +4,29 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  * @author Áron Samuel Kovács <aron.kovacs@mail.muni.cz>
  */
-export const wboit_write = `
-#if defined(dRenderVariant_colorWboit)
-    if (uRenderMask == MaskOpaque) {
-        if (preFogAlpha < 1.0) {
-            discard;
-        }
-    } else if (uRenderMask == MaskTransparent) {
-        if (preFogAlpha != 1.0 && fragmentDepth < getDepth(gl_FragCoord.xy / uDrawingBufferSize)) {
-            #ifdef dTransparentBackfaces_off
-                if (interior) discard;
-            #endif
-            float alpha = gl_FragColor.a;
-            float wboitWeight = alpha * clamp(pow(1.0 - fragmentDepth, 2.0), 0.01, 1.0);
-            gl_FragColor = vec4(gl_FragColor.rgb * alpha * wboitWeight, alpha);
-            // extra alpha is to handle pre-multiplied alpha
-            #ifndef dGeometryType_directVolume
-                gl_FragData[1] = vec4((uTransparentBackground ? alpha : 1.0) * alpha * wboitWeight);
-            #else
-                gl_FragData[1] = vec4(alpha * alpha * wboitWeight);
-            #endif
-        } else {
-            discard;
-        }
-    }
-#endif
+export const wboit_write = `
+#if defined(dRenderVariant_colorWboit)
+    if (uRenderMask == MaskOpaque) {
+        if (preFogAlpha < 1.0) {
+            discard;
+        }
+    } else if (uRenderMask == MaskTransparent) {
+        if (preFogAlpha != 1.0 && fragmentDepth < getDepth(gl_FragCoord.xy / uDrawingBufferSize)) {
+            #ifdef dTransparentBackfaces_off
+                if (interior) discard;
+            #endif
+            float alpha = gl_FragColor.a;
+            float wboitWeight = alpha * clamp(pow(1.0 - fragmentDepth, 2.0), 0.01, 1.0);
+            gl_FragColor = vec4(gl_FragColor.rgb * alpha * wboitWeight, alpha);
+            // extra alpha is to handle pre-multiplied alpha
+            #ifndef dGeometryType_directVolume
+                gl_FragData[1] = vec4((uTransparentBackground ? alpha : 1.0) * alpha * wboitWeight);
+            #else
+                gl_FragData[1] = vec4(alpha * alpha * wboitWeight);
+            #endif
+        } else {
+            discard;
+        }
+    }
+#endif
 `;

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

@@ -1,13 +1,13 @@
-export const compose_frag = `
-precision highp float;
-precision highp sampler2D;
-
-uniform sampler2D tColor;
-uniform vec2 uTexSize;
-uniform float uWeight;
-
-void main() {
-    vec2 coords = gl_FragCoord.xy / uTexSize;
-    gl_FragColor = texture2D(tColor, coords) * uWeight;
-}
+export const compose_frag = `
+precision highp float;
+precision highp sampler2D;
+
+uniform sampler2D tColor;
+uniform vec2 uTexSize;
+uniform float uWeight;
+
+void main() {
+    vec2 coords = gl_FragCoord.xy / uTexSize;
+    gl_FragColor = texture2D(tColor, coords) * uWeight;
+}
 `;

package/lib/mol-gl/shader/compute/color-smoothing/accumulate.frag.js

@@ -3,27 +3,27 @@
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
-export const accumulate_frag = `
-precision highp float;
-
-varying vec3 vPosition;
-varying vec4 vColor;
-
-uniform float uCurrentSlice;
-uniform float uCurrentX;
-uniform float uCurrentY;
-uniform float uResolution;
-
-const float p = 2.0;
-
-void main() {
-    vec2 v = gl_FragCoord.xy - vec2(uCurrentX, uCurrentY) - 0.5;
-    vec3 fragPos = vec3(v.x, v.y, uCurrentSlice);
-    float dist = distance(fragPos, vPosition);
-    if (dist > p) discard;
-
-    float f = p - dist;
-    gl_FragColor = vColor * f;
-    gl_FragData[1] = vec4(f);
-}
+export const accumulate_frag = `
+precision highp float;
+
+varying vec3 vPosition;
+varying vec4 vColor;
+
+uniform float uCurrentSlice;
+uniform float uCurrentX;
+uniform float uCurrentY;
+uniform float uResolution;
+
+const float p = 2.0;
+
+void main() {
+    vec2 v = gl_FragCoord.xy - vec2(uCurrentX, uCurrentY) - 0.5;
+    vec3 fragPos = vec3(v.x, v.y, uCurrentSlice);
+    float dist = distance(fragPos, vPosition);
+    if (dist > p) discard;
+
+    float f = p - dist;
+    gl_FragColor = vColor * f;
+    gl_FragData[1] = vec4(f);
+}
 `;

package/lib/mol-gl/shader/compute/color-smoothing/accumulate.vert.js

@@ -3,47 +3,47 @@
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
-export const accumulate_vert = `
-precision highp float;
-
-#include common
-#include read_from_texture
-
-uniform int uGroupCount;
-
-attribute float aSample;
-#define SampleID int(aSample)
-
-attribute mat4 aTransform;
-attribute float aInstance;
-
-uniform vec2 uGeoTexDim;
-uniform sampler2D tPosition;
-uniform sampler2D tGroup;
-
-uniform vec2 uColorTexDim;
-uniform sampler2D tColor;
-
-varying vec3 vPosition;
-varying vec4 vColor;
-
-uniform vec3 uBboxSize;
-uniform vec3 uBboxMin;
-uniform float uResolution;
-
-void main() {
-    vec3 position = readFromTexture(tPosition, SampleID, uGeoTexDim).xyz;
-    float group = unpackRGBToInt(readFromTexture(tGroup, SampleID, uGeoTexDim).rgb);
-
-    position = (aTransform * vec4(position, 1.0)).xyz;
-    gl_PointSize = 7.0;
-    vPosition = (position - uBboxMin) / uResolution;
-    gl_Position = vec4(((position - uBboxMin) / uBboxSize) * 2.0 - 1.0, 1.0);
-
-    #if defined(dColorType_group)
-        vColor = readFromTexture(tColor, group, uColorTexDim);
-    #elif defined(dColorType_groupInstance)
-        vColor = readFromTexture(tColor, aInstance * float(uGroupCount) + group, uColorTexDim);
-    #endif
-}
+export const accumulate_vert = `
+precision highp float;
+
+#include common
+#include read_from_texture
+
+uniform int uGroupCount;
+
+attribute float aSample;
+#define SampleID int(aSample)
+
+attribute mat4 aTransform;
+attribute float aInstance;
+
+uniform vec2 uGeoTexDim;
+uniform sampler2D tPosition;
+uniform sampler2D tGroup;
+
+uniform vec2 uColorTexDim;
+uniform sampler2D tColor;
+
+varying vec3 vPosition;
+varying vec4 vColor;
+
+uniform vec3 uBboxSize;
+uniform vec3 uBboxMin;
+uniform float uResolution;
+
+void main() {
+    vec3 position = readFromTexture(tPosition, SampleID, uGeoTexDim).xyz;
+    float group = unpackRGBToInt(readFromTexture(tGroup, SampleID, uGeoTexDim).rgb);
+
+    position = (aTransform * vec4(position, 1.0)).xyz;
+    gl_PointSize = 7.0;
+    vPosition = (position - uBboxMin) / uResolution;
+    gl_Position = vec4(((position - uBboxMin) / uBboxSize) * 2.0 - 1.0, 1.0);
+
+    #if defined(dColorType_group)
+        vColor = readFromTexture(tColor, group, uColorTexDim);
+    #elif defined(dColorType_groupInstance)
+        vColor = readFromTexture(tColor, aInstance * float(uGroupCount) + group, uColorTexDim);
+    #endif
+}
 `;

package/lib/mol-gl/shader/compute/color-smoothing/normalize.frag.js

@@ -3,19 +3,19 @@
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
-export const normalize_frag = `
-precision highp float;
-precision highp sampler2D;
-
-uniform sampler2D tColor;
-uniform sampler2D tCount;
-uniform vec2 uTexSize;
-
-void main(void) {
-    vec2 coords = gl_FragCoord.xy / uTexSize;
-    vec4 color = texture2D(tColor, coords);
-    float count = texture2D(tCount, coords).r;
-
-    gl_FragColor = color / count;
-}
+export const normalize_frag = `
+precision highp float;
+precision highp sampler2D;
+
+uniform sampler2D tColor;
+uniform sampler2D tCount;
+uniform vec2 uTexSize;
+
+void main(void) {
+    vec2 coords = gl_FragCoord.xy / uTexSize;
+    vec4 color = texture2D(tColor, coords);
+    float count = texture2D(tCount, coords).r;
+
+    gl_FragColor = color / count;
+}
 `;

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

@@ -1,12 +1,12 @@
-export const copy_frag = `
-precision highp float;
-precision highp sampler2D;
-
-uniform sampler2D tColor;
-uniform vec2 uTexSize;
-
-void main() {
-    vec2 coords = gl_FragCoord.xy / uTexSize;
-    gl_FragColor = texture2D(tColor, coords);
-}
+export const copy_frag = `
+precision highp float;
+precision highp sampler2D;
+
+uniform sampler2D tColor;
+uniform vec2 uTexSize;
+
+void main() {
+    vec2 coords = gl_FragCoord.xy / uTexSize;
+    gl_FragColor = texture2D(tColor, coords);
+}
 `;