molstar 3.0.0-dev.5 → 3.0.0-dev.9

package/lib/mol-repr/visual.js

@@ -44,7 +44,7 @@ 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;
@@ -101,7 +101,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 +110,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 +134,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 +161,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 +184,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 +211,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 +235,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 +262,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 +284,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>;

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

@@ -65,6 +65,16 @@ export declare const SliceParams: {
         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 SliceParams = typeof SliceParams;
 export declare function getSliceParams(ctx: ThemeRegistryContext, volume: Volume): {
@@ -121,6 +131,16 @@ export declare function getSliceParams(ctx: ThemeRegistryContext, volume: 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 function SliceVisual(materialId: number): VolumeVisual<SliceParams>;
 export declare function SliceRepresentation(ctx: RepresentationContext, getParams: RepresentationParamsGetter<Volume, SliceParams>): VolumeRepresentation<SliceParams>;
@@ -178,4 +198,14 @@ export declare const SliceRepresentationProvider: VolumeRepresentationProvider<{
         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;
+        }>[];
+    }>>;
 }, "slice">;

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

@@ -15,7 +15,7 @@ import { Interval, SortedArray } from '../../mol-data/int';
 import { transformPositionArray } from '../../mol-geo/util';
 import { Color } from '../../mol-util/color';
 import { ColorTheme } from '../../mol-theme/color';
-import { encodeFloatRGBtoArray } from '../../mol-util/float-packing';
+import { packIntToRGBArray } from '../../mol-util/number-packing';
 import { eachVolumeLoci } from './util';
 export function createImage(ctx, volume, theme, props, image) {
     return __awaiter(this, void 0, void 0, function () {
@@ -99,7 +99,7 @@ function getPackedGroupArray(grid, props) {
     for (var iy = y0; iy < ny; ++iy) {
         for (var ix = x0; ix < nx; ++ix) {
             for (var iz = z0; iz < nz; ++iz) {
-                encodeFloatRGBtoArray(space.dataOffset(ix, iy, iz), groupArray, j);
+                packIntToRGBArray(space.dataOffset(ix, iy, iz), groupArray, j);
                 j += 4;
             }
         }

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

@@ -7,7 +7,7 @@ import { Volume } from '../../mol-model/volume';
 import { Interval, OrderedSet } from '../../mol-data/int';
 import { equalEps } from '../../mol-math/linear-algebra/3d/common';
 import { Vec3 } from '../../mol-math/linear-algebra/3d/vec3';
-import { encodeFloatRGBtoArray } from '../../mol-util/float-packing';
+import { packIntToRGBArray } from '../../mol-util/number-packing';
 // avoiding namespace lookup improved performance in Chrome (Aug 2020)
 var v3set = Vec3.set;
 var v3normalize = Vec3.normalize;
@@ -113,7 +113,7 @@ export function createVolumeTexture2d(volume, variant, padding) {
                 }
                 else {
                     if (variant === 'groups') {
-                        encodeFloatRGBtoArray(offset, array, index);
+                        packIntToRGBArray(offset, array, index);
                     }
                     else {
                         v3set(n0, data[o(Math.max(0, x - 1), y, z)], data[o(x, Math.max(0, y - 1), z)], data[o(x, y, Math.max(0, z - 1))]);

package/lib/mol-script/language/builder.d.ts

@@ -10,7 +10,6 @@ export declare namespace MolScriptBuilder {
         '@header': string;
         type: {
             '@header': string;
-            /** atom macromolecular property set */
             bool: MSymbol<import("./symbol").Arguments<import("./symbol").Arguments.PropTypes<{
                 0: import("./symbol").Argument<import("./type").Type.AnyValue>;
             }>>, import("./type").Type.OneOf<boolean>>;

package/lib/mol-theme/clipping.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -10,7 +10,7 @@ export { Clipping };
 declare type Clipping = {
     readonly layers: ReadonlyArray<Clipping.Layer>;
 };
-declare function Clipping(layers: ReadonlyArray<Clipping.Layer>): Clipping;
+declare function Clipping(layers: Clipping['layers']): Clipping;
 declare namespace Clipping {
     type Layer = {
         readonly loci: StructureElement.Loci;
@@ -44,22 +44,14 @@ declare namespace Clipping {
         function fromNames(names: Names[]): Flag;
         function toNames(groups: Groups): Names[];
     }
-    /** Clip object types */
-    const Type: {
-        none: number;
-        plane: number;
-        sphere: number;
-        cube: number;
-        cylinder: number;
-        infiniteCone: number;
-    };
-    type Variant = 'instance' | 'pixel';
     function areEqual(cA: Clipping, cB: Clipping): boolean;
+    /** Check if layers empty */
     function isEmpty(clipping: Clipping): boolean;
-    function remap(clipping: Clipping, structure: Structure): {
-        layers: Layer[];
-    };
+    /** Remap layers */
+    function remap(clipping: Clipping, structure: Structure): Clipping;
+    /** Merge layers */
     function merge(clipping: Clipping): Clipping;
+    /** Filter layers */
     function filter(clipping: Clipping, filter: Structure): Clipping;
     type ScriptLayer = {
         script: Script;