molstar 3.0.0-dev.0 → 3.0.0-dev.10

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

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * 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>
@@ -36,8 +36,16 @@ exports.TrackballControlsParams = {
     rotateSpeed: param_definition_1.ParamDefinition.Numeric(5.0, { min: 1, max: 10, step: 1 }),
     zoomSpeed: param_definition_1.ParamDefinition.Numeric(7.0, { min: 1, max: 15, step: 1 }),
     panSpeed: param_definition_1.ParamDefinition.Numeric(1.0, { min: 0.1, max: 5, step: 0.1 }),
-    spin: param_definition_1.ParamDefinition.Boolean(false, { description: 'Spin the 3D scene around the x-axis in view space' }),
-    spinSpeed: param_definition_1.ParamDefinition.Numeric(1, { min: -20, max: 20, step: 1 }),
+    animate: param_definition_1.ParamDefinition.MappedStatic('off', {
+        off: param_definition_1.ParamDefinition.EmptyGroup(),
+        spin: param_definition_1.ParamDefinition.Group({
+            speed: param_definition_1.ParamDefinition.Numeric(1, { min: -20, max: 20, step: 1 }),
+        }, { description: 'Spin the 3D scene around the x-axis in view space' }),
+        rock: param_definition_1.ParamDefinition.Group({
+            speed: param_definition_1.ParamDefinition.Numeric(0.3, { min: -5, max: 5, step: 0.1 }),
+            angle: param_definition_1.ParamDefinition.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: param_definition_1.ParamDefinition.Boolean(true, { isHidden: true }),
     dynamicDampingFactor: param_definition_1.ParamDefinition.Numeric(0.2, {}, { isHidden: true }),
     minDistance: param_definition_1.ParamDefinition.Numeric(0.01, {}, { isHidden: true }),
@@ -101,6 +109,10 @@ var TrackballControls;
             return linear_algebra_1.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 = (0, linear_algebra_1.Vec3)();
         var rotQuat = (0, linear_algebra_1.Quat)();
         var rotEyeDir = (0, linear_algebra_1.Vec3)();
@@ -111,8 +123,7 @@ var TrackballControls;
             var dx = _rotCurr[0] - _rotPrev[0];
             var dy = _rotCurr[1] - _rotPrev[1];
             linear_algebra_1.Vec3.set(rotMoveDir, dx, dy, 0);
-            var aspectRatio = input.width / input.height;
-            var angle = linear_algebra_1.Vec3.magnitude(rotMoveDir) * p.rotateSpeed * input.pixelRatio * aspectRatio;
+            var angle = linear_algebra_1.Vec3.magnitude(rotMoveDir) * getRotateFactor();
             if (angle) {
                 linear_algebra_1.Vec3.sub(_eye, camera.position, camera.target);
                 linear_algebra_1.Vec3.normalize(rotEyeDir, _eye);
@@ -238,8 +249,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);
+            }
             linear_algebra_1.Vec3.sub(_eye, camera.position, camera.target);
             rotateCamera();
             zRotateCamera();
@@ -270,6 +285,7 @@ var TrackballControls;
             if (!isStart && !_isInteracting)
                 return;
             _isInteracting = true;
+            resetRock(); // start rocking from the center after interactions
             var dragRotate = binding_1.Binding.match(p.bindings.dragRotate, buttons, modifiers);
             var dragRotateZ = binding_1.Binding.match(p.bindings.dragRotateZ, buttons, modifiers);
             var dragPan = binding_1.Binding.match(p.bindings.dragPan, buttons, modifiers);
@@ -358,12 +374,30 @@ var TrackballControls;
         }
         var _spinSpeed = linear_algebra_1.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)
-                linear_algebra_1.Vec2.add(_rotCurr, _rotPrev, _spinSpeed);
+            linear_algebra_1.Vec2.add(_rotCurr, _rotPrev, _spinSpeed);
+        }
+        var _rockPhase = 0;
+        var _rockSpeed = linear_algebra_1.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 = (0, misc_1.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;
+            linear_algebra_1.Vec2.add(_rotCurr, _rotPrev, _rockSpeed);
+            _rockPhase += dt;
+            if (_rockPhase >= 1) {
+                _rockPhase = 0;
+            }
+        }
+        function resetRock() {
+            _rockPhase = 0;
         }
         function start(t) {
             lastUpdated = -1;
@@ -371,8 +405,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/commonjs/mol-canvas3d/helper/bounding-sphere-helper.js

@@ -18,6 +18,7 @@ var names_1 = require("../../mol-util/color/names");
 var sphere_2 = require("../../mol-geo/primitive/sphere");
 var mol_util_1 = require("../../mol-util");
 var geometry_2 = require("../../mol-geo/geometry/geometry");
+var render_item_1 = require("../../mol-gl/webgl/render-item");
 exports.DebugHelperParams = {
     sceneBoundingSpheres: param_definition_1.ParamDefinition.Boolean(false, { description: 'Show full scene bounding spheres.' }),
     visibleSceneBoundingSpheres: param_definition_1.ParamDefinition.Boolean(false, { description: 'Show visible scene bounding spheres.' }),
@@ -28,7 +29,7 @@ var BoundingSphereHelper = /** @class */ (function () {
     function BoundingSphereHelper(ctx, parent, props) {
         this.objectsData = new Map();
         this.instancesData = new Map();
-        this.scene = scene_1.Scene.create(ctx);
+        this.scene = scene_1.Scene.create(ctx, render_item_1.GraphicsRenderVariantsBlended);
         this.parent = parent;
         this._props = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, param_definition_1.ParamDefinition.getDefaultValues(exports.DebugHelperParams)), props);
     }
@@ -151,6 +152,6 @@ var objectMaterialId = (0, render_object_1.getNextMaterialId)();
 var instanceMaterialId = (0, render_object_1.getNextMaterialId)();
 function createBoundingSphereRenderObject(mesh, color, materialId, transform) {
     var values = mesh_1.Mesh.Utils.createValuesSimple(mesh, { alpha: 0.1, doubleSided: false }, color, 1, transform);
-    return (0, render_object_1.createRenderObject)('mesh', values, { disposed: false, visible: true, alphaFactor: 1, pickable: false, colorOnly: false, opaque: false, writeDepth: false, noClip: false }, materialId);
+    return (0, render_object_1.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/commonjs/mol-canvas3d/helper/camera-helper.d.ts

@@ -22,8 +22,18 @@ 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: import("../../mol-util/material").Material;
+        material: PD.Normalize<{
+            metalness: number;
+            roughness: number;
+            bumpiness: number;
+        }>;
+        clip: PD.Normalize<{
+            variant: any;
+            objects: any;
+        }>;
     }>, "on">>;
 };
 export declare type CameraHelperParams = typeof CameraHelperParams;

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

@@ -14,6 +14,7 @@ var sphere_1 = require("../../mol-geo/geometry/mesh/builder/sphere");
 var mesh_1 = require("../../mol-geo/geometry/mesh/mesh");
 var mesh_builder_1 = require("../../mol-geo/geometry/mesh/mesh-builder");
 var scene_1 = require("../../mol-gl/scene");
+var render_item_1 = require("../../mol-gl/webgl/render-item");
 var geometry_1 = require("../../mol-math/geometry");
 var linear_algebra_1 = require("../../mol-math/linear-algebra");
 var loci_1 = require("../../mol-model/loci");
@@ -55,7 +56,7 @@ var CameraHelper = /** @class */ (function () {
             }
             return changed;
         };
-        this.scene = scene_1.Scene.create(webgl);
+        this.scene = scene_1.Scene.create(webgl, render_item_1.GraphicsRenderVariantsBlended);
         this.camera = new camera_1.Camera();
         linear_algebra_1.Vec3.set(this.camera.up, 0, 1, 0);
         linear_algebra_1.Vec3.set(this.camera.target, 0, 0, 0);
@@ -70,7 +71,6 @@ var CameraHelper = /** @class */ (function () {
                     _this.scene.clear();
                     var params = (0, tslib_1.__assign)((0, tslib_1.__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();
                     linear_algebra_1.Vec3.set(_this.camera.position, 0, 0, params.scale * 200);

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

@@ -24,8 +24,18 @@ 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: import("../../mol-util/material").Material;
+        material: PD.Normalize<{
+            metalness: number;
+            roughness: number;
+            bumpiness: number;
+        }>;
+        clip: PD.Normalize<{
+            variant: any;
+            objects: any;
+        }>;
     }>, "on">>;
 };
 export declare type HandleHelperParams = typeof HandleHelperParams;

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

@@ -23,6 +23,7 @@ var loci_1 = require("../../mol-model/loci");
 var marker_action_1 = require("../../mol-util/marker-action");
 var visual_1 = require("../../mol-repr/visual");
 var int_1 = require("../../mol-data/int");
+var render_item_1 = require("../../mol-gl/webgl/render-item");
 var HandleParams = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, mesh_1.Mesh.Params), { alpha: (0, tslib_1.__assign)((0, tslib_1.__assign)({}, mesh_1.Mesh.Params.alpha), { defaultValue: 1 }), ignoreLight: (0, tslib_1.__assign)((0, tslib_1.__assign)({}, mesh_1.Mesh.Params.ignoreLight), { defaultValue: true }), colorX: param_definition_1.ParamDefinition.Color(names_1.ColorNames.red, { isEssential: true }), colorY: param_definition_1.ParamDefinition.Color(names_1.ColorNames.green, { isEssential: true }), colorZ: param_definition_1.ParamDefinition.Color(names_1.ColorNames.blue, { isEssential: true }), scale: param_definition_1.ParamDefinition.Numeric(0.33, { min: 0.1, max: 2, step: 0.1 }, { isEssential: true }) });
 exports.HandleHelperParams = {
     handle: param_definition_1.ParamDefinition.MappedStatic('off', {
@@ -55,7 +56,7 @@ var HandleHelper = /** @class */ (function () {
             }
             return changed;
         };
-        this.scene = scene_1.Scene.create(webgl);
+        this.scene = scene_1.Scene.create(webgl, render_item_1.GraphicsRenderVariantsBlended);
         this.setProps(props);
     }
     HandleHelper.prototype.getBoundingSphere = function (out, instanceId) {
@@ -75,7 +76,6 @@ var HandleHelper = /** @class */ (function () {
                     _this.scene.clear();
                     var params = (0, tslib_1.__assign)((0, tslib_1.__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 = (0, tslib_1.__assign)({}, props.handle.params);

package/lib/commonjs/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/commonjs/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/commonjs/mol-canvas3d/passes/draw.js

@@ -197,23 +197,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 = postprocessing_1.PostprocessingPass.isEnabled(postprocessingProps);
-        var antialiasingEnabled = postprocessing_1.AntialiasingPass.isEnabled(postprocessingProps);
-        var markingEnabled = marking_1.MarkingPass.isEnabled(markingProps);
+        var postprocessingEnabled = postprocessing_1.PostprocessingPass.isEnabled(props.postprocessing);
+        var antialiasingEnabled = postprocessing_1.AntialiasingPass.isEnabled(props.postprocessing);
+        var markingEnabled = marking_1.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();
@@ -225,7 +225,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);
@@ -234,7 +234,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) {
@@ -250,7 +250,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();
@@ -264,16 +264,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 (stereo_1.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/commonjs/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/commonjs/mol-canvas3d/passes/image.js

@@ -76,12 +76,13 @@ var ImagePass = /** @class */ (function () {
         camera_1.Camera.copySnapshot(this._camera.state, this.camera.state);
         util_1.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 (multi_sample_1.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/commonjs/mol-canvas3d/passes/marking.js

@@ -20,7 +20,7 @@ var overlay_frag_1 = require("../../mol-gl/shader/marking/overlay.frag");
 var color_1 = require("../../mol-util/color");
 var edge_frag_1 = require("../../mol-gl/shader/marking/edge.frag");
 exports.MarkingParams = {
-    enabled: param_definition_1.ParamDefinition.Boolean(false),
+    enabled: param_definition_1.ParamDefinition.Boolean(true),
     highlightEdgeColor: param_definition_1.ParamDefinition.Color(color_1.Color.darken(color_1.Color.fromNormalizedRgb(1.0, 0.4, 0.6), 1.0)),
     selectEdgeColor: param_definition_1.ParamDefinition.Color(color_1.Color.darken(color_1.Color.fromNormalizedRgb(0.2, 1.0, 0.1), 1.0)),
     edgeScale: param_definition_1.ParamDefinition.Numeric(1, { min: 1, max: 3, step: 1 }, { description: 'Thickness of the edge.' }),

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

@@ -23,6 +23,13 @@ declare type Props = {
     multiSample: MultiSampleProps;
     postprocessing: PostprocessingProps;
     marking: MarkingProps;
+    transparentBackground: boolean;
+};
+declare type RenderContext = {
+    renderer: Renderer;
+    camera: Camera | StereoCamera;
+    scene: Scene;
+    helper: Helper;
 };
 export declare class MultiSamplePass {
     private webgl;
@@ -34,7 +41,7 @@ export declare class MultiSamplePass {
     private compose;
     constructor(webgl: WebGLContext, drawPass: DrawPass);
     syncSize(): void;
-    render(sampleIndex: number, renderer: Renderer, camera: Camera | StereoCamera, scene: Scene, helper: Helper, toDrawingBuffer: boolean, transparentBackground: boolean, props: Props): number;
+    render(sampleIndex: number, ctx: RenderContext, props: Props, toDrawingBuffer: boolean, forceOn: boolean): number;
     private bindOutputTarget;
     private renderMultiSample;
     private renderTemporalMultiSample;
@@ -43,7 +50,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(ctx: RenderContext, props: Props, toDrawingBuffer: boolean, forceOn?: boolean): boolean;
     constructor(multiSamplePass: MultiSamplePass);
 }
 export {};

package/lib/commonjs/mol-canvas3d/passes/multi-sample.js

@@ -27,8 +27,8 @@ function getComposeRenderable(ctx, colorTexture) {
     return (0, renderable_1.createComputeRenderable)(renderItem, values);
 }
 exports.MultiSampleParams = {
-    mode: param_definition_1.ParamDefinition.Select('off', [['off', 'Off'], ['on', 'On'], ['temporal', 'Temporal']]),
-    sampleLevel: param_definition_1.ParamDefinition.Numeric(2, { min: 0, max: 5, step: 1 }),
+    mode: param_definition_1.ParamDefinition.Select('temporal', [['off', 'Off'], ['on', 'On'], ['temporal', 'Temporal']]),
+    sampleLevel: param_definition_1.ParamDefinition.Numeric(2, { min: 0, max: 5, step: 1 }, { description: 'Take level^2 samples.' }),
 };
 var MultiSamplePass = /** @class */ (function () {
     function MultiSamplePass(webgl, drawPass) {
@@ -58,13 +58,13 @@ var MultiSamplePass = /** @class */ (function () {
             mol_util_1.ValueCell.update(this.compose.values.uTexSize, linear_algebra_1.Vec2.set(this.compose.values.uTexSize.ref.value, width, height));
         }
     };
-    MultiSamplePass.prototype.render = function (sampleIndex, renderer, camera, scene, helper, toDrawingBuffer, transparentBackground, props) {
-        if (props.multiSample.mode === 'temporal') {
-            return this.renderTemporalMultiSample(sampleIndex, renderer, camera, scene, helper, toDrawingBuffer, transparentBackground, props);
+    MultiSamplePass.prototype.render = function (sampleIndex, ctx, props, toDrawingBuffer, forceOn) {
+        if (props.multiSample.mode === 'temporal' && !forceOn) {
+            return this.renderTemporalMultiSample(sampleIndex, ctx, props, toDrawingBuffer);
         }
         else {
-            this.renderMultiSample(renderer, camera, scene, helper, toDrawingBuffer, transparentBackground, props);
-            return sampleIndex;
+            this.renderMultiSample(ctx, toDrawingBuffer, props);
+            return -2;
         }
     };
     MultiSamplePass.prototype.bindOutputTarget = function (toDrawingBuffer) {
@@ -75,7 +75,8 @@ var MultiSamplePass = /** @class */ (function () {
             this.colorTarget.bind();
         }
     };
-    MultiSamplePass.prototype.renderMultiSample = function (renderer, camera, scene, helper, toDrawingBuffer, transparentBackground, props) {
+    MultiSamplePass.prototype.renderMultiSample = function (ctx, toDrawingBuffer, props) {
+        var camera = ctx.camera;
         var _a = this, compose = _a.compose, composeTarget = _a.composeTarget, drawPass = _a.drawPass, webgl = _a.webgl;
         var gl = webgl.gl, state = webgl.state;
         // based on the Multisample Anti-Aliasing Render Pass
@@ -103,7 +104,7 @@ var MultiSamplePass = /** @class */ (function () {
             var sampleWeight = baseSampleWeight + roundingRange * uniformCenteredDistribution;
             mol_util_1.ValueCell.update(compose.values.uWeight, sampleWeight);
             // render scene
-            drawPass.render(renderer, camera, scene, helper, false, transparentBackground, props.postprocessing, props.marking);
+            drawPass.render(ctx, props, false);
             // compose rendered scene with compose target
             composeTarget.bind();
             state.enable(gl.BLEND);
@@ -130,7 +131,8 @@ var MultiSamplePass = /** @class */ (function () {
         camera.viewOffset.enabled = false;
         camera.update();
     };
-    MultiSamplePass.prototype.renderTemporalMultiSample = function (sampleIndex, renderer, camera, scene, helper, toDrawingBuffer, transparentBackground, props) {
+    MultiSamplePass.prototype.renderTemporalMultiSample = function (sampleIndex, ctx, props, toDrawingBuffer) {
+        var camera = ctx.camera;
         var _a = this, compose = _a.compose, composeTarget = _a.composeTarget, holdTarget = _a.holdTarget, drawPass = _a.drawPass, webgl = _a.webgl;
         var gl = webgl.gl, state = webgl.state;
         // based on the Multisample Anti-Aliasing Render Pass
@@ -144,7 +146,7 @@ var MultiSamplePass = /** @class */ (function () {
         var _b = camera.viewport, x = _b.x, y = _b.y, width = _b.width, height = _b.height;
         var sampleWeight = 1.0 / offsetList.length;
         if (sampleIndex === -1) {
-            drawPass.render(renderer, camera, scene, helper, false, transparentBackground, props.postprocessing, props.marking);
+            drawPass.render(ctx, props, false);
             mol_util_1.ValueCell.update(compose.values.uWeight, 1.0);
             mol_util_1.ValueCell.update(compose.values.tColor, drawPass.getColorTarget(props.postprocessing).texture);
             compose.update();
@@ -170,7 +172,7 @@ var MultiSamplePass = /** @class */ (function () {
                 camera_1.Camera.setViewOffset(camera.viewOffset, width, height, offset[0], offset[1], width, height);
                 camera.update();
                 // render scene
-                drawPass.render(renderer, camera, scene, helper, false, transparentBackground, props.postprocessing, props.marking);
+                drawPass.render(ctx, props, false);
                 // compose rendered scene with compose target
                 composeTarget.bind();
                 state.enable(gl.BLEND);
@@ -266,8 +268,10 @@ var MultiSampleHelper = /** @class */ (function () {
             this.sampleIndex = -1;
         return props.mode === 'temporal' ? this.sampleIndex !== -2 : false;
     };
-    MultiSampleHelper.prototype.render = function (renderer, camera, scene, helper, toDrawingBuffer, transparentBackground, props) {
-        this.sampleIndex = this.multiSamplePass.render(this.sampleIndex, renderer, camera, scene, helper, toDrawingBuffer, transparentBackground, props);
+    /** Return `true` while more samples are needed */
+    MultiSampleHelper.prototype.render = function (ctx, props, toDrawingBuffer, forceOn) {
+        this.sampleIndex = this.multiSamplePass.render(this.sampleIndex, ctx, props, toDrawingBuffer, !!forceOn);
+        return this.sampleIndex < 0;
     };
     return MultiSampleHelper;
 }());

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

@@ -8,7 +8,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PickHelper = exports.PickPass = void 0;
 var linear_algebra_1 = require("../../mol-math/linear-algebra");
 var misc_1 = require("../../mol-math/misc");
-var float_packing_1 = require("../../mol-util/float-packing");
+var number_packing_1 = require("../../mol-util/number-packing");
 var stereo_1 = require("../camera/stereo");
 var util_1 = require("../camera/util");
 var util_2 = require("../camera/util");
@@ -46,29 +46,29 @@ var PickPass = /** @class */ (function () {
             this.depthPickTarget.setSize(this.pickWidth, this.pickHeight);
         }
     };
-    PickPass.prototype.renderVariant = function (renderer, camera, scene, helper, variant) {
+    PickPass.prototype.renderVariant = function (renderer, camera, scene, helper, variant, pickType) {
         var depth = this.drawPass.depthTexturePrimitives;
         renderer.clear(false);
         renderer.update(camera);
-        renderer.renderPick(scene.primitives, camera, variant, null);
-        renderer.renderPick(scene.volumes, camera, variant, depth);
-        renderer.renderPick(helper.handle.scene, camera, variant, null);
+        renderer.renderPick(scene.primitives, camera, variant, null, pickType);
+        renderer.renderPick(scene.volumes, camera, variant, depth, pickType);
+        renderer.renderPick(helper.handle.scene, camera, variant, null, pickType);
         if (helper.camera.isEnabled) {
             helper.camera.update(camera);
             renderer.update(helper.camera.camera);
-            renderer.renderPick(helper.camera.scene, helper.camera.camera, variant, null);
+            renderer.renderPick(helper.camera.scene, helper.camera.camera, variant, null, pickType);
         }
     };
     PickPass.prototype.render = function (renderer, camera, scene, helper) {
         this.objectPickTarget.bind();
-        this.renderVariant(renderer, camera, scene, helper, 'pickObject');
+        this.renderVariant(renderer, camera, scene, helper, 'pick', 1 /* Object */);
         this.instancePickTarget.bind();
-        this.renderVariant(renderer, camera, scene, helper, 'pickInstance');
+        this.renderVariant(renderer, camera, scene, helper, 'pick', 2 /* Instance */);
         this.groupPickTarget.bind();
-        this.renderVariant(renderer, camera, scene, helper, 'pickGroup');
+        this.renderVariant(renderer, camera, scene, helper, 'pick', 3 /* Group */);
         // printTexture(this.webgl, this.groupPickTarget.texture, { id: 'group' })
         this.depthPickTarget.bind();
-        this.renderVariant(renderer, camera, scene, helper, 'depth');
+        this.renderVariant(renderer, camera, scene, helper, 'depth', 0 /* None */);
     };
     return PickPass;
 }());
@@ -127,11 +127,11 @@ var PickHelper = /** @class */ (function () {
     PickHelper.prototype.getDepth = function (x, y) {
         var idx = this.getBufferIdx(x, y);
         var b = this.depthBuffer;
-        return (0, float_packing_1.unpackRGBAToDepth)(b[idx], b[idx + 1], b[idx + 2], b[idx + 3]);
+        return (0, number_packing_1.unpackRGBAToDepth)(b[idx], b[idx + 1], b[idx + 2], b[idx + 3]);
     };
     PickHelper.prototype.getId = function (x, y, buffer) {
         var idx = this.getBufferIdx(x, y);
-        return (0, float_packing_1.decodeFloatRGB)(buffer[idx], buffer[idx + 1], buffer[idx + 2]);
+        return (0, number_packing_1.unpackRGBToInt)(buffer[idx], buffer[idx + 1], buffer[idx + 2]);
     };
     PickHelper.prototype.render = function (camera) {
         var _a = this, pickX = _a.pickX, pickY = _a.pickY, pickWidth = _a.pickWidth, pickHeight = _a.pickHeight, halfPickWidth = _a.halfPickWidth;

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

@@ -20,6 +20,7 @@ export declare const PostprocessingParams: {
     outline: PD.Mapped<PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
         scale: number;
         threshold: number;
+        color: Color;
     }>, "on">>;
     antialiasing: PD.Mapped<PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
         edgeThreshold: number;