molstar 4.3.0 → 4.4.1

package/lib/mol-gl/shader/chunks/common.glsl.js

@@ -1,235 +1,241 @@
-export const common = `
-// TODO find a better place for these convenience defines
-
-#if defined(dRenderVariant_colorBlended) || defined(dRenderVariant_colorWboit) || defined(dRenderVariant_colorDpoit)
-    #define dRenderVariant_color
-#endif
-
-#if defined(dColorType_instance) || defined(dColorType_group) || defined(dColorType_groupInstance) || defined(dColorType_vertex) || defined(dColorType_vertexInstance)
-    #define dColorType_texture
-#endif
-
-#if defined(dColorType_volume) || defined(dColorType_volumeInstance)
-    #define dColorType_grid
-#endif
-
-#if defined(dColorType_attribute) || defined(dColorType_texture) || defined(dColorType_grid)
-    #define dColorType_varying
-#endif
-
-#if (defined(dRenderVariant_color) && defined(dColorMarker)) || defined(dRenderVariant_marking)
-    #define dNeedsMarker
-#endif
-
-#if defined(dXrayShaded_on) || defined(dXrayShaded_inverted)
-    #define dXrayShaded
-#endif
-
-#define MaskAll 0
-#define MaskOpaque 1
-#define MaskTransparent 2
-
-//
-
-#define PI 3.14159265
-#define RECIPROCAL_PI 0.31830988618
-#define EPSILON 1e-6
-
-#define saturate(a) clamp(a, 0.0, 1.0)
-
-#if __VERSION__ == 100
-    #define round(x) floor((x) + 0.5)
-#endif
-
-float intDiv(const in float a, const in float b) { return float(int(a) / int(b)); }
-vec2 ivec2Div(const in vec2 a, const in vec2 b) { return vec2(ivec2(a) / ivec2(b)); }
-float intMod(const in float a, const in float b) { return a - b * float(int(a) / int(b)); }
-int imod(const in int a, const in int b) { return a - b * (a / b); }
-
-float pow2(const in float x) { return x * x; }
-
-vec3 packIntToRGB(in float value) {
-    value = clamp(round(value), 0.0, 16777216.0 - 1.0) + 1.0;
-    vec3 c = vec3(0.0);
-    c.b = mod(value, 256.0);
-    value = floor(value / 256.0);
-    c.g = mod(value, 256.0);
-    value = floor(value / 256.0);
-    c.r = mod(value, 256.0);
-    return c / 255.0;
-}
-float unpackRGBToInt(const in vec3 rgb) {
-    return (floor(rgb.r * 255.0 + 0.5) * 256.0 * 256.0 + floor(rgb.g * 255.0 + 0.5) * 256.0 + floor(rgb.b * 255.0 + 0.5)) - 1.0;
-}
-
-vec2 packUnitIntervalToRG(const in float v) {
-    vec2 enc;
-    enc.xy = vec2(fract(v * 256.0), v);
-    enc.y -= enc.x * (1.0 / 256.0);
-    enc.xy *=  256.0 / 255.0;
-
-    return enc;
-}
-
-float unpackRGToUnitInterval(const in vec2 enc) {
-    return dot(enc, vec2(255.0 / (256.0 * 256.0), 255.0 / 256.0));
-}
-
-vec3 screenSpaceToViewSpace(const in vec3 ssPos, const in mat4 invProjection) {
-    vec4 p = vec4(ssPos * 2.0 - 1.0, 1.0);
-    p = invProjection * p;
-    return p.xyz / p.w;
-}
-
-const float PackUpscale = 256.0 / 255.0; // fraction -> 0..1 (including 1)
-const float UnpackDownscale = 255.0 / 256.0; // 0..1 -> fraction (excluding 1)
-const vec3 PackFactors = vec3(256.0 * 256.0 * 256.0, 256.0 * 256.0,  256.0);
-const vec4 UnpackFactors = UnpackDownscale / vec4(PackFactors, 1.0);
-const float ShiftRight8 = 1.0 / 256.0;
-
-vec4 packDepthToRGBA(const in float v) {
-    vec4 r = vec4(fract(v * PackFactors), v);
-    r.yzw -= r.xyz * ShiftRight8; // tidy overflow
-    return r * PackUpscale;
-}
-float unpackRGBAToDepth(const in vec4 v) {
-    return dot(v, UnpackFactors);
-}
-
-vec4 sRGBToLinear(const in vec4 c) {
-    return vec4(mix(pow(c.rgb * 0.9478672986 + vec3(0.0521327014), vec3(2.4)), c.rgb * 0.0773993808, vec3(lessThanEqual(c.rgb, vec3(0.04045)))), c.a);
-}
-vec4 linearTosRGB(const in vec4 c) {
-    return vec4(mix(pow(c.rgb, vec3(0.41666)) * 1.055 - vec3(0.055), c.rgb * 12.92, vec3(lessThanEqual(c.rgb, vec3(0.0031308)))), c.a);
-}
-
-float linearizeDepth(const in float depth, const in float near, const in float far) {
-    return (2.0 * near) / (far + near - depth * (far - near));
-}
-
-float perspectiveDepthToViewZ(const in float invClipZ, const in float near, const in float far) {
-    return (near * far) / ((far - near) * invClipZ - far);
-}
-
-float orthographicDepthToViewZ(const in float linearClipZ, const in float near, const in float far) {
-    return linearClipZ * (near - far) - near;
-}
-
-float depthToViewZ(const in float isOrtho, const in float linearClipZ, const in float near, const in float far) {
-    return isOrtho == 1.0 ? orthographicDepthToViewZ(linearClipZ, near, far) : perspectiveDepthToViewZ(linearClipZ, near, far);
-}
-
-#if __VERSION__ == 100
-    // transpose
-
-    float transpose(const in float m) {
-        return m;
-    }
-
-    mat2 transpose2(const in mat2 m) {
-        return mat2(
-            m[0][0], m[1][0],
-            m[0][1], m[1][1]
-        );
-    }
-
-    mat3 transpose3(const in mat3 m) {
-        return mat3(
-            m[0][0], m[1][0], m[2][0],
-            m[0][1], m[1][1], m[2][1],
-            m[0][2], m[1][2], m[2][2]
-        );
-    }
-
-    mat4 transpose4(const in mat4 m) {
-        return mat4(
-            m[0][0], m[1][0], m[2][0], m[3][0],
-            m[0][1], m[1][1], m[2][1], m[3][1],
-            m[0][2], m[1][2], m[2][2], m[3][2],
-            m[0][3], m[1][3], m[2][3], m[3][3]
-        );
-    }
-
-    // inverse
-
-    float inverse(const in float m) {
-        return 1.0 / m;
-    }
-
-    mat2 inverse2(const in mat2 m) {
-        return mat2(m[1][1],-m[0][1],
-                -m[1][0], m[0][0]) / (m[0][0]*m[1][1] - m[0][1]*m[1][0]);
-    }
-
-    mat3 inverse3(const in mat3 m) {
-        float a00 = m[0][0], a01 = m[0][1], a02 = m[0][2];
-        float a10 = m[1][0], a11 = m[1][1], a12 = m[1][2];
-        float a20 = m[2][0], a21 = m[2][1], a22 = m[2][2];
-
-        float b01 = a22 * a11 - a12 * a21;
-        float b11 = -a22 * a10 + a12 * a20;
-        float b21 = a21 * a10 - a11 * a20;
-
-        float det = a00 * b01 + a01 * b11 + a02 * b21;
-
-        return mat3(b01, (-a22 * a01 + a02 * a21), (a12 * a01 - a02 * a11),
-                    b11, (a22 * a00 - a02 * a20), (-a12 * a00 + a02 * a10),
-                    b21, (-a21 * a00 + a01 * a20), (a11 * a00 - a01 * a10)) / det;
-    }
-
-    mat4 inverse4(const in mat4 m) {
-        float
-            a00 = m[0][0], a01 = m[0][1], a02 = m[0][2], a03 = m[0][3],
-            a10 = m[1][0], a11 = m[1][1], a12 = m[1][2], a13 = m[1][3],
-            a20 = m[2][0], a21 = m[2][1], a22 = m[2][2], a23 = m[2][3],
-            a30 = m[3][0], a31 = m[3][1], a32 = m[3][2], a33 = m[3][3],
-
-            b00 = a00 * a11 - a01 * a10,
-            b01 = a00 * a12 - a02 * a10,
-            b02 = a00 * a13 - a03 * a10,
-            b03 = a01 * a12 - a02 * a11,
-            b04 = a01 * a13 - a03 * a11,
-            b05 = a02 * a13 - a03 * a12,
-            b06 = a20 * a31 - a21 * a30,
-            b07 = a20 * a32 - a22 * a30,
-            b08 = a20 * a33 - a23 * a30,
-            b09 = a21 * a32 - a22 * a31,
-            b10 = a21 * a33 - a23 * a31,
-            b11 = a22 * a33 - a23 * a32,
-
-            det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
-
-        return mat4(
-            a11 * b11 - a12 * b10 + a13 * b09,
-            a02 * b10 - a01 * b11 - a03 * b09,
-            a31 * b05 - a32 * b04 + a33 * b03,
-            a22 * b04 - a21 * b05 - a23 * b03,
-            a12 * b08 - a10 * b11 - a13 * b07,
-            a00 * b11 - a02 * b08 + a03 * b07,
-            a32 * b02 - a30 * b05 - a33 * b01,
-            a20 * b05 - a22 * b02 + a23 * b01,
-            a10 * b10 - a11 * b08 + a13 * b06,
-            a01 * b08 - a00 * b10 - a03 * b06,
-            a30 * b04 - a31 * b02 + a33 * b00,
-            a21 * b02 - a20 * b04 - a23 * b00,
-            a11 * b07 - a10 * b09 - a12 * b06,
-            a00 * b09 - a01 * b07 + a02 * b06,
-            a31 * b01 - a30 * b03 - a32 * b00,
-            a20 * b03 - a21 * b01 + a22 * b00) / det;
-    }
-
-    #define isNaN(x) ((x) != (x))
-    #define isInf(x) ((x) == (x) + 1.0)
-#else
-    #define transpose2(m) transpose(m)
-    #define transpose3(m) transpose(m)
-    #define transpose4(m) transpose(m)
-
-    #define inverse2(m) inverse(m)
-    #define inverse3(m) inverse(m)
-    #define inverse4(m) inverse(m)
-
-    #define isNaN isnan
-    #define isInf isinf
-#endif
+export const common = `
+// TODO find a better place for these convenience defines
+
+#if defined(dRenderVariant_colorBlended) || defined(dRenderVariant_colorWboit) || defined(dRenderVariant_colorDpoit)
+    #define dRenderVariant_color
+#endif
+
+#if defined(dColorType_instance) || defined(dColorType_group) || defined(dColorType_groupInstance) || defined(dColorType_vertex) || defined(dColorType_vertexInstance)
+    #define dColorType_texture
+#endif
+
+#if defined(dColorType_volume) || defined(dColorType_volumeInstance)
+    #define dColorType_grid
+#endif
+
+#if defined(dColorType_attribute) || defined(dColorType_texture) || defined(dColorType_grid)
+    #define dColorType_varying
+#endif
+
+#if (defined(dRenderVariant_color) && defined(dColorMarker)) || defined(dRenderVariant_marking)
+    #define dNeedsMarker
+#endif
+
+#if defined(dXrayShaded_on) || defined(dXrayShaded_inverted)
+    #define dXrayShaded
+#endif
+
+#define MaskAll 0
+#define MaskOpaque 1
+#define MaskTransparent 2
+
+//
+
+#define PI 3.14159265
+#define RECIPROCAL_PI 0.31830988618
+#define EPSILON 1e-6
+
+#define saturate(a) clamp(a, 0.0, 1.0)
+
+#if __VERSION__ == 100
+    #define round(x) floor((x) + 0.5)
+#endif
+
+float intDiv(const in float a, const in float b) { return float(int(a) / int(b)); }
+vec2 ivec2Div(const in vec2 a, const in vec2 b) { return vec2(ivec2(a) / ivec2(b)); }
+float intMod(const in float a, const in float b) { return a - b * float(int(a) / int(b)); }
+int imod(const in int a, const in int b) { return a - b * (a / b); }
+
+float pow2(const in float x) { return x * x; }
+
+vec3 packIntToRGB(in float value) {
+    value = clamp(round(value), 0.0, 16777216.0 - 1.0) + 1.0;
+    vec3 c = vec3(0.0);
+    c.b = mod(value, 256.0);
+    value = floor(value / 256.0);
+    c.g = mod(value, 256.0);
+    value = floor(value / 256.0);
+    c.r = mod(value, 256.0);
+    return c / 255.0;
+}
+float unpackRGBToInt(const in vec3 rgb) {
+    return (floor(rgb.r * 255.0 + 0.5) * 256.0 * 256.0 + floor(rgb.g * 255.0 + 0.5) * 256.0 + floor(rgb.b * 255.0 + 0.5)) - 1.0;
+}
+
+vec2 packUnitIntervalToRG(const in float v) {
+    vec2 enc;
+    enc.xy = vec2(fract(v * 256.0), v);
+    enc.y -= enc.x * (1.0 / 256.0);
+    enc.xy *=  256.0 / 255.0;
+
+    return enc;
+}
+
+float unpackRGToUnitInterval(const in vec2 enc) {
+    return dot(enc, vec2(255.0 / (256.0 * 256.0), 255.0 / 256.0));
+}
+
+vec3 screenSpaceToViewSpace(const in vec3 ssPos, const in mat4 invProjection) {
+    vec4 p = vec4(ssPos * 2.0 - 1.0, 1.0);
+    p = invProjection * p;
+    return p.xyz / p.w;
+}
+
+const float PackUpscale = 256.0 / 255.0; // fraction -> 0..1 (including 1)
+const float UnpackDownscale = 255.0 / 256.0; // 0..1 -> fraction (excluding 1)
+const vec3 PackFactors = vec3(256.0 * 256.0 * 256.0, 256.0 * 256.0,  256.0);
+const vec4 UnpackFactors = UnpackDownscale / vec4(PackFactors, 1.0);
+const float ShiftRight8 = 1.0 / 256.0;
+
+vec4 packDepthToRGBA(const in float v) {
+    vec4 r = vec4(fract(v * PackFactors), v);
+    r.yzw -= r.xyz * ShiftRight8; // tidy overflow
+    return r * PackUpscale;
+}
+float unpackRGBAToDepth(const in vec4 v) {
+    return dot(v, UnpackFactors);
+}
+
+vec4 sRGBToLinear(const in vec4 c) {
+    return vec4(mix(pow(c.rgb * 0.9478672986 + vec3(0.0521327014), vec3(2.4)), c.rgb * 0.0773993808, vec3(lessThanEqual(c.rgb, vec3(0.04045)))), c.a);
+}
+vec4 linearTosRGB(const in vec4 c) {
+    return vec4(mix(pow(c.rgb, vec3(0.41666)) * 1.055 - vec3(0.055), c.rgb * 12.92, vec3(lessThanEqual(c.rgb, vec3(0.0031308)))), c.a);
+}
+
+float luminance(vec3 c) {
+    // https://www.w3.org/TR/WCAG21/#dfn-relative-luminance
+    const vec3 W = vec3(0.2125, 0.7154, 0.0721);
+    return dot(c, W);
+}
+
+float linearizeDepth(const in float depth, const in float near, const in float far) {
+    return (2.0 * near) / (far + near - depth * (far - near));
+}
+
+float perspectiveDepthToViewZ(const in float invClipZ, const in float near, const in float far) {
+    return (near * far) / ((far - near) * invClipZ - far);
+}
+
+float orthographicDepthToViewZ(const in float linearClipZ, const in float near, const in float far) {
+    return linearClipZ * (near - far) - near;
+}
+
+float depthToViewZ(const in float isOrtho, const in float linearClipZ, const in float near, const in float far) {
+    return isOrtho == 1.0 ? orthographicDepthToViewZ(linearClipZ, near, far) : perspectiveDepthToViewZ(linearClipZ, near, far);
+}
+
+#if __VERSION__ == 100
+    // transpose
+
+    float transpose(const in float m) {
+        return m;
+    }
+
+    mat2 transpose2(const in mat2 m) {
+        return mat2(
+            m[0][0], m[1][0],
+            m[0][1], m[1][1]
+        );
+    }
+
+    mat3 transpose3(const in mat3 m) {
+        return mat3(
+            m[0][0], m[1][0], m[2][0],
+            m[0][1], m[1][1], m[2][1],
+            m[0][2], m[1][2], m[2][2]
+        );
+    }
+
+    mat4 transpose4(const in mat4 m) {
+        return mat4(
+            m[0][0], m[1][0], m[2][0], m[3][0],
+            m[0][1], m[1][1], m[2][1], m[3][1],
+            m[0][2], m[1][2], m[2][2], m[3][2],
+            m[0][3], m[1][3], m[2][3], m[3][3]
+        );
+    }
+
+    // inverse
+
+    float inverse(const in float m) {
+        return 1.0 / m;
+    }
+
+    mat2 inverse2(const in mat2 m) {
+        return mat2(m[1][1],-m[0][1],
+                -m[1][0], m[0][0]) / (m[0][0]*m[1][1] - m[0][1]*m[1][0]);
+    }
+
+    mat3 inverse3(const in mat3 m) {
+        float a00 = m[0][0], a01 = m[0][1], a02 = m[0][2];
+        float a10 = m[1][0], a11 = m[1][1], a12 = m[1][2];
+        float a20 = m[2][0], a21 = m[2][1], a22 = m[2][2];
+
+        float b01 = a22 * a11 - a12 * a21;
+        float b11 = -a22 * a10 + a12 * a20;
+        float b21 = a21 * a10 - a11 * a20;
+
+        float det = a00 * b01 + a01 * b11 + a02 * b21;
+
+        return mat3(b01, (-a22 * a01 + a02 * a21), (a12 * a01 - a02 * a11),
+                    b11, (a22 * a00 - a02 * a20), (-a12 * a00 + a02 * a10),
+                    b21, (-a21 * a00 + a01 * a20), (a11 * a00 - a01 * a10)) / det;
+    }
+
+    mat4 inverse4(const in mat4 m) {
+        float
+            a00 = m[0][0], a01 = m[0][1], a02 = m[0][2], a03 = m[0][3],
+            a10 = m[1][0], a11 = m[1][1], a12 = m[1][2], a13 = m[1][3],
+            a20 = m[2][0], a21 = m[2][1], a22 = m[2][2], a23 = m[2][3],
+            a30 = m[3][0], a31 = m[3][1], a32 = m[3][2], a33 = m[3][3],
+
+            b00 = a00 * a11 - a01 * a10,
+            b01 = a00 * a12 - a02 * a10,
+            b02 = a00 * a13 - a03 * a10,
+            b03 = a01 * a12 - a02 * a11,
+            b04 = a01 * a13 - a03 * a11,
+            b05 = a02 * a13 - a03 * a12,
+            b06 = a20 * a31 - a21 * a30,
+            b07 = a20 * a32 - a22 * a30,
+            b08 = a20 * a33 - a23 * a30,
+            b09 = a21 * a32 - a22 * a31,
+            b10 = a21 * a33 - a23 * a31,
+            b11 = a22 * a33 - a23 * a32,
+
+            det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+
+        return mat4(
+            a11 * b11 - a12 * b10 + a13 * b09,
+            a02 * b10 - a01 * b11 - a03 * b09,
+            a31 * b05 - a32 * b04 + a33 * b03,
+            a22 * b04 - a21 * b05 - a23 * b03,
+            a12 * b08 - a10 * b11 - a13 * b07,
+            a00 * b11 - a02 * b08 + a03 * b07,
+            a32 * b02 - a30 * b05 - a33 * b01,
+            a20 * b05 - a22 * b02 + a23 * b01,
+            a10 * b10 - a11 * b08 + a13 * b06,
+            a01 * b08 - a00 * b10 - a03 * b06,
+            a30 * b04 - a31 * b02 + a33 * b00,
+            a21 * b02 - a20 * b04 - a23 * b00,
+            a11 * b07 - a10 * b09 - a12 * b06,
+            a00 * b09 - a01 * b07 + a02 * b06,
+            a31 * b01 - a30 * b03 - a32 * b00,
+            a20 * b03 - a21 * b01 + a22 * b00) / det;
+    }
+
+    #define isNaN(x) ((x) != (x))
+    #define isInf(x) ((x) == (x) + 1.0)
+#else
+    #define transpose2(m) transpose(m)
+    #define transpose3(m) transpose(m)
+    #define transpose4(m) transpose(m)
+
+    #define inverse2(m) inverse(m)
+    #define inverse3(m) inverse(m)
+    #define inverse4(m) inverse(m)
+
+    #define isNaN isnan
+    #define isInf isinf
+#endif
 `;

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

@@ -3,66 +3,66 @@
  *
  * @author Gianluca Tomasello <giagitom@gmail.com>
  */
-export const dpoit_write = `
-#if defined(dRenderVariant_colorDpoit)
-    if (uRenderMask == MaskOpaque) {
-        if (preFogAlpha < 1.0) {
-            discard;
-        }
-    } else if (uRenderMask == MaskTransparent) {
-        vec2 coords = gl_FragCoord.xy / uDrawingBufferSize;
-        if (preFogAlpha != 1.0 && fragmentDepth < getDepth(coords)) {
-            #ifdef dTransparentBackfaces_off
-                if (interior) discard;
-            #endif
-
-            // adapted from https://github.com/tsherif/webgl2examples
-            // The MIT License, Copyright 2017 Tarek Sherif, Shuai Shao
-
-            vec2 lastDepth = texture2D(tDpoitDepth, coords).rg;
-            vec4 lastFrontColor = texture2D(tDpoitFrontColor, coords);
-
-            vec4 fragColor = gl_FragColor;
-
-            // depth value always increases
-            // so we can use MAX blend equation
-            gl_FragData[2].rg = vec2(-MAX_DPOIT_DEPTH);
-
-            // front color always increases
-            // so we can use MAX blend equation
-            gl_FragColor = lastFrontColor;
-
-            // back color is separately blend afterwards each pass
-            gl_FragData[1] = vec4(0.0);
-
-            float nearestDepth = -lastDepth.x;
-            float furthestDepth = lastDepth.y;
-            float alphaMultiplier = 1.0 - lastFrontColor.a;
-
-            if (fragmentDepth < nearestDepth || fragmentDepth > furthestDepth) {
-                // Skip this depth since it's been peeled.
-                return;
-            }
-
-            if (fragmentDepth > nearestDepth && fragmentDepth < furthestDepth) {
-                // This needs to be peeled.
-                // The ones remaining after MAX blended for
-                // all need-to-peel will be peeled next pass.
-                gl_FragData[2].rg = vec2(-fragmentDepth, fragmentDepth);
-                return;
-            }
-
-            // write to back and front color buffer
-            if (fragmentDepth == nearestDepth) {
-                gl_FragColor.rgb += fragColor.rgb * fragColor.a * alphaMultiplier;
-                gl_FragColor.a = 1.0 - alphaMultiplier * (1.0 - fragColor.a);
-            } else {
-                gl_FragData[1] += fragColor;
-            }
-
-        } else {
-            discard;
-        }
-    }
-#endif
+export const dpoit_write = `
+#if defined(dRenderVariant_colorDpoit)
+    if (uRenderMask == MaskOpaque) {
+        if (preFogAlpha < 1.0) {
+            discard;
+        }
+    } else if (uRenderMask == MaskTransparent) {
+        vec2 coords = gl_FragCoord.xy / uDrawingBufferSize;
+        if (preFogAlpha != 1.0 && fragmentDepth < getDepth(coords)) {
+            #ifdef dTransparentBackfaces_off
+                if (interior) discard;
+            #endif
+
+            // adapted from https://github.com/tsherif/webgl2examples
+            // The MIT License, Copyright 2017 Tarek Sherif, Shuai Shao
+
+            vec2 lastDepth = texture2D(tDpoitDepth, coords).rg;
+            vec4 lastFrontColor = texture2D(tDpoitFrontColor, coords);
+
+            vec4 fragColor = gl_FragColor;
+
+            // depth value always increases
+            // so we can use MAX blend equation
+            gl_FragData[2].rg = vec2(-MAX_DPOIT_DEPTH);
+
+            // front color always increases
+            // so we can use MAX blend equation
+            gl_FragColor = lastFrontColor;
+
+            // back color is separately blend afterwards each pass
+            gl_FragData[1] = vec4(0.0);
+
+            float nearestDepth = -lastDepth.x;
+            float furthestDepth = lastDepth.y;
+            float alphaMultiplier = 1.0 - lastFrontColor.a;
+
+            if (fragmentDepth < nearestDepth || fragmentDepth > furthestDepth) {
+                // Skip this depth since it's been peeled.
+                return;
+            }
+
+            if (fragmentDepth > nearestDepth && fragmentDepth < furthestDepth) {
+                // This needs to be peeled.
+                // The ones remaining after MAX blended for
+                // all need-to-peel will be peeled next pass.
+                gl_FragData[2].rg = vec2(-fragmentDepth, fragmentDepth);
+                return;
+            }
+
+            // write to back and front color buffer
+            if (fragmentDepth == nearestDepth) {
+                gl_FragColor.rgb += fragColor.rgb * fragColor.a * alphaMultiplier;
+                gl_FragColor.a = 1.0 - alphaMultiplier * (1.0 - fragColor.a);
+            } else {
+                gl_FragData[1] += fragColor;
+            }
+
+        } else {
+            discard;
+        }
+    }
+#endif
 `;