molstar 3.26.0 → 3.28.0

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

@@ -11,13 +11,14 @@ import { Geometry } from '../../mol-geo/geometry/geometry';
 import { Theme } from '../../mol-theme/theme';
 import { createIdentityTransform } from '../../mol-geo/geometry/transform-data';
 import { createRenderObject, getNextMaterialId } from '../../mol-gl/render-object';
-import { isEveryLoci, EmptyLoci } from '../../mol-model/loci';
-import { Interval } from '../../mol-data/int';
+import { isEveryLoci, EmptyLoci, isEmptyLoci } from '../../mol-model/loci';
+import { Interval, SortedArray } from '../../mol-data/int';
 import { getQualityProps, VisualUpdateState } from '../util';
 import { ColorTheme } from '../../mol-theme/color';
 import { ValueCell } from '../../mol-util';
 import { createSizes } from '../../mol-geo/geometry/size-data';
 import { createColors } from '../../mol-geo/geometry/color-data';
+import { EPSILON, Mat4 } from '../../mol-math/linear-algebra';
 import { Representation } from '../representation';
 import { BaseGeometry } from '../../mol-geo/geometry/base';
 import { Subject } from 'rxjs';
@@ -39,25 +40,28 @@ export function VolumeVisual(builder, materialId) {
     var newProps;
     var newTheme;
     var newVolume;
+    var newKey;
     var currentProps = Object.assign({}, defaultProps);
     var currentTheme = 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;
         VisualUpdateState.reset(updateState);
         if (!renderObject) {
             updateState.createNew = true;
         }
-        else if (!currentVolume || !Volume.areEquivalent(newVolume, currentVolume)) {
+        else if (!Volume.areEquivalent(newVolume, currentVolume) || newKey !== currentKey) {
             updateState.createNew = true;
         }
         if (updateState.createNew) {
@@ -76,7 +80,7 @@ export 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);
@@ -91,7 +95,7 @@ export 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) {
                     createMarkers(instanceCount, 'instance', renderObject.values);
@@ -132,21 +136,32 @@ export 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.Cell.isLoci(loci))
-            return false;
-        if (Volume.Cell.isLociEmpty(loci))
-            return false;
-        if (!Volume.areEquivalent(loci.volume, volume))
-            return false;
-        if (apply(Interval.ofSingleton(0)))
-            changed = true;
+        if (Volume.Cell.isLoci(loci)) {
+            if (Volume.Cell.isLociEmpty(loci))
+                return false;
+            if (!Volume.areEquivalent(loci.volume, volume))
+                return false;
+            if (apply(Interval.ofSingleton(0)))
+                changed = true;
+        }
+        else if (Volume.Segment.isLoci(loci)) {
+            if (Volume.Segment.isLociEmpty(loci))
+                return false;
+            if (!Volume.areEquivalent(loci.volume, volume))
+                return false;
+            if (!SortedArray.has(loci.segments, key))
+                return false;
+            if (apply(Interval.ofSingleton(0)))
+                changed = true;
+        }
         return changed;
     }
     function lociApply(loci, apply) {
@@ -160,10 +175,10 @@ export 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);
             }
         }
     }
@@ -171,14 +186,14 @@ export 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 __awaiter(this, void 0, void 0, function () {
                 var newGeometry;
                 return __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*/, isPromiseLike(newGeometry) ? newGeometry.then(update) : update(newGeometry)];
                     }
                     else {
@@ -189,7 +204,7 @@ export function VolumeVisual(builder, materialId) {
             });
         },
         getLoci: function (pickingId) {
-            return renderObject ? getLoci(pickingId, currentVolume, currentProps, renderObject.id) : EmptyLoci;
+            return renderObject ? getLoci(pickingId, currentVolume, currentKey, currentProps, renderObject.id) : EmptyLoci;
         },
         mark: function (loci, action) {
             return Visual.mark(renderObject, loci, action, lociApply);
@@ -237,7 +252,8 @@ export function VolumeVisual(builder, materialId) {
 export function VolumeRepresentationProvider(p) { return p; }
 //
 export var VolumeParams = __assign({}, BaseGeometry.Params);
-export function VolumeRepresentation(label, ctx, getParams, visualCtor, getLoci) {
+export 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 Subject();
@@ -245,11 +261,31 @@ export function VolumeRepresentation(label, ctx, getParams, visualCtor, getLoci)
     var materialId = getNextMaterialId();
     var renderObjects = [];
     var _state = Representation.createState();
-    var visual;
+    var visuals = new Map();
     var _volume;
+    var _keys;
     var _params;
     var _props;
     var _theme = Theme.createEmpty();
+    function visual(runtime, key) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var visual;
+            return __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 = {}; }
@@ -261,32 +297,42 @@ export function VolumeRepresentation(label, ctx, getParams, visualCtor, getLoci)
         }
         var qualityProps = getQualityProps(Object.assign({}, _props, props), _volume);
         Object.assign(_props, props, qualityProps);
+        _keys = getKeys(_props);
         return Task.create('Creating or updating VolumeRepresentation', function (runtime) { return __awaiter(_this, void 0, void 0, function () {
-            var promise;
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            var toDelete, i, il, segment, promise;
+            return __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++);
@@ -296,9 +342,13 @@ export 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)
@@ -309,21 +359,60 @@ export 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 && !Mat4.areEqual(transform, _state.transform, 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.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; },
@@ -336,7 +425,13 @@ export function VolumeRepresentation(label, ctx, getParams, visualCtor, getLoci)
         setState: setState,
         setTheme: setTheme,
         getLoci: function (pickingId) {
-            return visual ? visual.getLoci(pickingId) : EmptyLoci;
+            var loci = EmptyLoci;
+            visuals.forEach(function (visual) {
+                var _loci = visual.getLoci(pickingId);
+                if (!isEmptyLoci(_loci))
+                    loci = _loci;
+            });
+            return loci;
         },
         getAllLoci: function () {
             return [getLoci(_volume, _props)];

package/lib/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">;