molstar 3.0.0-dev.2 → 3.0.0-dev.6

package/lib/extensions/model-archive/quality-assessment/color/plddt.js

@@ -0,0 +1,120 @@
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Mandar Deshpande <mandar@ebi.ac.uk>
+ * @author Sebastian Bittrich <sebastian.bittrich@rcsb.org>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { __awaiter, __generator } from "tslib";
+import { QualityAssessment, QualityAssessmentProvider } from '../prop';
+import { Bond, StructureElement, Unit } from '../../../../mol-model/structure';
+import { Color } from '../../../../mol-util/color';
+import { ParamDefinition as PD } from '../../../../mol-util/param-definition';
+import { TableLegend } from '../../../../mol-util/legend';
+var DefaultColor = Color(0xaaaaaa);
+var ConfidenceColors = {
+    'No Score': DefaultColor,
+    'Very Low': Color(0xff7d45),
+    'Low': Color(0xffdb13),
+    'Confident': Color(0x65cbf3),
+    'Very High': Color(0x0053d6)
+};
+var ConfidenceColorLegend = TableLegend(Object.entries(ConfidenceColors));
+export function getPLDDTConfidenceColorThemeParams(ctx) {
+    return {};
+}
+export function PLDDTConfidenceColorTheme(ctx, props) {
+    var color = function () { return DefaultColor; };
+    if (ctx.structure) {
+        var l_1 = StructureElement.Location.create(ctx.structure.root);
+        var getColor_1 = function (location) {
+            var _a, _b;
+            var unit = location.unit, element = location.element;
+            if (!Unit.isAtomic(unit))
+                return DefaultColor;
+            var qualityAssessment = QualityAssessmentProvider.get(unit.model).value;
+            var score = (_b = (_a = qualityAssessment === null || qualityAssessment === void 0 ? void 0 : qualityAssessment.pLDDT) === null || _a === void 0 ? void 0 : _a.get(unit.model.atomicHierarchy.residueAtomSegments.index[element])) !== null && _b !== void 0 ? _b : -1;
+            if (score < 0) {
+                return DefaultColor;
+            }
+            else if (score <= 50) {
+                return Color(0xff7d45);
+            }
+            else if (score <= 70) {
+                return Color(0xffdb13);
+            }
+            else if (score <= 90) {
+                return Color(0x65cbf3);
+            }
+            else {
+                return Color(0x0053d6);
+            }
+        };
+        color = function (location) {
+            if (StructureElement.Location.is(location)) {
+                return getColor_1(location);
+            }
+            else if (Bond.isLocation(location)) {
+                l_1.unit = location.aUnit;
+                l_1.element = location.aUnit.elements[location.aIndex];
+                return getColor_1(l_1);
+            }
+            return DefaultColor;
+        };
+    }
+    return {
+        factory: PLDDTConfidenceColorTheme,
+        granularity: 'group',
+        preferSmoothing: true,
+        color: color,
+        props: props,
+        description: 'Assigns residue colors according to the pLDDT Confidence score.',
+        legend: ConfidenceColorLegend
+    };
+}
+export var PLDDTConfidenceColorThemeProvider = {
+    name: 'plddt-confidence',
+    label: 'pLDDT Confidence',
+    category: "Validation" /* Validation */,
+    factory: PLDDTConfidenceColorTheme,
+    getParams: getPLDDTConfidenceColorThemeParams,
+    defaultValues: PD.getDefaultValues(getPLDDTConfidenceColorThemeParams({})),
+    isApplicable: function (ctx) { var _a; return !!((_a = ctx.structure) === null || _a === void 0 ? void 0 : _a.models.some(function (m) { return QualityAssessment.isApplicable(m, 'pLDDT'); })); },
+    ensureCustomProperties: {
+        attach: function (ctx, data) { return __awaiter(void 0, void 0, void 0, function () {
+            var _i, _a, m;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!data.structure) return [3 /*break*/, 4];
+                        _i = 0, _a = data.structure.models;
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 4];
+                        m = _a[_i];
+                        return [4 /*yield*/, QualityAssessmentProvider.attach(ctx, m, void 0, true)];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); },
+        detach: function (data) { return __awaiter(void 0, void 0, void 0, function () {
+            var _i, _a, m;
+            return __generator(this, function (_b) {
+                if (data.structure) {
+                    for (_i = 0, _a = data.structure.models; _i < _a.length; _i++) {
+                        m = _a[_i];
+                        QualityAssessmentProvider.ref(m, false);
+                    }
+                }
+                return [2 /*return*/];
+            });
+        }); }
+    }
+};
+//# sourceMappingURL=plddt.js.map

package/lib/extensions/model-archive/quality-assessment/color/qmean.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { ColorTheme } from '../../../../mol-theme/color';
+import { ThemeDataContext } from '../../../../mol-theme/theme';
+import { ParamDefinition as PD } from '../../../../mol-util/param-definition';
+export declare function getQmeanScoreColorThemeParams(ctx: ThemeDataContext): {};
+export declare type QmeanScoreColorThemeParams = ReturnType<typeof getQmeanScoreColorThemeParams>;
+export declare function QmeanScoreColorTheme(ctx: ThemeDataContext, props: PD.Values<QmeanScoreColorThemeParams>): ColorTheme<QmeanScoreColorThemeParams>;
+export declare const QmeanScoreColorThemeProvider: ColorTheme.Provider<QmeanScoreColorThemeParams, 'qmean-score'>;

package/lib/extensions/model-archive/quality-assessment/color/qmean.js

@@ -0,0 +1,106 @@
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { __awaiter, __generator } from "tslib";
+import { QualityAssessment, QualityAssessmentProvider } from '../prop';
+import { Bond, StructureElement, Unit } from '../../../../mol-model/structure';
+import { Color, ColorScale } from '../../../../mol-util/color';
+import { ParamDefinition as PD } from '../../../../mol-util/param-definition';
+var DefaultColor = Color(0xaaaaaa);
+export function getQmeanScoreColorThemeParams(ctx) {
+    return {};
+}
+export function QmeanScoreColorTheme(ctx, props) {
+    var color = function () { return DefaultColor; };
+    var scale = ColorScale.create({
+        domain: [0, 1],
+        listOrName: [
+            [Color(0xFF5000), 0.5], [Color(0x025AFD), 1.0]
+        ]
+    });
+    if (ctx.structure) {
+        var l_1 = StructureElement.Location.create(ctx.structure.root);
+        var getColor_1 = function (location) {
+            var _a, _b;
+            var unit = location.unit, element = location.element;
+            if (!Unit.isAtomic(unit))
+                return DefaultColor;
+            var qualityAssessment = QualityAssessmentProvider.get(unit.model).value;
+            var score = (_b = (_a = qualityAssessment === null || qualityAssessment === void 0 ? void 0 : qualityAssessment.qmean) === null || _a === void 0 ? void 0 : _a.get(unit.model.atomicHierarchy.residueAtomSegments.index[element])) !== null && _b !== void 0 ? _b : -1;
+            if (score < 0) {
+                return DefaultColor;
+            }
+            else {
+                return scale.color(score);
+            }
+        };
+        color = function (location) {
+            if (StructureElement.Location.is(location)) {
+                return getColor_1(location);
+            }
+            else if (Bond.isLocation(location)) {
+                l_1.unit = location.aUnit;
+                l_1.element = location.aUnit.elements[location.aIndex];
+                return getColor_1(l_1);
+            }
+            return DefaultColor;
+        };
+    }
+    return {
+        factory: QmeanScoreColorTheme,
+        granularity: 'group',
+        preferSmoothing: true,
+        color: color,
+        props: props,
+        description: 'Assigns residue colors according to the QMEAN score.',
+        legend: scale.legend
+    };
+}
+export var QmeanScoreColorThemeProvider = {
+    name: 'qmean-score',
+    label: 'QMEAN Score',
+    category: "Validation" /* Validation */,
+    factory: QmeanScoreColorTheme,
+    getParams: getQmeanScoreColorThemeParams,
+    defaultValues: PD.getDefaultValues(getQmeanScoreColorThemeParams({})),
+    isApplicable: function (ctx) { var _a; return !!((_a = ctx.structure) === null || _a === void 0 ? void 0 : _a.models.some(function (m) { return QualityAssessment.isApplicable(m, 'qmean'); })); },
+    ensureCustomProperties: {
+        attach: function (ctx, data) { return __awaiter(void 0, void 0, void 0, function () {
+            var _i, _a, m;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!data.structure) return [3 /*break*/, 4];
+                        _i = 0, _a = data.structure.models;
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 4];
+                        m = _a[_i];
+                        return [4 /*yield*/, QualityAssessmentProvider.attach(ctx, m, void 0, true)];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); },
+        detach: function (data) { return __awaiter(void 0, void 0, void 0, function () {
+            var _i, _a, m;
+            return __generator(this, function (_b) {
+                if (data.structure) {
+                    for (_i = 0, _a = data.structure.models; _i < _a.length; _i++) {
+                        m = _a[_i];
+                        QualityAssessmentProvider.ref(m, false);
+                    }
+                }
+                return [2 /*return*/];
+            });
+        }); }
+    }
+};
+//# sourceMappingURL=qmean.js.map

package/lib/extensions/model-archive/quality-assessment/prop.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) 2021 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 { CustomProperty } from '../../../mol-model-props/common/custom-property';
+import { CustomModelProperty } from '../../../mol-model-props/common/custom-model-property';
+import { Model, ResidueIndex } from '../../../mol-model/structure/model';
+import { QuerySymbolRuntime } from '../../../mol-script/runtime/query/compiler';
+export { QualityAssessment };
+interface QualityAssessment {
+    localMetrics: Map<string, Map<ResidueIndex, number>>;
+    pLDDT?: Map<ResidueIndex, number>;
+    qmean?: Map<ResidueIndex, number>;
+}
+declare namespace QualityAssessment {
+    function isApplicable(model?: Model, localMetricName?: 'pLDDT' | 'qmean'): boolean;
+    function obtain(ctx: CustomProperty.Context, model: Model, props: QualityAssessmentProps): Promise<CustomProperty.Data<QualityAssessment>>;
+    const symbols: {
+        pLDDT: QuerySymbolRuntime;
+        qmean: QuerySymbolRuntime;
+    };
+}
+export declare const QualityAssessmentParams: {};
+export declare type QualityAssessmentParams = typeof QualityAssessmentParams;
+export declare type QualityAssessmentProps = PD.Values<QualityAssessmentParams>;
+export declare const QualityAssessmentProvider: CustomModelProperty.Provider<QualityAssessmentParams, QualityAssessment>;

package/lib/extensions/model-archive/quality-assessment/prop.js

@@ -0,0 +1,127 @@
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { __assign, __awaiter, __generator } from "tslib";
+import { ParamDefinition as PD } from '../../../mol-util/param-definition';
+import { Unit } from '../../../mol-model/structure';
+import { CustomModelProperty } from '../../../mol-model-props/common/custom-model-property';
+import { QuerySymbolRuntime } from '../../../mol-script/runtime/query/compiler';
+import { CustomPropSymbol } from '../../../mol-script/language/symbol';
+import { Type } from '../../../mol-script/language/type';
+import { CustomPropertyDescriptor } from '../../../mol-model/custom-property';
+import { MmcifFormat } from '../../../mol-model-formats/structure/mmcif';
+export { QualityAssessment };
+var QualityAssessment;
+(function (QualityAssessment) {
+    var Empty = {
+        value: {
+            localMetrics: new Map()
+        }
+    };
+    function isApplicable(model, localMetricName) {
+        if (!model || !MmcifFormat.is(model.sourceData))
+            return false;
+        var db = model.sourceData.data.db;
+        var hasLocalMetric = (db.ma_qa_metric.id.isDefined &&
+            db.ma_qa_metric_local.ordinal_id.isDefined);
+        if (localMetricName && hasLocalMetric) {
+            for (var i = 0, il = db.ma_qa_metric._rowCount; i < il; i++) {
+                if (db.ma_qa_metric.mode.value(i) !== 'local')
+                    continue;
+                if (localMetricName === db.ma_qa_metric.name.value(i))
+                    return true;
+            }
+            return false;
+        }
+        else {
+            return hasLocalMetric;
+        }
+    }
+    QualityAssessment.isApplicable = isApplicable;
+    function obtain(ctx, model, props) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, ma_qa_metric, ma_qa_metric_local, model_id, label_asym_id, label_seq_id, metric_id, metric_value, index, localMetrics, localNames, i, il, name_1, i, il, labelAsymId, entityIndex, rI, name_2;
+            return __generator(this, function (_b) {
+                if (!model || !MmcifFormat.is(model.sourceData))
+                    return [2 /*return*/, Empty];
+                _a = model.sourceData.data.db, ma_qa_metric = _a.ma_qa_metric, ma_qa_metric_local = _a.ma_qa_metric_local;
+                model_id = ma_qa_metric_local.model_id, label_asym_id = ma_qa_metric_local.label_asym_id, label_seq_id = ma_qa_metric_local.label_seq_id, metric_id = ma_qa_metric_local.metric_id, metric_value = ma_qa_metric_local.metric_value;
+                index = model.atomicHierarchy.index;
+                localMetrics = new Map();
+                localNames = new Map();
+                for (i = 0, il = ma_qa_metric._rowCount; i < il; i++) {
+                    if (ma_qa_metric.mode.value(i) !== 'local')
+                        continue;
+                    name_1 = ma_qa_metric.name.value(i);
+                    if (localMetrics.has(name_1)) {
+                        console.warn("local ma_qa_metric with name '".concat(name_1, "' already added"));
+                        continue;
+                    }
+                    localMetrics.set(name_1, new Map());
+                    localNames.set(ma_qa_metric.id.value(i), name_1);
+                }
+                for (i = 0, il = ma_qa_metric_local._rowCount; i < il; i++) {
+                    if (model_id.value(i) !== model.modelNum)
+                        continue;
+                    labelAsymId = label_asym_id.value(i);
+                    entityIndex = index.findEntity(labelAsymId);
+                    rI = index.findResidue(model.entities.data.id.value(entityIndex), labelAsymId, label_seq_id.value(i));
+                    name_2 = localNames.get(metric_id.value(i));
+                    localMetrics.get(name_2).set(rI, metric_value.value(i));
+                }
+                return [2 /*return*/, {
+                        value: {
+                            localMetrics: localMetrics,
+                            pLDDT: localMetrics.get('pLDDT'),
+                            qmean: localMetrics.get('qmean'),
+                        }
+                    }];
+            });
+        });
+    }
+    QualityAssessment.obtain = obtain;
+    QualityAssessment.symbols = {
+        pLDDT: QuerySymbolRuntime.Dynamic(CustomPropSymbol('ma', 'quality-assessment.pLDDT', Type.Num), function (ctx) {
+            var _a, _b;
+            var _c = ctx.element, unit = _c.unit, element = _c.element;
+            if (!Unit.isAtomic(unit))
+                return -1;
+            var qualityAssessment = QualityAssessmentProvider.get(unit.model).value;
+            return (_b = (_a = qualityAssessment === null || qualityAssessment === void 0 ? void 0 : qualityAssessment.pLDDT) === null || _a === void 0 ? void 0 : _a.get(unit.model.atomicHierarchy.residueAtomSegments.index[element])) !== null && _b !== void 0 ? _b : -1;
+        }),
+        qmean: QuerySymbolRuntime.Dynamic(CustomPropSymbol('ma', 'quality-assessment.qmean', Type.Num), function (ctx) {
+            var _a, _b;
+            var _c = ctx.element, unit = _c.unit, element = _c.element;
+            if (!Unit.isAtomic(unit))
+                return -1;
+            var qualityAssessment = QualityAssessmentProvider.get(unit.model).value;
+            return (_b = (_a = qualityAssessment === null || qualityAssessment === void 0 ? void 0 : qualityAssessment.qmean) === null || _a === void 0 ? void 0 : _a.get(unit.model.atomicHierarchy.residueAtomSegments.index[element])) !== null && _b !== void 0 ? _b : -1;
+        }),
+    };
+})(QualityAssessment || (QualityAssessment = {}));
+export var QualityAssessmentParams = {};
+export var QualityAssessmentProvider = CustomModelProperty.createProvider({
+    label: 'QualityAssessment',
+    descriptor: CustomPropertyDescriptor({
+        name: 'ma_quality_assessment',
+        symbols: QualityAssessment.symbols
+    }),
+    type: 'static',
+    defaultParams: QualityAssessmentParams,
+    getParams: function (data) { return QualityAssessmentParams; },
+    isApplicable: function (data) { return QualityAssessment.isApplicable(data); },
+    obtain: function (ctx, data, props) { return __awaiter(void 0, void 0, void 0, function () {
+        var p;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    p = __assign(__assign({}, PD.getDefaultValues(QualityAssessmentParams)), props);
+                    return [4 /*yield*/, QualityAssessment.obtain(ctx, data, p)];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    }); }
+});
+//# sourceMappingURL=prop.js.map

package/lib/extensions/mp4-export/controls.d.ts

@@ -46,5 +46,6 @@ export declare class Mp4Controls extends PluginComponent {
     private syncInfo;
     private sync;
     private init;
+    private updateCanApply;
     constructor(plugin: PluginContext);
 }

package/lib/extensions/mp4-export/controls.js

@@ -121,16 +121,18 @@ var Mp4Controls = /** @class */ (function (_super) {
         });
         this.subscribe((_a = this.plugin.canvas3d) === null || _a === void 0 ? void 0 : _a.resized, function () { return _this.syncInfo(); });
         this.subscribe((_b = this.plugin.helpers.viewportScreenshot) === null || _b === void 0 ? void 0 : _b.events.previewed, function () { return _this.syncInfo(); });
-        this.subscribe(this.plugin.behaviors.state.isBusy, function (b) {
-            var _a, _b, _c;
-            var anim = _this.current;
-            if (!b && anim) {
-                _this.behaviors.canApply.next((_c = (_b = (_a = anim.anim).canApply) === null || _b === void 0 ? void 0 : _b.call(_a, _this.plugin)) !== null && _c !== void 0 ? _c : { canApply: true });
-            }
-        });
+        this.subscribe(this.plugin.behaviors.state.isBusy, function (b) { return _this.updateCanApply(b); });
+        this.subscribe(this.plugin.managers.snapshot.events.changed, function (b) { return _this.updateCanApply(b); });
         this.sync();
         this.syncInfo();
     };
+    Mp4Controls.prototype.updateCanApply = function (b) {
+        var _a, _b, _c;
+        var anim = this.current;
+        if (!b && anim) {
+            this.behaviors.canApply.next((_c = (_b = (_a = anim.anim).canApply) === null || _b === void 0 ? void 0 : _b.call(_a, this.plugin)) !== null && _c !== void 0 ? _c : { canApply: true });
+        }
+    };
     return Mp4Controls;
 }(PluginComponent));
 export { Mp4Controls };

package/lib/extensions/pdbe/structure-quality-report/prop.js

@@ -30,7 +30,7 @@ var StructureQualityReport;
     }
     StructureQualityReport.getEntryUrl = getEntryUrl;
     function isApplicable(model) {
-        return !!model && Model.isFromPdbArchive(model);
+        return !!model && Model.hasPdbId(model);
     }
     StructureQualityReport.isApplicable = isApplicable;
     StructureQualityReport.Schema = {

package/lib/extensions/rcsb/assembly-symmetry/behavior.d.ts

@@ -24,11 +24,14 @@ declare const AssemblySymmetry3D: StateTransformer<PluginStateObject.Molecule.St
     flatShaded: boolean;
     ignoreLight: boolean;
     xrayShaded: boolean;
+    bumpFrequency: number;
+    bumpAmplitude: number;
     alpha: number;
     quality: "auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest";
     material: PD.Normalize<{
         metalness: number;
         roughness: number;
+        bumpiness: number;
     }>;
     axesColor: PD.NamedParams<PD.Normalize<{
         colorValue: any;

package/lib/extensions/rcsb/assembly-symmetry/prop.js

@@ -49,7 +49,7 @@ export var AssemblySymmetry;
     AssemblySymmetry.DefaultServerUrl = 'https://data.rcsb.org/graphql';
     function isApplicable(structure) {
         return (!!structure && structure.models.length === 1 &&
-            Model.isFromPdbArchive(structure.models[0]) &&
+            Model.hasPdbId(structure.models[0]) &&
             isBiologicalAssembly(structure));
     }
     AssemblySymmetry.isApplicable = isApplicable;

package/lib/extensions/rcsb/assembly-symmetry/representation.d.ts

@@ -16,11 +16,14 @@ export declare const AssemblySymmetryParams: {
     flatShaded: PD.BooleanParam;
     ignoreLight: PD.BooleanParam;
     xrayShaded: PD.BooleanParam;
+    bumpFrequency: PD.Numeric;
+    bumpAmplitude: PD.Numeric;
     alpha: PD.Numeric;
     quality: PD.Select<"auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest">;
     material: PD.Group<PD.Normalize<{
         metalness: number;
         roughness: number;
+        bumpiness: number;
     }>>;
     axesColor: PD.Mapped<PD.NamedParams<PD.Normalize<{
         colorValue: Color;

package/lib/extensions/rcsb/validation-report/prop.js

@@ -37,7 +37,7 @@ var ValidationReport;
     }
     ValidationReport.getEntryUrl = getEntryUrl;
     function isApplicable(model) {
-        return !!model && Model.isFromPdbArchive(model);
+        return !!model && Model.hasPdbId(model);
     }
     ValidationReport.isApplicable = isApplicable;
     function fromXml(xml, model) {

package/lib/extensions/rcsb/validation-report/representation.d.ts

@@ -31,11 +31,14 @@ export declare const IntraUnitClashParams: {
     flatShaded: PD.BooleanParam;
     ignoreLight: PD.BooleanParam;
     xrayShaded: PD.BooleanParam;
+    bumpFrequency: PD.Numeric;
+    bumpAmplitude: PD.Numeric;
     alpha: PD.Numeric;
     quality: PD.Select<"auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest">;
     material: PD.Group<PD.Normalize<{
         metalness: number;
         roughness: number;
+        bumpiness: number;
     }>>;
 };
 export declare type IntraUnitClashParams = typeof IntraUnitClashParams;
@@ -60,11 +63,14 @@ export declare const InterUnitClashParams: {
     flatShaded: PD.BooleanParam;
     ignoreLight: PD.BooleanParam;
     xrayShaded: PD.BooleanParam;
+    bumpFrequency: PD.Numeric;
+    bumpAmplitude: PD.Numeric;
     alpha: PD.Numeric;
     quality: PD.Select<"auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest">;
     material: PD.Group<PD.Normalize<{
         metalness: number;
         roughness: number;
+        bumpiness: number;
     }>>;
 };
 export declare type InterUnitClashParams = typeof InterUnitClashParams;
@@ -90,11 +96,14 @@ export declare const ClashesParams: {
     flatShaded: PD.BooleanParam;
     ignoreLight: PD.BooleanParam;
     xrayShaded: PD.BooleanParam;
+    bumpFrequency: PD.Numeric;
+    bumpAmplitude: PD.Numeric;
     alpha: PD.Numeric;
     quality: PD.Select<"auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest">;
     material: PD.Group<PD.Normalize<{
         metalness: number;
         roughness: number;
+        bumpiness: number;
     }>>;
 };
 export declare type ClashesParams = typeof ClashesParams;
@@ -119,11 +128,14 @@ export declare function getClashesParams(ctx: ThemeRegistryContext, structure: S
     flatShaded: PD.BooleanParam;
     ignoreLight: PD.BooleanParam;
     xrayShaded: PD.BooleanParam;
+    bumpFrequency: PD.Numeric;
+    bumpAmplitude: PD.Numeric;
     alpha: PD.Numeric;
     quality: PD.Select<"auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest">;
     material: PD.Group<PD.Normalize<{
         metalness: number;
         roughness: number;
+        bumpiness: number;
     }>>;
 };
 export declare type ClashesRepresentation = StructureRepresentation<ClashesParams>;
@@ -149,10 +161,13 @@ export declare const ClashesRepresentationProvider: StructureRepresentationProvi
     flatShaded: PD.BooleanParam;
     ignoreLight: PD.BooleanParam;
     xrayShaded: PD.BooleanParam;
+    bumpFrequency: PD.Numeric;
+    bumpAmplitude: PD.Numeric;
     alpha: PD.Numeric;
     quality: PD.Select<"auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest">;
     material: PD.Group<PD.Normalize<{
         metalness: number;
         roughness: number;
+        bumpiness: number;
     }>>;
 }, ValidationReport.Tag.Clashes>;

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

@@ -67,6 +67,7 @@ export declare const Canvas3DParams: {
         outline: PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
             scale: any;
             threshold: any;
+            color: any;
         }>, "on">;
         antialiasing: PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
             edgeThreshold: any;
@@ -164,6 +165,8 @@ export declare const Canvas3DParams: {
             flipSided: any;
             flatShaded: any;
             xrayShaded: any;
+            bumpFrequency: any;
+            bumpAmplitude: any;
             quality: any;
             material: any;
         }>, "on">;
@@ -215,6 +218,7 @@ export declare const DefaultCanvas3DParams: PD.Values<{
         outline: PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
             scale: any;
             threshold: any;
+            color: any;
         }>, "on">;
         antialiasing: PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
             edgeThreshold: any;
@@ -312,6 +316,8 @@ export declare const DefaultCanvas3DParams: PD.Values<{
             flipSided: any;
             flatShaded: any;
             xrayShaded: any;
+            bumpFrequency: any;
+            bumpAmplitude: any;
             quality: any;
             material: any;
         }>, "on">;

package/lib/mol-canvas3d/canvas3d.js

@@ -286,7 +286,13 @@ var Canvas3D;
                     cam = stereoCamera;
                 }
                 if (MultiSamplePass.isEnabled(p.multiSample)) {
-                    multiSampleHelper.render(renderer, cam, scene, helper, true, p.transparentBackground, p);
+                    if (!cameraChanged) {
+                        while (!multiSampleHelper.render(renderer, cam, scene, helper, true, p.transparentBackground, p))
+                            ;
+                    }
+                    else {
+                        multiSampleHelper.render(renderer, cam, scene, helper, true, p.transparentBackground, p);
+                    }
                 }
                 else {
                     passes.draw.render(renderer, cam, scene, helper, true, p.transparentBackground, p.postprocessing, p.marking);
@@ -391,7 +397,7 @@ var Canvas3D;
                 return true;
             if (camera.transition.inTransition || nextCameraResetSnapshot)
                 return false;
-            var cameraSphereOverlapsNone = true;
+            var cameraSphereOverlapsNone = true, isEmpty = true;
             Sphere3D.set(cameraSphere, camera.state.target, camera.state.radius);
             // check if any renderable has moved outside of the old bounding sphere
             // and if no renderable is overlapping with the camera sphere
@@ -402,13 +408,14 @@ var Canvas3D;
                 var b = r.values.boundingSphere.ref.value;
                 if (!b.radius)
                     continue;
+                isEmpty = false;
                 var cameraDist = Vec3.distance(cameraSphere.center, b.center);
                 if ((cameraDist > cameraSphere.radius || cameraDist > b.radius || b.radius > camera.state.radiusMax) && !Sphere3D.includes(oldBoundingSphereVisible, b))
                     return true;
                 if (Sphere3D.overlaps(cameraSphere, b))
                     cameraSphereOverlapsNone = false;
             }
-            return cameraSphereOverlapsNone;
+            return cameraSphereOverlapsNone || (!isEmpty && cameraSphere.radius <= 0.1);
         }
         var sceneCommitTimeoutMs = 250;
         function commitScene(isSynchronous) {

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

@@ -22,10 +22,13 @@ export declare const CameraHelperParams: {
         flipSided: boolean;
         flatShaded: boolean;
         xrayShaded: boolean;
+        bumpFrequency: number;
+        bumpAmplitude: number;
         quality: "auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest";
         material: PD.Normalize<{
             metalness: number;
             roughness: number;
+            bumpiness: number;
         }>;
     }>, "on">>;
 };