molstar 3.0.0-dev.6 → 3.0.0

package/lib/commonjs/mol-theme/color.d.ts

@@ -128,6 +128,127 @@ declare namespace ColorTheme {
             }>, "operator-name">>;
             saturation: PD.Numeric;
             lightness: PD.Numeric;
+            colors: PD.Mapped<PD.NamedParams<PD.Normalize<unknown>, "default"> | PD.NamedParams<PD.Normalize<{
+                H: Color;
+                D: Color;
+                T: Color;
+                HE: Color;
+                LI: Color;
+                BE: Color;
+                B: Color;
+                C: Color;
+                N: Color;
+                O: Color;
+                F: Color;
+                NE: Color;
+                NA: Color;
+                MG: Color;
+                AL: Color;
+                SI: Color;
+                P: Color;
+                S: Color;
+                CL: Color;
+                AR: Color;
+                K: Color;
+                CA: Color;
+                SC: Color;
+                TI: Color;
+                V: Color;
+                CR: Color;
+                MN: Color;
+                FE: Color;
+                CO: Color;
+                NI: Color;
+                CU: Color;
+                ZN: Color;
+                GA: Color;
+                GE: Color;
+                AS: Color;
+                SE: Color;
+                BR: Color;
+                KR: Color;
+                RB: Color;
+                SR: Color;
+                Y: Color;
+                ZR: Color;
+                NB: Color;
+                MO: Color;
+                TC: Color;
+                RU: Color;
+                RH: Color;
+                PD: Color;
+                AG: Color;
+                CD: Color;
+                IN: Color;
+                SN: Color;
+                SB: Color;
+                TE: Color;
+                I: Color;
+                XE: Color;
+                CS: Color;
+                BA: Color;
+                LA: Color;
+                CE: Color;
+                PR: Color;
+                ND: Color;
+                PM: Color;
+                SM: Color;
+                EU: Color;
+                GD: Color;
+                TB: Color;
+                DY: Color;
+                HO: Color;
+                ER: Color;
+                TM: Color;
+                YB: Color;
+                LU: Color;
+                HF: Color;
+                TA: Color;
+                W: Color;
+                RE: Color;
+                OS: Color;
+                IR: Color;
+                PT: Color;
+                AU: Color;
+                HG: Color;
+                TL: Color;
+                PB: Color;
+                BI: Color;
+                PO: Color;
+                AT: Color;
+                RN: Color;
+                FR: Color;
+                RA: Color;
+                AC: Color;
+                TH: Color;
+                PA: Color;
+                U: Color;
+                NP: Color;
+                PU: Color;
+                AM: Color;
+                CM: Color;
+                BK: Color;
+                CF: Color;
+                ES: Color;
+                FM: Color;
+                MD: Color;
+                NO: Color;
+                LR: Color;
+                RF: Color;
+                DB: Color;
+                SG: Color;
+                BH: Color;
+                HS: Color;
+                MT: Color;
+                DS: Color;
+                RG: Color;
+                CN: Color;
+                UUT: Color;
+                FL: Color;
+                UUP: Color;
+                LV: Color;
+                UUH: Color;
+            }>, "custom">>;
         }, "element-symbol">;
         'entity-id': Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
@@ -164,21 +285,56 @@ declare namespace ColorTheme {
             scale: PD.Select<"DGwif" | "DGwoct" | "Oct-IF">;
         }, "hydrophobicity">;
         illustrative: Provider<{
+            style: PD.Mapped<PD.NamedParams<PD.Normalize<{
+                value: Color;
+            }>, "uniform"> | PD.NamedParams<PD.Normalize<{
+                palette: PD.NamedParams<PD.Normalize<{
+                    maxCount: any;
+                    hue: any;
+                    chroma: any;
+                    luminance: any;
+                    clusteringStepCount: any;
+                    minSampleCount: any;
+                }>, "generate"> | PD.NamedParams<PD.Normalize<{
+                    list: any;
+                }>, "colors">;
+                asymId: "label" | "auth";
+            }>, "chain-id"> | PD.NamedParams<PD.Normalize<{
+                saturation: number;
+                lightness: number;
+                colors: PD.NamedParams<PD.Normalize<unknown>, "default"> | PD.NamedParams<PD.Normalize<{
+                    water: any;
+                    ion: any;
+                    protein: any;
+                    RNA: any;
+                    DNA: any;
+                    PNA: any;
+                    saccharide: any;
+                }>, "custom">;
+            }>, "molecule-type"> | PD.NamedParams<PD.Normalize<{
+                palette: PD.NamedParams<PD.Normalize<{
+                    maxCount: any;
+                    hue: any;
+                    chroma: any;
+                    luminance: any;
+                    clusteringStepCount: any;
+                    minSampleCount: any;
+                }>, "generate"> | PD.NamedParams<PD.Normalize<{
+                    list: any;
+                }>, "colors">;
+            }>, "entity-source"> | PD.NamedParams<PD.Normalize<{
+                palette: PD.NamedParams<PD.Normalize<{
+                    maxCount: any;
+                    hue: any;
+                    chroma: any;
+                    luminance: any;
+                    clusteringStepCount: any;
+                    minSampleCount: any;
+                }>, "generate"> | PD.NamedParams<PD.Normalize<{
+                    list: any;
+                }>, "colors">;
+            }>, "entity-id">>;
             carbonLightness: PD.Numeric;
-            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-                maxCount: number;
-                hue: [number, number];
-                chroma: [number, number];
-                luminance: [number, number];
-                clusteringStepCount: number;
-                minSampleCount: number;
-            }>, "generate"> | PD.NamedParams<PD.Normalize<{
-                list: {
-                    kind: "set" | "interpolate";
-                    colors: import("../mol-util/color/color").ColorListEntry[];
-                };
-            }>, "colors">>;
-            asymId: PD.Select<"label" | "auth">;
         }, "illustrative">;
         'model-index': Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
@@ -198,6 +354,15 @@ declare namespace ColorTheme {
         'molecule-type': Provider<{
             saturation: PD.Numeric;
             lightness: PD.Numeric;
+            colors: PD.Mapped<PD.NamedParams<PD.Normalize<unknown>, "default"> | PD.NamedParams<PD.Normalize<{
+                water: Color;
+                ion: Color;
+                protein: Color;
+                RNA: Color;
+                DNA: Color;
+                PNA: Color;
+                saccharide: Color;
+            }>, "custom">>;
         }, "molecule-type">;
         occupancy: Provider<{
             domain: PD.Interval;
@@ -270,10 +435,61 @@ declare namespace ColorTheme {
         'residue-name': Provider<{
             saturation: PD.Numeric;
             lightness: PD.Numeric;
+            colors: PD.Mapped<PD.NamedParams<PD.Normalize<unknown>, "default"> | PD.NamedParams<PD.Normalize<{
+                ALA: Color;
+                ARG: Color;
+                ASN: Color;
+                ASP: Color;
+                CYS: Color;
+                GLN: Color;
+                GLU: Color;
+                GLY: Color;
+                HIS: Color;
+                ILE: Color;
+                LEU: Color;
+                LYS: Color;
+                MET: Color;
+                PHE: Color;
+                PRO: Color;
+                SER: Color;
+                THR: Color;
+                TRP: Color;
+                TYR: Color;
+                VAL: Color;
+                A: Color;
+                G: Color;
+                I: Color;
+                C: Color;
+                T: Color;
+                U: Color;
+                DA: Color;
+                DG: Color;
+                DI: Color;
+                DC: Color;
+                DT: Color;
+                DU: Color;
+                APN: Color;
+                GPN: Color;
+                CPN: Color;
+                TPN: Color;
+            }>, "custom">>;
         }, "residue-name">;
         'secondary-structure': Provider<{
             saturation: PD.Numeric;
             lightness: PD.Numeric;
+            colors: PD.Mapped<PD.NamedParams<PD.Normalize<unknown>, "default"> | PD.NamedParams<PD.Normalize<{
+                alphaHelix: Color;
+                threeTenHelix: Color;
+                piHelix: Color;
+                betaTurn: Color;
+                betaStrand: Color;
+                coil: Color;
+                bend: Color;
+                turn: Color;
+                dna: Color;
+                rna: Color;
+                carbohydrate: Color;
+            }>, "custom">>;
         }, "secondary-structure">;
         'sequence-id': Provider<{
             list: PD.ColorList;
@@ -301,6 +517,9 @@ declare namespace ColorTheme {
         uniform: Provider<{
             value: PD.Color;
         }, "uniform">;
+        'volume-value': Provider<{
+            colorList: PD.ColorList;
+        }, "volume-value">;
     };
     type _BuiltIn = typeof BuiltIn;
     export type BuiltIn = keyof _BuiltIn;

package/lib/commonjs/mol-theme/color.js

@@ -33,6 +33,7 @@ var operator_hkl_1 = require("./color/operator-hkl");
 var partial_charge_1 = require("./color/partial-charge");
 var atom_id_1 = require("./color/atom-id");
 var entity_id_1 = require("./color/entity-id");
+var volume_value_1 = require("./color/volume-value");
 var ColorTheme;
 (function (ColorTheme) {
     ColorTheme.PaletteScale = (1 << 24) - 1;
@@ -78,6 +79,7 @@ var ColorTheme;
         'uncertainty': uncertainty_1.UncertaintyColorThemeProvider,
         'unit-index': unit_index_1.UnitIndexColorThemeProvider,
         'uniform': uniform_1.UniformColorThemeProvider,
+        'volume-value': volume_value_1.VolumeValueColorThemeProvider,
     };
 })(ColorTheme || (ColorTheme = {}));
 exports.ColorTheme = ColorTheme;

package/lib/commonjs/mol-util/clip.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { Vec3 } from '../mol-math/linear-algebra';
+import { ParamDefinition as PD } from './param-definition';
+export interface Clip {
+    variant: Clip.Variant;
+    objects: Clip.Objects;
+}
+export declare function Clip(): void;
+export declare namespace Clip {
+    /** Clip object types */
+    const Type: {
+        none: number;
+        plane: number;
+        sphere: number;
+        cube: number;
+        cylinder: number;
+        infiniteCone: number;
+    };
+    type Variant = 'instance' | 'pixel';
+    type Objects = {
+        count: number;
+        type: number[];
+        invert: boolean[];
+        position: number[];
+        rotation: number[];
+        scale: number[];
+    };
+    const Params: {
+        variant: PD.Select<Variant>;
+        objects: PD.ObjectList<PD.Normalize<{
+            type: "none" | "sphere" | "cube" | "plane" | "cylinder" | "infiniteCone";
+            invert: boolean;
+            position: Vec3;
+            rotation: PD.Normalize<{
+                axis: any;
+                angle: any;
+            }>;
+            scale: Vec3;
+        }>>;
+    };
+    type Params = typeof Params;
+    type Props = PD.Values<Params>;
+    function getClip(props: Props, clip?: Clip): Clip;
+    function areEqual(cA: Clip, cB: Clip): boolean;
+}

package/lib/commonjs/mol-util/clip.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Clip = void 0;
+var linear_algebra_1 = require("../mol-math/linear-algebra");
+var misc_1 = require("../mol-math/misc");
+var param_definition_1 = require("./param-definition");
+var string_1 = require("./string");
+function Clip() {
+}
+exports.Clip = Clip;
+(function (Clip) {
+    /** Clip object types */
+    Clip.Type = {
+        none: 0,
+        plane: 1,
+        sphere: 2,
+        cube: 3,
+        cylinder: 4,
+        infiniteCone: 5,
+    };
+    Clip.Params = {
+        variant: param_definition_1.ParamDefinition.Select('pixel', param_definition_1.ParamDefinition.arrayToOptions(['instance', 'pixel'])),
+        objects: param_definition_1.ParamDefinition.ObjectList({
+            type: param_definition_1.ParamDefinition.Select('plane', param_definition_1.ParamDefinition.objectToOptions(Clip.Type, function (t) { return (0, string_1.stringToWords)(t); })),
+            invert: param_definition_1.ParamDefinition.Boolean(false),
+            position: param_definition_1.ParamDefinition.Vec3((0, linear_algebra_1.Vec3)()),
+            rotation: param_definition_1.ParamDefinition.Group({
+                axis: param_definition_1.ParamDefinition.Vec3(linear_algebra_1.Vec3.create(1, 0, 0)),
+                angle: param_definition_1.ParamDefinition.Numeric(0, { min: -180, max: 180, step: 1 }, { description: 'Angle in Degrees' }),
+            }, { isExpanded: true }),
+            scale: param_definition_1.ParamDefinition.Vec3(linear_algebra_1.Vec3.create(1, 1, 1)),
+        }, function (o) { return (0, string_1.stringToWords)(o.type); })
+    };
+    function createClipObjects() {
+        return {
+            count: 0,
+            type: (new Array(5)).fill(1),
+            invert: (new Array(5)).fill(false),
+            position: (new Array(5 * 3)).fill(0),
+            rotation: (new Array(5 * 4)).fill(0),
+            scale: (new Array(5 * 3)).fill(1),
+        };
+    }
+    var qA = (0, linear_algebra_1.Quat)();
+    var qB = (0, linear_algebra_1.Quat)();
+    var vA = (0, linear_algebra_1.Vec3)();
+    var vB = (0, linear_algebra_1.Vec3)();
+    function getClip(props, clip) {
+        var _a = (clip === null || clip === void 0 ? void 0 : clip.objects) || createClipObjects(), type = _a.type, invert = _a.invert, position = _a.position, rotation = _a.rotation, scale = _a.scale;
+        for (var i = 0, il = props.objects.length; i < il; ++i) {
+            var p = props.objects[i];
+            type[i] = Clip.Type[p.type];
+            invert[i] = p.invert;
+            linear_algebra_1.Vec3.toArray(p.position, position, i * 3);
+            linear_algebra_1.Quat.toArray(linear_algebra_1.Quat.setAxisAngle(qA, p.rotation.axis, (0, misc_1.degToRad)(p.rotation.angle)), rotation, i * 4);
+            linear_algebra_1.Vec3.toArray(p.scale, scale, i * 3);
+        }
+        return {
+            variant: props.variant,
+            objects: { count: props.objects.length, type: type, invert: invert, position: position, rotation: rotation, scale: scale }
+        };
+    }
+    Clip.getClip = getClip;
+    function areEqual(cA, cB) {
+        if (cA.variant !== cB.variant)
+            return false;
+        if (cA.objects.count !== cB.objects.count)
+            return false;
+        var oA = cA.objects, oB = cB.objects;
+        for (var i = 0, il = oA.count; i < il; ++i) {
+            if (oA.invert[i] !== oB.invert[i])
+                return false;
+            if (oA.type[i] !== oB.type[i])
+                return false;
+            linear_algebra_1.Vec3.fromArray(vA, oA.position, i * 3);
+            linear_algebra_1.Vec3.fromArray(vB, oB.position, i * 3);
+            if (!linear_algebra_1.Vec3.equals(vA, vB))
+                return false;
+            linear_algebra_1.Vec3.fromArray(vA, oA.scale, i * 3);
+            linear_algebra_1.Vec3.fromArray(vB, oB.scale, i * 3);
+            if (!linear_algebra_1.Vec3.equals(vA, vB))
+                return false;
+            linear_algebra_1.Quat.fromArray(qA, oA.rotation, i * 4);
+            linear_algebra_1.Quat.fromArray(qB, oB.rotation, i * 4);
+            if (!linear_algebra_1.Quat.equals(qA, qB))
+                return false;
+        }
+        return true;
+    }
+    Clip.areEqual = areEqual;
+})(Clip = exports.Clip || (exports.Clip = {}));
+//# sourceMappingURL=clip.js.map

package/lib/commonjs/mol-util/color/color.d.ts

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

package/lib/commonjs/mol-util/color/color.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */

package/lib/commonjs/mol-util/color/params.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { ParamDefinition as PD } from '../../mol-util/param-definition';
+import { ColorMap } from './color';
+export declare function getColorMapParams<T extends {
+    [k: string]: number;
+}>(map: ColorMap<T>): { [k in keyof T]: PD.Color; };

package/lib/commonjs/mol-util/color/params.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getColorMapParams = void 0;
+var param_definition_1 = require("../../mol-util/param-definition");
+var object_1 = require("../object");
+function getColorMapParams(map) {
+    var colors = {};
+    (0, object_1.objectForEach)(map, function (_, k) {
+        colors[k] = param_definition_1.ParamDefinition.Color(map[k]);
+    });
+    return colors;
+}
+exports.getColorMapParams = getColorMapParams;
+//# sourceMappingURL=params.js.map

package/lib/commonjs/mol-util/number-packing.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) 2019-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { NumberArray } from './type-helpers';
+/** encode positive integer as rgb byte triplet into array at offset */
+export declare function packIntToRGBArray(value: number, array: NumberArray, offset: number): NumberArray;
+/** decode positive integer encoded as rgb byte triplet */
+export declare function unpackRGBToInt(r: number, g: number, b: number): number;
+export declare function unpackRGBAToDepth(r: number, g: number, b: number, a: number): number;

package/lib/commonjs/mol-util/{float-packing.js → number-packing.js}

@@ -1,25 +1,16 @@
 "use strict";
 /**
- * Copyright (c) 2019-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2019-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unpackRGBAToDepth = exports.decodeFloatRGB = exports.encodeFloatRGBtoArray = exports.decodeFloatLog = exports.encodeFloatLog = void 0;
+exports.unpackRGBAToDepth = exports.unpackRGBToInt = exports.packIntToRGBArray = void 0;
 var interpolate_1 = require("../mol-math/interpolate");
-var approx_1 = require("../mol-math/approx");
 var linear_algebra_1 = require("../mol-math/linear-algebra");
-var maxFloat = 10000.0; // NOTE same constant is set in shaders
-var floatLogFactor = (0, approx_1.fasterLog)(maxFloat + 1);
-/** encode float logarithmically */
-function encodeFloatLog(value) { return (0, approx_1.fasterLog)(value + 1) / floatLogFactor; }
-exports.encodeFloatLog = encodeFloatLog;
-/** decode logarithmically encoded float */
-function decodeFloatLog(value) { return (0, approx_1.fasterExp)(value * floatLogFactor) - 1; }
-exports.decodeFloatLog = decodeFloatLog;
-/** encode float as rgb triplet into array at offset */
-function encodeFloatRGBtoArray(value, array, offset) {
-    value = (0, interpolate_1.clamp)(value, 0, 16777216 - 1) + 1;
+/** encode positive integer as rgb byte triplet into array at offset */
+function packIntToRGBArray(value, array, offset) {
+    value = (0, interpolate_1.clamp)(Math.round(value), 0, 16777216 - 1) + 1;
     array[offset + 2] = value % 256;
     value = Math.floor(value / 256);
     array[offset + 1] = value % 256;
@@ -27,12 +18,12 @@ function encodeFloatRGBtoArray(value, array, offset) {
     array[offset] = value % 256;
     return array;
 }
-exports.encodeFloatRGBtoArray = encodeFloatRGBtoArray;
-/** decode float encoded as rgb triplet */
-function decodeFloatRGB(r, g, b) {
+exports.packIntToRGBArray = packIntToRGBArray;
+/** decode positive integer encoded as rgb byte triplet */
+function unpackRGBToInt(r, g, b) {
     return (Math.floor(r) * 256 * 256 + Math.floor(g) * 256 + Math.floor(b)) - 1;
 }
-exports.decodeFloatRGB = decodeFloatRGB;
+exports.unpackRGBToInt = unpackRGBToInt;
 var UnpackDownscale = 255 / 256; // 0..1 -> fraction (excluding 1)
 var PackFactors = linear_algebra_1.Vec3.create(256 * 256 * 256, 256 * 256, 256);
 var UnpackFactors = linear_algebra_1.Vec4.create(UnpackDownscale / PackFactors[0], UnpackDownscale / PackFactors[1], UnpackDownscale / PackFactors[2], UnpackDownscale / 1);
@@ -42,4 +33,4 @@ function unpackRGBAToDepth(r, g, b, a) {
     return linear_algebra_1.Vec4.dot(tmpDepthRGBA, UnpackFactors);
 }
 exports.unpackRGBAToDepth = unpackRGBAToDepth;
-//# sourceMappingURL=float-packing.js.map
+//# sourceMappingURL=number-packing.js.map

package/lib/examples/alpha-orbitals/index.js

@@ -21,7 +21,7 @@ require('mol-plugin-ui/skin/light.scss');
 var AlphaOrbitalsExample = /** @class */ (function () {
     function AlphaOrbitalsExample() {
         this.params = new BehaviorSubject({});
-        this.state = new BehaviorSubject({ show: { name: 'orbital', params: { index: 32 } }, isoValue: 1, gpuSurface: false });
+        this.state = new BehaviorSubject({ show: { name: 'orbital', params: { index: 32 } }, isoValue: 1, gpuSurface: true });
         this.selectors = void 0;
         this.basis = void 0;
         this.currentParams = __assign({}, this.state.value);

package/lib/examples/basic-wrapper/index.js

@@ -242,13 +242,17 @@ var BasicWrapper = /** @class */ (function () {
     BasicWrapper.prototype.toggleSpin = function () {
         if (!this.plugin.canvas3d)
             return;
+        var trackball = this.plugin.canvas3d.props.trackball;
         PluginCommands.Canvas3D.SetSettings(this.plugin, {
-            settings: function (props) {
-                props.trackball.spin = !props.trackball.spin;
+            settings: {
+                trackball: __assign(__assign({}, trackball), { animate: trackball.animate.name === 'spin'
+                        ? { name: 'off', params: {} }
+                        : { name: 'spin', params: { speed: 1 } } })
             }
         });
-        if (!this.plugin.canvas3d.props.trackball.spin)
+        if (this.plugin.canvas3d.props.trackball.animate.name !== 'spin') {
             PluginCommands.Camera.Reset(this.plugin, {});
+        }
     };
     BasicWrapper.prototype.animateModelIndexTargetFps = function () {
         return Math.max(1, this.animate.modelIndex.targetFps | 0);

package/lib/examples/proteopedia-wrapper/index.js

@@ -477,7 +477,13 @@ var MolStarProteopediaWrapper = /** @class */ (function () {
         if (!this.plugin.canvas3d)
             return;
         var trackball = this.plugin.canvas3d.props.trackball;
-        PluginCommands.Canvas3D.SetSettings(this.plugin, { settings: { trackball: __assign(__assign({}, trackball), { spin: !trackball.spin }) } });
+        PluginCommands.Canvas3D.SetSettings(this.plugin, {
+            settings: {
+                trackball: __assign(__assign({}, trackball), { animate: trackball.animate.name === 'spin'
+                        ? { name: 'off', params: {} }
+                        : { name: 'spin', params: { speed: 1 } } })
+            }
+        });
     };
     MolStarProteopediaWrapper.prototype.animateModelIndexTargetFps = function () {
         return Math.max(1, this.animate.modelIndex.targetFps | 0);

package/lib/extensions/anvil/behavior.d.ts

@@ -32,6 +32,10 @@ declare const MembraneOrientation3D: StateTransformer<PluginStateObject.Molecule
         roughness: number;
         bumpiness: number;
     }>;
+    clip: PD.Normalize<{
+        variant: any;
+        objects: any;
+    }>;
     sectorOpacity: number;
     doubleSided: boolean;
     flipSided: boolean;