molstar 4.2.0 → 4.3.0

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

@@ -6,152 +6,152 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.spheres_frag = void 0;
-exports.spheres_frag = `
-precision highp float;
-precision highp int;
-
-#define bumpEnabled
-
-#include common
-#include common_frag_params
-#include color_frag_params
-#include light_frag_params
-#include common_clip
-
-uniform mat4 uInvView;
-uniform float uAlphaThickness;
-
-varying float vRadius;
-varying vec3 vPoint;
-varying vec3 vPointViewPosition;
-
-#ifdef dSolidInterior
-    const bool solidInterior = true;
-#else
-    const bool solidInterior = false;
-#endif
-
-bool SphereImpostor(out vec3 modelPos, out vec3 cameraPos, out vec3 cameraNormal, out bool interior, out float fragmentDepth){
-    vec3 cameraSpherePos = -vPointViewPosition;
-
-    vec3 rayOrigin = mix(vec3(0.0, 0.0, 0.0), vPoint, uIsOrtho);
-    vec3 rayDirection = mix(normalize(vPoint), vec3(0.0, 0.0, 1.0), uIsOrtho);
-    vec3 cameraSphereDir = mix(cameraSpherePos, rayOrigin - cameraSpherePos, uIsOrtho);
-
-    float B = dot(rayDirection, cameraSphereDir);
-    float det = B * B + vRadius * vRadius - dot(cameraSphereDir, cameraSphereDir);
-
-    if (det < 0.0) return false;
-
-    float sqrtDet = sqrt(det);
-    float posT = mix(B + sqrtDet, B - sqrtDet, uIsOrtho);
-    float negT = mix(B - sqrtDet, B + sqrtDet, uIsOrtho);
-
-    cameraPos = rayDirection * negT + rayOrigin;
-    modelPos = (uInvView * vec4(cameraPos, 1.0)).xyz;
-    fragmentDepth = calcDepth(cameraPos);
-
-    bool objectClipped = false;
-
-    #if !defined(dClipPrimitive) && defined(dClipVariant_pixel) && dClipObjectCount != 0
-        if (clipTest(vec4(modelPos, 0.0))) {
-            objectClipped = true;
-            fragmentDepth = -1.0;
-        }
-    #endif
-
-    if (fragmentDepth > 0.0) {
-        cameraNormal = normalize(cameraPos - cameraSpherePos);
-        interior = false;
-        return true;
-    } else if (uDoubleSided || solidInterior) {
-        cameraPos = rayDirection * posT + rayOrigin;
-        modelPos = (uInvView * vec4(cameraPos, 1.0)).xyz;
-        fragmentDepth = calcDepth(cameraPos);
-        cameraNormal = -normalize(cameraPos - cameraSpherePos);
-        interior = true;
-        if (fragmentDepth > 0.0) {
-            #ifdef dSolidInterior
-                if (!objectClipped) {
-                    fragmentDepth = 0.0 + (0.0000001 / vRadius);
-                    cameraNormal = -mix(normalize(vPoint), vec3(0.0, 0.0, 1.0), uIsOrtho);
-                }
-            #endif
-            return true;
-        }
-    }
-
-    return false;
-}
-
-void main(void){
-    vec3 cameraNormal;
-    float fragmentDepth;
-
-    #ifdef dApproximate
-        vec3 pointDir = -vPointViewPosition - vPoint;
-        if (dot(pointDir, pointDir) > vRadius * vRadius) discard;
-        vec3 vViewPosition = -vPointViewPosition;
-        fragmentDepth = gl_FragCoord.z;
-        #if !defined(dIgnoreLight) || defined(dXrayShaded)
-            pointDir.z -= cos(length(pointDir) / vRadius);
-            cameraNormal = -normalize(pointDir / vRadius);
-        #endif
-        interior = false;
-    #else
-        vec3 modelPos;
-        vec3 cameraPos;
-        bool hit = SphereImpostor(modelPos, cameraPos, cameraNormal, interior, fragmentDepth);
-        if (!hit) discard;
-
-        if (fragmentDepth < 0.0) discard;
-        if (fragmentDepth > 1.0) discard;
-
-        gl_FragDepthEXT = fragmentDepth;
-
-        vec3 vModelPosition = modelPos;
-        vec3 vViewPosition = cameraPos;
-    #endif
-
-    #include fade_lod
-    #if !defined(dClipPrimitive) && defined(dClipVariant_pixel) && dClipObjectCount != 0
-        #include clip_pixel
-    #endif
-    #include assign_material_color
-
-    #if defined(dRenderVariant_color)
-        if (uRenderMask == MaskTransparent && uAlphaThickness > 0.0) {
-            material.a *= min(1.0, vRadius / uAlphaThickness);
-        }
-    #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)
-        vec3 normal = -cameraNormal;
-        #include apply_light_color
-
-        #include apply_interior_color
-        #include apply_marker_color
-        #include apply_fog
-        #include wboit_write
-        #include dpoit_write
-    #endif
-}
+exports.spheres_frag = `
+precision highp float;
+precision highp int;
+
+#define bumpEnabled
+
+#include common
+#include common_frag_params
+#include color_frag_params
+#include light_frag_params
+#include common_clip
+
+uniform mat4 uInvView;
+uniform float uAlphaThickness;
+
+varying float vRadius;
+varying vec3 vPoint;
+varying vec3 vPointViewPosition;
+
+#ifdef dSolidInterior
+    const bool solidInterior = true;
+#else
+    const bool solidInterior = false;
+#endif
+
+bool SphereImpostor(out vec3 modelPos, out vec3 cameraPos, out vec3 cameraNormal, out bool interior, out float fragmentDepth){
+    vec3 cameraSpherePos = -vPointViewPosition;
+
+    vec3 rayOrigin = mix(vec3(0.0, 0.0, 0.0), vPoint, uIsOrtho);
+    vec3 rayDirection = mix(normalize(vPoint), vec3(0.0, 0.0, 1.0), uIsOrtho);
+    vec3 cameraSphereDir = mix(cameraSpherePos, rayOrigin - cameraSpherePos, uIsOrtho);
+
+    float B = dot(rayDirection, cameraSphereDir);
+    float det = B * B + vRadius * vRadius - dot(cameraSphereDir, cameraSphereDir);
+
+    if (det < 0.0) return false;
+
+    float sqrtDet = sqrt(det);
+    float posT = mix(B + sqrtDet, B - sqrtDet, uIsOrtho);
+    float negT = mix(B - sqrtDet, B + sqrtDet, uIsOrtho);
+
+    cameraPos = rayDirection * negT + rayOrigin;
+    modelPos = (uInvView * vec4(cameraPos, 1.0)).xyz;
+    fragmentDepth = calcDepth(cameraPos);
+
+    bool objectClipped = false;
+
+    #if !defined(dClipPrimitive) && defined(dClipVariant_pixel) && dClipObjectCount != 0
+        if (clipTest(vec4(modelPos, 0.0))) {
+            objectClipped = true;
+            fragmentDepth = -1.0;
+        }
+    #endif
+
+    if (fragmentDepth > 0.0) {
+        cameraNormal = normalize(cameraPos - cameraSpherePos);
+        interior = false;
+        return true;
+    } else if (uDoubleSided || solidInterior) {
+        cameraPos = rayDirection * posT + rayOrigin;
+        modelPos = (uInvView * vec4(cameraPos, 1.0)).xyz;
+        fragmentDepth = calcDepth(cameraPos);
+        cameraNormal = -normalize(cameraPos - cameraSpherePos);
+        interior = true;
+        if (fragmentDepth > 0.0) {
+            #ifdef dSolidInterior
+                if (!objectClipped) {
+                    fragmentDepth = 0.0 + (0.0000001 / vRadius);
+                    cameraNormal = -mix(normalize(vPoint), vec3(0.0, 0.0, 1.0), uIsOrtho);
+                }
+            #endif
+            return true;
+        }
+    }
+
+    return false;
+}
+
+void main(void){
+    vec3 cameraNormal;
+    float fragmentDepth;
+
+    #ifdef dApproximate
+        vec3 pointDir = -vPointViewPosition - vPoint;
+        if (dot(pointDir, pointDir) > vRadius * vRadius) discard;
+        vec3 vViewPosition = -vPointViewPosition;
+        fragmentDepth = gl_FragCoord.z;
+        #if !defined(dIgnoreLight) || defined(dXrayShaded)
+            pointDir.z -= cos(length(pointDir) / vRadius);
+            cameraNormal = -normalize(pointDir / vRadius);
+        #endif
+        interior = false;
+    #else
+        vec3 modelPos;
+        vec3 cameraPos;
+        bool hit = SphereImpostor(modelPos, cameraPos, cameraNormal, interior, fragmentDepth);
+        if (!hit) discard;
+
+        if (fragmentDepth < 0.0) discard;
+        if (fragmentDepth > 1.0) discard;
+
+        gl_FragDepthEXT = fragmentDepth;
+
+        vec3 vModelPosition = modelPos;
+        vec3 vViewPosition = cameraPos;
+    #endif
+
+    #include fade_lod
+    #if !defined(dClipPrimitive) && defined(dClipVariant_pixel) && dClipObjectCount != 0
+        #include clip_pixel
+    #endif
+    #include assign_material_color
+
+    #if defined(dRenderVariant_color)
+        if (uRenderMask == MaskTransparent && uAlphaThickness > 0.0) {
+            material.a *= min(1.0, vRadius / uAlphaThickness);
+        }
+    #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)
+        vec3 normal = -cameraNormal;
+        #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/spheres.vert.js

@@ -6,136 +6,136 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.spheres_vert = void 0;
-exports.spheres_vert = `
-precision highp float;
-precision highp int;
-
-#include common
-#include read_from_texture
-#include common_vert_params
-#include color_vert_params
-#include size_vert_params
-#include common_clip
-
-uniform mat4 uModelView;
-uniform mat4 uInvProjection;
-uniform float uIsOrtho;
-
-uniform vec2 uTexDim;
-uniform sampler2D tPositionGroup;
-
-attribute mat4 aTransform;
-attribute float aInstance;
-
-varying float vRadius;
-varying vec3 vPoint;
-varying vec3 vPointViewPosition;
-
-#include matrix_scale
-
-/**
- * Bounding rectangle of a clipped, perspective-projected 3D Sphere.
- * Michael Mara, Morgan McGuire. 2013
- *
- * Specialization by Arseny Kapoulkine, MIT License Copyright (c) 2018
- * https://github.com/zeux/niagara
- */
-void sphereProjection(const in vec3 p, const in float r, const in vec2 mapping) {
-    vec3 pr = p * r;
-    float pzr2 = p.z * p.z - r * r;
-
-    float vx = sqrt(p.x * p.x + pzr2);
-    float minx = ((vx * p.x - pr.z) / (vx * p.z + pr.x)) * uProjection[0][0];
-    float maxx = ((vx * p.x + pr.z) / (vx * p.z - pr.x)) * uProjection[0][0];
-
-    float vy = sqrt(p.y * p.y + pzr2);
-    float miny = ((vy * p.y - pr.z) / (vy * p.z + pr.y)) * uProjection[1][1];
-    float maxy = ((vy * p.y + pr.z) / (vy * p.z - pr.y)) * uProjection[1][1];
-
-    gl_Position.xy = vec2(maxx + minx, maxy + miny) * -0.5;
-    gl_Position.xy -= mapping * vec2(maxx - minx, maxy - miny) * 0.5;
-    gl_Position.xy *= gl_Position.w;
-}
-
-void main(void){
-    vec2 mapping = vec2(1.0, 1.0); // vertices 2 and 5
-    #if __VERSION__ == 100
-        int m = imod(VertexID, 6);
-    #else
-        int m = VertexID % 6;
-    #endif
-    if (m == 0) {
-        mapping = vec2(-1.0, 1.0);
-    } else if (m == 1 || m == 3) {
-        mapping = vec2(-1.0, -1.0);
-    } else if (m == 4) {
-        mapping = vec2(1.0, -1.0);
-    }
-
-    vec4 positionGroup = readFromTexture(tPositionGroup, VertexID / 6, uTexDim);
-    vec3 position = positionGroup.rgb;
-    float group = positionGroup.a;
-
-    #include assign_color_varying
-    #include assign_marker_varying
-    #include assign_clipping_varying
-    #include assign_size
-
-    vRadius = size * matrixScale(uModelView);
-
-    vec4 position4 = vec4(position, 1.0);
-    vModelPosition = (uModel * aTransform * position4).xyz; // for clipping in frag shader
-
-    float d;
-    if (uLod.w != 0.0 && (uLod.x != 0.0 || uLod.y != 0.0)) {
-        d = dot(uCameraPlane.xyz, vModelPosition) + uCameraPlane.w;
-        float f = min(
-            smoothstep(uLod.x, uLod.x + uLod.z, d),
-            1.0 - smoothstep(uLod.y - uLod.z, uLod.y, d)
-        ) * uLod.w;
-        vRadius *= f;
-    }
-
-    vec4 mvPosition = uModelView * aTransform * position4;
-
-    #ifdef dApproximate
-        vec4 mvCorner = vec4(mvPosition.xyz, 1.0);
-        mvCorner.xy += mapping * vRadius;
-        gl_Position = uProjection * mvCorner;
-    #else
-        if (uIsOrtho == 1.0) {
-            vec4 mvCorner = vec4(mvPosition.xyz, 1.0);
-            mvCorner.xy += mapping * vRadius;
-            gl_Position = uProjection * mvCorner;
-        } else {
-            gl_Position = uProjection * vec4(mvPosition.xyz, 1.0);
-            sphereProjection(mvPosition.xyz, vRadius, mapping);
-        }
-    #endif
-
-    vec4 vPoint4 = uInvProjection * gl_Position;
-    vPoint = vPoint4.xyz / vPoint4.w;
-    vPointViewPosition = -mvPosition.xyz / mvPosition.w;
-
-    if (gl_Position.z < -gl_Position.w) {
-        mvPosition.z -= 2.0 * vRadius; // avoid clipping
-        gl_Position.z = (uProjection * vec4(mvPosition.xyz, 1.0)).z;
-    }
-
-    if (uLod.w != 0.0 && (uLod.x != 0.0 || uLod.y != 0.0)) {
-        if (d < uLod.x || d > uLod.y) {
-            // move out of [ -w, +w ] to 'discard' in vert shader
-            gl_Position.z = 2.0 * gl_Position.w;
-        }
-    }
-
-    #if defined(dClipPrimitive) && !defined(dClipVariant_instance) && dClipObjectCount != 0
-        if (clipTest(vec4(vModelPosition.xyz, 0.0))) {
-            // move out of [ -w, +w ] to 'discard' in vert shader
-            gl_Position.z = 2.0 * gl_Position.w;
-        }
-    #else
-        #include clip_instance
-    #endif
-}
+exports.spheres_vert = `
+precision highp float;
+precision highp int;
+
+#include common
+#include read_from_texture
+#include common_vert_params
+#include color_vert_params
+#include size_vert_params
+#include common_clip
+
+uniform mat4 uModelView;
+uniform mat4 uInvProjection;
+uniform float uIsOrtho;
+
+uniform vec2 uTexDim;
+uniform sampler2D tPositionGroup;
+
+attribute mat4 aTransform;
+attribute float aInstance;
+
+varying float vRadius;
+varying vec3 vPoint;
+varying vec3 vPointViewPosition;
+
+#include matrix_scale
+
+/**
+ * Bounding rectangle of a clipped, perspective-projected 3D Sphere.
+ * Michael Mara, Morgan McGuire. 2013
+ *
+ * Specialization by Arseny Kapoulkine, MIT License Copyright (c) 2018
+ * https://github.com/zeux/niagara
+ */
+void sphereProjection(const in vec3 p, const in float r, const in vec2 mapping) {
+    vec3 pr = p * r;
+    float pzr2 = p.z * p.z - r * r;
+
+    float vx = sqrt(p.x * p.x + pzr2);
+    float minx = ((vx * p.x - pr.z) / (vx * p.z + pr.x)) * uProjection[0][0];
+    float maxx = ((vx * p.x + pr.z) / (vx * p.z - pr.x)) * uProjection[0][0];
+
+    float vy = sqrt(p.y * p.y + pzr2);
+    float miny = ((vy * p.y - pr.z) / (vy * p.z + pr.y)) * uProjection[1][1];
+    float maxy = ((vy * p.y + pr.z) / (vy * p.z - pr.y)) * uProjection[1][1];
+
+    gl_Position.xy = vec2(maxx + minx, maxy + miny) * -0.5;
+    gl_Position.xy -= mapping * vec2(maxx - minx, maxy - miny) * 0.5;
+    gl_Position.xy *= gl_Position.w;
+}
+
+void main(void){
+    vec2 mapping = vec2(1.0, 1.0); // vertices 2 and 5
+    #if __VERSION__ == 100
+        int m = imod(VertexID, 6);
+    #else
+        int m = VertexID % 6;
+    #endif
+    if (m == 0) {
+        mapping = vec2(-1.0, 1.0);
+    } else if (m == 1 || m == 3) {
+        mapping = vec2(-1.0, -1.0);
+    } else if (m == 4) {
+        mapping = vec2(1.0, -1.0);
+    }
+
+    vec4 positionGroup = readFromTexture(tPositionGroup, VertexID / 6, uTexDim);
+    vec3 position = positionGroup.rgb;
+    float group = positionGroup.a;
+
+    #include assign_color_varying
+    #include assign_marker_varying
+    #include assign_clipping_varying
+    #include assign_size
+
+    vRadius = size * matrixScale(uModelView);
+
+    vec4 position4 = vec4(position, 1.0);
+    vModelPosition = (uModel * aTransform * position4).xyz; // for clipping in frag shader
+
+    float d;
+    if (uLod.w != 0.0 && (uLod.x != 0.0 || uLod.y != 0.0)) {
+        d = dot(uCameraPlane.xyz, vModelPosition) + uCameraPlane.w;
+        float f = min(
+            smoothstep(uLod.x, uLod.x + uLod.z, d),
+            1.0 - smoothstep(uLod.y - uLod.z, uLod.y, d)
+        ) * uLod.w;
+        vRadius *= f;
+    }
+
+    vec4 mvPosition = uModelView * aTransform * position4;
+
+    #ifdef dApproximate
+        vec4 mvCorner = vec4(mvPosition.xyz, 1.0);
+        mvCorner.xy += mapping * vRadius;
+        gl_Position = uProjection * mvCorner;
+    #else
+        if (uIsOrtho == 1.0) {
+            vec4 mvCorner = vec4(mvPosition.xyz, 1.0);
+            mvCorner.xy += mapping * vRadius;
+            gl_Position = uProjection * mvCorner;
+        } else {
+            gl_Position = uProjection * vec4(mvPosition.xyz, 1.0);
+            sphereProjection(mvPosition.xyz, vRadius, mapping);
+        }
+    #endif
+
+    vec4 vPoint4 = uInvProjection * gl_Position;
+    vPoint = vPoint4.xyz / vPoint4.w;
+    vPointViewPosition = -mvPosition.xyz / mvPosition.w;
+
+    if (gl_Position.z < -gl_Position.w) {
+        mvPosition.z -= 2.0 * vRadius; // avoid clipping
+        gl_Position.z = (uProjection * vec4(mvPosition.xyz, 1.0)).z;
+    }
+
+    if (uLod.w != 0.0 && (uLod.x != 0.0 || uLod.y != 0.0)) {
+        if (d < uLod.x || d > uLod.y) {
+            // move out of [ -w, +w ] to 'discard' in vert shader
+            gl_Position.z = 2.0 * gl_Position.w;
+        }
+    }
+
+    #if defined(dClipPrimitive) && !defined(dClipVariant_instance) && dClipObjectCount != 0
+        if (clipTest(vec4(vModelPosition.xyz, 0.0))) {
+            // move out of [ -w, +w ] to 'discard' in vert shader
+            gl_Position.z = 2.0 * gl_Position.w;
+        }
+    #else
+        #include clip_instance
+    #endif
+}
 `;