molstar 4.2.0 → 4.4.0

package/lib/extensions/sb-ncbr/tunnels/data-model.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Dušan Veľký <dvelky@mail.muni.cz>
+ */
+import { WebGLContext } from '../../../mol-gl/webgl/context';
+import { PluginStateObject } from '../../../mol-plugin-state/objects';
+import { ParamDefinition as PD } from '../../../mol-util/param-definition';
+export interface Profile {
+    Charge: number;
+    Radius: number;
+    FreeRadius: number;
+    T: number;
+    Distance: number;
+    X: number;
+    Y: number;
+    Z: number;
+}
+export interface Layerweightedproperties {
+    Hydrophobicity: number;
+    Hydropathy: number;
+    Polarity: number;
+    Mutability: number;
+}
+export interface LayerGeometry {
+    MinRadius: number;
+    MinFreeRadius: number;
+    StartDistance: number;
+    EndDistance: number;
+    LocalMinimum: boolean;
+    Bottleneck: boolean;
+    bottleneck: boolean;
+}
+export interface Properties {
+    Charge: number;
+    NumPositives: number;
+    NumNegatives: number;
+    Hydrophobicity: number;
+    Hydropathy: number;
+    Polarity: number;
+    Mutability: number;
+}
+export interface LayersInfo {
+    LayerGeometry: LayerGeometry;
+    Residues: string[];
+    FlowIndices: string[];
+    Properties: Properties;
+}
+export interface Layers {
+    ResidueFlow: string[];
+    HetResidues: any[];
+    LayerWeightedProperties: Layerweightedproperties;
+    LayersInfo: LayersInfo[];
+}
+export interface TunnelDB {
+    Type: string;
+    Id: string;
+    Cavity: string;
+    Auto: boolean;
+    Properties: Properties;
+    Profile: Profile[];
+    Layers: Layers;
+}
+export interface ChannelsDBdata {
+    'CSATunnels_MOLE': TunnelDB[];
+    'CSATunnels_Caver': TunnelDB[];
+    'ReviewedChannels_MOLE': TunnelDB[];
+    'ReviewedChannels_Caver': TunnelDB[];
+    'CofactorTunnels_MOLE': TunnelDB[];
+    'CofactorTunnels_Caver': TunnelDB[];
+    'TransmembranePores_MOLE': TunnelDB[];
+    'TransmembranePores_Caver': TunnelDB[];
+    'ProcognateTunnels_MOLE': TunnelDB[];
+    'ProcognateTunnels_Caver': TunnelDB[];
+    'AlphaFillTunnels_MOLE': TunnelDB[];
+    'AlphaFillTunnels_Caver': TunnelDB[];
+}
+export interface ChannelsCache {
+    Channels: ChannelsDBdata;
+}
+export interface Tunnel {
+    data: Profile[];
+    props: {
+        highlight_label?: string;
+        type?: string;
+        id?: string;
+        label?: string;
+        description?: string;
+    };
+}
+export declare const TunnelShapeParams: {
+    webgl: PD.Value<WebGLContext | null>;
+    colorTheme: PD.Color;
+    visual: PD.Mapped<PD.NamedParams<PD.Normalize<{
+        resolution: number;
+    }>, "spheres"> | PD.NamedParams<PD.Normalize<{
+        resolution: number;
+    }>, "mesh">>;
+    samplingRate: PD.Numeric;
+    showRadii: PD.BooleanParam;
+};
+declare const TunnelStateObject_base: {
+    new (data: {
+        tunnel: Tunnel;
+    }, props?: {
+        label: string;
+        description?: string;
+    } | undefined): {
+        id: import("../../../mol-util").UUID;
+        type: PluginStateObject.TypeInfo;
+        label: string;
+        description?: string;
+        data: {
+            tunnel: Tunnel;
+        };
+    };
+    type: PluginStateObject.TypeInfo;
+    is(obj?: import("../../../mol-state").StateObject): obj is import("../../../mol-state").StateObject<{
+        tunnel: Tunnel;
+    }, PluginStateObject.TypeInfo>;
+};
+export declare class TunnelStateObject extends TunnelStateObject_base {
+}
+declare const TunnelsStateObject_base: {
+    new (data: {
+        tunnels: Tunnel[];
+    }, props?: {
+        label: string;
+        description?: string;
+    } | undefined): {
+        id: import("../../../mol-util").UUID;
+        type: PluginStateObject.TypeInfo;
+        label: string;
+        description?: string;
+        data: {
+            tunnels: Tunnel[];
+        };
+    };
+    type: PluginStateObject.TypeInfo;
+    is(obj?: import("../../../mol-state").StateObject): obj is import("../../../mol-state").StateObject<{
+        tunnels: Tunnel[];
+    }, PluginStateObject.TypeInfo>;
+};
+export declare class TunnelsStateObject extends TunnelsStateObject_base {
+}
+export {};

package/lib/extensions/sb-ncbr/tunnels/data-model.js

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Dušan Veľký <dvelky@mail.muni.cz>
+ */
+import { PluginStateObject } from '../../../mol-plugin-state/objects';
+import { Color } from '../../../mol-util/color';
+import { ParamDefinition as PD } from '../../../mol-util/param-definition';
+;
+export const TunnelShapeParams = {
+    webgl: PD.Value(null),
+    colorTheme: PD.Color(Color(0xff0000)),
+    visual: PD.MappedStatic('mesh', {
+        mesh: PD.Group({ resolution: PD.Numeric(2) }),
+        spheres: PD.Group({ resolution: PD.Numeric(2) })
+    }),
+    samplingRate: PD.Numeric(1, { min: 0.05, max: 1, step: 0.05 }),
+    showRadii: PD.Boolean(false),
+};
+export class TunnelStateObject extends PluginStateObject.Create({ name: 'Tunnel Entry', typeClass: 'Data' }) {
+}
+export class TunnelsStateObject extends PluginStateObject.Create({ name: 'Tunnels', typeClass: 'Data' }) {
+}

package/lib/extensions/sb-ncbr/tunnels/examples.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Dušan Veľký <dvelky@mail.muni.cz>
+ */
+import { PluginContext } from '../../../mol-plugin/context';
+export declare const DB_URL = "https://channelsdb2.biodata.ceitec.cz/api/channels/";
+export declare const SUB_DB = "pdb";
+export declare const CHANNEL = "1ymg";
+export declare const URL = "https://channelsdb2.biodata.ceitec.cz/api/channels/pdb/1ymg";
+export declare function runVisualizeTunnels(plugin: PluginContext, url?: string): Promise<void>;
+export declare function runVisualizeTunnel(plugin: PluginContext): Promise<void>;

package/lib/extensions/sb-ncbr/tunnels/examples.js

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Dušan Veľký <dvelky@mail.muni.cz>
+ */
+import { StateTransforms } from '../../../mol-plugin-state/transforms';
+import { TunnelsFromRawData, SelectTunnel, TunnelShapeProvider, TunnelFromRawData } from './representation';
+export const DB_URL = 'https://channelsdb2.biodata.ceitec.cz/api/channels/';
+export const SUB_DB = 'pdb';
+export const CHANNEL = '1ymg';
+export const URL = `${DB_URL}${SUB_DB}/${CHANNEL}`;
+export async function runVisualizeTunnels(plugin, url = URL) {
+    var _a;
+    const update = plugin.build();
+    const webgl = (_a = plugin.canvas3dContext) === null || _a === void 0 ? void 0 : _a.webgl;
+    const response = await (await fetch(url)).json();
+    const tunnels = [];
+    Object.entries(response.Channels).forEach(([key, values]) => {
+        if (values.length > 0) {
+            values.forEach((item) => {
+                tunnels.push({ data: item.Profile, props: { id: item.Id, type: item.Type } });
+            });
+        }
+    });
+    update
+        .toRoot()
+        .apply(TunnelsFromRawData, { data: tunnels })
+        .apply(SelectTunnel)
+        .apply(TunnelShapeProvider, {
+        webgl,
+    })
+        .apply(StateTransforms.Representation.ShapeRepresentation3D);
+    await update.commit();
+}
+export async function runVisualizeTunnel(plugin) {
+    var _a;
+    const update = plugin.build();
+    const webgl = (_a = plugin.canvas3dContext) === null || _a === void 0 ? void 0 : _a.webgl;
+    const response = await (await fetch(URL)).json();
+    const tunnel = response.Channels.TransmembranePores_MOLE[0];
+    update
+        .toRoot()
+        .apply(TunnelFromRawData, { data: { data: tunnel.Profile, props: { id: tunnel.Id, type: tunnel.Type } } })
+        .apply(TunnelShapeProvider, {
+        webgl,
+    })
+        .apply(StateTransforms.Representation.ShapeRepresentation3D);
+    await update.commit();
+}

package/lib/extensions/sb-ncbr/tunnels/props.d.ts

@@ -0,0 +1,19 @@
+import { PluginConfigItem } from '../../../mol-plugin/config';
+import { PluginContext } from '../../../mol-plugin/context';
+import { ParamDefinition as PD } from '../../../mol-util/param-definition';
+export declare namespace TunnelsData {
+    const DefaultServerUrl = "https://channelsdb2.biodata.ceitec.cz/api";
+    const DefaultServerType = "pdb";
+}
+export declare const TunnelsDataParams: {
+    serverType: PD.Select<"pdb">;
+    serverUrl: PD.Text<string>;
+};
+export type TunnelsDataParams = typeof TunnelsDataParams;
+export declare const TunnelsServerConfig: {
+    DefaultServerUrl: PluginConfigItem<string>;
+    DefaultServerType: PluginConfigItem<"pdb">;
+};
+export declare function getTunnelsConfig(plugin: PluginContext): {
+    [key in keyof typeof TunnelsServerConfig]: NonNullable<typeof TunnelsServerConfig[key]['defaultValue']>;
+};

package/lib/extensions/sb-ncbr/tunnels/props.js

@@ -0,0 +1,22 @@
+import { PluginConfigItem } from '../../../mol-plugin/config';
+import { ParamDefinition as PD } from '../../../mol-util/param-definition';
+export var TunnelsData;
+(function (TunnelsData) {
+    TunnelsData.DefaultServerUrl = 'https://channelsdb2.biodata.ceitec.cz/api';
+    TunnelsData.DefaultServerType = 'pdb';
+})(TunnelsData || (TunnelsData = {}));
+export const TunnelsDataParams = {
+    serverType: PD.Select('pdb', [['pdb', 'pdb']]),
+    serverUrl: PD.Text(TunnelsData.DefaultServerUrl)
+};
+export const TunnelsServerConfig = {
+    DefaultServerUrl: new PluginConfigItem('channelsdb-server', 'https://channelsdb2.biodata.ceitec.cz/api'),
+    DefaultServerType: new PluginConfigItem('serverType', 'pdb')
+};
+export function getTunnelsConfig(plugin) {
+    var _a, _b, _c, _d;
+    return {
+        DefaultServerUrl: (_b = (_a = plugin.config.get(TunnelsServerConfig.DefaultServerUrl)) !== null && _a !== void 0 ? _a : TunnelsServerConfig.DefaultServerUrl.defaultValue) !== null && _b !== void 0 ? _b : TunnelsData.DefaultServerUrl,
+        DefaultServerType: (_d = (_c = plugin.config.get(TunnelsServerConfig.DefaultServerType)) !== null && _c !== void 0 ? _c : TunnelsServerConfig.DefaultServerType.defaultValue) !== null && _d !== void 0 ? _d : TunnelsData.DefaultServerType,
+    };
+}

package/lib/extensions/sb-ncbr/tunnels/representation.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Dušan Veľký <dvelky@mail.muni.cz>
+ */
+import { PluginStateObject } from '../../../mol-plugin-state/objects';
+import { StateTransformer } from '../../../mol-state';
+import { TunnelStateObject, Tunnel, TunnelsStateObject } from './data-model';
+import { ParamDefinition as PD } from '../../../mol-util/param-definition';
+export declare const TunnelsFromRawData: StateTransformer<PluginStateObject.Root, TunnelsStateObject, PD.Normalize<{
+    data: Tunnel[];
+}>>;
+export declare const SelectTunnel: StateTransformer<TunnelsStateObject, TunnelStateObject, PD.Normalize<{
+    index: number;
+}>>;
+export declare const TunnelFromRawData: StateTransformer<PluginStateObject.Root, TunnelStateObject, PD.Normalize<{
+    data: Tunnel;
+}>>;
+export declare const TunnelShapeProvider: StateTransformer<TunnelStateObject, PluginStateObject.Shape.Provider, PD.Normalize<{
+    webgl: import("../../../mol-gl/webgl/context").WebGLContext | null;
+    colorTheme: import("../../../mol-util/color").Color;
+    visual: PD.NamedParams<PD.Normalize<{
+        resolution: any;
+    }>, "spheres"> | PD.NamedParams<PD.Normalize<{
+        resolution: any;
+    }>, "mesh">;
+    samplingRate: number;
+    showRadii: boolean;
+}>>;

package/lib/extensions/sb-ncbr/tunnels/representation.js

@@ -0,0 +1,96 @@
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Dušan Veľký <dvelky@mail.muni.cz>
+ */
+import { PluginStateObject } from '../../../mol-plugin-state/objects';
+import { StateTransformer } from '../../../mol-state';
+import { TunnelStateObject, TunnelShapeParams, TunnelsStateObject } from './data-model';
+import { ParamDefinition as PD } from '../../../mol-util/param-definition';
+import { Mesh } from '../../../mol-geo/geometry/mesh/mesh';
+import { Task } from '../../../mol-task';
+import { createTunnelShape, createSpheresShape } from './algorithm';
+const Transform = StateTransformer.builderFactory('sb-ncbr-tunnels');
+export const TunnelsFromRawData = Transform({
+    name: 'sb-ncbr-tunnels-from-data',
+    display: { name: 'Tunnels' },
+    from: PluginStateObject.Root,
+    to: TunnelsStateObject,
+    params: {
+        data: PD.Value([]),
+    },
+})({
+    apply({ params }) {
+        return new TunnelsStateObject({ tunnels: params.data });
+    },
+});
+export const SelectTunnel = Transform({
+    name: 'sb-ncbr-tunnel-from-tunnels',
+    display: { name: 'Tunnel Selection' },
+    from: TunnelsStateObject,
+    to: TunnelStateObject,
+    params: a => {
+        return {
+            index: PD.Numeric(0, { min: 0, max: a.data.tunnels.length - 1, step: 1 })
+        };
+    }
+})({
+    apply({ a, params }) {
+        return new TunnelStateObject({ tunnel: a.data.tunnels[params.index] });
+    }
+});
+export const TunnelFromRawData = Transform({
+    name: 'sb-ncbr-tunnel-from-data',
+    display: { name: 'Tunnel Entry' },
+    from: PluginStateObject.Root,
+    to: TunnelStateObject,
+    params: {
+        data: PD.Value(undefined, { isHidden: true })
+    },
+})({
+    apply({ params }) {
+        return new TunnelStateObject({ tunnel: params.data });
+    },
+});
+export const TunnelShapeProvider = Transform({
+    name: 'sb-ncbr-tunnel-shape-provider',
+    display: { name: 'Tunnel' },
+    from: TunnelStateObject,
+    to: PluginStateObject.Shape.Provider,
+    params: a => { return TunnelShapeParams; },
+})({
+    apply({ a, params }) {
+        return Task.create('Tunnel Shape Representation', async (ctx) => {
+            var _a, _b;
+            return new PluginStateObject.Shape.Provider({
+                label: 'Surface',
+                data: { params, data: a.data },
+                params: Mesh.Params,
+                geometryUtils: Mesh.Utils,
+                getShape: (_, data, __, mesh) => {
+                    if (data.params.visual.name === 'mesh' && !data.params.showRadii) {
+                        return createTunnelShape({
+                            tunnel: data.data.tunnel,
+                            color: data.params.colorTheme,
+                            resolution: data.params.visual.params.resolution,
+                            sampleRate: data.params.samplingRate,
+                            webgl: data.params.webgl, prev: mesh
+                        });
+                    }
+                    return createSpheresShape({
+                        tunnel: data.data.tunnel,
+                        color: data.params.colorTheme,
+                        resolution: data.params.visual.params.resolution,
+                        sampleRate: data.params.samplingRate,
+                        showRadii: data.params.showRadii, prev: mesh
+                    });
+                }
+            }, {
+                label: (_a = a.data.tunnel.props.label) !== null && _a !== void 0 ? _a : 'Tunnel',
+                description: ((_b = a.data.tunnel.props.description) !== null && _b !== void 0 ? _b : (a.data.tunnel.props.type && a.data.tunnel.props.id))
+                    ? `${a.data.tunnel.props.type} ${a.data.tunnel.props.id}`
+                    : '',
+            });
+        });
+    },
+});

package/lib/extensions/volumes-and-segmentations/entry-root.d.ts

@@ -37,16 +37,16 @@ export declare namespace VolsegEntryParamValues {
 declare const VolsegEntry_base: {
     new (data: VolsegEntryData, props?: {
         label: string;
-        description?: string | undefined;
+        description?: string;
     } | undefined): {
         id: import("../../mol-util").UUID;
         type: PluginStateObject.TypeInfo;
         label: string;
-        description?: string | undefined;
+        description?: string;
         data: VolsegEntryData;
     };
     type: PluginStateObject.TypeInfo;
-    is(obj?: import("../../mol-state").StateObject<any, import("../../mol-state").StateObject.Type<any>> | undefined): obj is import("../../mol-state").StateObject<VolsegEntryData, PluginStateObject.TypeInfo>;
+    is(obj?: import("../../mol-state").StateObject): obj is import("../../mol-state").StateObject<VolsegEntryData, PluginStateObject.TypeInfo>;
 };
 export declare class VolsegEntry extends VolsegEntry_base {
 }

package/lib/extensions/volumes-and-segmentations/entry-state.d.ts

@@ -39,12 +39,12 @@ declare const VolsegState_base: {
         }>>;
     }>, props?: {
         label: string;
-        description?: string | undefined;
+        description?: string;
     } | undefined): {
         id: import("../../mol-util").UUID;
         type: PluginStateObject.TypeInfo;
         label: string;
-        description?: string | undefined;
+        description?: string;
         data: PD.Values<{
             volumeType: PD.Select<"off" | "direct-volume" | "isosurface">;
             volumeIsovalueKind: PD.Select<string>;
@@ -61,7 +61,7 @@ declare const VolsegState_base: {
         }>;
     };
     type: PluginStateObject.TypeInfo;
-    is(obj?: import("../../mol-state").StateObject<any, import("../../mol-state").StateObject.Type<any>> | undefined): obj is import("../../mol-state").StateObject<PD.Values<{
+    is(obj?: import("../../mol-state").StateObject): obj is import("../../mol-state").StateObject<PD.Values<{
         volumeType: PD.Select<"off" | "direct-volume" | "isosurface">;
         volumeIsovalueKind: PD.Select<string>;
         volumeIsovalueValue: PD.Numeric;

package/lib/extensions/volumes-and-segmentations/global-state.d.ts

@@ -16,16 +16,16 @@ export type VolsegGlobalStateParamValues = PD.Values<typeof VolsegGlobalStatePar
 declare const VolsegGlobalState_base: {
     new (data: VolsegGlobalStateData, props?: {
         label: string;
-        description?: string | undefined;
+        description?: string;
     } | undefined): {
         id: import("../../mol-util").UUID;
         type: PluginStateObject.TypeInfo;
         label: string;
-        description?: string | undefined;
+        description?: string;
         data: VolsegGlobalStateData;
     };
     type: PluginStateObject.TypeInfo;
-    is(obj?: import("../../mol-state").StateObject<any, import("../../mol-state").StateObject.Type<any>> | undefined): obj is import("../../mol-state").StateObject<VolsegGlobalStateData, PluginStateObject.TypeInfo>;
+    is(obj?: import("../../mol-state").StateObject): obj is import("../../mol-state").StateObject<VolsegGlobalStateData, PluginStateObject.TypeInfo>;
 };
 export declare class VolsegGlobalState extends VolsegGlobalState_base {
 }

package/lib/extensions/volumes-and-segmentations/ui.d.ts

@@ -3,7 +3,6 @@
  *
  * @author Adam Midlik <midlik@gmail.com>
  */
-/// <reference types="react" />
 import { CollapsableControls, CollapsableState } from '../../mol-plugin-ui/base';
 import { VolsegEntry } from './entry-root';
 import { VolsegGlobalStateData } from './global-state';

package/lib/extensions/zenodo/ui.d.ts

@@ -3,7 +3,6 @@
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
-/// <reference types="react" />
 import { CollapsableControls, CollapsableState } from '../../mol-plugin-ui/base';
 import { PluginContext } from '../../mol-plugin/context';
 import { ParamDefinition as PD } from '../../mol-util/param-definition';

package/lib/mol-canvas3d/camera/transition.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2019 Mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2024 Mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  */

package/lib/mol-canvas3d/camera/transition.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2019 Mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2024 Mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  */
@@ -68,19 +68,36 @@ class CameraTransitionManager {
     }
 }
 (function (CameraTransitionManager) {
-    const _rot = Quat.identity();
+    const _rotUp = Quat.identity();
+    const _rotDist = Quat.identity();
+    const _sourcePosition = Vec3();
+    const _targetPosition = Vec3();
     function defaultTransition(out, t, source, target) {
         Camera.copySnapshot(out, target);
         // Rotate up
-        Quat.slerp(_rot, Quat.Identity, Quat.rotationTo(_rot, source.up, target.up), t);
-        Vec3.transformQuat(out.up, source.up, _rot);
+        Quat.slerp(_rotUp, Quat.Identity, Quat.rotationTo(_rotUp, source.up, target.up), t);
+        Vec3.transformQuat(out.up, source.up, _rotUp);
         // Lerp target, position & radius
         Vec3.lerp(out.target, source.target, target.target, t);
-        Vec3.lerp(out.position, source.position, target.position, t);
+        // Interpolate distance
+        const distSource = Vec3.distance(source.target, source.position);
+        const distTarget = Vec3.distance(target.target, target.position);
+        const dist = lerp(distSource, distTarget, t);
+        // Rotate between source and targer direction
+        Vec3.sub(_sourcePosition, source.position, source.target);
+        Vec3.normalize(_sourcePosition, _sourcePosition);
+        Vec3.sub(_targetPosition, target.position, target.target);
+        Vec3.normalize(_targetPosition, _targetPosition);
+        Quat.rotationTo(_rotDist, _sourcePosition, _targetPosition);
+        Quat.slerp(_rotDist, Quat.Identity, _rotDist, t);
+        Vec3.transformQuat(_sourcePosition, _sourcePosition, _rotDist);
+        Vec3.scale(_sourcePosition, _sourcePosition, dist);
+        Vec3.add(out.position, out.target, _sourcePosition);
+        // Interpolate radius
         out.radius = lerp(source.radius, target.radius, t);
         // TODO take change of `clipFar` into account
         out.radiusMax = lerp(source.radiusMax, target.radiusMax, t);
-        // Lerp fov & fog
+        // Interpolate fov & fog
         out.fov = lerp(source.fov, target.fov, t);
         out.fog = lerp(source.fog, target.fog, t);
     }

package/lib/mol-canvas3d/canvas3d.d.ts

@@ -64,6 +64,7 @@ export declare const Canvas3DParams: {
         mode: string;
         sampleLevel: number;
         reduceFlicker: boolean;
+        reuseOcclusion: boolean;
     }>>;
     postprocessing: PD.Group<PD.Normalize<{
         occlusion: PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
@@ -72,6 +73,7 @@ export declare const Canvas3DParams: {
             radius: any;
             bias: any;
             blurKernelSize: any;
+            blurDepthBias: any;
             resolutionScale: any;
             color: any;
         }>, "on">;
@@ -87,6 +89,14 @@ export declare const Canvas3DParams: {
             color: any;
             includeTransparent: any;
         }>, "on">;
+        dof: PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
+            blurSize: any;
+            blurSpread: any;
+            inFocus: any;
+            PPM: any;
+            center: any;
+            mode: any;
+        }>, "on">;
         antialiasing: PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
             edgeThreshold: any;
             maxSearchSteps: any;
@@ -140,6 +150,7 @@ export declare const Canvas3DParams: {
         dimStrength: number;
         markerPriority: number;
         xrayEdgeFalloff: number;
+        celSteps: number;
         exposure: number;
         light: PD.Normalize<{
             inclination: number;
@@ -223,6 +234,7 @@ export declare const Canvas3DParams: {
             doubleSided: any;
             flipSided: any;
             flatShaded: any;
+            celShaded: any;
             xrayShaded: any;
             transparentBackfaces: any;
             bumpFrequency: any;
@@ -279,6 +291,7 @@ export declare const DefaultCanvas3DParams: PD.Values<{
         mode: string;
         sampleLevel: number;
         reduceFlicker: boolean;
+        reuseOcclusion: boolean;
     }>>;
     postprocessing: PD.Group<PD.Normalize<{
         occlusion: PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
@@ -287,6 +300,7 @@ export declare const DefaultCanvas3DParams: PD.Values<{
             radius: any;
             bias: any;
             blurKernelSize: any;
+            blurDepthBias: any;
             resolutionScale: any;
             color: any;
         }>, "on">;
@@ -302,6 +316,14 @@ export declare const DefaultCanvas3DParams: PD.Values<{
             color: any;
             includeTransparent: any;
         }>, "on">;
+        dof: PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
+            blurSize: any;
+            blurSpread: any;
+            inFocus: any;
+            PPM: any;
+            center: any;
+            mode: any;
+        }>, "on">;
         antialiasing: PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
             edgeThreshold: any;
             maxSearchSteps: any;
@@ -355,6 +377,7 @@ export declare const DefaultCanvas3DParams: PD.Values<{
         dimStrength: number;
         markerPriority: number;
         xrayEdgeFalloff: number;
+        celSteps: number;
         exposure: number;
         light: PD.Normalize<{
             inclination: number;
@@ -438,6 +461,7 @@ export declare const DefaultCanvas3DParams: PD.Values<{
             doubleSided: any;
             flipSided: any;
             flatShaded: any;
+            celShaded: any;
             xrayShaded: any;
             transparentBackfaces: any;
             bumpFrequency: any;
@@ -480,7 +504,7 @@ interface Canvas3DContext {
 }
 declare namespace Canvas3DContext {
     const DefaultAttribs: {
-        powerPreference: WebGLPowerPreference | undefined;
+        powerPreference: WebGLContextAttributes["powerPreference"];
         failIfMajorPerformanceCaveat: boolean;
         /** true by default to avoid issues with Safari (Jan 2021) */
         antialias: boolean;
@@ -519,6 +543,7 @@ interface Canvas3D {
     tick(t: now.Timestamp, options?: {
         isSynchronous?: boolean;
         manualDraw?: boolean;
+        updateControls?: boolean;
     }): void;
     update(repr?: Representation.Any, keepBoundingSphere?: boolean): void;
     clear(): void;

package/lib/mol-canvas3d/canvas3d.js

@@ -391,6 +391,10 @@ var Canvas3D;
         function tick(t, options) {
             currentTime = t;
             commit(options === null || options === void 0 ? void 0 : options.isSynchronous);
+            // update the controler before the camera transition
+            if (options === null || options === void 0 ? void 0 : options.updateControls) {
+                controls.update(currentTime);
+            }
             camera.transition.tick(currentTime);
             hiZ.tick();
             if (options === null || options === void 0 ? void 0 : options.manualDraw) {