molstar 3.0.0-dev.3 → 3.0.0-dev.7

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,18 @@ 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;
+    }>;
+    clip: PD.Normalize<{
+        variant: any;
+        objects: any;
     }>;
     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,24 @@ 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;
+    }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
     }>>;
     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,24 @@ 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;
+    }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
     }>>;
 };
 export declare type IntraUnitClashParams = typeof IntraUnitClashParams;
@@ -60,11 +73,24 @@ 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;
+    }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
     }>>;
 };
 export declare type InterUnitClashParams = typeof InterUnitClashParams;
@@ -90,11 +116,24 @@ 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;
+    }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
     }>>;
 };
 export declare type ClashesParams = typeof ClashesParams;
@@ -119,11 +158,24 @@ 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;
+    }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
     }>>;
 };
 export declare type ClashesRepresentation = StructureRepresentation<ClashesParams>;
@@ -149,10 +201,23 @@ 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;
+    }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
     }>>;
 }, 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;
@@ -106,10 +107,6 @@ export declare const Canvas3DParams: {
         }>[];
         ambientColor: import("../mol-util/color").Color;
         ambientIntensity: number;
-        clip: PD.Normalize<{
-            variant: any;
-            objects: any;
-        }>;
     }>>;
     trackball: PD.Group<PD.Normalize<{
         noScroll: boolean;
@@ -164,8 +161,11 @@ export declare const Canvas3DParams: {
             flipSided: any;
             flatShaded: any;
             xrayShaded: any;
+            bumpFrequency: any;
+            bumpAmplitude: any;
             quality: any;
             material: any;
+            clip: any;
         }>, "on">;
     }>>;
 };
@@ -215,6 +215,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;
@@ -254,10 +255,6 @@ export declare const DefaultCanvas3DParams: PD.Values<{
         }>[];
         ambientColor: import("../mol-util/color").Color;
         ambientIntensity: number;
-        clip: PD.Normalize<{
-            variant: any;
-            objects: any;
-        }>;
     }>>;
     trackball: PD.Group<PD.Normalize<{
         noScroll: boolean;
@@ -312,8 +309,11 @@ export declare const DefaultCanvas3DParams: PD.Values<{
             flipSided: any;
             flatShaded: any;
             xrayShaded: any;
+            bumpFrequency: any;
+            bumpAmplitude: any;
             quality: any;
             material: any;
+            clip: any;
         }>, "on">;
     }>>;
 }>;

package/lib/mol-canvas3d/canvas3d.js

@@ -35,6 +35,7 @@ import { Helper } from './helper/helper';
 import { Passes } from './passes/passes';
 import { shallowEqual } from '../mol-util';
 import { MarkingParams } from './passes/marking';
+import { GraphicsRenderVariantsBlended, GraphicsRenderVariantsWboit } from '../mol-gl/webgl/render-item';
 export var Canvas3DParams = {
     camera: PD.Group({
         mode: PD.Select('perspective', PD.arrayToOptions(['perspective', 'orthographic']), { label: 'Camera' }),
@@ -200,7 +201,7 @@ var Canvas3D;
         var width = 128;
         var height = 128;
         updateViewport();
-        var scene = Scene.create(webgl);
+        var scene = Scene.create(webgl, passes.draw.wboitEnabled ? GraphicsRenderVariantsWboit : GraphicsRenderVariantsBlended);
         var camera = new Camera({
             position: Vec3.create(0, 0, 100),
             mode: p.camera.mode,
@@ -286,7 +287,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 +398,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 +409,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/bounding-sphere-helper.js

@@ -15,6 +15,7 @@ import { ColorNames } from '../../mol-util/color/names';
 import { sphereVertexCount } from '../../mol-geo/primitive/sphere';
 import { ValueCell } from '../../mol-util';
 import { Geometry } from '../../mol-geo/geometry/geometry';
+import { GraphicsRenderVariantsBlended } from '../../mol-gl/webgl/render-item';
 export var DebugHelperParams = {
     sceneBoundingSpheres: PD.Boolean(false, { description: 'Show full scene bounding spheres.' }),
     visibleSceneBoundingSpheres: PD.Boolean(false, { description: 'Show visible scene bounding spheres.' }),
@@ -25,7 +26,7 @@ var BoundingSphereHelper = /** @class */ (function () {
     function BoundingSphereHelper(ctx, parent, props) {
         this.objectsData = new Map();
         this.instancesData = new Map();
-        this.scene = Scene.create(ctx);
+        this.scene = Scene.create(ctx, GraphicsRenderVariantsBlended);
         this.parent = parent;
         this._props = __assign(__assign({}, PD.getDefaultValues(DebugHelperParams)), props);
     }
@@ -148,6 +149,6 @@ var objectMaterialId = getNextMaterialId();
 var instanceMaterialId = getNextMaterialId();
 function createBoundingSphereRenderObject(mesh, color, materialId, transform) {
     var values = Mesh.Utils.createValuesSimple(mesh, { alpha: 0.1, doubleSided: false }, color, 1, transform);
-    return createRenderObject('mesh', values, { disposed: false, visible: true, alphaFactor: 1, pickable: false, colorOnly: false, opaque: false, writeDepth: false, noClip: false }, materialId);
+    return createRenderObject('mesh', values, { disposed: false, visible: true, alphaFactor: 1, pickable: false, colorOnly: false, opaque: false, writeDepth: false }, materialId);
 }
 //# sourceMappingURL=bounding-sphere-helper.js.map

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

@@ -22,10 +22,17 @@ 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;
+        }>;
+        clip: PD.Normalize<{
+            variant: any;
+            objects: any;
         }>;
     }>, "on">>;
 };

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

@@ -11,6 +11,7 @@ import { addSphere } from '../../mol-geo/geometry/mesh/builder/sphere';
 import { Mesh } from '../../mol-geo/geometry/mesh/mesh';
 import { MeshBuilder } from '../../mol-geo/geometry/mesh/mesh-builder';
 import { Scene } from '../../mol-gl/scene';
+import { GraphicsRenderVariantsBlended } from '../../mol-gl/webgl/render-item';
 import { Sphere3D } from '../../mol-math/geometry';
 import { Mat4, Vec3 } from '../../mol-math/linear-algebra';
 import { DataLoci, EmptyLoci } from '../../mol-model/loci';
@@ -52,7 +53,7 @@ var CameraHelper = /** @class */ (function () {
             }
             return changed;
         };
-        this.scene = Scene.create(webgl);
+        this.scene = Scene.create(webgl, GraphicsRenderVariantsBlended);
         this.camera = new Camera();
         Vec3.set(this.camera.up, 0, 1, 0);
         Vec3.set(this.camera.target, 0, 0, 0);
@@ -67,7 +68,6 @@ var CameraHelper = /** @class */ (function () {
                     _this.scene.clear();
                     var params = __assign(__assign({}, props.axes.params), { scale: props.axes.params.scale * _this.webgl.pixelRatio });
                     _this.renderObject = createAxesRenderObject(params);
-                    _this.renderObject.state.noClip = true;
                     _this.scene.add(_this.renderObject);
                     _this.scene.commit();
                     Vec3.set(_this.camera.position, 0, 0, params.scale * 200);

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

@@ -24,10 +24,17 @@ export declare const HandleHelperParams: {
         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;
+        }>;
+        clip: PD.Normalize<{
+            variant: any;
+            objects: any;
         }>;
     }>, "on">>;
 };

package/lib/mol-canvas3d/helper/handle-helper.js

@@ -20,6 +20,7 @@ import { DataLoci, EmptyLoci } from '../../mol-model/loci';
 import { MarkerActions } from '../../mol-util/marker-action';
 import { Visual } from '../../mol-repr/visual';
 import { Interval } from '../../mol-data/int';
+import { GraphicsRenderVariantsBlended } from '../../mol-gl/webgl/render-item';
 var HandleParams = __assign(__assign({}, Mesh.Params), { alpha: __assign(__assign({}, Mesh.Params.alpha), { defaultValue: 1 }), ignoreLight: __assign(__assign({}, Mesh.Params.ignoreLight), { defaultValue: true }), colorX: PD.Color(ColorNames.red, { isEssential: true }), colorY: PD.Color(ColorNames.green, { isEssential: true }), colorZ: PD.Color(ColorNames.blue, { isEssential: true }), scale: PD.Numeric(0.33, { min: 0.1, max: 2, step: 0.1 }, { isEssential: true }) });
 export var HandleHelperParams = {
     handle: PD.MappedStatic('off', {
@@ -52,7 +53,7 @@ var HandleHelper = /** @class */ (function () {
             }
             return changed;
         };
-        this.scene = Scene.create(webgl);
+        this.scene = Scene.create(webgl, GraphicsRenderVariantsBlended);
         this.setProps(props);
     }
     HandleHelper.prototype.getBoundingSphere = function (out, instanceId) {
@@ -72,7 +73,6 @@ var HandleHelper = /** @class */ (function () {
                     _this.scene.clear();
                     var params = __assign(__assign({}, props.handle.params), { scale: props.handle.params.scale * _this.webgl.pixelRatio });
                     _this.renderObject = createHandleRenderObject(params);
-                    _this.renderObject.state.noClip = true;
                     _this.scene.add(_this.renderObject);
                     _this.scene.commit();
                     p.handle.params = __assign({}, props.handle.params);

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

@@ -33,8 +33,11 @@ export declare const HelperParams: {
             flipSided: any;
             flatShaded: any;
             xrayShaded: any;
+            bumpFrequency: any;
+            bumpAmplitude: any;
             quality: any;
             material: any;
+            clip: any;
         }>, "on">;
     }>>;
 };
@@ -62,8 +65,11 @@ export declare const DefaultHelperProps: PD.Values<{
             flipSided: any;
             flatShaded: any;
             xrayShaded: any;
+            bumpFrequency: any;
+            bumpAmplitude: any;
             quality: any;
             material: any;
+            clip: any;
         }>, "on">;
     }>>;
 }>;

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

@@ -27,6 +27,7 @@ export declare const ImageParams: {
         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;
@@ -58,8 +59,11 @@ export declare const ImageParams: {
             flipSided: any;
             flatShaded: any;
             xrayShaded: any;
+            bumpFrequency: any;
+            bumpAmplitude: any;
             quality: any;
             material: any;
+            clip: any;
         }>, "on">;
     }>>;
 };

package/lib/mol-canvas3d/passes/multi-sample.d.ts

@@ -43,7 +43,8 @@ export declare class MultiSampleHelper {
     private multiSamplePass;
     private sampleIndex;
     update(changed: boolean, props: MultiSampleProps): boolean;
-    render(renderer: Renderer, camera: Camera | StereoCamera, scene: Scene, helper: Helper, toDrawingBuffer: boolean, transparentBackground: boolean, props: Props): void;
+    /** Return `true` while more samples are needed */
+    render(renderer: Renderer, camera: Camera | StereoCamera, scene: Scene, helper: Helper, toDrawingBuffer: boolean, transparentBackground: boolean, props: Props): boolean;
     constructor(multiSamplePass: MultiSamplePass);
 }
 export {};