molstar 4.2.0 → 4.3.0

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

@@ -6,89 +6,89 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.text_frag = void 0;
-exports.text_frag = `
-precision highp float;
-precision highp int;
-
-#include common
-#include common_frag_params
-#include color_frag_params
-#include common_clip
-
-uniform sampler2D tFont;
-
-uniform vec3 uBorderColor;
-uniform float uBorderWidth;
-uniform vec3 uBackgroundColor;
-uniform float uBackgroundOpacity;
-
-varying vec2 vTexCoord;
-
-const float smoothness = 32.0;
-const float gamma = 2.2;
-
-void main2(){
-    gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-void main(){
-    #include fade_lod
-    #include clip_pixel
-
-    float fragmentDepth = gl_FragCoord.z;
-    #include assign_material_color
-
-    if (vTexCoord.x > 1.0) {
-        #if defined(dRenderVariant_color)
-            material = vec4(uBackgroundColor, uBackgroundOpacity * material.a);
-        #endif
-    } else {
-        // retrieve signed distance
-        float sdf = texture2D(tFont, vTexCoord).a + uBorderWidth;
-
-        // perform adaptive anti-aliasing of the edges
-        float w = clamp(smoothness * (abs(dFdx(vTexCoord.x)) + abs(dFdy(vTexCoord.y))), 0.0, 0.5);
-        float a = clamp(0.0, 1.0, smoothstep(0.5 - w, 0.5 + w, sdf));
-
-        // gamma correction for linear attenuation
-        a = pow(a, 1.0 / gamma);
-
-        if (a < 0.5) discard;
-
-        #if defined(dRenderVariant_color)
-            // add border
-            float t = 0.5 + uBorderWidth;
-            if (uBorderWidth > 0.0 && sdf < t) {
-                material.xyz = mix(uBorderColor, material.xyz, smoothstep(t - w, t, sdf));
-            }
-        #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.text_frag = `
+precision highp float;
+precision highp int;
+
+#include common
+#include common_frag_params
+#include color_frag_params
+#include common_clip
+
+uniform sampler2D tFont;
+
+uniform vec3 uBorderColor;
+uniform float uBorderWidth;
+uniform vec3 uBackgroundColor;
+uniform float uBackgroundOpacity;
+
+varying vec2 vTexCoord;
+
+const float smoothness = 32.0;
+const float gamma = 2.2;
+
+void main2(){
+    gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+void main(){
+    #include fade_lod
+    #include clip_pixel
+
+    float fragmentDepth = gl_FragCoord.z;
+    #include assign_material_color
+
+    if (vTexCoord.x > 1.0) {
+        #if defined(dRenderVariant_color)
+            material = vec4(uBackgroundColor, uBackgroundOpacity * material.a);
+        #endif
+    } else {
+        // retrieve signed distance
+        float sdf = texture2D(tFont, vTexCoord).a + uBorderWidth;
+
+        // perform adaptive anti-aliasing of the edges
+        float w = clamp(smoothness * (abs(dFdx(vTexCoord.x)) + abs(dFdy(vTexCoord.y))), 0.0, 0.5);
+        float a = clamp(0.0, 1.0, smoothstep(0.5 - w, 0.5 + w, sdf));
+
+        // gamma correction for linear attenuation
+        a = pow(a, 1.0 / gamma);
+
+        if (a < 0.5) discard;
+
+        #if defined(dRenderVariant_color)
+            // add border
+            float t = 0.5 + uBorderWidth;
+            if (uBorderWidth > 0.0 && sdf < t) {
+                material.xyz = mix(uBorderColor, material.xyz, smoothstep(t - w, t, sdf));
+            }
+        #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
+}
 `;

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

@@ -6,89 +6,89 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.text_vert = void 0;
-exports.text_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;
-
-attribute vec3 aPosition;
-attribute vec2 aMapping;
-attribute float aDepth;
-attribute vec2 aTexCoord;
-attribute mat4 aTransform;
-attribute float aInstance;
-attribute float aGroup;
-
-uniform float uOffsetX;
-uniform float uOffsetY;
-uniform float uOffsetZ;
-
-uniform float uIsOrtho;
-uniform float uPixelRatio;
-uniform vec4 uViewport;
-
-varying vec2 vTexCoord;
-
-#include matrix_scale
-
-void main(void){
-    #include assign_group
-    #include assign_color_varying
-    #include assign_marker_varying
-    #include assign_clipping_varying
-    #include assign_size
-
-    vTexCoord = aTexCoord;
-
-    float scale = matrixScale(uModelView);
-
-    float offsetX = uOffsetX * scale;
-    float offsetY = uOffsetY * scale;
-    float offsetZ = (uOffsetZ + aDepth * 0.95) * scale;
-
-    vec4 position4 = vec4(aPosition, 1.0);
-    vec4 mvPosition = uModelView * aTransform * position4;
-
-    vModelPosition = (uModel * aTransform * position4).xyz; // for clipping in frag shader
-
-    // TODO
-    // #ifdef FIXED_SIZE
-    //     if (ortho) {
-    //         scale /= pixelRatio * ((uViewport.w / 2.0) / -uCameraPosition.z) * 0.1;
-    //     } else {
-    //         scale /= pixelRatio * ((uViewport.w / 2.0) / -mvPosition.z) * 0.1;
-    //     }
-    // #endif
-
-    vec4 mvCorner = vec4(mvPosition.xyz, 1.0);
-
-    if (vTexCoord.x == 10.0) { // indicates background plane
-        // move a bit to the back, taking distance to camera into account to avoid z-fighting
-        offsetZ -= 0.001 * distance(uCameraPosition, (uProjection * mvCorner).xyz);
-    }
-
-    mvCorner.xy += aMapping * size * scale;
-    mvCorner.x += offsetX;
-    mvCorner.y += offsetY;
-
-    if (uIsOrtho == 1.0) {
-        mvCorner.z += offsetZ;
-    } else {
-        mvCorner.xyz += normalize(-mvCorner.xyz) * offsetZ;
-    }
-
-    gl_Position = uProjection * mvCorner;
-
-    vViewPosition = -mvCorner.xyz;
-
-    #include clip_instance
-}
+exports.text_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;
+
+attribute vec3 aPosition;
+attribute vec2 aMapping;
+attribute float aDepth;
+attribute vec2 aTexCoord;
+attribute mat4 aTransform;
+attribute float aInstance;
+attribute float aGroup;
+
+uniform float uOffsetX;
+uniform float uOffsetY;
+uniform float uOffsetZ;
+
+uniform float uIsOrtho;
+uniform float uPixelRatio;
+uniform vec4 uViewport;
+
+varying vec2 vTexCoord;
+
+#include matrix_scale
+
+void main(void){
+    #include assign_group
+    #include assign_color_varying
+    #include assign_marker_varying
+    #include assign_clipping_varying
+    #include assign_size
+
+    vTexCoord = aTexCoord;
+
+    float scale = matrixScale(uModelView);
+
+    float offsetX = uOffsetX * scale;
+    float offsetY = uOffsetY * scale;
+    float offsetZ = (uOffsetZ + aDepth * 0.95) * scale;
+
+    vec4 position4 = vec4(aPosition, 1.0);
+    vec4 mvPosition = uModelView * aTransform * position4;
+
+    vModelPosition = (uModel * aTransform * position4).xyz; // for clipping in frag shader
+
+    // TODO
+    // #ifdef FIXED_SIZE
+    //     if (ortho) {
+    //         scale /= pixelRatio * ((uViewport.w / 2.0) / -uCameraPosition.z) * 0.1;
+    //     } else {
+    //         scale /= pixelRatio * ((uViewport.w / 2.0) / -mvPosition.z) * 0.1;
+    //     }
+    // #endif
+
+    vec4 mvCorner = vec4(mvPosition.xyz, 1.0);
+
+    if (vTexCoord.x == 10.0) { // indicates background plane
+        // move a bit to the back, taking distance to camera into account to avoid z-fighting
+        offsetZ -= 0.001 * distance(uCameraPosition, (uProjection * mvCorner).xyz);
+    }
+
+    mvCorner.xy += aMapping * size * scale;
+    mvCorner.x += offsetX;
+    mvCorner.y += offsetY;
+
+    if (uIsOrtho == 1.0) {
+        mvCorner.z += offsetZ;
+    } else {
+        mvCorner.xyz += normalize(-mvCorner.xyz) * offsetZ;
+    }
+
+    gl_Position = uProjection * mvCorner;
+
+    vViewPosition = -mvCorner.xyz;
+
+    #include clip_instance
+}
 `;

package/lib/commonjs/mol-gl/shader/util/grid3d-template.frag.js

@@ -6,50 +6,50 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.grid3dTemplate_frag = void 0;
-exports.grid3dTemplate_frag = `
-precision highp float;
-precision highp int;
-precision highp sampler2D;
-
-uniform vec2 uQuadShift;
-uniform vec3 uDimensions;
-uniform vec3 uMin;
-uniform vec3 uDelta;
-uniform bool uLittleEndian;
-uniform float uWidth;
-
-#ifdef CUMULATIVE
-    uniform sampler2D tCumulativeSum;
-#endif
-
-{UNIFORMS}
-
-{UTILS}
-
-#include float_to_rgba
-#ifdef CUMULATIVE
-    #include rgba_to_float
-#endif
-
-float intDiv(float a, float b) { return float(int(a) / int(b)); }
-float intMod(float a, float b) { return a - b * float(int(a) / int(b)); }
-
-void main(void) {
-    float offset = floor(gl_FragCoord.x) + floor(gl_FragCoord.y) * uWidth;
-
-    // axis order fast to slow Z, Y, X
-    // TODO: support arbitrary axis orders?
-    float k = intMod(offset, uDimensions.z), kk = intDiv(offset, uDimensions.z);
-    float j = intMod(kk, uDimensions.y);
-    float i = intDiv(kk, uDimensions.y);
-
-    vec3 xyz = uMin + uDelta * vec3(i, j, k);
-
-    {MAIN}
-
-    #ifdef CUMULATIVE
-        float current = rgbaToFloat(texture2D(tCumulativeSum, gl_FragCoord.xy / vec2(uWidth, uWidth)), uLittleEndian);
-    #endif
-    gl_FragColor = floatToRgba({RETURN}, uLittleEndian);
-}
+exports.grid3dTemplate_frag = `
+precision highp float;
+precision highp int;
+precision highp sampler2D;
+
+uniform vec2 uQuadShift;
+uniform vec3 uDimensions;
+uniform vec3 uMin;
+uniform vec3 uDelta;
+uniform bool uLittleEndian;
+uniform float uWidth;
+
+#ifdef CUMULATIVE
+    uniform sampler2D tCumulativeSum;
+#endif
+
+{UNIFORMS}
+
+{UTILS}
+
+#include float_to_rgba
+#ifdef CUMULATIVE
+    #include rgba_to_float
+#endif
+
+float intDiv(float a, float b) { return float(int(a) / int(b)); }
+float intMod(float a, float b) { return a - b * float(int(a) / int(b)); }
+
+void main(void) {
+    float offset = floor(gl_FragCoord.x) + floor(gl_FragCoord.y) * uWidth;
+
+    // axis order fast to slow Z, Y, X
+    // TODO: support arbitrary axis orders?
+    float k = intMod(offset, uDimensions.z), kk = intDiv(offset, uDimensions.z);
+    float j = intMod(kk, uDimensions.y);
+    float i = intDiv(kk, uDimensions.y);
+
+    vec3 xyz = uMin + uDelta * vec3(i, j, k);
+
+    {MAIN}
+
+    #ifdef CUMULATIVE
+        float current = rgbaToFloat(texture2D(tCumulativeSum, gl_FragCoord.xy / vec2(uWidth, uWidth)), uLittleEndian);
+    #endif
+    gl_FragColor = floatToRgba({RETURN}, uLittleEndian);
+}
 `;

package/lib/commonjs/mol-gl/shader-code.js

@@ -265,22 +265,22 @@ function getGlsl100FragPrefix(extensions, shaderExtensions) {
     }
     return prefix.join('\n') + '\n';
 }
-const glsl300VertPrefixCommon = `
-#define attribute in
-#define varying out
-#define texture2D texture
+const glsl300VertPrefixCommon = `
+#define attribute in
+#define varying out
+#define texture2D texture
 `;
-const glsl300FragPrefixCommon = `
-#define varying in
-#define texture2D texture
-#define textureCube texture
-#define texture2DLodEXT textureLod
-#define textureCubeLodEXT textureLod
-
-#define gl_FragColor out_FragData0
-#define gl_FragDepthEXT gl_FragDepth
-
-#define depthTextureSupport
+const glsl300FragPrefixCommon = `
+#define varying in
+#define texture2D texture
+#define textureCube texture
+#define texture2DLodEXT textureLod
+#define textureCubeLodEXT textureLod
+
+#define gl_FragColor out_FragData0
+#define gl_FragDepthEXT gl_FragDepth
+
+#define depthTextureSupport
 `;
 function getGlsl300VertPrefix(extensions, shaderExtensions) {
     const prefix = [

package/lib/commonjs/mol-gl/webgl/compat.js

@@ -460,19 +460,19 @@ function getNoNonInstancedActiveAttribs(gl) {
 }
 exports.getNoNonInstancedActiveAttribs = getNoNonInstancedActiveAttribs;
 //
-const TextureTestVertShader = `
-attribute vec4 aPosition;
-
-void main() {
-    gl_Position = aPosition;
+const TextureTestVertShader = `
+attribute vec4 aPosition;
+
+void main() {
+    gl_Position = aPosition;
 }`;
-const TextureTestFragShader = `
-precision mediump float;
-uniform vec4 uColor;
-uniform sampler2D uTexture;
-
-void main() {
-    gl_FragColor = texture2D(uTexture, vec2(0.5, 0.5)) * uColor;
+const TextureTestFragShader = `
+precision mediump float;
+uniform vec4 uColor;
+uniform sampler2D uTexture;
+
+void main() {
+    gl_FragColor = texture2D(uTexture, vec2(0.5, 0.5)) * uColor;
 }`;
 const TextureTestTexCoords = new Float32Array([
     -1.0, -1.0, 1.0, -1.0, -1.0, 1.0, -1.0, 1.0, 1.0, -1.0, 1.0, 1.0

package/lib/commonjs/mol-gl/webgl/context.js

@@ -279,6 +279,7 @@ function createContext(gl, props = {}) {
         contextRestored,
         setContextLost: () => {
             isContextLost = true;
+            timer.clear();
         },
         handleContextRestored: (extraResets) => {
             Object.assign(extensions, (0, extensions_1.createExtensions)(gl));

package/lib/commonjs/mol-gl/webgl/timer.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2022-2023 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2022-2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */

package/lib/commonjs/mol-gl/webgl/timer.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Copyright (c) 2022-2023 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2022-2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -25,6 +25,9 @@ class MovingAverage {
     stats() {
         return Object.fromEntries(this.avgs.entries());
     }
+    clear() {
+        this.avgs.clear();
+    }
     constructor(count) {
         this.count = count;
         this.avgs = new Map();
@@ -61,8 +64,12 @@ function createTimer(gl, extensions, stats, options) {
             dtq.deleteQuery(query);
         });
         pending.clear();
+        stack.length = 0;
+        gpuAvgs.clear();
+        cpuAvgs.clear();
         measures = [];
         current = null;
+        capturingStats = false;
     };
     const add = () => {
         if (!dtq)

package/lib/commonjs/mol-math/linear-algebra/3d/minimize-rmsd.js

@@ -55,7 +55,8 @@ function computeN(state) {
     const cA = state.centerA;
     const cB = state.centerB;
     let sizeSq = 0.0;
-    for (let i = 0, _l = state.a.x.length; i < _l; i++) {
+    const L = Math.min(state.a.x.length, state.b.x.length);
+    for (let i = 0; i < L; i++) {
         const aX = xsA[i] - cA[0], aY = ysA[i] - cA[1], aZ = zsA[i] - cA[2];
         const bX = xsB[i] - cB[0], bY = ysB[i] - cB[1], bZ = zsB[i] - cB[2];
         sizeSq += aX * aX + aY * aY + aZ * aZ + bX * bX + bY * bY + bZ * bZ;

package/lib/commonjs/mol-plugin/animation-loop.d.ts

@@ -15,6 +15,7 @@ export declare class PluginAnimationLoop {
         isSynchronous?: boolean;
         manualDraw?: boolean;
         animation?: PluginAnimationManager.AnimationInfo;
+        updateControls?: boolean;
     }): Promise<void>;
     private frame;
     resetTime(t?: number): void;

package/lib/commonjs/mol-plugin/behavior/dynamic/volume-streaming/behavior.d.ts

@@ -55,14 +55,14 @@ export declare namespace VolumeStreaming {
                 topRight: Vec3;
             }>, "box"> | PD.NamedParams<PD.Normalize<{
                 radius: number;
+                dynamicDetailLevel: number;
                 bottomLeft: Vec3;
                 topRight: Vec3;
-            }>, "selection-box"> | PD.NamedParams<PD.Normalize<{
+            }>, "camera-target"> | PD.NamedParams<PD.Normalize<{
                 radius: number;
-                dynamicDetailLevel: number;
                 bottomLeft: Vec3;
                 topRight: Vec3;
-            }>, "camera-target">>;
+            }>, "selection-box">>;
             detailLevel: PD.Select<number>;
             channels: PD.Group<PD.Normalize<{
                 em: PD.Normalize<ChannelParams>;
@@ -92,14 +92,14 @@ export declare namespace VolumeStreaming {
             topRight: Vec3;
         }>, "box"> | PD.NamedParams<PD.Normalize<{
             radius: number;
+            dynamicDetailLevel: number;
             bottomLeft: Vec3;
             topRight: Vec3;
-        }>, "selection-box"> | PD.NamedParams<PD.Normalize<{
+        }>, "camera-target"> | PD.NamedParams<PD.Normalize<{
             radius: number;
-            dynamicDetailLevel: number;
             bottomLeft: Vec3;
             topRight: Vec3;
-        }>, "camera-target">>;
+        }>, "selection-box">>;
         detailLevel: PD.Select<number>;
         channels: PD.Group<PD.Normalize<{
             em: PD.Normalize<ChannelParams>;

package/lib/commonjs/mol-plugin/behavior/dynamic/volume-streaming/model.d.ts

@@ -12,7 +12,7 @@ declare const VolumeServerInfo_base: {
         label: string;
         description?: string | undefined;
     } | undefined): {
-        id: import("../../../../mol-util").UUID;
+        id: import("../../../../mol-util").UUID; /** The value are stored in blockSize^3 cubes */
         type: PluginStateObject.TypeInfo;
         label: string;
         description?: string | undefined;

package/lib/commonjs/mol-plugin/behavior/dynamic/volume-streaming/transformers.d.ts

@@ -50,14 +50,14 @@ declare const CreateVolumeStreamingBehavior: StateTransformer<VolumeServerInfo,
             topRight: any;
         }>, "box"> | PD.NamedParams<PD.Normalize<{
             radius: any;
+            dynamicDetailLevel: any;
             bottomLeft: any;
             topRight: any;
-        }>, "selection-box"> | PD.NamedParams<PD.Normalize<{
+        }>, "camera-target"> | PD.NamedParams<PD.Normalize<{
             radius: any;
-            dynamicDetailLevel: any;
             bottomLeft: any;
             topRight: any;
-        }>, "camera-target">>;
+        }>, "selection-box">>;
         detailLevel: PD.Select<number>;
         channels: PD.Group<PD.Normalize<{
             em: any;