molstar 3.8.2 → 3.9.0

package/lib/commonjs/servers/volume/server/algebra/coordinate.js

@@ -19,22 +19,22 @@ function domain(kind, info) {
 }
 exports.domain = domain;
 function cartesian(x, y, z) {
-    return { 0: x, 1: y, 2: z, kind: 0 /* Cartesian */ };
+    return { 0: x, 1: y, 2: z, kind: 0 /* Space.Cartesian */ };
 }
 exports.cartesian = cartesian;
 function fractional(x, y, z) {
-    return { 0: x, 1: y, 2: z, kind: 1 /* Fractional */ };
+    return { 0: x, 1: y, 2: z, kind: 1 /* Space.Fractional */ };
 }
 exports.fractional = fractional;
 function grid(domain, x, y, z) {
-    return { 0: x, 1: y, 2: z, kind: 2 /* Grid */, domain: domain };
+    return { 0: x, 1: y, 2: z, kind: 2 /* Space.Grid */, domain: domain };
 }
 exports.grid = grid;
 function withCoord(a, x, y, z) {
     switch (a.kind) {
-        case 0 /* Cartesian */: return cartesian(x, y, z);
-        case 1 /* Fractional */: return fractional(x, y, z);
-        case 2 /* Grid */: return grid(a.domain, x, y, z);
+        case 0 /* Space.Cartesian */: return cartesian(x, y, z);
+        case 1 /* Space.Fractional */: return fractional(x, y, z);
+        case 2 /* Space.Grid */: return grid(a.domain, x, y, z);
     }
 }
 exports.withCoord = withCoord;

package/lib/commonjs/servers/volume/server/query/encode.js

@@ -21,7 +21,7 @@ function encode(query, output) {
 exports.encode = encode;
 function string(name, str, isSpecified) {
     if (isSpecified) {
-        return cif_1.CifWriter.Field.str(name, function (i, d) { return str(d); }, { valueKind: function (i, d) { return isSpecified(d) ? 0 /* Present */ : 1 /* NotPresent */; } });
+        return cif_1.CifWriter.Field.str(name, function (i, d) { return str(d); }, { valueKind: function (i, d) { return isSpecified(d) ? 0 /* Column.ValueKind.Present */ : 1 /* Column.ValueKind.NotPresent */; } });
     }
     return cif_1.CifWriter.Field.str(name, function (i, d) { return str(d); });
 }

package/lib/examples/alpha-orbitals/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  */

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

@@ -55,6 +55,17 @@
             </a>
         </div>
         <script>
+            function getParam(name, regex) {
+                var r = new RegExp(name + '=' + '(' + regex + ')[&]?', 'i');
+                return decodeURIComponent(((window.location.search || '').match(r) || [])[1] || '');
+            }
+
+            var debugMode = getParam('debug-mode', '[^&]+').trim() === '1';
+            if (debugMode) AlphaOrbitalsExample.setDebugMode(debugMode);
+
+            var timingMode = getParam('timing-mode', '[^&]+').trim() === '1';
+            if (timingMode) AlphaOrbitalsExample.setTimingMode(timingMode);
+
             AlphaOrbitalsExample.init('app')
         </script>
         <!-- __MOLSTAR_ANALYTICS__ -->

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  */
@@ -18,6 +18,7 @@ import { mountControls } from './controls';
 import { DemoMoleculeSDF, DemoOrbitals } from './example-data';
 import './index.html';
 require('mol-plugin-ui/skin/light.scss');
+import { setDebugMode, setTimingMode } from '../../mol-util/debug';
 var AlphaOrbitalsExample = /** @class */ (function () {
     function AlphaOrbitalsExample() {
         this.params = new BehaviorSubject({});
@@ -229,3 +230,5 @@ var AlphaOrbitalsExample = /** @class */ (function () {
 }());
 export { AlphaOrbitalsExample };
 window.AlphaOrbitalsExample = new AlphaOrbitalsExample();
+window.AlphaOrbitalsExample.setDebugMode = setDebugMode;
+window.AlphaOrbitalsExample.setTimingMode = setTimingMode;

package/lib/examples/basic-wrapper/custom-theme.js

@@ -36,7 +36,7 @@ export function CustomColorTheme(ctx, props) {
 export var CustomColorThemeProvider = {
     name: 'basic-wrapper-custom-color-theme',
     label: 'Custom Color Theme',
-    category: "Miscellaneous" /* Misc */,
+    category: "Miscellaneous" /* ColorTheme.Category.Misc */,
     factory: CustomColorTheme,
     getParams: function () { return ({}); },
     defaultValues: {},

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

@@ -20,10 +20,10 @@ export function createProteopediaCustomTheme(colors) {
     }
     function getAsymId(unit) {
         switch (unit.kind) {
-            case 0 /* Atomic */:
+            case 0 /* Unit.Kind.Atomic */:
                 return StructureProperties.chain.label_asym_id;
-            case 1 /* Spheres */:
-            case 2 /* Gaussians */:
+            case 1 /* Unit.Kind.Spheres */:
+            case 2 /* Unit.Kind.Gaussians */:
                 return StructureProperties.coarse.asym_id;
         }
     }

package/lib/extensions/alpha-orbitals/density.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  */

package/lib/extensions/alpha-orbitals/density.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  */
@@ -7,6 +7,7 @@ import { __awaiter, __generator } from "tslib";
 import { sortArray } from '../../mol-data/util';
 import { canComputeGrid3dOnGPU } from '../../mol-gl/compute/grid3d';
 import { Task } from '../../mol-task';
+import { isTimingMode } from '../../mol-util/debug';
 import { createGrid, initCubeGrid } from './data-model';
 import { gpuComputeAlphaOrbitalsDensityGridValues } from './gpu/compute';
 export function createSphericalCollocationDensityGrid(params, orbitals, webgl) {
@@ -18,10 +19,13 @@ export function createSphericalCollocationDensityGrid(params, orbitals, webgl) {
                 case 0:
                     cubeGrid = initCubeGrid(params);
                     if (!canComputeGrid3dOnGPU(webgl)) return [3 /*break*/, 2];
+                    if (isTimingMode)
+                        webgl.timer.mark('createSphericalCollocationDensityGrid');
                     return [4 /*yield*/, gpuComputeAlphaOrbitalsDensityGridValues(ctx, webgl, cubeGrid, orbitals)];
                 case 1:
-                    // console.time('gpu');
                     matrix = _a.sent();
+                    if (isTimingMode)
+                        webgl.timer.markEnd('createSphericalCollocationDensityGrid');
                     return [3 /*break*/, 3];
                 case 2: throw new Error('Missing OES_texture_float WebGL extension.');
                 case 3:

package/lib/extensions/alpha-orbitals/orbitals.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * Inspired by https://github.com/dgasmith/gau2grid.
  *

package/lib/extensions/alpha-orbitals/orbitals.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * Inspired by https://github.com/dgasmith/gau2grid.
  *
@@ -9,10 +9,10 @@ import { __awaiter, __generator } from "tslib";
 import { sortArray } from '../../mol-data/util';
 import { canComputeGrid3dOnGPU } from '../../mol-gl/compute/grid3d';
 import { Task } from '../../mol-task';
+import { isTimingMode } from '../../mol-util/debug';
 import { sphericalCollocation } from './collocation';
 import { createGrid, initCubeGrid } from './data-model';
 import { gpuComputeAlphaOrbitalsGridValues } from './gpu/compute';
-// setDebugMode(true);
 export function createSphericalCollocationGrid(params, orbital, webgl) {
     var _this = this;
     return Task.create('Spherical Collocation Grid', function (ctx) { return __awaiter(_this, void 0, void 0, function () {
@@ -22,10 +22,13 @@ export function createSphericalCollocationGrid(params, orbital, webgl) {
                 case 0:
                     cubeGrid = initCubeGrid(params);
                     if (!canComputeGrid3dOnGPU(webgl)) return [3 /*break*/, 2];
+                    if (isTimingMode)
+                        webgl.timer.mark('createSphericalCollocationGrid');
                     return [4 /*yield*/, gpuComputeAlphaOrbitalsGridValues(ctx, webgl, cubeGrid, orbital)];
                 case 1:
-                    // console.time('gpu');
                     matrix = _a.sent();
+                    if (isTimingMode)
+                        webgl.timer.markEnd('createSphericalCollocationGrid');
                     return [3 /*break*/, 4];
                 case 2: return [4 /*yield*/, sphericalCollocation(cubeGrid, orbital, ctx)];
                 case 3:

package/lib/extensions/anvil/algorithm.js

@@ -93,7 +93,7 @@ function initialize(structure, props, accessibleSurfaceArea) {
                     eI = elements[j];
                     l.element = eI;
                     // consider only amino acids in chains
-                    if (getElementMoleculeType(unit, eI) !== 5 /* Protein */ || !isPartOfEntity(l)) {
+                    if (getElementMoleculeType(unit, eI) !== 5 /* MoleculeType.Protein */ || !isPartOfEntity(l)) {
                         continue;
                     }
                     // only CA is considered for downstream operations

package/lib/extensions/cellpack/color/generate.js

@@ -69,7 +69,7 @@ export function CellPackGenerateColorTheme(ctx, props) {
 export var CellPackGenerateColorThemeProvider = {
     name: 'cellpack-generate',
     label: 'CellPack Generate',
-    category: "Chain Property" /* Chain */,
+    category: "Chain Property" /* ColorTheme.Category.Chain */,
     factory: CellPackGenerateColorTheme,
     getParams: getCellPackGenerateColorThemeParams,
     defaultValues: PD.getDefaultValues(CellPackGenerateColorThemeParams),

package/lib/extensions/cellpack/color/provided.js

@@ -49,7 +49,7 @@ export function CellPackProvidedColorTheme(ctx, props) {
 export var CellPackProvidedColorThemeProvider = {
     name: 'cellpack-provided',
     label: 'CellPack Provided',
-    category: "Chain Property" /* Chain */,
+    category: "Chain Property" /* ColorTheme.Category.Chain */,
     factory: CellPackProvidedColorTheme,
     getParams: getCellPackProvidedColorThemeParams,
     defaultValues: PD.getDefaultValues(CellPackProvidedColorThemeParams),

package/lib/extensions/cellpack/state.js

@@ -336,7 +336,7 @@ var StructureFromAssemblies = PluginStateTransform.BuiltIn({
                                 invariantId = u.invariantId + offsetInvariantId;
                                 if (u.invariantId > maxInvariantId)
                                     maxInvariantId = u.invariantId;
-                                builder.addUnit(u.kind, u.model, u.conformation.operator, u.elements, 0 /* None */, invariantId);
+                                builder.addUnit(u.kind, u.model, u.conformation.operator, u.elements, 0 /* Unit.Trait.None */, invariantId);
                             }
                             offsetInvariantId += maxInvariantId + 1;
                         }

package/lib/extensions/dnatco/confal-pyramids/color.js

@@ -252,7 +252,7 @@ export function ConfalPyramidsColorTheme(ctx, props) {
 export var ConfalPyramidsColorThemeProvider = {
     name: 'confal-pyramids',
     label: 'Confal Pyramids',
-    category: "Residue Property" /* Residue */,
+    category: "Residue Property" /* ColorTheme.Category.Residue */,
     factory: ConfalPyramidsColorTheme,
     getParams: getConfalPyramidsColorThemeParams,
     defaultValues: PD.getDefaultValues(ConfalPyramidsColorThemeParams),

package/lib/extensions/g3d/model.js

@@ -93,7 +93,7 @@ function getTraj(ctx, data) {
                     for (i = 0; i < rowCount; ++i) {
                         e = normalized.entity_id[i];
                         eName.customName = e;
-                        entityId = entityBuilder.getEntityId(e, 7 /* DNA */, e, eName);
+                        entityId = entityBuilder.getEntityId(e, 7 /* MoleculeType.DNA */, e, eName);
                         entityIds[i] = entityId;
                     }
                     ihm_sphere_obj_site = Table.ofPartialColumns(BasicSchema.ihm_sphere_obj_site, {

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

@@ -75,7 +75,7 @@ export function PLDDTConfidenceColorTheme(ctx, props) {
 export var PLDDTConfidenceColorThemeProvider = {
     name: 'plddt-confidence',
     label: 'pLDDT Confidence',
-    category: "Validation" /* Validation */,
+    category: "Validation" /* ColorTheme.Category.Validation */,
     factory: PLDDTConfidenceColorTheme,
     getParams: getPLDDTConfidenceColorThemeParams,
     defaultValues: PD.getDefaultValues(getPLDDTConfidenceColorThemeParams({})),

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

@@ -61,7 +61,7 @@ export function QmeanScoreColorTheme(ctx, props) {
 export var QmeanScoreColorThemeProvider = {
     name: 'qmean-score',
     label: 'QMEAN Score',
-    category: "Validation" /* Validation */,
+    category: "Validation" /* ColorTheme.Category.Validation */,
     factory: QmeanScoreColorTheme,
     getParams: getQmeanScoreColorThemeParams,
     defaultValues: PD.getDefaultValues(getQmeanScoreColorThemeParams({})),

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

@@ -79,7 +79,7 @@ export function StructureQualityReportColorTheme(ctx, props) {
 export var StructureQualityReportColorThemeProvider = {
     name: 'pdbe-structure-quality-report',
     label: 'Structure Quality Report',
-    category: "Validation" /* Validation */,
+    category: "Validation" /* ColorTheme.Category.Validation */,
     factory: StructureQualityReportColorTheme,
     getParams: function (ctx) {
         var issueTypes = StructureQualityReport.getIssueTypes(ctx.structure);

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

@@ -12,10 +12,10 @@ import { getPalette, getPaletteParams } from '../../../mol-util/color/palette';
 var DefaultColor = Color(0xCCCCCC);
 function getAsymId(unit) {
     switch (unit.kind) {
-        case 0 /* Atomic */:
+        case 0 /* Unit.Kind.Atomic */:
             return StructureProperties.chain.label_asym_id;
-        case 1 /* Spheres */:
-        case 2 /* Gaussians */:
+        case 1 /* Unit.Kind.Spheres */:
+        case 2 /* Unit.Kind.Gaussians */:
             return StructureProperties.coarse.asym_id;
     }
 }
@@ -83,7 +83,7 @@ export function AssemblySymmetryClusterColorTheme(ctx, props) {
 export var AssemblySymmetryClusterColorThemeProvider = {
     name: AssemblySymmetry.Tag.Cluster,
     label: 'Assembly Symmetry Cluster',
-    category: "Symmetry" /* Symmetry */,
+    category: "Symmetry" /* ColorTheme.Category.Symmetry */,
     factory: AssemblySymmetryClusterColorTheme,
     getParams: getAssemblySymmetryClusterColorThemeParams,
     defaultValues: PD.getDefaultValues(AssemblySymmetryClusterColorThemeParams),

package/lib/extensions/rcsb/validation-report/color/density-fit.js

@@ -62,7 +62,7 @@ export function DensityFitColorTheme(ctx, props) {
 export var DensityFitColorThemeProvider = {
     name: ValidationReport.Tag.DensityFit,
     label: 'Density Fit',
-    category: "Validation" /* Validation */,
+    category: "Validation" /* ColorTheme.Category.Validation */,
     factory: DensityFitColorTheme,
     getParams: function () { return ({}); },
     defaultValues: PD.getDefaultValues({}),

package/lib/extensions/rcsb/validation-report/color/geometry-quality.js

@@ -51,7 +51,7 @@ export function GeometryQualityColorTheme(ctx, props) {
             if (value === undefined)
                 return DefaultColor;
             var count = SetUtils.differenceSize(value, ignore_1);
-            if (count > 0 && polymerType_1[rI] === 0 /* NA */) {
+            if (count > 0 && polymerType_1[rI] === 0 /* PolymerType.NA */) {
                 count = 0;
                 if (!ignore_1.has('clash') && clashes_1.getVertexEdgeCount(element) > 0)
                     count += 1;
@@ -92,7 +92,7 @@ export function GeometryQualityColorTheme(ctx, props) {
 export var GeometryQualityColorThemeProvider = {
     name: ValidationReport.Tag.GeometryQuality,
     label: 'Geometry Quality',
-    category: "Validation" /* Validation */,
+    category: "Validation" /* ColorTheme.Category.Validation */,
     factory: GeometryQualityColorTheme,
     getParams: getGeometricQualityColorThemeParams,
     defaultValues: PD.getDefaultValues(getGeometricQualityColorThemeParams({})),

package/lib/extensions/rcsb/validation-report/color/random-coil-index.js

@@ -50,7 +50,7 @@ export function RandomCoilIndexColorTheme(ctx, props) {
 export var RandomCoilIndexColorThemeProvider = {
     name: ValidationReport.Tag.RandomCoilIndex,
     label: 'Random Coil Index',
-    category: "Validation" /* Validation */,
+    category: "Validation" /* ColorTheme.Category.Validation */,
     factory: RandomCoilIndexColorTheme,
     getParams: function () { return ({}); },
     defaultValues: PD.getDefaultValues({}),

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

@@ -39,7 +39,7 @@ function createIntraUnitClashCylinderMesh(ctx, unit, structure, theme, props, me
             pos(elements[a[edgeIndex]], posA);
             pos(elements[b[edgeIndex]], posB);
         },
-        style: function (edgeIndex) { return 6 /* Disk */; },
+        style: function (edgeIndex) { return 6 /* LinkStyle.Disk */; },
         radius: function (edgeIndex) { return magnitude[edgeIndex] * sizeFactor; },
     };
     var _a = createLinkCylinderMesh(ctx, builderProps, props, mesh), m = _a.mesh, boundingSphere = _a.boundingSphere;
@@ -139,7 +139,7 @@ function createInterUnitClashCylinderMesh(ctx, structure, theme, props, mesh) {
             uA.conformation.position(uA.elements[b.indexA], posA);
             uB.conformation.position(uB.elements[b.indexB], posB);
         },
-        style: function (edgeIndex) { return 6 /* Disk */; },
+        style: function (edgeIndex) { return 6 /* LinkStyle.Disk */; },
         radius: function (edgeIndex) { return edges[edgeIndex].props.magnitude * sizeFactor; }
     };
     var _a = createLinkCylinderMesh(ctx, builderProps, props, mesh), m = _a.mesh, boundingSphere = _a.boundingSphere;

package/lib/mol-canvas3d/canvas3d.js

@@ -26,7 +26,7 @@ import { MultiSampleHelper, MultiSampleParams, MultiSamplePass } from './passes/
 import { PickHelper } from './passes/pick';
 import { ImagePass } from './passes/image';
 import { Sphere3D } from '../mol-math/geometry';
-import { isDebugMode } from '../mol-util/debug';
+import { isDebugMode, isTimingMode } from '../mol-util/debug';
 import { CameraHelperParams } from './helper/camera-helper';
 import { produce } from 'immer';
 import { HandleHelperParams } from './helper/handle-helper';
@@ -300,6 +300,8 @@ var Canvas3D;
                     stereoCamera.update();
                     cam = stereoCamera;
                 }
+                if (isTimingMode)
+                    webgl.timer.mark('Canvas3D.render');
                 var ctx = { renderer: renderer, camera: cam, scene: scene, helper: helper };
                 if (MultiSamplePass.isEnabled(p.multiSample)) {
                     var forceOn = !cameraChanged && markingUpdated && !controls.isAnimating;
@@ -308,6 +310,8 @@ var Canvas3D;
                 else {
                     passes.draw.render(ctx, p, true);
                 }
+                if (isTimingMode)
+                    webgl.timer.markEnd('Canvas3D.render');
                 // if only marking has updated, do not set the flag to dirty
                 pickHelper.dirty = pickHelper.dirty || shouldRender;
                 didRender = true;

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

@@ -18,14 +18,14 @@ var B = ButtonsType;
 var M = ModifiersKeys;
 var Trigger = Binding.Trigger;
 export var DefaultTrackballBindings = {
-    dragRotate: Binding([Trigger(1 /* Primary */, M.create())], 'Rotate', 'Drag using ${triggers}'),
-    dragRotateZ: Binding([Trigger(1 /* Primary */, M.create({ shift: true }))], 'Rotate around z-axis', 'Drag using ${triggers}'),
-    dragPan: Binding([Trigger(2 /* Secondary */, M.create()), Trigger(1 /* Primary */, M.create({ control: true }))], 'Pan', 'Drag using ${triggers}'),
+    dragRotate: Binding([Trigger(1 /* B.Flag.Primary */, M.create())], 'Rotate', 'Drag using ${triggers}'),
+    dragRotateZ: Binding([Trigger(1 /* B.Flag.Primary */, M.create({ shift: true }))], 'Rotate around z-axis', 'Drag using ${triggers}'),
+    dragPan: Binding([Trigger(2 /* B.Flag.Secondary */, M.create()), Trigger(1 /* B.Flag.Primary */, M.create({ control: true }))], 'Pan', 'Drag using ${triggers}'),
     dragZoom: Binding.Empty,
-    dragFocus: Binding([Trigger(8 /* Forth */, M.create())], 'Focus', 'Drag using ${triggers}'),
-    dragFocusZoom: Binding([Trigger(4 /* Auxilary */, M.create())], 'Focus and zoom', 'Drag using ${triggers}'),
-    scrollZoom: Binding([Trigger(4 /* Auxilary */, M.create())], 'Zoom', 'Scroll using ${triggers}'),
-    scrollFocus: Binding([Trigger(4 /* Auxilary */, M.create({ shift: true }))], 'Clip', 'Scroll using ${triggers}'),
+    dragFocus: Binding([Trigger(8 /* B.Flag.Forth */, M.create())], 'Focus', 'Drag using ${triggers}'),
+    dragFocusZoom: Binding([Trigger(4 /* B.Flag.Auxilary */, M.create())], 'Focus and zoom', 'Drag using ${triggers}'),
+    scrollZoom: Binding([Trigger(4 /* B.Flag.Auxilary */, M.create())], 'Zoom', 'Scroll using ${triggers}'),
+    scrollFocus: Binding([Trigger(4 /* B.Flag.Auxilary */, M.create({ shift: true }))], 'Clip', 'Scroll using ${triggers}'),
     scrollFocusZoom: Binding.Empty,
 };
 export var TrackballControlsParams = {

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

@@ -86,7 +86,7 @@ var CameraHelper = /** @class */ (function () {
     });
     CameraHelper.prototype.getLoci = function (pickingId) {
         var objectId = pickingId.objectId, groupId = pickingId.groupId, instanceId = pickingId.instanceId;
-        if (!this.renderObject || objectId !== this.renderObject.id || groupId === 0 /* None */)
+        if (!this.renderObject || objectId !== this.renderObject.id || groupId === 0 /* CameraHelperAxis.None */)
             return EmptyLoci;
         return CameraAxesLoci(this, groupId, instanceId);
     };
@@ -114,12 +114,12 @@ var CameraHelper = /** @class */ (function () {
 export { CameraHelper };
 function getAxisLabel(axis) {
     switch (axis) {
-        case 1 /* X */: return 'X Axis';
-        case 2 /* Y */: return 'Y Axis';
-        case 3 /* Z */: return 'Z Axis';
-        case 4 /* XY */: return 'XY Plane';
-        case 5 /* XZ */: return 'XZ Plane';
-        case 6 /* YZ */: return 'YZ Plane';
+        case 1 /* CameraHelperAxis.X */: return 'X Axis';
+        case 2 /* CameraHelperAxis.Y */: return 'Y Axis';
+        case 3 /* CameraHelperAxis.Z */: return 'Z Axis';
+        case 4 /* CameraHelperAxis.XY */: return 'XY Plane';
+        case 5 /* CameraHelperAxis.XZ */: return 'XZ Plane';
+        case 6 /* CameraHelperAxis.YZ */: return 'YZ Plane';
         default: return 'Axes';
     }
 }
@@ -160,33 +160,33 @@ function createAxesMesh(scale, mesh) {
     var y = Vec3.scale(Vec3(), Vec3.unitY, scale);
     var z = Vec3.scale(Vec3(), Vec3.unitZ, scale);
     var cylinderProps = { radiusTop: radius, radiusBottom: radius, radialSegments: 32 };
-    state.currentGroup = 0 /* None */;
+    state.currentGroup = 0 /* CameraHelperAxis.None */;
     addSphere(state, Vec3.origin, radius, 2);
-    state.currentGroup = 1 /* X */;
+    state.currentGroup = 1 /* CameraHelperAxis.X */;
     addSphere(state, x, radius, 2);
     addCylinder(state, Vec3.origin, x, 1, cylinderProps);
-    state.currentGroup = 2 /* Y */;
+    state.currentGroup = 2 /* CameraHelperAxis.Y */;
     addSphere(state, y, radius, 2);
     addCylinder(state, Vec3.origin, y, 1, cylinderProps);
-    state.currentGroup = 3 /* Z */;
+    state.currentGroup = 3 /* CameraHelperAxis.Z */;
     addSphere(state, z, radius, 2);
     addCylinder(state, Vec3.origin, z, 1, cylinderProps);
     Vec3.scale(x, x, 0.5);
     Vec3.scale(y, y, 0.5);
     Vec3.scale(z, z, 0.5);
-    state.currentGroup = 4 /* XY */;
+    state.currentGroup = 4 /* CameraHelperAxis.XY */;
     MeshBuilder.addTriangle(state, Vec3.origin, x, y);
     MeshBuilder.addTriangle(state, Vec3.origin, y, x);
     var xy = Vec3.add(Vec3(), x, y);
     MeshBuilder.addTriangle(state, xy, x, y);
     MeshBuilder.addTriangle(state, xy, y, x);
-    state.currentGroup = 5 /* XZ */;
+    state.currentGroup = 5 /* CameraHelperAxis.XZ */;
     MeshBuilder.addTriangle(state, Vec3.origin, x, z);
     MeshBuilder.addTriangle(state, Vec3.origin, z, x);
     var xz = Vec3.add(Vec3(), x, z);
     MeshBuilder.addTriangle(state, xz, x, z);
     MeshBuilder.addTriangle(state, xz, z, x);
-    state.currentGroup = 6 /* YZ */;
+    state.currentGroup = 6 /* CameraHelperAxis.YZ */;
     MeshBuilder.addTriangle(state, Vec3.origin, y, z);
     MeshBuilder.addTriangle(state, Vec3.origin, z, y);
     var yz = Vec3.add(Vec3(), y, z);

package/lib/mol-canvas3d/helper/interaction-events.js

@@ -85,7 +85,7 @@ var Canvas3dInteractionHelper = /** @class */ (function () {
     };
     Canvas3dInteractionHelper.prototype.identify = function (e, t) {
         var xyChanged = this.startX !== this.endX || this.startY !== this.endY;
-        if (e === 2 /* Drag */) {
+        if (e === 2 /* InputEvent.Drag */) {
             if (xyChanged && !this.outsideViewport(this.startX, this.startY)) {
                 this.events.drag.next({ current: this.prevLoci, buttons: this.buttons, button: this.button, modifiers: this.modifiers, pageStart: Vec2.create(this.startX, this.startY), pageEnd: Vec2.create(this.endX, this.endY) });
                 this.startX = this.endX;
@@ -100,7 +100,7 @@ var Canvas3dInteractionHelper = /** @class */ (function () {
             this.startX = this.endX;
             this.startY = this.endY;
         }
-        if (e === 1 /* Click */) {
+        if (e === 1 /* InputEvent.Click */) {
             var loci_1 = this.getLoci(this.id, this.position);
             this.events.click.next({ current: loci_1, buttons: this.buttons, button: this.button, modifiers: this.modifiers, page: Vec2.create(this.endX, this.endY), position: this.position });
             this.prevLoci = loci_1;
@@ -116,7 +116,7 @@ var Canvas3dInteractionHelper = /** @class */ (function () {
         if (this.inside && t - this.prevT > 1000 / this.props.maxFps) {
             this.prevT = t;
             this.currentIdentifyT = t;
-            this.identify(this.isInteracting ? 2 /* Drag */ : 0 /* Move */, t);
+            this.identify(this.isInteracting ? 2 /* InputEvent.Drag */ : 0 /* InputEvent.Move */, t);
         }
     };
     Canvas3dInteractionHelper.prototype.leave = function () {
@@ -140,7 +140,7 @@ var Canvas3dInteractionHelper = /** @class */ (function () {
         this.buttons = buttons;
         this.button = button;
         this.modifiers = modifiers;
-        this.identify(1 /* Click */, 0);
+        this.identify(1 /* InputEvent.Click */, 0);
     };
     Canvas3dInteractionHelper.prototype.drag = function (x, y, buttons, button, modifiers) {
         this.endX = x;
@@ -148,7 +148,7 @@ var Canvas3dInteractionHelper = /** @class */ (function () {
         this.buttons = buttons;
         this.button = button;
         this.modifiers = modifiers;
-        this.identify(2 /* Drag */, 0);
+        this.identify(2 /* InputEvent.Drag */, 0);
     };
     Canvas3dInteractionHelper.prototype.modify = function (modifiers) {
         if (ModifiersKeys.areEqual(modifiers, this.modifiers))

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

@@ -12,6 +12,7 @@ import { WboitPass } from './wboit';
 import { AntialiasingPass, PostprocessingPass } from './postprocessing';
 import { MarkingPass } from './marking';
 import { createCopyRenderable } from '../../mol-gl/compute/util';
+import { isTimingMode } from '../../mol-util/debug';
 var DrawPass = /** @class */ (function () {
     function DrawPass(webgl, width, height, enableWboit) {
         this.webgl = webgl;
@@ -92,8 +93,12 @@ var DrawPass = /** @class */ (function () {
         // render transparent primitives and volumes
         if (scene.opacityAverage < 1 || scene.volumes.renderables.length > 0) {
             this.wboit.bind();
-            renderer.renderWboitTransparent(scene.primitives, camera, this.depthTextureOpaque);
-            renderer.renderWboitTransparent(scene.volumes, camera, this.depthTextureOpaque);
+            if (scene.opacityAverage < 1) {
+                renderer.renderWboitTransparent(scene.primitives, camera, this.depthTextureOpaque);
+            }
+            if (scene.volumes.renderables.length > 0) {
+                renderer.renderWboitTransparent(scene.volumes, camera, this.depthTextureOpaque);
+            }
             // evaluate wboit
             if (PostprocessingPass.isEnabled(postprocessingProps)) {
                 this.postprocessing.target.bind();
@@ -105,7 +110,7 @@ var DrawPass = /** @class */ (function () {
         }
     };
     DrawPass.prototype._renderBlended = function (renderer, camera, scene, toDrawingBuffer, transparentBackground, postprocessingProps) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         if (toDrawingBuffer) {
             this.drawTarget.bind();
         }
@@ -148,9 +153,29 @@ var DrawPass = /** @class */ (function () {
                     (_b = this.colorTarget.depthRenderbuffer) === null || _b === void 0 ? void 0 : _b.attachFramebuffer(this.postprocessing.target.framebuffer);
                 }
             }
-            renderer.renderBlendedVolume(scene.volumes, camera, this.depthTextureOpaque);
+            if (scene.volumes.renderables.length > 0) {
+                var target = PostprocessingPass.isEnabled(postprocessingProps)
+                    ? this.postprocessing.target : this.colorTarget;
+                if (!this.packedDepth) {
+                    this.depthTextureOpaque.detachFramebuffer(target.framebuffer, 'depth');
+                }
+                else {
+                    (_c = this.colorTarget.depthRenderbuffer) === null || _c === void 0 ? void 0 : _c.detachFramebuffer(target.framebuffer);
+                }
+                target.bind();
+                renderer.renderBlendedVolume(scene.volumes, camera, this.depthTextureOpaque);
+                if (!this.packedDepth) {
+                    this.depthTextureOpaque.attachFramebuffer(target.framebuffer, 'depth');
+                }
+                else {
+                    (_d = this.colorTarget.depthRenderbuffer) === null || _d === void 0 ? void 0 : _d.attachFramebuffer(target.framebuffer);
+                }
+                target.bind();
+            }
+        }
+        if (scene.opacityAverage < 1) {
+            renderer.renderBlendedTransparent(scene.primitives, camera, null);
         }
-        renderer.renderBlendedTransparent(scene.primitives, camera, null);
     };
     DrawPass.prototype._render = function (renderer, camera, scene, helper, toDrawingBuffer, props) {
         var volumeRendering = scene.volumes.renderables.length > 0;
@@ -222,6 +247,8 @@ var DrawPass = /** @class */ (function () {
         this.webgl.gl.flush();
     };
     DrawPass.prototype.render = function (ctx, props, toDrawingBuffer) {
+        if (isTimingMode)
+            this.webgl.timer.mark('DrawPass.render');
         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());
@@ -233,6 +260,8 @@ var DrawPass = /** @class */ (function () {
         else {
             this._render(renderer, camera, scene, helper, toDrawingBuffer, props);
         }
+        if (isTimingMode)
+            this.webgl.timer.markEnd('DrawPass.render');
     };
     DrawPass.prototype.getColorTarget = function (postprocessingProps) {
         if (AntialiasingPass.isEnabled(postprocessingProps)) {