molstar 3.26.0 → 3.28.0

package/lib/commonjs/mol-repr/volume/representation.js

@@ -21,6 +21,7 @@ var color_1 = require("../../mol-theme/color");
 var mol_util_1 = require("../../mol-util");
 var size_data_1 = require("../../mol-geo/geometry/size-data");
 var color_data_1 = require("../../mol-geo/geometry/color-data");
+var linear_algebra_1 = require("../../mol-math/linear-algebra");
 var representation_1 = require("../representation");
 var base_1 = require("../../mol-geo/geometry/base");
 var rxjs_1 = require("rxjs");
@@ -42,25 +43,28 @@ function VolumeVisual(builder, materialId) {
     var newProps;
     var newTheme;
     var newVolume;
+    var newKey;
     var currentProps = Object.assign({}, defaultProps);
     var currentTheme = theme_1.Theme.createEmpty();
     var currentVolume;
+    var currentKey;
     var geometry;
     var geometryVersion = -1;
     var locationIt;
     var positionIt;
-    function prepareUpdate(theme, props, volume) {
+    function prepareUpdate(theme, props, volume, key) {
         if (!volume && !currentVolume) {
             throw new Error('missing volume');
         }
         newProps = Object.assign({}, currentProps, props);
         newTheme = theme;
         newVolume = volume;
+        newKey = key;
         util_1.VisualUpdateState.reset(updateState);
         if (!renderObject) {
             updateState.createNew = true;
         }
-        else if (!currentVolume || !volume_1.Volume.areEquivalent(newVolume, currentVolume)) {
+        else if (!volume_1.Volume.areEquivalent(newVolume, currentVolume) || newKey !== currentKey) {
             updateState.createNew = true;
         }
         if (updateState.createNew) {
@@ -79,7 +83,7 @@ function VolumeVisual(builder, materialId) {
     }
     function update(newGeometry) {
         if (updateState.createNew) {
-            locationIt = createLocationIterator(newVolume);
+            locationIt = createLocationIterator(newVolume, newKey);
             if (newGeometry) {
                 renderObject = createVolumeRenderObject(newVolume, newGeometry, locationIt, newTheme, newProps, materialId);
                 positionIt = createPositionIterator(newGeometry, renderObject.values);
@@ -94,7 +98,7 @@ function VolumeVisual(builder, materialId) {
             }
             if (updateState.updateTransform) {
                 // console.log('update transform');
-                locationIt = createLocationIterator(newVolume);
+                locationIt = createLocationIterator(newVolume, newKey);
                 var instanceCount = locationIt.instanceCount, groupCount = locationIt.groupCount;
                 if (newProps.instanceGranularity) {
                     (0, marker_data_1.createMarkers)(instanceCount, 'instance', renderObject.values);
@@ -135,21 +139,32 @@ function VolumeVisual(builder, materialId) {
         currentProps = newProps;
         currentTheme = newTheme;
         currentVolume = newVolume;
+        currentKey = newKey;
         if (newGeometry) {
             geometry = newGeometry;
             geometryVersion += 1;
         }
     }
-    function eachInstance(loci, volume, apply) {
+    function eachInstance(loci, volume, key, apply) {
         var changed = false;
-        if (!volume_1.Volume.Cell.isLoci(loci))
-            return false;
-        if (volume_1.Volume.Cell.isLociEmpty(loci))
-            return false;
-        if (!volume_1.Volume.areEquivalent(loci.volume, volume))
-            return false;
-        if (apply(int_1.Interval.ofSingleton(0)))
-            changed = true;
+        if (volume_1.Volume.Cell.isLoci(loci)) {
+            if (volume_1.Volume.Cell.isLociEmpty(loci))
+                return false;
+            if (!volume_1.Volume.areEquivalent(loci.volume, volume))
+                return false;
+            if (apply(int_1.Interval.ofSingleton(0)))
+                changed = true;
+        }
+        else if (volume_1.Volume.Segment.isLoci(loci)) {
+            if (volume_1.Volume.Segment.isLociEmpty(loci))
+                return false;
+            if (!volume_1.Volume.areEquivalent(loci.volume, volume))
+                return false;
+            if (!int_1.SortedArray.has(loci.segments, key))
+                return false;
+            if (apply(int_1.Interval.ofSingleton(0)))
+                changed = true;
+        }
         return changed;
     }
     function lociApply(loci, apply) {
@@ -163,10 +178,10 @@ function VolumeVisual(builder, materialId) {
         }
         else {
             if (currentProps.instanceGranularity) {
-                return eachInstance(loci, currentVolume, apply);
+                return eachInstance(loci, currentVolume, currentKey, apply);
             }
             else {
-                return eachLocation(loci, currentVolume, currentProps, apply);
+                return eachLocation(loci, currentVolume, currentKey, currentProps, apply);
             }
         }
     }
@@ -174,14 +189,14 @@ function VolumeVisual(builder, materialId) {
         get groupCount() { return locationIt ? locationIt.count : 0; },
         get renderObject() { return renderObject; },
         get geometryVersion() { return geometryVersion; },
-        createOrUpdate: function (ctx, theme, props, volume) {
+        createOrUpdate: function (ctx, theme, props, volumeKey) {
             if (props === void 0) { props = {}; }
             return tslib_1.__awaiter(this, void 0, void 0, function () {
                 var newGeometry;
                 return tslib_1.__generator(this, function (_a) {
-                    prepareUpdate(theme, props, volume || currentVolume);
+                    prepareUpdate(theme, props, (volumeKey === null || volumeKey === void 0 ? void 0 : volumeKey.volume) || currentVolume, (volumeKey === null || volumeKey === void 0 ? void 0 : volumeKey.key) || currentKey);
                     if (updateState.createGeometry) {
-                        newGeometry = createGeometry(ctx, newVolume, newTheme, newProps, geometry);
+                        newGeometry = createGeometry(ctx, newVolume, newKey, newTheme, newProps, geometry);
                         return [2 /*return*/, (0, type_helpers_1.isPromiseLike)(newGeometry) ? newGeometry.then(update) : update(newGeometry)];
                     }
                     else {
@@ -192,7 +207,7 @@ function VolumeVisual(builder, materialId) {
             });
         },
         getLoci: function (pickingId) {
-            return renderObject ? getLoci(pickingId, currentVolume, currentProps, renderObject.id) : loci_1.EmptyLoci;
+            return renderObject ? getLoci(pickingId, currentVolume, currentKey, currentProps, renderObject.id) : loci_1.EmptyLoci;
         },
         mark: function (loci, action) {
             return visual_1.Visual.mark(renderObject, loci, action, lociApply);
@@ -242,7 +257,8 @@ function VolumeRepresentationProvider(p) { return p; }
 exports.VolumeRepresentationProvider = VolumeRepresentationProvider;
 //
 exports.VolumeParams = tslib_1.__assign({}, base_1.BaseGeometry.Params);
-function VolumeRepresentation(label, ctx, getParams, visualCtor, getLoci) {
+function VolumeRepresentation(label, ctx, getParams, visualCtor, getLoci, getKeys) {
+    if (getKeys === void 0) { getKeys = function () { return [-1]; }; }
     var version = 0;
     var webgl = ctx.webgl;
     var updated = new rxjs_1.Subject();
@@ -250,11 +266,31 @@ function VolumeRepresentation(label, ctx, getParams, visualCtor, getLoci) {
     var materialId = (0, render_object_1.getNextMaterialId)();
     var renderObjects = [];
     var _state = representation_1.Representation.createState();
-    var visual;
+    var visuals = new Map();
     var _volume;
+    var _keys;
     var _params;
     var _props;
     var _theme = theme_1.Theme.createEmpty();
+    function visual(runtime, key) {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var visual;
+            return tslib_1.__generator(this, function (_b) {
+                visual = visuals.get(key);
+                if (!visual) {
+                    visual = visualCtor(materialId, _volume, key, _props, webgl);
+                    visuals.set(key, visual);
+                }
+                else if ((_a = visual.mustRecreate) === null || _a === void 0 ? void 0 : _a.call(visual, { volume: _volume, key: key }, _props, webgl)) {
+                    visual.destroy();
+                    visual = visualCtor(materialId, _volume, key, _props, webgl);
+                    visuals.set(key, visual);
+                }
+                return [2 /*return*/, visual.createOrUpdate({ webgl: webgl, runtime: runtime }, _theme, _props, { volume: _volume, key: key })];
+            });
+        });
+    }
     function createOrUpdate(props, volume) {
         var _this = this;
         if (props === void 0) { props = {}; }
@@ -266,32 +302,42 @@ function VolumeRepresentation(label, ctx, getParams, visualCtor, getLoci) {
         }
         var qualityProps = (0, util_1.getQualityProps)(Object.assign({}, _props, props), _volume);
         Object.assign(_props, props, qualityProps);
+        _keys = getKeys(_props);
         return mol_task_1.Task.create('Creating or updating VolumeRepresentation', function (runtime) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            var promise;
-            var _a;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
+            var toDelete, i, il, segment, promise;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
-                        if (!visual) {
-                            visual = visualCtor(materialId, _volume, _props, webgl);
-                        }
-                        else if ((_a = visual.mustRecreate) === null || _a === void 0 ? void 0 : _a.call(visual, _volume, _props, webgl)) {
-                            visual.destroy();
-                            visual = visualCtor(materialId, _volume, _props, webgl);
-                        }
-                        promise = visual.createOrUpdate({ webgl: webgl, runtime: runtime }, _theme, _props, volume);
-                        if (!promise) return [3 /*break*/, 2];
-                        return [4 /*yield*/, promise];
+                        toDelete = new Set(visuals.keys());
+                        i = 0, il = _keys.length;
+                        _a.label = 1;
                     case 1:
-                        _b.sent();
-                        _b.label = 2;
+                        if (!(i < il)) return [3 /*break*/, 4];
+                        segment = _keys[i];
+                        toDelete.delete(segment);
+                        promise = visual(runtime, segment);
+                        if (!promise) return [3 /*break*/, 3];
+                        return [4 /*yield*/, promise];
                     case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        ++i;
+                        return [3 /*break*/, 1];
+                    case 4:
+                        toDelete.forEach(function (segment) {
+                            var _a;
+                            (_a = visuals.get(segment)) === null || _a === void 0 ? void 0 : _a.destroy();
+                            visuals.delete(segment);
+                        });
                         // update list of renderObjects
                         renderObjects.length = 0;
-                        if (visual && visual.renderObject) {
-                            renderObjects.push(visual.renderObject);
-                            geometryState.add(visual.renderObject.id, visual.geometryVersion);
-                        }
+                        visuals.forEach(function (visual) {
+                            if (visual.renderObject) {
+                                renderObjects.push(visual.renderObject);
+                                geometryState.add(visual.renderObject.id, visual.geometryVersion);
+                            }
+                        });
                         geometryState.snapshot();
                         // increment version
                         updated.next(version++);
@@ -301,9 +347,13 @@ function VolumeRepresentation(label, ctx, getParams, visualCtor, getLoci) {
         }); });
     }
     function mark(loci, action) {
-        return visual ? visual.mark(loci, action) : false;
+        var changed = false;
+        visuals.forEach(function (visual) {
+            changed = visual.mark(loci, action) || changed;
+        });
+        return changed;
     }
-    function setState(state) {
+    function setVisualState(visual, state) {
         if (state.visible !== undefined && visual)
             visual.setVisibility(state.visible);
         if (state.alphaFactor !== undefined && visual)
@@ -314,21 +364,60 @@ function VolumeRepresentation(label, ctx, getParams, visualCtor, getLoci) {
             visual.setOverpaint(state.overpaint);
         if (state.transparency !== undefined && visual)
             visual.setTransparency(state.transparency);
+        if (state.substance !== undefined && visual)
+            visual.setSubstance(state.substance);
+        if (state.clipping !== undefined && visual)
+            visual.setClipping(state.clipping);
         if (state.transform !== undefined && visual)
             visual.setTransform(state.transform);
+        if (state.themeStrength !== undefined && visual)
+            visual.setThemeStrength(state.themeStrength);
+    }
+    function setState(state) {
+        var visible = state.visible, alphaFactor = state.alphaFactor, pickable = state.pickable, overpaint = state.overpaint, transparency = state.transparency, substance = state.substance, clipping = state.clipping, transform = state.transform, themeStrength = state.themeStrength, syncManually = state.syncManually, markerActions = state.markerActions;
+        var newState = {};
+        if (visible !== _state.visible)
+            newState.visible = visible;
+        if (alphaFactor !== _state.alphaFactor)
+            newState.alphaFactor = alphaFactor;
+        if (pickable !== _state.pickable)
+            newState.pickable = pickable;
+        if (overpaint !== undefined)
+            newState.overpaint = overpaint;
+        if (transparency !== undefined)
+            newState.transparency = transparency;
+        if (substance !== undefined)
+            newState.substance = substance;
+        if (clipping !== undefined)
+            newState.clipping = clipping;
+        if (themeStrength !== undefined)
+            newState.themeStrength = themeStrength;
+        if (transform !== undefined && !linear_algebra_1.Mat4.areEqual(transform, _state.transform, linear_algebra_1.EPSILON)) {
+            newState.transform = transform;
+        }
+        if (syncManually !== _state.syncManually)
+            newState.syncManually = syncManually;
+        if (markerActions !== _state.markerActions)
+            newState.markerActions = markerActions;
+        visuals.forEach(function (visual) { return setVisualState(visual, newState); });
         representation_1.Representation.updateState(_state, state);
     }
     function setTheme(theme) {
         _theme = theme;
     }
     function destroy() {
-        if (visual)
-            visual.destroy();
+        visuals.forEach(function (visual) { return visual.destroy(); });
+        visuals.clear();
     }
     return {
         label: label,
         get groupCount() {
-            return visual ? visual.groupCount : 0;
+            var groupCount = 0;
+            visuals.forEach(function (visual) {
+                if (visual.renderObject)
+                    groupCount += visual.groupCount;
+            });
+            return groupCount;
         },
         get props() { return _props; },
         get params() { return _params; },
@@ -341,7 +430,13 @@ function VolumeRepresentation(label, ctx, getParams, visualCtor, getLoci) {
         setState: setState,
         setTheme: setTheme,
         getLoci: function (pickingId) {
-            return visual ? visual.getLoci(pickingId) : loci_1.EmptyLoci;
+            var loci = loci_1.EmptyLoci;
+            visuals.forEach(function (visual) {
+                var _loci = visual.getLoci(pickingId);
+                if (!(0, loci_1.isEmptyLoci)(_loci))
+                    loci = _loci;
+            });
+            return loci;
         },
         getAllLoci: function () {
             return [getLoci(_volume, _props)];

package/lib/commonjs/mol-repr/volume/segment.d.ts

@@ -0,0 +1,291 @@
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { ParamDefinition as PD } from '../../mol-util/param-definition';
+import { Volume } from '../../mol-model/volume';
+import { VisualContext } from '../visual';
+import { Theme, ThemeRegistryContext } from '../../mol-theme/theme';
+import { Mesh } from '../../mol-geo/geometry/mesh/mesh';
+import { VolumeVisual, VolumeRepresentation, VolumeRepresentationProvider } from './representation';
+import { RepresentationContext, RepresentationParamsGetter } from '../representation';
+import { Loci } from '../../mol-model/loci';
+import { Interval } from '../../mol-data/int';
+import { WebGLContext } from '../../mol-gl/webgl/context';
+export declare const VolumeSegmentParams: {
+    segments: PD.Converted<number[], string[]>;
+};
+export type VolumeSegmentParams = typeof VolumeSegmentParams;
+export type VolumeSegmentProps = PD.Values<VolumeSegmentParams>;
+export declare function SegmentVisual(materialId: number, volume: Volume, key: number, props: PD.Values<SegmentMeshParams>, webgl?: WebGLContext): VolumeVisual<{
+    quality: {
+        isEssential: boolean;
+        type: "select";
+        options: readonly (readonly ["auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest", string] | readonly ["auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest", string, string | undefined])[];
+        cycle?: boolean | undefined;
+        isOptional?: boolean | undefined;
+        defaultValue: "auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest";
+        label?: string | undefined;
+        description?: string | undefined;
+        legend?: import("../../mol-util/legend").Legend | undefined;
+        fieldLabels?: {
+            [name: string]: string;
+        } | undefined;
+        isHidden?: boolean | undefined;
+        shortLabel?: boolean | undefined;
+        twoColumns?: boolean | undefined;
+        category?: string | undefined;
+        hideIf?: ((currentGroup: any) => boolean) | undefined;
+        help?: ((value: any) => {
+            description?: string | undefined;
+            legend?: import("../../mol-util/legend").Legend | undefined;
+        }) | undefined;
+    };
+    tryUseGpu: PD.BooleanParam;
+    segments: PD.Converted<number[], string[]>;
+    doubleSided: PD.BooleanParam;
+    flipSided: PD.BooleanParam;
+    flatShaded: PD.BooleanParam;
+    ignoreLight: PD.BooleanParam;
+    xrayShaded: PD.BooleanParam;
+    transparentBackfaces: PD.Select<string>;
+    bumpFrequency: PD.Numeric;
+    bumpAmplitude: PD.Numeric;
+    alpha: PD.Numeric;
+    material: PD.Group<PD.Normalize<{
+        metalness: number;
+        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;
+        }>[];
+    }>>;
+    instanceGranularity: PD.BooleanParam;
+}>;
+export declare function eachSegment(loci: Loci, volume: Volume, key: number, props: VolumeSegmentProps, apply: (interval: Interval) => boolean): boolean;
+export declare function createVolumeSegmentMesh(ctx: VisualContext, volume: Volume, key: number, theme: Theme, props: VolumeSegmentProps, mesh?: Mesh): Promise<Mesh>;
+export declare const SegmentMeshParams: {
+    quality: {
+        isEssential: boolean;
+        type: "select";
+        options: readonly (readonly ["auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest", string] | readonly ["auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest", string, string | undefined])[];
+        cycle?: boolean | undefined;
+        isOptional?: boolean | undefined;
+        defaultValue: "auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest";
+        label?: string | undefined;
+        description?: string | undefined;
+        legend?: import("../../mol-util/legend").Legend | undefined;
+        fieldLabels?: {
+            [name: string]: string;
+        } | undefined;
+        isHidden?: boolean | undefined;
+        shortLabel?: boolean | undefined;
+        twoColumns?: boolean | undefined;
+        category?: string | undefined;
+        hideIf?: ((currentGroup: any) => boolean) | undefined;
+        help?: ((value: any) => {
+            description?: string | undefined;
+            legend?: import("../../mol-util/legend").Legend | undefined;
+        }) | undefined;
+    };
+    tryUseGpu: PD.BooleanParam;
+    segments: PD.Converted<number[], string[]>;
+    doubleSided: PD.BooleanParam;
+    flipSided: PD.BooleanParam;
+    flatShaded: PD.BooleanParam;
+    ignoreLight: PD.BooleanParam;
+    xrayShaded: PD.BooleanParam;
+    transparentBackfaces: PD.Select<string>;
+    bumpFrequency: PD.Numeric;
+    bumpAmplitude: PD.Numeric;
+    alpha: PD.Numeric;
+    material: PD.Group<PD.Normalize<{
+        metalness: number;
+        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;
+        }>[];
+    }>>;
+    instanceGranularity: PD.BooleanParam;
+};
+export type SegmentMeshParams = typeof SegmentMeshParams;
+export declare function SegmentMeshVisual(materialId: number): VolumeVisual<SegmentMeshParams>;
+export declare function SegmentTextureMeshVisual(materialId: number): VolumeVisual<SegmentMeshParams>;
+export declare const SegmentParams: {
+    visuals: PD.MultiSelect<"segment">;
+    bumpFrequency: PD.Numeric;
+    quality: {
+        isEssential: boolean;
+        type: "select";
+        options: readonly (readonly ["auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest", string] | readonly ["auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest", string, string | undefined])[];
+        cycle?: boolean | undefined;
+        isOptional?: boolean | undefined;
+        defaultValue: "auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest";
+        label?: string | undefined;
+        description?: string | undefined;
+        legend?: import("../../mol-util/legend").Legend | undefined;
+        fieldLabels?: {
+            [name: string]: string;
+        } | undefined;
+        isHidden?: boolean | undefined;
+        shortLabel?: boolean | undefined;
+        twoColumns?: boolean | undefined;
+        category?: string | undefined;
+        hideIf?: ((currentGroup: any) => boolean) | undefined;
+        help?: ((value: any) => {
+            description?: string | undefined;
+            legend?: import("../../mol-util/legend").Legend | undefined;
+        }) | undefined;
+    };
+    tryUseGpu: PD.BooleanParam;
+    segments: PD.Converted<number[], string[]>;
+    doubleSided: PD.BooleanParam;
+    flipSided: PD.BooleanParam;
+    flatShaded: PD.BooleanParam;
+    ignoreLight: PD.BooleanParam;
+    xrayShaded: PD.BooleanParam;
+    transparentBackfaces: PD.Select<string>;
+    bumpAmplitude: PD.Numeric;
+    alpha: PD.Numeric;
+    material: PD.Group<PD.Normalize<{
+        metalness: number;
+        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;
+        }>[];
+    }>>;
+    instanceGranularity: PD.BooleanParam;
+};
+export type SegmentParams = typeof SegmentParams;
+export declare function getSegmentParams(ctx: ThemeRegistryContext, volume: Volume): {
+    visuals: PD.MultiSelect<"segment">;
+    bumpFrequency: PD.Numeric;
+    quality: {
+        isEssential: boolean;
+        type: "select";
+        options: readonly (readonly ["auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest", string] | readonly ["auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest", string, string | undefined])[];
+        cycle?: boolean | undefined;
+        isOptional?: boolean | undefined;
+        defaultValue: "auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest";
+        label?: string | undefined;
+        description?: string | undefined;
+        legend?: import("../../mol-util/legend").Legend | undefined;
+        fieldLabels?: {
+            [name: string]: string;
+        } | undefined;
+        isHidden?: boolean | undefined;
+        shortLabel?: boolean | undefined;
+        twoColumns?: boolean | undefined;
+        category?: string | undefined;
+        hideIf?: ((currentGroup: any) => boolean) | undefined;
+        help?: ((value: any) => {
+            description?: string | undefined;
+            legend?: import("../../mol-util/legend").Legend | undefined;
+        }) | undefined;
+    };
+    tryUseGpu: PD.BooleanParam;
+    segments: PD.Converted<number[], string[]>;
+    doubleSided: PD.BooleanParam;
+    flipSided: PD.BooleanParam;
+    flatShaded: PD.BooleanParam;
+    ignoreLight: PD.BooleanParam;
+    xrayShaded: PD.BooleanParam;
+    transparentBackfaces: PD.Select<string>;
+    bumpAmplitude: PD.Numeric;
+    alpha: PD.Numeric;
+    material: PD.Group<PD.Normalize<{
+        metalness: number;
+        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;
+        }>[];
+    }>>;
+    instanceGranularity: PD.BooleanParam;
+};
+export type SegmentRepresentation = VolumeRepresentation<SegmentParams>;
+export declare function SegmentRepresentation(ctx: RepresentationContext, getParams: RepresentationParamsGetter<Volume, SegmentParams>): SegmentRepresentation;
+export declare const SegmentRepresentationProvider: VolumeRepresentationProvider<{
+    visuals: PD.MultiSelect<"segment">;
+    bumpFrequency: PD.Numeric;
+    quality: {
+        isEssential: boolean;
+        type: "select";
+        options: readonly (readonly ["auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest", string] | readonly ["auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest", string, string | undefined])[];
+        cycle?: boolean | undefined;
+        isOptional?: boolean | undefined;
+        defaultValue: "auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest";
+        label?: string | undefined;
+        description?: string | undefined;
+        legend?: import("../../mol-util/legend").Legend | undefined;
+        fieldLabels?: {
+            [name: string]: string;
+        } | undefined;
+        isHidden?: boolean | undefined;
+        shortLabel?: boolean | undefined;
+        twoColumns?: boolean | undefined;
+        category?: string | undefined;
+        hideIf?: ((currentGroup: any) => boolean) | undefined;
+        help?: ((value: any) => {
+            description?: string | undefined;
+            legend?: import("../../mol-util/legend").Legend | undefined;
+        }) | undefined;
+    };
+    tryUseGpu: PD.BooleanParam;
+    segments: PD.Converted<number[], string[]>;
+    doubleSided: PD.BooleanParam;
+    flipSided: PD.BooleanParam;
+    flatShaded: PD.BooleanParam;
+    ignoreLight: PD.BooleanParam;
+    xrayShaded: PD.BooleanParam;
+    transparentBackfaces: PD.Select<string>;
+    bumpAmplitude: PD.Numeric;
+    alpha: PD.Numeric;
+    material: PD.Group<PD.Normalize<{
+        metalness: number;
+        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;
+        }>[];
+    }>>;
+    instanceGranularity: PD.BooleanParam;
+}, "segment">;