molstar 3.0.0-dev.6 → 3.0.0

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

@@ -107,18 +107,18 @@ 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;
         rotateSpeed: number;
         zoomSpeed: number;
         panSpeed: number;
-        spin: boolean;
-        spinSpeed: number;
+        animate: PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
+            speed: any;
+        }>, "spin"> | PD.NamedParams<PD.Normalize<{
+            speed: any;
+            angle: any;
+        }>, "rock">;
         staticMoving: boolean;
         dynamicDampingFactor: number;
         minDistance: number;
@@ -169,6 +169,7 @@ export declare const Canvas3DParams: {
             bumpAmplitude: any;
             quality: any;
             material: any;
+            clip: any;
         }>, "on">;
     }>>;
 };
@@ -258,18 +259,18 @@ 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;
         rotateSpeed: number;
         zoomSpeed: number;
         panSpeed: number;
-        spin: boolean;
-        spinSpeed: number;
+        animate: PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
+            speed: any;
+        }>, "spin"> | PD.NamedParams<PD.Normalize<{
+            speed: any;
+            angle: any;
+        }>, "rock">;
         staticMoving: boolean;
         dynamicDampingFactor: number;
         minDistance: number;
@@ -320,6 +321,7 @@ export declare const DefaultCanvas3DParams: PD.Values<{
             bumpAmplitude: any;
             quality: any;
             material: any;
+            clip: any;
         }>, "on">;
     }>>;
 }>;
@@ -380,7 +382,7 @@ interface Canvas3D {
     update(repr?: Representation.Any, keepBoundingSphere?: boolean): void;
     clear(): void;
     syncVisibility(): void;
-    requestDraw(force?: boolean): void;
+    requestDraw(): void;
     /** Reset the timers, used by "animate" */
     resetTime(t: number): void;
     animate(): void;

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,
@@ -252,16 +253,24 @@ var Canvas3D;
                 changed = helper.camera.mark(loci, action) || changed;
                 reprRenderObjects.forEach(function (_, _repr) { changed = _repr.mark(loci, action) || changed; });
             }
-            if (changed && !noDraw) {
-                scene.update(void 0, true);
-                helper.handle.scene.update(void 0, true);
-                helper.camera.scene.update(void 0, true);
-                var prevPickDirty = pickHelper.dirty;
-                draw(true);
-                pickHelper.dirty = prevPickDirty; // marking does not change picking buffers
+            if (changed) {
+                if (noDraw) {
+                    // Even with `noDraw` make sure changes will be rendered.
+                    // Note that with this calling mark (with or without `noDraw`) multiple times
+                    // during a JS event loop iteration will only result in a single render call.
+                    forceNextRender = true;
+                }
+                else {
+                    scene.update(void 0, true);
+                    helper.handle.scene.update(void 0, true);
+                    helper.camera.scene.update(void 0, true);
+                    var prevPickDirty = pickHelper.dirty;
+                    draw({ force: true, allowMulti: true });
+                    pickHelper.dirty = prevPickDirty; // marking does not change picking buffers
+                }
             }
         }
-        function render(force) {
+        function render(force, allowMulti) {
             if (webgl.isContextLost)
                 return false;
             var resized = false;
@@ -285,17 +294,13 @@ var Canvas3D;
                     stereoCamera.update();
                     cam = stereoCamera;
                 }
+                var ctx = { renderer: renderer, camera: cam, scene: scene, helper: helper };
                 if (MultiSamplePass.isEnabled(p.multiSample)) {
-                    if (!cameraChanged) {
-                        while (!multiSampleHelper.render(renderer, cam, scene, helper, true, p.transparentBackground, p))
-                            ;
-                    }
-                    else {
-                        multiSampleHelper.render(renderer, cam, scene, helper, true, p.transparentBackground, p);
-                    }
+                    var forceOn = !cameraChanged && allowMulti && !controls.isAnimating;
+                    multiSampleHelper.render(ctx, p, true, forceOn);
                 }
                 else {
-                    passes.draw.render(renderer, cam, scene, helper, true, p.transparentBackground, p.postprocessing, p.marking);
+                    passes.draw.render(ctx, p, true);
                 }
                 pickHelper.dirty = true;
                 didRender = true;
@@ -306,15 +311,15 @@ var Canvas3D;
         var forceDrawAfterAllCommited = false;
         var currentTime = 0;
         var drawPaused = false;
-        function draw(force) {
+        function draw(options) {
             if (drawPaused)
                 return;
-            if (render(!!force) && notifyDidDraw) {
+            if (render(!!(options === null || options === void 0 ? void 0 : options.force), !!(options === null || options === void 0 ? void 0 : options.allowMulti)) && notifyDidDraw) {
                 didDraw.next(now() - startTime);
             }
         }
-        function requestDraw(force) {
-            forceNextRender = forceNextRender || !!force;
+        function requestDraw() {
+            forceNextRender = true;
         }
         var animationFrameHandle = 0;
         function tick(t, options) {
@@ -324,7 +329,7 @@ var Canvas3D;
             if (options === null || options === void 0 ? void 0 : options.manualDraw) {
                 return;
             }
-            draw(false);
+            draw();
             if (!camera.transition.inTransition && !webgl.isContextLost) {
                 interactionHelper.tick(currentTime);
             }
@@ -362,7 +367,7 @@ var Canvas3D;
                 if (forceDrawAfterAllCommited) {
                     if (helper.debug.isEnabled)
                         helper.debug.update();
-                    draw(true);
+                    draw({ force: true });
                     forceDrawAfterAllCommited = false;
                 }
                 commited.next(now());
@@ -531,11 +536,11 @@ var Canvas3D;
         }
         var contextRestoredSub = contextRestored.subscribe(function () {
             pickHelper.dirty = true;
-            draw(true);
+            draw({ force: true });
             // Unclear why, but in Chrome with wboit enabled the first `draw` only clears
             // the drawingBuffer. Note that in Firefox the drawingBuffer is preserved after
             // context loss so it is unclear if it behaves the same.
-            draw(true);
+            draw({ force: true });
         });
         var resized = new BehaviorSubject(0);
         function handleResize(draw) {
@@ -544,7 +549,7 @@ var Canvas3D;
             updateViewport();
             syncViewport();
             if (draw)
-                requestDraw(true);
+                requestDraw();
             resized.next(+new Date());
         }
         return {
@@ -569,7 +574,7 @@ var Canvas3D;
                 reprRenderObjects.clear();
                 scene.clear();
                 helper.debug.clear();
-                requestDraw(true);
+                requestDraw();
                 reprCount.next(reprRenderObjects.size);
             },
             syncVisibility: function () {
@@ -581,7 +586,7 @@ var Canvas3D;
                     if (helper.debug.isEnabled)
                         helper.debug.update();
                 }
-                requestDraw(true);
+                requestDraw();
             },
             requestDraw: requestDraw,
             tick: tick,
@@ -678,7 +683,7 @@ var Canvas3D;
                     p.camera.stereo.name = 'off';
                 }
                 if (!doNotRequestDraw) {
-                    requestDraw(true);
+                    requestDraw();
                 }
             },
             getImagePass: function (props) {

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2021 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>
  * @author David Sehnal <david.sehnal@gmail.com>
@@ -28,8 +28,12 @@ export declare const TrackballControlsParams: {
     rotateSpeed: PD.Numeric;
     zoomSpeed: PD.Numeric;
     panSpeed: PD.Numeric;
-    spin: PD.BooleanParam;
-    spinSpeed: PD.Numeric;
+    animate: PD.Mapped<PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
+        speed: number;
+    }>, "spin"> | PD.NamedParams<PD.Normalize<{
+        speed: number;
+        angle: number;
+    }>, "rock">>;
     staticMoving: PD.BooleanParam;
     dynamicDampingFactor: PD.Numeric;
     minDistance: PD.Numeric;
@@ -61,7 +65,8 @@ export declare const TrackballControlsParams: {
 export declare type TrackballControlsProps = PD.Values<typeof TrackballControlsParams>;
 export { TrackballControls };
 interface TrackballControls {
-    viewport: Viewport;
+    readonly viewport: Viewport;
+    readonly isAnimating: boolean;
     readonly props: Readonly<TrackballControlsProps>;
     setProps: (props: Partial<TrackballControlsProps>) => void;
     start: (t: number) => void;

package/lib/mol-canvas3d/controls/trackball.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2021 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>
  * @author David Sehnal <david.sehnal@gmail.com>
@@ -12,7 +12,7 @@ import { Quat, Vec2, Vec3, EPSILON } from '../../mol-math/linear-algebra';
 import { Viewport } from '../camera/util';
 import { ButtonsType, ModifiersKeys } from '../../mol-util/input/input-observer';
 import { ParamDefinition as PD } from '../../mol-util/param-definition';
-import { absMax } from '../../mol-math/misc';
+import { absMax, degToRad } from '../../mol-math/misc';
 import { Binding } from '../../mol-util/binding';
 var B = ButtonsType;
 var M = ModifiersKeys;
@@ -33,8 +33,16 @@ export var TrackballControlsParams = {
     rotateSpeed: PD.Numeric(5.0, { min: 1, max: 10, step: 1 }),
     zoomSpeed: PD.Numeric(7.0, { min: 1, max: 15, step: 1 }),
     panSpeed: PD.Numeric(1.0, { min: 0.1, max: 5, step: 0.1 }),
-    spin: PD.Boolean(false, { description: 'Spin the 3D scene around the x-axis in view space' }),
-    spinSpeed: PD.Numeric(1, { min: -20, max: 20, step: 1 }),
+    animate: PD.MappedStatic('off', {
+        off: PD.EmptyGroup(),
+        spin: PD.Group({
+            speed: PD.Numeric(1, { min: -20, max: 20, step: 1 }),
+        }, { description: 'Spin the 3D scene around the x-axis in view space' }),
+        rock: PD.Group({
+            speed: PD.Numeric(0.3, { min: -5, max: 5, step: 0.1 }),
+            angle: PD.Numeric(10, { min: 0, max: 90, step: 1 }, { description: 'How many degrees to rotate in each direction.' }),
+        }, { description: 'Rock the 3D scene around the x-axis in view space' })
+    }),
     staticMoving: PD.Boolean(true, { isHidden: true }),
     dynamicDampingFactor: PD.Numeric(0.2, {}, { isHidden: true }),
     minDistance: PD.Numeric(0.01, {}, { isHidden: true }),
@@ -99,6 +107,10 @@ var TrackballControls;
             return Vec2.set(mouseOnCircleVec2, (pageX - viewport.width * 0.5 - viewport.x) / (viewport.width * 0.5), (viewport.height + 2 * (viewport.y - pageY)) / viewport.width // screen.width intentional
             );
         }
+        function getRotateFactor() {
+            var aspectRatio = input.width / input.height;
+            return p.rotateSpeed * input.pixelRatio * aspectRatio;
+        }
         var rotAxis = Vec3();
         var rotQuat = Quat();
         var rotEyeDir = Vec3();
@@ -109,8 +121,7 @@ var TrackballControls;
             var dx = _rotCurr[0] - _rotPrev[0];
             var dy = _rotCurr[1] - _rotPrev[1];
             Vec3.set(rotMoveDir, dx, dy, 0);
-            var aspectRatio = input.width / input.height;
-            var angle = Vec3.magnitude(rotMoveDir) * p.rotateSpeed * input.pixelRatio * aspectRatio;
+            var angle = Vec3.magnitude(rotMoveDir) * getRotateFactor();
             if (angle) {
                 Vec3.sub(_eye, camera.position, camera.target);
                 Vec3.normalize(rotEyeDir, _eye);
@@ -236,8 +247,12 @@ var TrackballControls;
         function update(t) {
             if (lastUpdated === t)
                 return;
-            if (p.spin && lastUpdated > 0)
-                spin(t - lastUpdated);
+            if (lastUpdated > 0) {
+                if (p.animate.name === 'spin')
+                    spin(t - lastUpdated);
+                else if (p.animate.name === 'rock')
+                    rock(t - lastUpdated);
+            }
             Vec3.sub(_eye, camera.position, camera.target);
             rotateCamera();
             zRotateCamera();
@@ -268,6 +283,7 @@ var TrackballControls;
             if (!isStart && !_isInteracting)
                 return;
             _isInteracting = true;
+            resetRock(); // start rocking from the center after interactions
             var dragRotate = Binding.match(p.bindings.dragRotate, buttons, modifiers);
             var dragRotateZ = Binding.match(p.bindings.dragRotateZ, buttons, modifiers);
             var dragPan = Binding.match(p.bindings.dragPan, buttons, modifiers);
@@ -356,12 +372,30 @@ var TrackballControls;
         }
         var _spinSpeed = Vec2.create(0.005, 0);
         function spin(deltaT) {
-            if (p.spinSpeed === 0)
+            if (p.animate.name !== 'spin' || p.animate.params.speed === 0 || _isInteracting)
                 return;
-            var frameSpeed = (p.spinSpeed || 0) / 1000;
+            var frameSpeed = p.animate.params.speed / 1000;
             _spinSpeed[0] = 60 * Math.min(Math.abs(deltaT), 1000 / 8) / 1000 * frameSpeed;
-            if (!_isInteracting)
-                Vec2.add(_rotCurr, _rotPrev, _spinSpeed);
+            Vec2.add(_rotCurr, _rotPrev, _spinSpeed);
+        }
+        var _rockPhase = 0;
+        var _rockSpeed = Vec2.create(0.005, 0);
+        function rock(deltaT) {
+            if (p.animate.name !== 'rock' || p.animate.params.speed === 0 || _isInteracting)
+                return;
+            var dt = deltaT / 1000 * p.animate.params.speed;
+            var maxAngle = degToRad(p.animate.params.angle) / getRotateFactor();
+            var angleA = Math.sin(_rockPhase * Math.PI * 2) * maxAngle;
+            var angleB = Math.sin((_rockPhase + dt) * Math.PI * 2) * maxAngle;
+            _rockSpeed[0] = angleB - angleA;
+            Vec2.add(_rotCurr, _rotPrev, _rockSpeed);
+            _rockPhase += dt;
+            if (_rockPhase >= 1) {
+                _rockPhase = 0;
+            }
+        }
+        function resetRock() {
+            _rockPhase = 0;
         }
         function start(t) {
             lastUpdated = -1;
@@ -369,8 +403,13 @@ var TrackballControls;
         }
         return {
             viewport: viewport,
+            get isAnimating() { return p.animate.name !== 'off'; },
             get props() { return p; },
             setProps: function (props) {
+                var _a;
+                if (((_a = props.animate) === null || _a === void 0 ? void 0 : _a.name) === 'rock' && p.animate.name !== 'rock') {
+                    resetRock(); // start rocking from the center
+                }
                 Object.assign(p, props);
             },
             start: start,

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

@@ -30,6 +30,10 @@ export declare const CameraHelperParams: {
             roughness: number;
             bumpiness: number;
         }>;
+        clip: PD.Normalize<{
+            variant: any;
+            objects: any;
+        }>;
     }>, "on">>;
 };
 export declare type CameraHelperParams = typeof CameraHelperParams;

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

@@ -32,6 +32,10 @@ export declare const HandleHelperParams: {
             roughness: number;
             bumpiness: number;
         }>;
+        clip: PD.Normalize<{
+            variant: any;
+            objects: any;
+        }>;
     }>, "on">>;
 };
 export declare type HandleHelperParams = typeof HandleHelperParams;

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

@@ -37,6 +37,7 @@ export declare const HelperParams: {
             bumpAmplitude: any;
             quality: any;
             material: any;
+            clip: any;
         }>, "on">;
     }>>;
 };
@@ -68,6 +69,7 @@ export declare const DefaultHelperProps: PD.Values<{
             bumpAmplitude: any;
             quality: any;
             material: any;
+            clip: any;
         }>, "on">;
     }>>;
 }>;

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

@@ -14,6 +14,17 @@ import { Helper } from '../helper/helper';
 import { StereoCamera } from '../camera/stereo';
 import { PostprocessingPass, PostprocessingProps } from './postprocessing';
 import { MarkingProps } from './marking';
+declare type Props = {
+    postprocessing: PostprocessingProps;
+    marking: MarkingProps;
+    transparentBackground: boolean;
+};
+declare type RenderContext = {
+    renderer: Renderer;
+    camera: Camera | StereoCamera;
+    scene: Scene;
+    helper: Helper;
+};
 export declare class DrawPass {
     private webgl;
     private readonly drawTarget;
@@ -40,6 +51,7 @@ export declare class DrawPass {
     private _renderWboit;
     private _renderBlended;
     private _render;
-    render(renderer: Renderer, camera: Camera | StereoCamera, scene: Scene, helper: Helper, toDrawingBuffer: boolean, transparentBackground: boolean, postprocessingProps: PostprocessingProps, markingProps: MarkingProps): void;
+    render(ctx: RenderContext, props: Props, toDrawingBuffer: boolean): void;
     getColorTarget(postprocessingProps: PostprocessingProps): RenderTarget;
 }
+export {};

package/lib/mol-canvas3d/passes/draw.js

@@ -194,23 +194,23 @@ var DrawPass = /** @class */ (function () {
         }
         renderer.renderBlendedTransparent(scene.primitives, camera, null);
     };
-    DrawPass.prototype._render = function (renderer, camera, scene, helper, toDrawingBuffer, transparentBackground, postprocessingProps, markingProps) {
+    DrawPass.prototype._render = function (renderer, camera, scene, helper, toDrawingBuffer, props) {
         var volumeRendering = scene.volumes.renderables.length > 0;
-        var postprocessingEnabled = PostprocessingPass.isEnabled(postprocessingProps);
-        var antialiasingEnabled = AntialiasingPass.isEnabled(postprocessingProps);
-        var markingEnabled = MarkingPass.isEnabled(markingProps);
+        var postprocessingEnabled = PostprocessingPass.isEnabled(props.postprocessing);
+        var antialiasingEnabled = AntialiasingPass.isEnabled(props.postprocessing);
+        var markingEnabled = MarkingPass.isEnabled(props.marking);
         var _a = camera.viewport, x = _a.x, y = _a.y, width = _a.width, height = _a.height;
         renderer.setViewport(x, y, width, height);
         renderer.update(camera);
-        if (transparentBackground && !antialiasingEnabled && toDrawingBuffer) {
+        if (props.transparentBackground && !antialiasingEnabled && toDrawingBuffer) {
             this.drawTarget.bind();
             renderer.clear(false);
         }
         if (this.wboitEnabled) {
-            this._renderWboit(renderer, camera, scene, transparentBackground, postprocessingProps);
+            this._renderWboit(renderer, camera, scene, props.transparentBackground, props.postprocessing);
         }
         else {
-            this._renderBlended(renderer, camera, scene, !volumeRendering && !postprocessingEnabled && !antialiasingEnabled && toDrawingBuffer, transparentBackground, postprocessingProps);
+            this._renderBlended(renderer, camera, scene, !volumeRendering && !postprocessingEnabled && !antialiasingEnabled && toDrawingBuffer, props.transparentBackground, props.postprocessing);
         }
         if (postprocessingEnabled) {
             this.postprocessing.target.bind();
@@ -222,7 +222,7 @@ var DrawPass = /** @class */ (function () {
             this.drawTarget.bind();
         }
         if (markingEnabled) {
-            var markingDepthTest = markingProps.ghostEdgeStrength < 1;
+            var markingDepthTest = props.marking.ghostEdgeStrength < 1;
             if (markingDepthTest) {
                 this.marking.depthTarget.bind();
                 renderer.clear(false);
@@ -231,7 +231,7 @@ var DrawPass = /** @class */ (function () {
             this.marking.maskTarget.bind();
             renderer.clear(false);
             renderer.renderMarkingMask(scene.primitives, camera, markingDepthTest ? this.marking.depthTarget.texture : null);
-            this.marking.update(markingProps);
+            this.marking.update(props.marking);
             this.marking.render(camera.viewport, postprocessingEnabled ? this.postprocessing.target : this.colorTarget);
         }
         if (helper.debug.isEnabled) {
@@ -247,7 +247,7 @@ var DrawPass = /** @class */ (function () {
             renderer.renderBlended(helper.camera.scene, helper.camera.camera, null);
         }
         if (antialiasingEnabled) {
-            this.antialiasing.render(camera, toDrawingBuffer, postprocessingProps);
+            this.antialiasing.render(camera, toDrawingBuffer, props.postprocessing);
         }
         else if (toDrawingBuffer) {
             this.drawTarget.bind();
@@ -261,16 +261,17 @@ var DrawPass = /** @class */ (function () {
         }
         this.webgl.gl.flush();
     };
-    DrawPass.prototype.render = function (renderer, camera, scene, helper, toDrawingBuffer, transparentBackground, postprocessingProps, markingProps) {
-        renderer.setTransparentBackground(transparentBackground);
+    DrawPass.prototype.render = function (ctx, props, toDrawingBuffer) {
+        var renderer = ctx.renderer, camera = ctx.camera, scene = ctx.scene, helper = ctx.helper;
+        renderer.setTransparentBackground(props.transparentBackground);
         renderer.setDrawingBufferSize(this.colorTarget.getWidth(), this.colorTarget.getHeight());
         renderer.setPixelRatio(this.webgl.pixelRatio);
         if (StereoCamera.is(camera)) {
-            this._render(renderer, camera.left, scene, helper, toDrawingBuffer, transparentBackground, postprocessingProps, markingProps);
-            this._render(renderer, camera.right, scene, helper, toDrawingBuffer, transparentBackground, postprocessingProps, markingProps);
+            this._render(renderer, camera.left, scene, helper, toDrawingBuffer, props);
+            this._render(renderer, camera.right, scene, helper, toDrawingBuffer, props);
         }
         else {
-            this._render(renderer, camera, scene, helper, toDrawingBuffer, transparentBackground, postprocessingProps, markingProps);
+            this._render(renderer, camera, scene, helper, toDrawingBuffer, props);
         }
     };
     DrawPass.prototype.getColorTarget = function (postprocessingProps) {

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

@@ -63,6 +63,7 @@ export declare const ImageParams: {
             bumpAmplitude: any;
             quality: any;
             material: any;
+            clip: any;
         }>, "on">;
     }>>;
 };

package/lib/mol-canvas3d/passes/image.js

@@ -73,12 +73,13 @@ var ImagePass = /** @class */ (function () {
         Camera.copySnapshot(this._camera.state, this.camera.state);
         Viewport.set(this._camera.viewport, 0, 0, this._width, this._height);
         this._camera.update();
+        var ctx = { renderer: this.renderer, camera: this._camera, scene: this.scene, helper: this.helper };
         if (MultiSamplePass.isEnabled(this.props.multiSample)) {
-            this.multiSampleHelper.render(this.renderer, this._camera, this.scene, this.helper, false, this.props.transparentBackground, this.props);
+            this.multiSampleHelper.render(ctx, this.props, false);
             this._colorTarget = this.multiSamplePass.colorTarget;
         }
         else {
-            this.drawPass.render(this.renderer, this._camera, this.scene, this.helper, false, this.props.transparentBackground, this.props.postprocessing, this.props.marking);
+            this.drawPass.render(ctx, this.props, false);
             this._colorTarget = this.drawPass.getColorTarget(this.props.postprocessing);
         }
     };

package/lib/mol-canvas3d/passes/marking.js

@@ -17,7 +17,7 @@ import { overlay_frag } from '../../mol-gl/shader/marking/overlay.frag';
 import { Color } from '../../mol-util/color';
 import { edge_frag } from '../../mol-gl/shader/marking/edge.frag';
 export var MarkingParams = {
-    enabled: PD.Boolean(false),
+    enabled: PD.Boolean(true),
     highlightEdgeColor: PD.Color(Color.darken(Color.fromNormalizedRgb(1.0, 0.4, 0.6), 1.0)),
     selectEdgeColor: PD.Color(Color.darken(Color.fromNormalizedRgb(0.2, 1.0, 0.1), 1.0)),
     edgeScale: PD.Numeric(1, { min: 1, max: 3, step: 1 }, { description: 'Thickness of the edge.' }),