molstar 3.0.0-dev.6 → 3.0.0

package/lib/mol-repr/structure/visual/util/gaussian.js

@@ -18,11 +18,11 @@ export function getTextureMaxCells(webgl, structure) {
     return (d * d) / Math.max(1, (structure ? structure.units.length / 16 : 1));
 }
 //
-export function computeUnitGaussianDensity(structure, unit, props) {
+export function computeUnitGaussianDensity(structure, unit, sizeTheme, props) {
     var _this = this;
     var box = unit.lookup3d.boundary.box;
     var p = ensureReasonableResolution(box, props);
-    var _a = getUnitConformationAndRadius(structure, unit, p), position = _a.position, radius = _a.radius;
+    var _a = getUnitConformationAndRadius(structure, unit, sizeTheme, p), position = _a.position, radius = _a.radius;
     return Task.create('Gaussian Density', function (ctx) { return __awaiter(_this, void 0, void 0, function () {
         return __generator(this, function (_a) {
             switch (_a.label) {
@@ -32,22 +32,22 @@ export function computeUnitGaussianDensity(structure, unit, props) {
         });
     }); });
 }
-export function computeUnitGaussianDensityTexture(structure, unit, props, webgl, texture) {
+export function computeUnitGaussianDensityTexture(structure, unit, sizeTheme, props, webgl, texture) {
     var _this = this;
     var box = unit.lookup3d.boundary.box;
     var p = ensureReasonableResolution(box, props, getTextureMaxCells(webgl, structure));
-    var _a = getUnitConformationAndRadius(structure, unit, p), position = _a.position, radius = _a.radius;
+    var _a = getUnitConformationAndRadius(structure, unit, sizeTheme, p), position = _a.position, radius = _a.radius;
     return Task.create('Gaussian Density', function (ctx) { return __awaiter(_this, void 0, void 0, function () {
         return __generator(this, function (_a) {
             return [2 /*return*/, GaussianDensityTexture(webgl, position, box, radius, p, texture)];
         });
     }); });
 }
-export function computeUnitGaussianDensityTexture2d(structure, unit, powerOfTwo, props, webgl, texture) {
+export function computeUnitGaussianDensityTexture2d(structure, unit, sizeTheme, powerOfTwo, props, webgl, texture) {
     var _this = this;
     var box = unit.lookup3d.boundary.box;
     var p = ensureReasonableResolution(box, props, getTextureMaxCells(webgl, structure));
-    var _a = getUnitConformationAndRadius(structure, unit, p), position = _a.position, radius = _a.radius;
+    var _a = getUnitConformationAndRadius(structure, unit, sizeTheme, p), position = _a.position, radius = _a.radius;
     return Task.create('Gaussian Density', function (ctx) { return __awaiter(_this, void 0, void 0, function () {
         return __generator(this, function (_a) {
             return [2 /*return*/, GaussianDensityTexture2d(webgl, position, box, radius, powerOfTwo, p, texture)];
@@ -55,11 +55,11 @@ export function computeUnitGaussianDensityTexture2d(structure, unit, powerOfTwo,
     }); });
 }
 //
-export function computeStructureGaussianDensity(structure, props) {
+export function computeStructureGaussianDensity(structure, sizeTheme, props) {
     var _this = this;
     var box = structure.lookup3d.boundary.box;
     var p = ensureReasonableResolution(box, props);
-    var _a = getStructureConformationAndRadius(structure, props.ignoreHydrogens, props.traceOnly), position = _a.position, radius = _a.radius;
+    var _a = getStructureConformationAndRadius(structure, sizeTheme, props.ignoreHydrogens, props.traceOnly), position = _a.position, radius = _a.radius;
     return Task.create('Gaussian Density', function (ctx) { return __awaiter(_this, void 0, void 0, function () {
         return __generator(this, function (_a) {
             switch (_a.label) {
@@ -69,22 +69,22 @@ export function computeStructureGaussianDensity(structure, props) {
         });
     }); });
 }
-export function computeStructureGaussianDensityTexture(structure, props, webgl, texture) {
+export function computeStructureGaussianDensityTexture(structure, sizeTheme, props, webgl, texture) {
     var _this = this;
     var box = structure.lookup3d.boundary.box;
     var p = ensureReasonableResolution(box, props, getTextureMaxCells(webgl));
-    var _a = getStructureConformationAndRadius(structure, props.ignoreHydrogens, props.traceOnly), position = _a.position, radius = _a.radius;
+    var _a = getStructureConformationAndRadius(structure, sizeTheme, props.ignoreHydrogens, props.traceOnly), position = _a.position, radius = _a.radius;
     return Task.create('Gaussian Density', function (ctx) { return __awaiter(_this, void 0, void 0, function () {
         return __generator(this, function (_a) {
             return [2 /*return*/, GaussianDensityTexture(webgl, position, box, radius, p, texture)];
         });
     }); });
 }
-export function computeStructureGaussianDensityTexture2d(structure, powerOfTwo, props, webgl, texture) {
+export function computeStructureGaussianDensityTexture2d(structure, sizeTheme, powerOfTwo, props, webgl, texture) {
     var _this = this;
     var box = structure.lookup3d.boundary.box;
     var p = ensureReasonableResolution(box, props, getTextureMaxCells(webgl));
-    var _a = getStructureConformationAndRadius(structure, props.ignoreHydrogens, props.traceOnly), position = _a.position, radius = _a.radius;
+    var _a = getStructureConformationAndRadius(structure, sizeTheme, props.ignoreHydrogens, props.traceOnly), position = _a.position, radius = _a.radius;
     return Task.create('Gaussian Density', function (ctx) { return __awaiter(_this, void 0, void 0, function () {
         return __generator(this, function (_a) {
             return [2 /*return*/, GaussianDensityTexture2d(webgl, position, box, radius, powerOfTwo, p, texture)];

package/lib/mol-repr/structure/visual/util/molecular-surface.d.ts

@@ -8,5 +8,6 @@ import { Task } from '../../../../mol-task';
 import { CommonSurfaceProps } from './common';
 import { DensityData } from '../../../../mol-math/geometry';
 import { MolecularSurfaceCalculationProps } from '../../../../mol-math/geometry/molecular-surface';
+import { SizeTheme } from '../../../../mol-theme/size';
 export declare type MolecularSurfaceProps = MolecularSurfaceCalculationProps & CommonSurfaceProps;
-export declare function computeUnitMolecularSurface(structure: Structure, unit: Unit, props: MolecularSurfaceProps): Task<DensityData>;
+export declare function computeUnitMolecularSurface(structure: Structure, unit: Unit, sizeTheme: SizeTheme<any>, props: MolecularSurfaceProps): Task<DensityData>;

package/lib/mol-repr/structure/visual/util/molecular-surface.js

@@ -8,9 +8,9 @@ import { Task } from '../../../../mol-task';
 import { getUnitConformationAndRadius, ensureReasonableResolution } from './common';
 import { calcMolecularSurface } from '../../../../mol-math/geometry/molecular-surface';
 import { OrderedSet } from '../../../../mol-data/int';
-function getPositionDataAndMaxRadius(structure, unit, props) {
+function getPositionDataAndMaxRadius(structure, unit, sizeTheme, props) {
     var probeRadius = props.probeRadius;
-    var _a = getUnitConformationAndRadius(structure, unit, props), position = _a.position, boundary = _a.boundary, radius = _a.radius;
+    var _a = getUnitConformationAndRadius(structure, unit, sizeTheme, props), position = _a.position, boundary = _a.boundary, radius = _a.radius;
     var indices = position.indices;
     var n = OrderedSet.size(indices);
     var radii = new Float32Array(OrderedSet.end(indices));
@@ -24,11 +24,11 @@ function getPositionDataAndMaxRadius(structure, unit, props) {
     }
     return { position: __assign(__assign({}, position), { radius: radii }), boundary: boundary, maxRadius: maxRadius };
 }
-export function computeUnitMolecularSurface(structure, unit, props) {
+export function computeUnitMolecularSurface(structure, unit, sizeTheme, props) {
     var _this = this;
     var box = unit.lookup3d.boundary.box;
     var p = ensureReasonableResolution(box, props);
-    var _a = getPositionDataAndMaxRadius(structure, unit, p), position = _a.position, boundary = _a.boundary, maxRadius = _a.maxRadius;
+    var _a = getPositionDataAndMaxRadius(structure, unit, sizeTheme, p), position = _a.position, boundary = _a.boundary, maxRadius = _a.maxRadius;
     return Task.create('Molecular Surface', function (ctx) { return __awaiter(_this, void 0, void 0, function () {
         return __generator(this, function (_a) {
             switch (_a.label) {

package/lib/mol-repr/visual.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>
  */

package/lib/mol-repr/visual.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>
  */
@@ -44,11 +44,12 @@ var Visual;
     function mark(renderObject, loci, action, lociApply, previous) {
         if (!renderObject || isEmptyLoci(loci))
             return false;
-        var _a = renderObject.values, tMarker = _a.tMarker, dMarkerType = _a.dMarkerType, uMarker = _a.uMarker, markerAverage = _a.markerAverage, markerStatus = _a.markerStatus, uGroupCount = _a.uGroupCount, instanceCount = _a.instanceCount;
+        var _a = renderObject.values, tMarker = _a.tMarker, uMarker = _a.uMarker, markerAverage = _a.markerAverage, markerStatus = _a.markerStatus, uGroupCount = _a.uGroupCount, instanceCount = _a.instanceCount;
         var count = uGroupCount.ref.value * instanceCount.ref.value;
         var array = tMarker.ref.value.array;
         var currentStatus = markerStatus.ref.value;
         if (!isEveryLoci(loci)) {
+            // assume that all interval are non-overlapping
             var intervalSize_1 = 0;
             lociApply(loci, function (interval) {
                 intervalSize_1 += Interval.size(interval);
@@ -101,7 +102,6 @@ var Visual;
             ValueCell.updateIfChanged(uMarker, status);
             if (status === -1)
                 ValueCell.update(tMarker, tMarker.ref.value);
-            ValueCell.updateIfChanged(dMarkerType, status === -1 ? 'groupInstance' : 'uniform');
             ValueCell.updateIfChanged(markerAverage, average);
             ValueCell.updateIfChanged(markerStatus, status);
         }
@@ -111,7 +111,7 @@ var Visual;
     function setOverpaint(renderObject, overpaint, lociApply, clear, smoothing) {
         if (!renderObject)
             return;
-        var _a = renderObject.values, tOverpaint = _a.tOverpaint, dOverpaintType = _a.dOverpaintType, uGroupCount = _a.uGroupCount, instanceCount = _a.instanceCount;
+        var _a = renderObject.values, tOverpaint = _a.tOverpaint, dOverpaintType = _a.dOverpaintType, dOverpaint = _a.dOverpaint, uGroupCount = _a.uGroupCount, instanceCount = _a.instanceCount;
         var count = uGroupCount.ref.value * instanceCount.ref.value;
         // ensure texture has right size
         createOverpaint(overpaint.layers.length ? count : 0, renderObject.values);
@@ -135,6 +135,7 @@ var Visual;
         }
         ValueCell.update(tOverpaint, tOverpaint.ref.value);
         ValueCell.updateIfChanged(dOverpaintType, 'groupInstance');
+        ValueCell.updateIfChanged(dOverpaint, overpaint.layers.length > 0);
         if (overpaint.layers.length === 0)
             return;
         if (smoothing && hasColorSmoothingProp(smoothing.props)) {
@@ -161,7 +162,7 @@ var Visual;
     function setTransparency(renderObject, transparency, lociApply, clear, smoothing) {
         if (!renderObject)
             return;
-        var _a = renderObject.values, tTransparency = _a.tTransparency, dTransparencyType = _a.dTransparencyType, transparencyAverage = _a.transparencyAverage, uGroupCount = _a.uGroupCount, instanceCount = _a.instanceCount;
+        var _a = renderObject.values, tTransparency = _a.tTransparency, dTransparencyType = _a.dTransparencyType, transparencyAverage = _a.transparencyAverage, dTransparency = _a.dTransparency, uGroupCount = _a.uGroupCount, instanceCount = _a.instanceCount;
         var count = uGroupCount.ref.value * instanceCount.ref.value;
         // ensure texture has right size and variant
         createTransparency(transparency.layers.length ? count : 0, renderObject.values);
@@ -184,6 +185,7 @@ var Visual;
         ValueCell.update(tTransparency, tTransparency.ref.value);
         ValueCell.updateIfChanged(transparencyAverage, getTransparencyAverage(array, count));
         ValueCell.updateIfChanged(dTransparencyType, 'groupInstance');
+        ValueCell.updateIfChanged(dTransparency, transparency.layers.length > 0);
         if (transparency.layers.length === 0)
             return;
         if (smoothing && hasColorSmoothingProp(smoothing.props)) {
@@ -210,7 +212,7 @@ var Visual;
     function setSubstance(renderObject, substance, lociApply, clear, smoothing) {
         if (!renderObject)
             return;
-        var _a = renderObject.values, tSubstance = _a.tSubstance, dSubstanceType = _a.dSubstanceType, uGroupCount = _a.uGroupCount, instanceCount = _a.instanceCount;
+        var _a = renderObject.values, tSubstance = _a.tSubstance, dSubstanceType = _a.dSubstanceType, dSubstance = _a.dSubstance, uGroupCount = _a.uGroupCount, instanceCount = _a.instanceCount;
         var count = uGroupCount.ref.value * instanceCount.ref.value;
         // ensure texture has right size
         createSubstance(substance.layers.length ? count : 0, renderObject.values);
@@ -234,6 +236,7 @@ var Visual;
         }
         ValueCell.update(tSubstance, tSubstance.ref.value);
         ValueCell.updateIfChanged(dSubstanceType, 'groupInstance');
+        ValueCell.updateIfChanged(dSubstance, substance.layers.length > 0);
         if (substance.layers.length === 0)
             return;
         if (smoothing && hasColorSmoothingProp(smoothing.props)) {
@@ -260,10 +263,11 @@ var Visual;
     function setClipping(renderObject, clipping, lociApply, clear) {
         if (!renderObject)
             return;
-        var _a = renderObject.values, tClipping = _a.tClipping, uGroupCount = _a.uGroupCount, instanceCount = _a.instanceCount;
+        var _a = renderObject.values, tClipping = _a.tClipping, dClipping = _a.dClipping, uGroupCount = _a.uGroupCount, instanceCount = _a.instanceCount;
         var count = uGroupCount.ref.value * instanceCount.ref.value;
+        var layers = clipping.layers;
         // ensure texture has right size
-        createClipping(clipping.layers.length ? count : 0, renderObject.values);
+        createClipping(layers.length ? count : 0, renderObject.values);
         var array = tClipping.ref.value.array;
         // clear if requested
         if (clear)
@@ -281,6 +285,7 @@ var Visual;
             _loop_4(i, il);
         }
         ValueCell.update(tClipping, tClipping.ref.value);
+        ValueCell.updateIfChanged(dClipping, clipping.layers.length > 0);
     }
     Visual.setClipping = setClipping;
     function setTransform(renderObject, transform, instanceTransforms) {

package/lib/mol-repr/volume/direct-volume.d.ts

@@ -46,27 +46,9 @@ export declare const DirectVolumeParams: {
             legend?: import("../../mol-util/legend").Legend | undefined;
         }) | undefined;
     };
-    doubleSided: PD.BooleanParam;
-    flipSided: PD.BooleanParam;
-    flatShaded: PD.BooleanParam;
     ignoreLight: PD.BooleanParam;
     xrayShaded: PD.BooleanParam;
-    renderMode: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        controlPoints: import("../../mol-math/linear-algebra/3d/vec2").Vec2[];
-        list: {
-            kind: "set" | "interpolate";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "volume"> | PD.NamedParams<PD.Normalize<{
-        isoValue: Readonly<{
-            kind: "absolute";
-            absoluteValue: number;
-        }> | Readonly<{
-            kind: "relative";
-            relativeValue: number;
-        }>;
-        singleLayer: boolean;
-    }>, "isosurface">>;
+    controlPoints: PD.LineGraph;
     stepsPerCell: PD.Numeric;
     jumpLength: PD.Numeric;
     alpha: PD.Numeric;
@@ -75,6 +57,16 @@ export declare const DirectVolumeParams: {
         roughness: number;
         bumpiness: number;
     }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
 };
 export declare type DirectVolumeParams = typeof DirectVolumeParams;
 export declare function getDirectVolumeParams(ctx: ThemeRegistryContext, volume: Volume): {
@@ -101,27 +93,9 @@ export declare function getDirectVolumeParams(ctx: ThemeRegistryContext, volume:
             legend?: import("../../mol-util/legend").Legend | undefined;
         }) | undefined;
     };
-    doubleSided: PD.BooleanParam;
-    flipSided: PD.BooleanParam;
-    flatShaded: PD.BooleanParam;
     ignoreLight: PD.BooleanParam;
     xrayShaded: PD.BooleanParam;
-    renderMode: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        controlPoints: import("../../mol-math/linear-algebra/3d/vec2").Vec2[];
-        list: {
-            kind: "set" | "interpolate";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "volume"> | PD.NamedParams<PD.Normalize<{
-        isoValue: Readonly<{
-            kind: "absolute";
-            absoluteValue: number;
-        }> | Readonly<{
-            kind: "relative";
-            relativeValue: number;
-        }>;
-        singleLayer: boolean;
-    }>, "isosurface">>;
+    controlPoints: PD.LineGraph;
     stepsPerCell: PD.Numeric;
     jumpLength: PD.Numeric;
     alpha: PD.Numeric;
@@ -130,6 +104,16 @@ export declare function getDirectVolumeParams(ctx: ThemeRegistryContext, volume:
         roughness: number;
         bumpiness: number;
     }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
 };
 export declare type DirectVolumeProps = PD.Values<DirectVolumeParams>;
 export declare function DirectVolumeVisual(materialId: number): VolumeVisual<DirectVolumeParams>;
@@ -158,27 +142,9 @@ export declare const DirectVolumeRepresentationProvider: VolumeRepresentationPro
             legend?: import("../../mol-util/legend").Legend | undefined;
         }) | undefined;
     };
-    doubleSided: PD.BooleanParam;
-    flipSided: PD.BooleanParam;
-    flatShaded: PD.BooleanParam;
     ignoreLight: PD.BooleanParam;
     xrayShaded: PD.BooleanParam;
-    renderMode: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        controlPoints: import("../../mol-math/linear-algebra/3d/vec2").Vec2[];
-        list: {
-            kind: "set" | "interpolate";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "volume"> | PD.NamedParams<PD.Normalize<{
-        isoValue: Readonly<{
-            kind: "absolute";
-            absoluteValue: number;
-        }> | Readonly<{
-            kind: "relative";
-            relativeValue: number;
-        }>;
-        singleLayer: boolean;
-    }>, "isosurface">>;
+    controlPoints: PD.LineGraph;
     stepsPerCell: PD.Numeric;
     jumpLength: PD.Numeric;
     alpha: PD.Numeric;
@@ -187,4 +153,14 @@ export declare const DirectVolumeRepresentationProvider: VolumeRepresentationPro
         roughness: number;
         bumpiness: number;
     }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
 }, "direct-volume">;

package/lib/mol-repr/volume/direct-volume.js

@@ -35,7 +35,8 @@ export function createDirectVolume2d(ctx, webgl, volume, directVolume) {
     var texture = directVolume ? directVolume.gridTexture.ref.value : webgl.resources.texture('image-uint8', 'rgba', 'ubyte', 'linear');
     texture.load(textureImage);
     var _b = getUnitToCartn(volume.grid), unitToCartn = _b.unitToCartn, cellDim = _b.cellDim;
-    return DirectVolume.create(bbox, gridDimension, transform, unitToCartn, cellDim, texture, volume.grid.stats, false, directVolume);
+    var axisOrder = volume.grid.cells.space.axisOrderSlowToFast;
+    return DirectVolume.create(bbox, gridDimension, transform, unitToCartn, cellDim, texture, volume.grid.stats, false, axisOrder, directVolume);
 }
 // 3d volume texture
 function getUnitToCartn(grid) {
@@ -63,7 +64,8 @@ export function createDirectVolume3d(ctx, webgl, volume, directVolume) {
     var texture = directVolume ? directVolume.gridTexture.ref.value : webgl.resources.texture('volume-uint8', 'rgba', 'ubyte', 'linear');
     texture.load(textureVolume);
     var _a = getUnitToCartn(volume.grid), unitToCartn = _a.unitToCartn, cellDim = _a.cellDim;
-    return DirectVolume.create(bbox, gridDimension, transform, unitToCartn, cellDim, texture, volume.grid.stats, false, directVolume);
+    var axisOrder = volume.grid.cells.space.axisOrderSlowToFast;
+    return DirectVolume.create(bbox, gridDimension, transform, unitToCartn, cellDim, texture, volume.grid.stats, false, axisOrder, directVolume);
 }
 //
 export function createDirectVolume(ctx, volume, theme, props, directVolume) {
@@ -80,9 +82,7 @@ export function createDirectVolume(ctx, volume, theme, props, directVolume) {
     });
 }
 function getLoci(volume, props) {
-    return props.renderMode.name === 'isosurface'
-        ? Volume.Isosurface.Loci(volume, props.renderMode.params.isoValue)
-        : Volume.Loci(volume);
+    return Volume.Loci(volume);
 }
 export function getDirectVolumeLoci(pickingId, volume, props, id) {
     var objectId = pickingId.objectId, groupId = pickingId.groupId;
@@ -92,16 +92,12 @@ export function getDirectVolumeLoci(pickingId, volume, props, id) {
     return EmptyLoci;
 }
 export function eachDirectVolume(loci, volume, props, apply) {
-    var isoValue = props.renderMode.name === 'isosurface'
-        ? props.renderMode.params.isoValue : undefined;
-    return eachVolumeLoci(loci, volume, isoValue, apply);
+    return eachVolumeLoci(loci, volume, undefined, apply);
 }
 //
 export var DirectVolumeParams = __assign(__assign({}, DirectVolume.Params), { quality: __assign(__assign({}, DirectVolume.Params.quality), { isEssential: false }) });
 export function getDirectVolumeParams(ctx, volume) {
-    var p = PD.clone(DirectVolumeParams);
-    p.renderMode = DirectVolume.createRenderModeParam(volume.grid.stats);
-    return p;
+    return PD.clone(DirectVolumeParams);
 }
 export function DirectVolumeVisual(materialId) {
     return VolumeVisual({
@@ -128,7 +124,7 @@ export var DirectVolumeRepresentationProvider = VolumeRepresentationProvider({
     factory: DirectVolumeRepresentation,
     getParams: getDirectVolumeParams,
     defaultValues: PD.getDefaultValues(DirectVolumeParams),
-    defaultColorTheme: { name: 'uniform' },
+    defaultColorTheme: { name: 'volume-value' },
     defaultSizeTheme: { name: 'uniform' },
     isApplicable: function (volume) { return !Volume.isEmpty(volume); }
 });

package/lib/mol-repr/volume/isosurface.d.ts

@@ -101,6 +101,16 @@ export declare function IsosurfaceVisual(materialId: number, volume: Volume, pro
         roughness: number;
         bumpiness: number;
     }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
 }>;
 export declare function eachIsosurface(loci: Loci, volume: Volume, props: VolumeIsosurfaceProps, apply: (interval: Interval) => boolean): boolean;
 export declare function createVolumeIsosurfaceMesh(ctx: VisualContext, volume: Volume, theme: Theme, props: VolumeIsosurfaceProps, mesh?: Mesh): Promise<Mesh>;
@@ -164,6 +174,16 @@ export declare const IsosurfaceMeshParams: {
         roughness: number;
         bumpiness: number;
     }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
 };
 export declare type IsosurfaceMeshParams = typeof IsosurfaceMeshParams;
 export declare function IsosurfaceMeshVisual(materialId: number): VolumeVisual<IsosurfaceMeshParams>;
@@ -223,6 +243,16 @@ export declare const IsosurfaceWireframeParams: {
         roughness: number;
         bumpiness: number;
     }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
 };
 export declare type IsosurfaceWireframeParams = typeof IsosurfaceWireframeParams;
 export declare function IsosurfaceWireframeVisual(materialId: number): VolumeVisual<IsosurfaceWireframeParams>;
@@ -282,6 +312,16 @@ export declare const IsosurfaceParams: {
         roughness: number;
         bumpiness: number;
     }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
     tryUseGpu: PD.BooleanParam;
     doubleSided: PD.BooleanParam;
     flipSided: PD.BooleanParam;
@@ -347,6 +387,16 @@ export declare function getIsosurfaceParams(ctx: ThemeRegistryContext, volume: V
         roughness: number;
         bumpiness: number;
     }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
     tryUseGpu: PD.BooleanParam;
     doubleSided: PD.BooleanParam;
     flipSided: PD.BooleanParam;
@@ -413,6 +463,16 @@ export declare const IsosurfaceRepresentationProvider: VolumeRepresentationProvi
         roughness: number;
         bumpiness: number;
     }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
     tryUseGpu: PD.BooleanParam;
     doubleSided: PD.BooleanParam;
     flipSided: PD.BooleanParam;

package/lib/mol-repr/volume/isosurface.js

@@ -31,6 +31,11 @@ function gpuSupport(webgl) {
 }
 var Padding = 1;
 function suitableForGpu(volume, webgl) {
+    // small volumes are about as fast or faster on CPU vs integrated GPU
+    if (volume.grid.cells.data.length < Math.pow(10, 3))
+        return false;
+    // the GPU is much more memory contraint, especially true for integrated GPUs,
+    // fallback to CPU for large volumes
     var gridDim = volume.grid.cells.space.dimensions;
     var powerOfTwoSize = getVolumeTexture2dLayout(gridDim, Padding).powerOfTwoSize;
     return powerOfTwoSize <= webgl.maxTextureSize / 2;
@@ -140,17 +145,21 @@ var VolumeIsosurfaceTexture;
 })(VolumeIsosurfaceTexture || (VolumeIsosurfaceTexture = {}));
 function createVolumeIsosurfaceTextureMesh(ctx, volume, theme, props, textureMesh) {
     return __awaiter(this, void 0, void 0, function () {
-        var _a, max, min, diff, value, isoLevel, _b, texture, gridDimension, gridTexDim, gridTexScale, transform, buffer, gv, surface;
+        var _a, max, min, diff, value, isoLevel, _b, texture, gridDimension, gridTexDim, gridTexScale, transform, axisOrder, buffer, gv, surface;
         return __generator(this, function (_c) {
             if (!ctx.webgl)
                 throw new Error('webgl context required to create volume isosurface texture-mesh');
+            if (volume.grid.cells.data.length <= 1) {
+                return [2 /*return*/, TextureMesh.createEmpty(textureMesh)];
+            }
             _a = volume.grid.stats, max = _a.max, min = _a.min;
             diff = max - min;
             value = Volume.IsoValue.toAbsolute(props.isoValue, volume.grid.stats).absoluteValue;
             isoLevel = ((value - min) / diff);
             _b = VolumeIsosurfaceTexture.get(volume, ctx.webgl), texture = _b.texture, gridDimension = _b.gridDimension, gridTexDim = _b.gridTexDim, gridTexScale = _b.gridTexScale, transform = _b.transform;
+            axisOrder = volume.grid.cells.space.axisOrderSlowToFast;
             buffer = textureMesh === null || textureMesh === void 0 ? void 0 : textureMesh.doubleBuffer.get();
-            gv = extractIsosurface(ctx.webgl, texture, gridDimension, gridTexDim, gridTexScale, transform, isoLevel, value < 0, false, buffer === null || buffer === void 0 ? void 0 : buffer.vertex, buffer === null || buffer === void 0 ? void 0 : buffer.group, buffer === null || buffer === void 0 ? void 0 : buffer.normal);
+            gv = extractIsosurface(ctx.webgl, texture, gridDimension, gridTexDim, gridTexScale, transform, isoLevel, value < 0, false, axisOrder, buffer === null || buffer === void 0 ? void 0 : buffer.vertex, buffer === null || buffer === void 0 ? void 0 : buffer.group, buffer === null || buffer === void 0 ? void 0 : buffer.normal);
             surface = TextureMesh.create(gv.vertexCount, 1, gv.vertexTexture, gv.groupTexture, gv.normalTexture, Volume.getBoundingSphere(volume), textureMesh);
             return [2 /*return*/, surface];
         });

package/lib/mol-repr/volume/registry.d.ts

@@ -66,6 +66,16 @@ export declare namespace VolumeRepresentationRegistry {
                 roughness: number;
                 bumpiness: number;
             }>>;
+            clip: import("../../mol-util/param-definition").ParamDefinition.Group<import("../../mol-util/param-definition").ParamDefinition.Normalize<{
+                variant: import("../../mol-util/clip").Clip.Variant;
+                objects: import("../../mol-util/param-definition").ParamDefinition.Normalize<{
+                    type: any;
+                    invert: any;
+                    position: any;
+                    rotation: any;
+                    scale: any;
+                }>[];
+            }>>;
             tryUseGpu: import("../../mol-util/param-definition").ParamDefinition.BooleanParam;
             doubleSided: import("../../mol-util/param-definition").ParamDefinition.BooleanParam;
             flipSided: import("../../mol-util/param-definition").ParamDefinition.BooleanParam;
@@ -128,6 +138,16 @@ export declare namespace VolumeRepresentationRegistry {
                 roughness: number;
                 bumpiness: number;
             }>>;
+            clip: import("../../mol-util/param-definition").ParamDefinition.Group<import("../../mol-util/param-definition").ParamDefinition.Normalize<{
+                variant: import("../../mol-util/clip").Clip.Variant;
+                objects: import("../../mol-util/param-definition").ParamDefinition.Normalize<{
+                    type: any;
+                    invert: any;
+                    position: any;
+                    rotation: any;
+                    scale: any;
+                }>[];
+            }>>;
         }, "slice">;
         'direct-volume': import("./representation").VolumeRepresentationProvider<{
             quality: {
@@ -153,27 +173,9 @@ export declare namespace VolumeRepresentationRegistry {
                     legend?: import("../../mol-util/legend").Legend | undefined;
                 }) | undefined;
             };
-            doubleSided: import("../../mol-util/param-definition").ParamDefinition.BooleanParam;
-            flipSided: import("../../mol-util/param-definition").ParamDefinition.BooleanParam;
-            flatShaded: import("../../mol-util/param-definition").ParamDefinition.BooleanParam;
             ignoreLight: import("../../mol-util/param-definition").ParamDefinition.BooleanParam;
             xrayShaded: import("../../mol-util/param-definition").ParamDefinition.BooleanParam;
-            renderMode: import("../../mol-util/param-definition").ParamDefinition.Mapped<import("../../mol-util/param-definition").ParamDefinition.NamedParams<import("../../mol-util/param-definition").ParamDefinition.Normalize<{
-                controlPoints: import("../../mol-math/linear-algebra/3d/vec2").Vec2[];
-                list: {
-                    kind: "set" | "interpolate";
-                    colors: import("../../mol-util/color/color").ColorListEntry[];
-                };
-            }>, "volume"> | import("../../mol-util/param-definition").ParamDefinition.NamedParams<import("../../mol-util/param-definition").ParamDefinition.Normalize<{
-                isoValue: Readonly<{
-                    kind: "absolute";
-                    absoluteValue: number;
-                }> | Readonly<{
-                    kind: "relative";
-                    relativeValue: number;
-                }>;
-                singleLayer: boolean;
-            }>, "isosurface">>;
+            controlPoints: import("../../mol-util/param-definition").ParamDefinition.LineGraph;
             stepsPerCell: import("../../mol-util/param-definition").ParamDefinition.Numeric;
             jumpLength: import("../../mol-util/param-definition").ParamDefinition.Numeric;
             alpha: import("../../mol-util/param-definition").ParamDefinition.Numeric;
@@ -182,6 +184,16 @@ export declare namespace VolumeRepresentationRegistry {
                 roughness: number;
                 bumpiness: number;
             }>>;
+            clip: import("../../mol-util/param-definition").ParamDefinition.Group<import("../../mol-util/param-definition").ParamDefinition.Normalize<{
+                variant: import("../../mol-util/clip").Clip.Variant;
+                objects: import("../../mol-util/param-definition").ParamDefinition.Normalize<{
+                    type: any;
+                    invert: any;
+                    position: any;
+                    rotation: any;
+                    scale: any;
+                }>[];
+            }>>;
         }, "direct-volume">;
     };
     type _BuiltIn = typeof BuiltIn;

package/lib/mol-repr/volume/representation.d.ts

@@ -43,6 +43,16 @@ export declare const VolumeParams: {
         roughness: number;
         bumpiness: number;
     }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
 };
 export declare type VolumeParams = typeof VolumeParams;
 export declare function VolumeRepresentation<P extends VolumeParams>(label: string, ctx: RepresentationContext, getParams: RepresentationParamsGetter<Volume, P>, visualCtor: (materialId: number, volume: Volume, props: PD.Values<P>, webgl?: WebGLContext) => VolumeVisual<P>, getLoci: (volume: Volume, props: PD.Values<P>) => Loci): VolumeRepresentation<P>;