molstar 4.2.0 → 4.3.0

package/lib/commonjs/mol-gl/shader/marking/edge.frag.js

@@ -1,32 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.edge_frag = void 0;
-exports.edge_frag = `
-precision highp float;
-precision highp sampler2D;
-
-uniform sampler2D tMaskTexture;
-uniform vec2 uTexSizeInv;
-
-void main() {
-    vec2 coords = gl_FragCoord.xy * uTexSizeInv;
-    vec4 offset = vec4(float(dEdgeScale), 0.0, 0.0, float(dEdgeScale)) * vec4(uTexSizeInv, uTexSizeInv);
-    vec4 c0 = texture2D(tMaskTexture, coords);
-    vec4 c1 = texture2D(tMaskTexture, coords + offset.xy);
-    vec4 c2 = texture2D(tMaskTexture, coords - offset.xy);
-    vec4 c3 = texture2D(tMaskTexture, coords + offset.yw);
-    vec4 c4 = texture2D(tMaskTexture, coords - offset.yw);
-    float diff1 = (c1.r - c2.r) * 0.5;
-    float diff2 = (c3.r - c4.r) * 0.5;
-    float d = length(vec2(diff1, diff2));
-    if (d <= 0.0)
-        discard;
-    float a1 = min(c1.g, c2.g);
-    float a2 = min(c3.g, c4.g);
-    float visibility = min(a1, a2) > 0.001 ? 1.0 : 0.0;
-    float mask = c0.r;
-    float marker = min(c1.b, min(c2.b, min(c3.b, c4.b)));
-    float fogAlpha = min(c1.a, min(c2.a, min(c3.a, c4.a)));
-    gl_FragColor = vec4(visibility, mask, marker, fogAlpha);
-}
+exports.edge_frag = `
+precision highp float;
+precision highp sampler2D;
+
+uniform sampler2D tMaskTexture;
+uniform vec2 uTexSizeInv;
+
+void main() {
+    vec2 coords = gl_FragCoord.xy * uTexSizeInv;
+    vec4 offset = vec4(float(dEdgeScale), 0.0, 0.0, float(dEdgeScale)) * vec4(uTexSizeInv, uTexSizeInv);
+    vec4 c0 = texture2D(tMaskTexture, coords);
+    vec4 c1 = texture2D(tMaskTexture, coords + offset.xy);
+    vec4 c2 = texture2D(tMaskTexture, coords - offset.xy);
+    vec4 c3 = texture2D(tMaskTexture, coords + offset.yw);
+    vec4 c4 = texture2D(tMaskTexture, coords - offset.yw);
+    float diff1 = (c1.r - c2.r) * 0.5;
+    float diff2 = (c3.r - c4.r) * 0.5;
+    float d = length(vec2(diff1, diff2));
+    if (d <= 0.0)
+        discard;
+    float a1 = min(c1.g, c2.g);
+    float a2 = min(c3.g, c4.g);
+    float visibility = min(a1, a2) > 0.001 ? 1.0 : 0.0;
+    float mask = c0.r;
+    float marker = min(c1.b, min(c2.b, min(c3.b, c4.b)));
+    float fogAlpha = min(c1.a, min(c2.a, min(c3.a, c4.a)));
+    gl_FragColor = vec4(visibility, mask, marker, fogAlpha);
+}
 `;

package/lib/commonjs/mol-gl/shader/marking/overlay.frag.js

@@ -1,30 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.overlay_frag = void 0;
-exports.overlay_frag = `
-precision highp float;
-precision highp sampler2D;
-
-uniform vec2 uTexSizeInv;
-uniform sampler2D tEdgeTexture;
-uniform vec3 uHighlightEdgeColor;
-uniform vec3 uSelectEdgeColor;
-uniform float uHighlightEdgeStrength;
-uniform float uSelectEdgeStrength;
-uniform float uGhostEdgeStrength;
-uniform float uInnerEdgeFactor;
-
-void main() {
-    vec2 coords = gl_FragCoord.xy * uTexSizeInv;
-    vec4 edgeValue = texture2D(tEdgeTexture, coords);
-    if (edgeValue.a > 0.0) {
-        vec3 edgeColor = edgeValue.b == 1.0 ? uHighlightEdgeColor : uSelectEdgeColor;
-        gl_FragColor.rgb = edgeValue.g > 0.0 ? edgeColor : edgeColor * uInnerEdgeFactor;
-        gl_FragColor.a = (edgeValue.r == 1.0 ? uGhostEdgeStrength : 1.0) * edgeValue.a;
-        float edgeStrength = edgeValue.b == 1.0 ? uHighlightEdgeStrength : uSelectEdgeStrength;
-        gl_FragColor.a *= edgeStrength;
-    } else {
-        gl_FragColor = vec4(0.0);
-    }
-}
+exports.overlay_frag = `
+precision highp float;
+precision highp sampler2D;
+
+uniform vec2 uTexSizeInv;
+uniform sampler2D tEdgeTexture;
+uniform vec3 uHighlightEdgeColor;
+uniform vec3 uSelectEdgeColor;
+uniform float uHighlightEdgeStrength;
+uniform float uSelectEdgeStrength;
+uniform float uGhostEdgeStrength;
+uniform float uInnerEdgeFactor;
+
+void main() {
+    vec2 coords = gl_FragCoord.xy * uTexSizeInv;
+    vec4 edgeValue = texture2D(tEdgeTexture, coords);
+    if (edgeValue.a > 0.0) {
+        vec3 edgeColor = edgeValue.b == 1.0 ? uHighlightEdgeColor : uSelectEdgeColor;
+        gl_FragColor.rgb = edgeValue.g > 0.0 ? edgeColor : edgeColor * uInnerEdgeFactor;
+        gl_FragColor.a = (edgeValue.r == 1.0 ? uGhostEdgeStrength : 1.0) * edgeValue.a;
+        float edgeStrength = edgeValue.b == 1.0 ? uHighlightEdgeStrength : uSelectEdgeStrength;
+        gl_FragColor.a *= edgeStrength;
+    } else {
+        gl_FragColor = vec4(0.0);
+    }
+}
 `;

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

@@ -6,69 +6,69 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mesh_frag = void 0;
-exports.mesh_frag = `
-precision highp float;
-precision highp int;
-
-#define bumpEnabled
-
-#include common
-#include common_frag_params
-#include color_frag_params
-#include light_frag_params
-#include normal_frag_params
-#include common_clip
-
-void main() {
-    #include fade_lod
-    #include clip_pixel
-
-    // Workaround for buggy gl_FrontFacing (e.g. on some integrated Intel GPUs)
-    vec3 fdx = dFdx(vViewPosition);
-    vec3 fdy = dFdy(vViewPosition);
-    vec3 faceNormal = normalize(cross(fdx,fdy));
-    bool frontFacing = dot(vNormal, faceNormal) > 0.0;
-
-    #if defined(dFlipSided)
-        interior = frontFacing;
-    #else
-        interior = !frontFacing;
-    #endif
-
-    float fragmentDepth = gl_FragCoord.z;
-    #include assign_material_color
-    #include check_transparency
-
-    #if defined(dRenderVariant_pick)
-        #include check_picking_alpha
-        #ifdef requiredDrawBuffers
-            gl_FragColor = vObject;
-            gl_FragData[1] = vInstance;
-            gl_FragData[2] = vGroup;
-            gl_FragData[3] = packDepthToRGBA(fragmentDepth);
-        #else
-            gl_FragColor = vColor;
-        #endif
-    #elif defined(dRenderVariant_depth)
-        gl_FragColor = material;
-    #elif defined(dRenderVariant_marking)
-        gl_FragColor = material;
-    #elif defined(dRenderVariant_emissive)
-        gl_FragColor = material;
-    #elif defined(dRenderVariant_color)
-        #if defined(dFlatShaded)
-            vec3 normal = -faceNormal;
-        #else
-            vec3 normal = -normalize(vNormal);
-            if (uDoubleSided) normal *= float(frontFacing) * 2.0 - 1.0;
-        #endif
-        #include apply_light_color
-
-        #include apply_interior_color
-        #include apply_marker_color
-        #include apply_fog
-        #include wboit_write
-        #include dpoit_write
-    #endif
-}
+exports.mesh_frag = `
+precision highp float;
+precision highp int;
+
+#define bumpEnabled
+
+#include common
+#include common_frag_params
+#include color_frag_params
+#include light_frag_params
+#include normal_frag_params
+#include common_clip
+
+void main() {
+    #include fade_lod
+    #include clip_pixel
+
+    // Workaround for buggy gl_FrontFacing (e.g. on some integrated Intel GPUs)
+    vec3 fdx = dFdx(vViewPosition);
+    vec3 fdy = dFdy(vViewPosition);
+    vec3 faceNormal = normalize(cross(fdx,fdy));
+    bool frontFacing = dot(vNormal, faceNormal) > 0.0;
+
+    #if defined(dFlipSided)
+        interior = frontFacing;
+    #else
+        interior = !frontFacing;
+    #endif
+
+    float fragmentDepth = gl_FragCoord.z;
+    #include assign_material_color
+    #include check_transparency
+
+    #if defined(dRenderVariant_pick)
+        #include check_picking_alpha
+        #ifdef requiredDrawBuffers
+            gl_FragColor = vObject;
+            gl_FragData[1] = vInstance;
+            gl_FragData[2] = vGroup;
+            gl_FragData[3] = packDepthToRGBA(fragmentDepth);
+        #else
+            gl_FragColor = vColor;
+        #endif
+    #elif defined(dRenderVariant_depth)
+        gl_FragColor = material;
+    #elif defined(dRenderVariant_marking)
+        gl_FragColor = material;
+    #elif defined(dRenderVariant_emissive)
+        gl_FragColor = material;
+    #elif defined(dRenderVariant_color)
+        #if defined(dFlatShaded)
+            vec3 normal = -faceNormal;
+        #else
+            vec3 normal = -normalize(vNormal);
+            if (uDoubleSided) normal *= float(frontFacing) * 2.0 - 1.0;
+        #endif
+        #include apply_light_color
+
+        #include apply_interior_color
+        #include apply_marker_color
+        #include apply_fog
+        #include wboit_write
+        #include dpoit_write
+    #endif
+}
 `;

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

@@ -6,53 +6,53 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mesh_vert = void 0;
-exports.mesh_vert = `
-precision highp float;
-precision highp int;
-precision highp sampler2D;
-
-#include common
-#include read_from_texture
-#include common_vert_params
-#include color_vert_params
-#include common_clip
-#include texture3d_from_2d_linear
-
-#ifdef dGeometryType_textureMesh
-    uniform vec2 uGeoTexDim;
-    uniform sampler2D tPosition;
-    uniform sampler2D tGroup;
-    uniform sampler2D tNormal;
-#else
-    attribute vec3 aPosition;
-    attribute float aGroup;
-    attribute vec3 aNormal;
-#endif
-attribute mat4 aTransform;
-attribute float aInstance;
-
-varying vec3 vNormal;
-
-void main(){
-    #include assign_group
-    #include assign_marker_varying
-    #include assign_clipping_varying
-    #include assign_position
-    #include assign_color_varying
-    #include clip_instance
-
-    #ifdef dGeometryType_textureMesh
-        vec3 normal = readFromTexture(tNormal, VertexID, uGeoTexDim).xyz;
-    #else
-        vec3 normal = aNormal;
-    #endif
-    mat3 normalMatrix = transpose3(inverse3(mat3(modelView)));
-    vec3 transformedNormal = normalize(normalMatrix * normalize(normal));
-    #if defined(dFlipSided)
-        if (!uDoubleSided) { // TODO checking uDoubleSided should not be required, ASR
-            transformedNormal = -transformedNormal;
-        }
-    #endif
-    vNormal = transformedNormal;
-}
+exports.mesh_vert = `
+precision highp float;
+precision highp int;
+precision highp sampler2D;
+
+#include common
+#include read_from_texture
+#include common_vert_params
+#include color_vert_params
+#include common_clip
+#include texture3d_from_2d_linear
+
+#ifdef dGeometryType_textureMesh
+    uniform vec2 uGeoTexDim;
+    uniform sampler2D tPosition;
+    uniform sampler2D tGroup;
+    uniform sampler2D tNormal;
+#else
+    attribute vec3 aPosition;
+    attribute float aGroup;
+    attribute vec3 aNormal;
+#endif
+attribute mat4 aTransform;
+attribute float aInstance;
+
+varying vec3 vNormal;
+
+void main(){
+    #include assign_group
+    #include assign_marker_varying
+    #include assign_clipping_varying
+    #include assign_position
+    #include assign_color_varying
+    #include clip_instance
+
+    #ifdef dGeometryType_textureMesh
+        vec3 normal = readFromTexture(tNormal, VertexID, uGeoTexDim).xyz;
+    #else
+        vec3 normal = aNormal;
+    #endif
+    mat3 normalMatrix = transpose3(inverse3(mat3(modelView)));
+    vec3 transformedNormal = normalize(normalMatrix * normalize(normal));
+    #if defined(dFlipSided)
+        if (!uDoubleSided) { // TODO checking uDoubleSided should not be required, ASR
+            transformedNormal = -transformedNormal;
+        }
+    #endif
+    vNormal = transformedNormal;
+}
 `;

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

@@ -7,99 +7,99 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.outlines_frag = void 0;
-exports.outlines_frag = `
-precision highp float;
-precision highp int;
-precision highp sampler2D;
-
-uniform sampler2D tDepthOpaque;
-uniform sampler2D tDepthTransparent;
-uniform vec2 uTexSize;
-
-uniform float uNear;
-uniform float uFar;
-uniform mat4 uInvProjection;
-
-uniform float uOutlineThreshold;
-
-#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 getPixelSize(const in vec2 coords, const in float depth) {
-    vec3 viewPos0 = screenSpaceToViewSpace(vec3(coords, depth), uInvProjection);
-    vec3 viewPos1 = screenSpaceToViewSpace(vec3(coords + vec2(1.0, 0.0) / uTexSize, depth), uInvProjection);
-    return distance(viewPos0, viewPos1);
-}
-
-void main(void) {
-    float backgroundViewZ = 2.0 * uFar;
-
-    vec2 coords = gl_FragCoord.xy / uTexSize;
-    vec2 invTexSize = 1.0 / uTexSize;
-
-    float selfDepthOpaque = getDepthOpaque(coords);
-    float selfViewZOpaque = isBackground(selfDepthOpaque) ? backgroundViewZ : getViewZ(selfDepthOpaque);
-    float pixelSizeOpaque = getPixelSize(coords, selfDepthOpaque) * uOutlineThreshold;
-
-    float selfDepthTransparent = getDepthTransparent(coords);
-    float selfViewZTransparent = isBackground(selfDepthTransparent) ? backgroundViewZ : getViewZ(selfDepthTransparent);
-    float pixelSizeTransparent = getPixelSize(coords, selfDepthTransparent) * uOutlineThreshold;
-
-    float outline = 1.0;
-    float bestDepth = 1.0;
-    float transparentFlag = 0.0;
-
-    for (int y = -1; y <= 1; y++) {
-        for (int x = -1; x <= 1; x++) {
-            vec2 sampleCoords = coords + vec2(float(x), float(y)) * invTexSize;
-
-            float sampleDepthOpaque = getDepthOpaque(sampleCoords);
-            float sampleDepthTransparent = getDepthTransparent(sampleCoords);
-
-            float sampleViewZOpaque = isBackground(sampleDepthOpaque) ? backgroundViewZ : getViewZ(sampleDepthOpaque);
-            if (abs(selfViewZOpaque - sampleViewZOpaque) > pixelSizeOpaque && selfDepthOpaque > sampleDepthOpaque && sampleDepthOpaque <= bestDepth) {
-                outline = 0.0;
-                bestDepth = sampleDepthOpaque;
-            }
-
-            if (sampleDepthTransparent < sampleDepthOpaque) {
-                float sampleViewZTransparent = isBackground(sampleDepthTransparent) ? backgroundViewZ : getViewZ(sampleDepthTransparent);
-                if (abs(selfViewZTransparent - sampleViewZTransparent) > pixelSizeTransparent && selfDepthTransparent > sampleDepthTransparent && sampleDepthTransparent <= bestDepth) {
-                    outline = 0.0;
-                    bestDepth = sampleDepthTransparent;
-                    transparentFlag = 1.0;
-                }
-            }
-        }
-    }
-
-    gl_FragColor = vec4(outline, packUnitIntervalToRG(bestDepth), transparentFlag);
-}
+exports.outlines_frag = `
+precision highp float;
+precision highp int;
+precision highp sampler2D;
+
+uniform sampler2D tDepthOpaque;
+uniform sampler2D tDepthTransparent;
+uniform vec2 uTexSize;
+
+uniform float uNear;
+uniform float uFar;
+uniform mat4 uInvProjection;
+
+uniform float uOutlineThreshold;
+
+#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 getPixelSize(const in vec2 coords, const in float depth) {
+    vec3 viewPos0 = screenSpaceToViewSpace(vec3(coords, depth), uInvProjection);
+    vec3 viewPos1 = screenSpaceToViewSpace(vec3(coords + vec2(1.0, 0.0) / uTexSize, depth), uInvProjection);
+    return distance(viewPos0, viewPos1);
+}
+
+void main(void) {
+    float backgroundViewZ = 2.0 * uFar;
+
+    vec2 coords = gl_FragCoord.xy / uTexSize;
+    vec2 invTexSize = 1.0 / uTexSize;
+
+    float selfDepthOpaque = getDepthOpaque(coords);
+    float selfViewZOpaque = isBackground(selfDepthOpaque) ? backgroundViewZ : getViewZ(selfDepthOpaque);
+    float pixelSizeOpaque = getPixelSize(coords, selfDepthOpaque) * uOutlineThreshold;
+
+    float selfDepthTransparent = getDepthTransparent(coords);
+    float selfViewZTransparent = isBackground(selfDepthTransparent) ? backgroundViewZ : getViewZ(selfDepthTransparent);
+    float pixelSizeTransparent = getPixelSize(coords, selfDepthTransparent) * uOutlineThreshold;
+
+    float outline = 1.0;
+    float bestDepth = 1.0;
+    float transparentFlag = 0.0;
+
+    for (int y = -1; y <= 1; y++) {
+        for (int x = -1; x <= 1; x++) {
+            vec2 sampleCoords = coords + vec2(float(x), float(y)) * invTexSize;
+
+            float sampleDepthOpaque = getDepthOpaque(sampleCoords);
+            float sampleDepthTransparent = getDepthTransparent(sampleCoords);
+
+            float sampleViewZOpaque = isBackground(sampleDepthOpaque) ? backgroundViewZ : getViewZ(sampleDepthOpaque);
+            if (abs(selfViewZOpaque - sampleViewZOpaque) > pixelSizeOpaque && selfDepthOpaque > sampleDepthOpaque && sampleDepthOpaque <= bestDepth) {
+                outline = 0.0;
+                bestDepth = sampleDepthOpaque;
+            }
+
+            if (sampleDepthTransparent < sampleDepthOpaque) {
+                float sampleViewZTransparent = isBackground(sampleDepthTransparent) ? backgroundViewZ : getViewZ(sampleDepthTransparent);
+                if (abs(selfViewZTransparent - sampleViewZTransparent) > pixelSizeTransparent && selfDepthTransparent > sampleDepthTransparent && sampleDepthTransparent <= bestDepth) {
+                    outline = 0.0;
+                    bestDepth = sampleDepthTransparent;
+                    transparentFlag = 1.0;
+                }
+            }
+        }
+    }
+
+    gl_FragColor = vec4(outline, packUnitIntervalToRG(bestDepth), transparentFlag);
+}
 `;

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

@@ -6,63 +6,63 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.points_frag = void 0;
-exports.points_frag = `
-precision highp float;
-precision highp int;
-
-#include common
-#include common_frag_params
-#include color_frag_params
-#include common_clip
-
-const vec2 center = vec2(0.5);
-const float radius = 0.5;
-
-void main(){
-    #include fade_lod
-    #include clip_pixel
-
-    float fragmentDepth = gl_FragCoord.z;
-    #include assign_material_color
-
-    #if defined(dPointStyle_circle)
-        float dist = distance(gl_PointCoord, center);
-        if (dist > radius) discard;
-    #elif defined(dPointStyle_fuzzy)
-        float dist = distance(gl_PointCoord, center);
-        float fuzzyAlpha = 1.0 - smoothstep(0.0, radius, dist);
-        if (fuzzyAlpha < 0.0001) discard;
-    #endif
-
-    #if defined(dPointStyle_fuzzy) && defined(dRenderVariant_color)
-        material.a *= fuzzyAlpha;
-    #endif
-
-    #include check_transparency
-
-    #if defined(dRenderVariant_pick)
-        #include check_picking_alpha
-        #ifdef requiredDrawBuffers
-            gl_FragColor = vObject;
-            gl_FragData[1] = vInstance;
-            gl_FragData[2] = vGroup;
-            gl_FragData[3] = packDepthToRGBA(fragmentDepth);
-        #else
-            gl_FragColor = vColor;
-        #endif
-    #elif defined(dRenderVariant_depth)
-        gl_FragColor = material;
-    #elif defined(dRenderVariant_marking)
-        gl_FragColor = material;
-    #elif defined(dRenderVariant_emissive)
-        gl_FragColor = material;
-    #elif defined(dRenderVariant_color)
-        gl_FragColor = material;
-
-        #include apply_marker_color
-        #include apply_fog
-        #include wboit_write
-        #include dpoit_write
-    #endif
-}
+exports.points_frag = `
+precision highp float;
+precision highp int;
+
+#include common
+#include common_frag_params
+#include color_frag_params
+#include common_clip
+
+const vec2 center = vec2(0.5);
+const float radius = 0.5;
+
+void main(){
+    #include fade_lod
+    #include clip_pixel
+
+    float fragmentDepth = gl_FragCoord.z;
+    #include assign_material_color
+
+    #if defined(dPointStyle_circle)
+        float dist = distance(gl_PointCoord, center);
+        if (dist > radius) discard;
+    #elif defined(dPointStyle_fuzzy)
+        float dist = distance(gl_PointCoord, center);
+        float fuzzyAlpha = 1.0 - smoothstep(0.0, radius, dist);
+        if (fuzzyAlpha < 0.0001) discard;
+    #endif
+
+    #if defined(dPointStyle_fuzzy) && defined(dRenderVariant_color)
+        material.a *= fuzzyAlpha;
+    #endif
+
+    #include check_transparency
+
+    #if defined(dRenderVariant_pick)
+        #include check_picking_alpha
+        #ifdef requiredDrawBuffers
+            gl_FragColor = vObject;
+            gl_FragData[1] = vInstance;
+            gl_FragData[2] = vGroup;
+            gl_FragData[3] = packDepthToRGBA(fragmentDepth);
+        #else
+            gl_FragColor = vColor;
+        #endif
+    #elif defined(dRenderVariant_depth)
+        gl_FragColor = material;
+    #elif defined(dRenderVariant_marking)
+        gl_FragColor = material;
+    #elif defined(dRenderVariant_emissive)
+        gl_FragColor = material;
+    #elif defined(dRenderVariant_color)
+        gl_FragColor = material;
+
+        #include apply_marker_color
+        #include apply_fog
+        #include wboit_write
+        #include dpoit_write
+    #endif
+}
 `;