molstar 4.2.0 → 4.3.0

package/lib/commonjs/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;
+    } | undefined): {
+        id: import("../../../mol-util").UUID;
+        type: PluginStateObject.TypeInfo;
+        label: string;
+        description?: string | undefined;
+        data: {
+            tunnel: Tunnel;
+        };
+    };
+    type: PluginStateObject.TypeInfo;
+    is(obj?: import("../../../mol-state").StateObject<any, import("../../../mol-state").StateObject.Type<any>> | undefined): 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;
+    } | undefined): {
+        id: import("../../../mol-util").UUID;
+        type: PluginStateObject.TypeInfo;
+        label: string;
+        description?: string | undefined;
+        data: {
+            tunnels: Tunnel[];
+        };
+    };
+    type: PluginStateObject.TypeInfo;
+    is(obj?: import("../../../mol-state").StateObject<any, import("../../../mol-state").StateObject.Type<any>> | undefined): obj is import("../../../mol-state").StateObject<{
+        tunnels: Tunnel[];
+    }, PluginStateObject.TypeInfo>;
+};
+export declare class TunnelsStateObject extends TunnelsStateObject_base {
+}
+export {};

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

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

package/lib/commonjs/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/commonjs/extensions/sb-ncbr/tunnels/examples.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Dušan Veľký <dvelky@mail.muni.cz>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runVisualizeTunnel = exports.runVisualizeTunnels = exports.URL = exports.CHANNEL = exports.SUB_DB = exports.DB_URL = void 0;
+const transforms_1 = require("../../../mol-plugin-state/transforms");
+const representation_1 = require("./representation");
+exports.DB_URL = 'https://channelsdb2.biodata.ceitec.cz/api/channels/';
+exports.SUB_DB = 'pdb';
+exports.CHANNEL = '1ymg';
+exports.URL = `${exports.DB_URL}${exports.SUB_DB}/${exports.CHANNEL}`;
+async function runVisualizeTunnels(plugin, url = exports.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(representation_1.TunnelsFromRawData, { data: tunnels })
+        .apply(representation_1.SelectTunnel)
+        .apply(representation_1.TunnelShapeProvider, {
+        webgl,
+    })
+        .apply(transforms_1.StateTransforms.Representation.ShapeRepresentation3D);
+    await update.commit();
+}
+exports.runVisualizeTunnels = runVisualizeTunnels;
+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(exports.URL)).json();
+    const tunnel = response.Channels.TransmembranePores_MOLE[0];
+    update
+        .toRoot()
+        .apply(representation_1.TunnelFromRawData, { data: { data: tunnel.Profile, props: { id: tunnel.Id, type: tunnel.Type } } })
+        .apply(representation_1.TunnelShapeProvider, {
+        webgl,
+    })
+        .apply(transforms_1.StateTransforms.Representation.ShapeRepresentation3D);
+    await update.commit();
+}
+exports.runVisualizeTunnel = runVisualizeTunnel;

package/lib/commonjs/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/commonjs/extensions/sb-ncbr/tunnels/props.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTunnelsConfig = exports.TunnelsServerConfig = exports.TunnelsDataParams = exports.TunnelsData = void 0;
+const config_1 = require("../../../mol-plugin/config");
+const param_definition_1 = require("../../../mol-util/param-definition");
+var TunnelsData;
+(function (TunnelsData) {
+    TunnelsData.DefaultServerUrl = 'https://channelsdb2.biodata.ceitec.cz/api';
+    TunnelsData.DefaultServerType = 'pdb';
+})(TunnelsData || (exports.TunnelsData = TunnelsData = {}));
+exports.TunnelsDataParams = {
+    serverType: param_definition_1.ParamDefinition.Select('pdb', [['pdb', 'pdb']]),
+    serverUrl: param_definition_1.ParamDefinition.Text(TunnelsData.DefaultServerUrl)
+};
+exports.TunnelsServerConfig = {
+    DefaultServerUrl: new config_1.PluginConfigItem('channelsdb-server', 'https://channelsdb2.biodata.ceitec.cz/api'),
+    DefaultServerType: new config_1.PluginConfigItem('serverType', 'pdb')
+};
+function getTunnelsConfig(plugin) {
+    var _a, _b, _c, _d;
+    return {
+        DefaultServerUrl: (_b = (_a = plugin.config.get(exports.TunnelsServerConfig.DefaultServerUrl)) !== null && _a !== void 0 ? _a : exports.TunnelsServerConfig.DefaultServerUrl.defaultValue) !== null && _b !== void 0 ? _b : TunnelsData.DefaultServerUrl,
+        DefaultServerType: (_d = (_c = plugin.config.get(exports.TunnelsServerConfig.DefaultServerType)) !== null && _c !== void 0 ? _c : exports.TunnelsServerConfig.DefaultServerType.defaultValue) !== null && _d !== void 0 ? _d : TunnelsData.DefaultServerType,
+    };
+}
+exports.getTunnelsConfig = getTunnelsConfig;

package/lib/commonjs/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/commonjs/extensions/sb-ncbr/tunnels/representation.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Dušan Veľký <dvelky@mail.muni.cz>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TunnelShapeProvider = exports.TunnelFromRawData = exports.SelectTunnel = exports.TunnelsFromRawData = void 0;
+const objects_1 = require("../../../mol-plugin-state/objects");
+const mol_state_1 = require("../../../mol-state");
+const data_model_1 = require("./data-model");
+const param_definition_1 = require("../../../mol-util/param-definition");
+const mesh_1 = require("../../../mol-geo/geometry/mesh/mesh");
+const mol_task_1 = require("../../../mol-task");
+const algorithm_1 = require("./algorithm");
+const Transform = mol_state_1.StateTransformer.builderFactory('sb-ncbr-tunnels');
+exports.TunnelsFromRawData = Transform({
+    name: 'sb-ncbr-tunnels-from-data',
+    display: { name: 'Tunnels' },
+    from: objects_1.PluginStateObject.Root,
+    to: data_model_1.TunnelsStateObject,
+    params: {
+        data: param_definition_1.ParamDefinition.Value([]),
+    },
+})({
+    apply({ params }) {
+        return new data_model_1.TunnelsStateObject({ tunnels: params.data });
+    },
+});
+exports.SelectTunnel = Transform({
+    name: 'sb-ncbr-tunnel-from-tunnels',
+    display: { name: 'Tunnel Selection' },
+    from: data_model_1.TunnelsStateObject,
+    to: data_model_1.TunnelStateObject,
+    params: a => {
+        return {
+            index: param_definition_1.ParamDefinition.Numeric(0, { min: 0, max: a.data.tunnels.length - 1, step: 1 })
+        };
+    }
+})({
+    apply({ a, params }) {
+        return new data_model_1.TunnelStateObject({ tunnel: a.data.tunnels[params.index] });
+    }
+});
+exports.TunnelFromRawData = Transform({
+    name: 'sb-ncbr-tunnel-from-data',
+    display: { name: 'Tunnel Entry' },
+    from: objects_1.PluginStateObject.Root,
+    to: data_model_1.TunnelStateObject,
+    params: {
+        data: param_definition_1.ParamDefinition.Value(undefined, { isHidden: true })
+    },
+})({
+    apply({ params }) {
+        return new data_model_1.TunnelStateObject({ tunnel: params.data });
+    },
+});
+exports.TunnelShapeProvider = Transform({
+    name: 'sb-ncbr-tunnel-shape-provider',
+    display: { name: 'Tunnel' },
+    from: data_model_1.TunnelStateObject,
+    to: objects_1.PluginStateObject.Shape.Provider,
+    params: a => { return data_model_1.TunnelShapeParams; },
+})({
+    apply({ a, params }) {
+        return mol_task_1.Task.create('Tunnel Shape Representation', async (ctx) => {
+            var _a, _b;
+            return new objects_1.PluginStateObject.Shape.Provider({
+                label: 'Surface',
+                data: { params, data: a.data },
+                params: mesh_1.Mesh.Params,
+                geometryUtils: mesh_1.Mesh.Utils,
+                getShape: (_, data, __, mesh) => {
+                    if (data.params.visual.name === 'mesh' && !data.params.showRadii) {
+                        return (0, algorithm_1.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 (0, algorithm_1.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/commonjs/mol-canvas3d/canvas3d.d.ts

@@ -87,6 +87,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;
@@ -302,6 +310,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;
@@ -519,6 +535,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/commonjs/mol-canvas3d/canvas3d.js

@@ -392,6 +392,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) {

package/lib/commonjs/mol-canvas3d/passes/dof.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Ludovic Autin <autin@scripps.edu>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { WebGLContext } from '../../mol-gl/webgl/context';
+import { Texture } from '../../mol-gl/webgl/texture';
+import { ParamDefinition as PD } from '../../mol-util/param-definition';
+import { Viewport } from '../camera/util';
+import { RenderTarget } from '../../mol-gl/webgl/render-target';
+import { ICamera } from '../../mol-canvas3d/camera';
+import { Sphere3D } from '../../mol-math/geometry';
+import { PostprocessingProps } from './postprocessing';
+export declare const DofParams: {
+    blurSize: PD.Numeric;
+    blurSpread: PD.Numeric;
+    inFocus: PD.Numeric;
+    PPM: PD.Numeric;
+    center: PD.Select<string>;
+    mode: PD.Select<string>;
+};
+export type DofProps = PD.Values<typeof DofParams>;
+export declare class DofPass {
+    private webgl;
+    static isEnabled(props: PostprocessingProps): boolean;
+    readonly target: RenderTarget;
+    private readonly renderable;
+    constructor(webgl: WebGLContext, width: number, height: number);
+    private updateState;
+    setSize(width: number, height: number): void;
+    update(camera: ICamera, input: Texture, depthOpaque: Texture, depthTransparent: Texture, props: DofProps, sphere: Sphere3D): void;
+    render(viewport: Viewport, target: undefined | RenderTarget): void;
+}

package/lib/commonjs/mol-canvas3d/passes/dof.js

@@ -0,0 +1,167 @@
+"use strict";
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Ludovic Autin <autin@scripps.edu>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DofPass = exports.DofParams = void 0;
+const util_1 = require("../../mol-gl/compute/util");
+const renderable_1 = require("../../mol-gl/renderable");
+const schema_1 = require("../../mol-gl/renderable/schema");
+const shader_code_1 = require("../../mol-gl/shader-code");
+const render_item_1 = require("../../mol-gl/webgl/render-item");
+const texture_1 = require("../../mol-gl/webgl/texture");
+const linear_algebra_1 = require("../../mol-math/linear-algebra");
+const mol_util_1 = require("../../mol-util");
+const param_definition_1 = require("../../mol-util/param-definition");
+const quad_vert_1 = require("../../mol-gl/shader/quad.vert");
+const dof_frag_1 = require("../../mol-gl/shader/dof.frag");
+const debug_1 = require("../../mol-util/debug");
+exports.DofParams = {
+    blurSize: param_definition_1.ParamDefinition.Numeric(9, { min: 1, max: 32, step: 1 }),
+    blurSpread: param_definition_1.ParamDefinition.Numeric(1.0, { min: 0.0, max: 10.0, step: 0.1 }),
+    inFocus: param_definition_1.ParamDefinition.Numeric(0.0, { min: -5000.0, max: 5000.0, step: 1.0 }, { description: 'Distance from the scene center that will be in focus' }),
+    PPM: param_definition_1.ParamDefinition.Numeric(20.0, { min: 0.0, max: 5000.0, step: 0.1 }, { description: 'Size of the area that will be in focus' }),
+    center: param_definition_1.ParamDefinition.Select('camera-target', param_definition_1.ParamDefinition.arrayToOptions(['scene-center', 'camera-target'])),
+    mode: param_definition_1.ParamDefinition.Select('plane', param_definition_1.ParamDefinition.arrayToOptions(['plane', 'sphere'])),
+};
+class DofPass {
+    static isEnabled(props) {
+        return props.dof.name !== 'off';
+    }
+    constructor(webgl, width, height) {
+        this.webgl = webgl;
+        this.target = webgl.createRenderTarget(width, height, false);
+        const nullTexture = (0, texture_1.createNullTexture)();
+        this.renderable = getDofRenderable(webgl, nullTexture, nullTexture, nullTexture);
+    }
+    updateState(viewport) {
+        const { gl, state } = this.webgl;
+        state.enable(gl.SCISSOR_TEST);
+        state.disable(gl.BLEND);
+        state.disable(gl.DEPTH_TEST);
+        state.depthMask(false);
+        const { x, y, width, height } = viewport;
+        state.viewport(x, y, width, height);
+        state.scissor(x, y, width, height);
+        state.clearColor(0, 0, 0, 1);
+        gl.clear(gl.COLOR_BUFFER_BIT);
+    }
+    setSize(width, height) {
+        const w = this.target.texture.getWidth();
+        const h = this.target.texture.getHeight();
+        if (width !== w || height !== h) {
+            this.target.setSize(width, height);
+            mol_util_1.ValueCell.update(this.renderable.values.uTexSize, linear_algebra_1.Vec2.set(this.renderable.values.uTexSize.ref.value, width, height));
+        }
+    }
+    update(camera, input, depthOpaque, depthTransparent, props, sphere) {
+        let needsUpdate = false;
+        if (this.renderable.values.tColor.ref.value !== input) {
+            mol_util_1.ValueCell.update(this.renderable.values.tColor, input);
+            needsUpdate = true;
+        }
+        if (this.renderable.values.tDepthOpaque.ref.value !== depthOpaque) {
+            mol_util_1.ValueCell.update(this.renderable.values.tDepthOpaque, depthOpaque);
+            needsUpdate = true;
+        }
+        if (this.renderable.values.tDepthTransparent.ref.value !== depthTransparent) {
+            mol_util_1.ValueCell.update(this.renderable.values.tDepthTransparent, depthTransparent);
+            needsUpdate = true;
+        }
+        const orthographic = camera.state.mode === 'orthographic' ? 1 : 0;
+        const invProjection = this.renderable.values.uInvProjection.ref.value;
+        linear_algebra_1.Mat4.invert(invProjection, camera.projection);
+        const [w, h] = this.renderable.values.uTexSize.ref.value;
+        const v = camera.viewport;
+        mol_util_1.ValueCell.update(this.renderable.values.uProjection, camera.projection);
+        mol_util_1.ValueCell.update(this.renderable.values.uInvProjection, invProjection);
+        mol_util_1.ValueCell.update(this.renderable.values.uMode, props.mode === 'sphere' ? 1 : 0);
+        linear_algebra_1.Vec4.set(this.renderable.values.uBounds.ref.value, v.x / w, v.y / h, (v.x + v.width) / w, (v.y + v.height) / h);
+        mol_util_1.ValueCell.update(this.renderable.values.uBounds, this.renderable.values.uBounds.ref.value);
+        mol_util_1.ValueCell.updateIfChanged(this.renderable.values.uNear, camera.near);
+        mol_util_1.ValueCell.updateIfChanged(this.renderable.values.uFar, camera.far);
+        mol_util_1.ValueCell.updateIfChanged(this.renderable.values.dOrthographic, orthographic);
+        if (this.renderable.values.dBlurSize.ref.value !== props.blurSize) {
+            mol_util_1.ValueCell.update(this.renderable.values.dBlurSize, props.blurSize);
+            needsUpdate = true;
+        }
+        const wolrdCenter = (props.center === 'scene-center' ? sphere.center : camera.state.target);
+        const distance = linear_algebra_1.Vec3.distance(camera.state.position, wolrdCenter);
+        const inFocus = distance + props.inFocus;
+        mol_util_1.ValueCell.updateIfChanged(this.renderable.values.uInFocus, inFocus);
+        // transform center in view space
+        const center = this.renderable.values.uCenter.ref.value;
+        linear_algebra_1.Vec3.transformMat4(center, wolrdCenter, camera.view);
+        mol_util_1.ValueCell.update(this.renderable.values.uCenter, center);
+        mol_util_1.ValueCell.updateIfChanged(this.renderable.values.uBlurSpread, props.blurSpread);
+        mol_util_1.ValueCell.updateIfChanged(this.renderable.values.uPPM, props.PPM);
+        if (needsUpdate) {
+            this.renderable.update();
+        }
+    }
+    render(viewport, target) {
+        if (debug_1.isTimingMode)
+            this.webgl.timer.mark('DofPass.render');
+        if (target) {
+            target.bind();
+        }
+        else {
+            this.webgl.unbindFramebuffer();
+        }
+        this.updateState(viewport);
+        this.renderable.render();
+        if (debug_1.isTimingMode)
+            this.webgl.timer.markEnd('DofPass.render');
+    }
+}
+exports.DofPass = DofPass;
+//
+const DofSchema = {
+    ...util_1.QuadSchema,
+    tDepthOpaque: (0, schema_1.TextureSpec)('texture', 'rgba', 'ubyte', 'nearest'),
+    tDepthTransparent: (0, schema_1.TextureSpec)('texture', 'rgba', 'ubyte', 'nearest'),
+    tColor: (0, schema_1.TextureSpec)('texture', 'rgba', 'ubyte', 'nearest'),
+    uTexSize: (0, schema_1.UniformSpec)('v2'),
+    uProjection: (0, schema_1.UniformSpec)('m4'),
+    uInvProjection: (0, schema_1.UniformSpec)('m4'),
+    uBounds: (0, schema_1.UniformSpec)('v4'),
+    uCenter: (0, schema_1.UniformSpec)('v3'),
+    uMode: (0, schema_1.UniformSpec)('i'),
+    dOrthographic: (0, schema_1.DefineSpec)('number'),
+    uNear: (0, schema_1.UniformSpec)('f'),
+    uFar: (0, schema_1.UniformSpec)('f'),
+    dBlurSize: (0, schema_1.DefineSpec)('number'),
+    uBlurSpread: (0, schema_1.UniformSpec)('f'),
+    uInFocus: (0, schema_1.UniformSpec)('f'),
+    uPPM: (0, schema_1.UniformSpec)('f'),
+};
+const DofShaderCode = (0, shader_code_1.ShaderCode)('dof', quad_vert_1.quad_vert, dof_frag_1.dof_frag);
+function getDofRenderable(ctx, colorTexture, depthTextureOpaque, depthTextureTransparent) {
+    const width = colorTexture.getWidth();
+    const height = colorTexture.getHeight();
+    const values = {
+        ...util_1.QuadValues,
+        tDepthOpaque: mol_util_1.ValueCell.create(depthTextureOpaque),
+        tDepthTransparent: mol_util_1.ValueCell.create(depthTextureTransparent),
+        tColor: mol_util_1.ValueCell.create(colorTexture),
+        uTexSize: mol_util_1.ValueCell.create(linear_algebra_1.Vec2.create(width, height)),
+        uProjection: mol_util_1.ValueCell.create(linear_algebra_1.Mat4.identity()),
+        uInvProjection: mol_util_1.ValueCell.create(linear_algebra_1.Mat4.identity()),
+        uBounds: mol_util_1.ValueCell.create((0, linear_algebra_1.Vec4)()),
+        uCenter: mol_util_1.ValueCell.create((0, linear_algebra_1.Vec3)()),
+        uMode: mol_util_1.ValueCell.create(0),
+        dOrthographic: mol_util_1.ValueCell.create(0),
+        uNear: mol_util_1.ValueCell.create(1),
+        uFar: mol_util_1.ValueCell.create(10000),
+        dBlurSize: mol_util_1.ValueCell.create(5),
+        uBlurSpread: mol_util_1.ValueCell.create(300.0),
+        uInFocus: mol_util_1.ValueCell.create(20.0),
+        uPPM: mol_util_1.ValueCell.create(20.0),
+    };
+    const schema = { ...DofSchema };
+    const renderItem = (0, render_item_1.createComputeRenderItem)(ctx, 'triangles', DofShaderCode, schema, values);
+    return (0, renderable_1.createComputeRenderable)(renderItem, values);
+}