molstar 2.3.9 → 3.0.0-dev.10

package/lib/commonjs/mol-theme/substance.js

@@ -0,0 +1,141 @@
+"use strict";
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Substance = void 0;
+var loci_1 = require("../mol-model/loci");
+var structure_1 = require("../mol-model/structure");
+var script_1 = require("../mol-script/script");
+var material_1 = require("../mol-util/material");
+var object_1 = require("../mol-util/object");
+function Substance(layers) {
+    return { layers: layers };
+}
+exports.Substance = Substance;
+(function (Substance) {
+    Substance.Empty = { layers: [] };
+    function areEqual(sA, sB) {
+        if (sA.layers.length === 0 && sB.layers.length === 0)
+            return true;
+        if (sA.layers.length !== sB.layers.length)
+            return false;
+        for (var i = 0, il = sA.layers.length; i < il; ++i) {
+            if (sA.layers[i].clear !== sB.layers[i].clear)
+                return false;
+            if (!(0, object_1.shallowEqual)(sA.layers[i].material, sB.layers[i].material))
+                return false;
+            if (!loci_1.Loci.areEqual(sA.layers[i].loci, sB.layers[i].loci))
+                return false;
+        }
+        return true;
+    }
+    Substance.areEqual = areEqual;
+    function isEmpty(overpaint) {
+        return overpaint.layers.length === 0;
+    }
+    Substance.isEmpty = isEmpty;
+    function remap(substance, structure) {
+        var layers = [];
+        for (var _i = 0, _a = substance.layers; _i < _a.length; _i++) {
+            var layer = _a[_i];
+            var loci = layer.loci, material = layer.material, clear = layer.clear;
+            loci = structure_1.StructureElement.Loci.remap(loci, structure);
+            if (!structure_1.StructureElement.Loci.isEmpty(loci)) {
+                layers.push({ loci: loci, material: material, clear: clear });
+            }
+        }
+        return { layers: layers };
+    }
+    Substance.remap = remap;
+    function merge(substance) {
+        if (isEmpty(substance))
+            return substance;
+        var structure = substance.layers[0].loci.structure;
+        var clearLoci = void 0;
+        var map = new Map();
+        var shadowed = structure_1.StructureElement.Loci.none(structure);
+        for (var i = 0, il = substance.layers.length; i < il; ++i) {
+            var _a = substance.layers[il - i - 1], loci = _a.loci, material = _a.material, clear = _a.clear; // process from end
+            loci = structure_1.StructureElement.Loci.subtract(loci, shadowed);
+            shadowed = structure_1.StructureElement.Loci.union(loci, shadowed);
+            if (!structure_1.StructureElement.Loci.isEmpty(loci)) {
+                if (clear) {
+                    clearLoci = clearLoci
+                        ? structure_1.StructureElement.Loci.union(loci, clearLoci)
+                        : loci;
+                }
+                else {
+                    if (map.has(material)) {
+                        loci = structure_1.StructureElement.Loci.union(loci, map.get(material));
+                    }
+                    map.set(material, loci);
+                }
+            }
+        }
+        var layers = [];
+        if (clearLoci) {
+            layers.push({ loci: clearLoci, material: (0, material_1.Material)(), clear: true });
+        }
+        map.forEach(function (loci, material) {
+            layers.push({ loci: loci, material: material, clear: false });
+        });
+        return { layers: layers };
+    }
+    Substance.merge = merge;
+    function filter(substance, filter) {
+        if (isEmpty(substance))
+            return substance;
+        var structure = substance.layers[0].loci.structure;
+        var layers = [];
+        for (var _i = 0, _a = substance.layers; _i < _a.length; _i++) {
+            var layer = _a[_i];
+            var loci = layer.loci, material = layer.material, clear = layer.clear;
+            // filter by first map to the `filter` structure and
+            // then map back to the original structure of the substance loci
+            var filtered = structure_1.StructureElement.Loci.remap(loci, filter);
+            loci = structure_1.StructureElement.Loci.remap(filtered, structure);
+            if (!structure_1.StructureElement.Loci.isEmpty(loci)) {
+                layers.push({ loci: loci, material: material, clear: clear });
+            }
+        }
+        return { layers: layers };
+    }
+    Substance.filter = filter;
+    function ofScript(scriptLayers, structure) {
+        var layers = [];
+        for (var i = 0, il = scriptLayers.length; i < il; ++i) {
+            var _a = scriptLayers[i], script = _a.script, material = _a.material, clear = _a.clear;
+            var loci = script_1.Script.toLoci(script, structure);
+            if (!structure_1.StructureElement.Loci.isEmpty(loci)) {
+                layers.push({ loci: loci, material: material, clear: clear });
+            }
+        }
+        return { layers: layers };
+    }
+    Substance.ofScript = ofScript;
+    function ofBundle(bundleLayers, structure) {
+        var layers = [];
+        for (var i = 0, il = bundleLayers.length; i < il; ++i) {
+            var _a = bundleLayers[i], bundle = _a.bundle, material = _a.material, clear = _a.clear;
+            var loci = structure_1.StructureElement.Bundle.toLoci(bundle, structure.root);
+            layers.push({ loci: loci, material: material, clear: clear });
+        }
+        return { layers: layers };
+    }
+    Substance.ofBundle = ofBundle;
+    function toBundle(overpaint) {
+        var layers = [];
+        for (var i = 0, il = overpaint.layers.length; i < il; ++i) {
+            var _a = overpaint.layers[i], loci = _a.loci, material = _a.material, clear = _a.clear;
+            var bundle = structure_1.StructureElement.Bundle.fromLoci(loci);
+            layers.push({ bundle: bundle, material: material, clear: clear });
+        }
+        return { layers: layers };
+    }
+    Substance.toBundle = toBundle;
+})(Substance || (Substance = {}));
+exports.Substance = Substance;
+//# sourceMappingURL=substance.js.map

package/lib/commonjs/mol-util/clip.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { Vec3 } from '../mol-math/linear-algebra';
+import { ParamDefinition as PD } from './param-definition';
+export interface Clip {
+    variant: Clip.Variant;
+    objects: Clip.Objects;
+}
+export declare function Clip(): void;
+export declare namespace Clip {
+    /** Clip object types */
+    const Type: {
+        none: number;
+        plane: number;
+        sphere: number;
+        cube: number;
+        cylinder: number;
+        infiniteCone: number;
+    };
+    type Variant = 'instance' | 'pixel';
+    type Objects = {
+        count: number;
+        type: number[];
+        invert: boolean[];
+        position: number[];
+        rotation: number[];
+        scale: number[];
+    };
+    const Params: {
+        variant: PD.Select<Variant>;
+        objects: PD.ObjectList<PD.Normalize<{
+            type: "none" | "sphere" | "cube" | "plane" | "cylinder" | "infiniteCone";
+            invert: boolean;
+            position: Vec3;
+            rotation: PD.Normalize<{
+                axis: any;
+                angle: any;
+            }>;
+            scale: Vec3;
+        }>>;
+    };
+    type Params = typeof Params;
+    type Props = PD.Values<Params>;
+    function getClip(props: Props, clip?: Clip): Clip;
+    function areEqual(cA: Clip, cB: Clip): boolean;
+}

package/lib/commonjs/mol-util/clip.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Clip = void 0;
+var linear_algebra_1 = require("../mol-math/linear-algebra");
+var misc_1 = require("../mol-math/misc");
+var param_definition_1 = require("./param-definition");
+var string_1 = require("./string");
+function Clip() {
+}
+exports.Clip = Clip;
+(function (Clip) {
+    /** Clip object types */
+    Clip.Type = {
+        none: 0,
+        plane: 1,
+        sphere: 2,
+        cube: 3,
+        cylinder: 4,
+        infiniteCone: 5,
+    };
+    Clip.Params = {
+        variant: param_definition_1.ParamDefinition.Select('pixel', param_definition_1.ParamDefinition.arrayToOptions(['instance', 'pixel'])),
+        objects: param_definition_1.ParamDefinition.ObjectList({
+            type: param_definition_1.ParamDefinition.Select('plane', param_definition_1.ParamDefinition.objectToOptions(Clip.Type, function (t) { return (0, string_1.stringToWords)(t); })),
+            invert: param_definition_1.ParamDefinition.Boolean(false),
+            position: param_definition_1.ParamDefinition.Vec3((0, linear_algebra_1.Vec3)()),
+            rotation: param_definition_1.ParamDefinition.Group({
+                axis: param_definition_1.ParamDefinition.Vec3(linear_algebra_1.Vec3.create(1, 0, 0)),
+                angle: param_definition_1.ParamDefinition.Numeric(0, { min: -180, max: 180, step: 1 }, { description: 'Angle in Degrees' }),
+            }, { isExpanded: true }),
+            scale: param_definition_1.ParamDefinition.Vec3(linear_algebra_1.Vec3.create(1, 1, 1)),
+        }, function (o) { return (0, string_1.stringToWords)(o.type); })
+    };
+    function createClipObjects() {
+        return {
+            count: 0,
+            type: (new Array(5)).fill(1),
+            invert: (new Array(5)).fill(false),
+            position: (new Array(5 * 3)).fill(0),
+            rotation: (new Array(5 * 4)).fill(0),
+            scale: (new Array(5 * 3)).fill(1),
+        };
+    }
+    var qA = (0, linear_algebra_1.Quat)();
+    var qB = (0, linear_algebra_1.Quat)();
+    var vA = (0, linear_algebra_1.Vec3)();
+    var vB = (0, linear_algebra_1.Vec3)();
+    function getClip(props, clip) {
+        var _a = (clip === null || clip === void 0 ? void 0 : clip.objects) || createClipObjects(), type = _a.type, invert = _a.invert, position = _a.position, rotation = _a.rotation, scale = _a.scale;
+        for (var i = 0, il = props.objects.length; i < il; ++i) {
+            var p = props.objects[i];
+            type[i] = Clip.Type[p.type];
+            invert[i] = p.invert;
+            linear_algebra_1.Vec3.toArray(p.position, position, i * 3);
+            linear_algebra_1.Quat.toArray(linear_algebra_1.Quat.setAxisAngle(qA, p.rotation.axis, (0, misc_1.degToRad)(p.rotation.angle)), rotation, i * 4);
+            linear_algebra_1.Vec3.toArray(p.scale, scale, i * 3);
+        }
+        return {
+            variant: props.variant,
+            objects: { count: props.objects.length, type: type, invert: invert, position: position, rotation: rotation, scale: scale }
+        };
+    }
+    Clip.getClip = getClip;
+    function areEqual(cA, cB) {
+        if (cA.variant !== cB.variant)
+            return false;
+        if (cA.objects.count !== cB.objects.count)
+            return false;
+        var oA = cA.objects, oB = cB.objects;
+        for (var i = 0, il = oA.count; i < il; ++i) {
+            if (oA.invert[i] !== oB.invert[i])
+                return false;
+            if (oA.type[i] !== oB.type[i])
+                return false;
+            linear_algebra_1.Vec3.fromArray(vA, oA.position, i * 3);
+            linear_algebra_1.Vec3.fromArray(vB, oB.position, i * 3);
+            if (!linear_algebra_1.Vec3.equals(vA, vB))
+                return false;
+            linear_algebra_1.Vec3.fromArray(vA, oA.scale, i * 3);
+            linear_algebra_1.Vec3.fromArray(vB, oB.scale, i * 3);
+            if (!linear_algebra_1.Vec3.equals(vA, vB))
+                return false;
+            linear_algebra_1.Quat.fromArray(qA, oA.rotation, i * 4);
+            linear_algebra_1.Quat.fromArray(qB, oB.rotation, i * 4);
+            if (!linear_algebra_1.Quat.equals(qA, qB))
+                return false;
+        }
+        return true;
+    }
+    Clip.areEqual = areEqual;
+})(Clip = exports.Clip || (exports.Clip = {}));
+//# sourceMappingURL=clip.js.map

package/lib/commonjs/mol-util/color/names.d.ts

@@ -164,4 +164,4 @@ export declare const ColorNames: ColorMap<{
 }>;
 export declare type ColorNames = typeof ColorNames;
 export declare type ColorName = keyof ColorNames;
-export declare const ColorNamesValueMap: Map<Color, "aliceblue" | "antiquewhite" | "aqua" | "aquamarine" | "azure" | "beige" | "bisque" | "black" | "blanchedalmond" | "blue" | "blueviolet" | "brown" | "burlywood" | "cadetblue" | "chartreuse" | "chocolate" | "coral" | "cornflower" | "cornflowerblue" | "cornsilk" | "crimson" | "cyan" | "darkblue" | "darkcyan" | "darkgoldenrod" | "darkgray" | "darkgreen" | "darkgrey" | "darkkhaki" | "darkmagenta" | "darkolivegreen" | "darkorange" | "darkorchid" | "darkred" | "darksalmon" | "darkseagreen" | "darkslateblue" | "darkslategray" | "darkslategrey" | "darkturquoise" | "darkviolet" | "deeppink" | "deepskyblue" | "dimgray" | "dimgrey" | "dodgerblue" | "firebrick" | "floralwhite" | "forestgreen" | "fuchsia" | "gainsboro" | "ghostwhite" | "gold" | "goldenrod" | "gray" | "green" | "greenyellow" | "grey" | "honeydew" | "hotpink" | "indianred" | "indigo" | "ivory" | "khaki" | "laserlemon" | "lavender" | "lavenderblush" | "lawngreen" | "lemonchiffon" | "lightblue" | "lightcoral" | "lightcyan" | "lightgoldenrod" | "lightgoldenrodyellow" | "lightgray" | "lightgreen" | "lightgrey" | "lightpink" | "lightsalmon" | "lightseagreen" | "lightskyblue" | "lightslategray" | "lightslategrey" | "lightsteelblue" | "lightyellow" | "lime" | "limegreen" | "linen" | "magenta" | "maroon" | "maroon2" | "maroon3" | "mediumaquamarine" | "mediumblue" | "mediumorchid" | "mediumpurple" | "mediumseagreen" | "mediumslateblue" | "mediumspringgreen" | "mediumturquoise" | "mediumvioletred" | "midnightblue" | "mintcream" | "mistyrose" | "moccasin" | "navajowhite" | "navy" | "oldlace" | "olive" | "olivedrab" | "orange" | "orangered" | "orchid" | "palegoldenrod" | "palegreen" | "paleturquoise" | "palevioletred" | "papayawhip" | "peachpuff" | "peru" | "pink" | "plum" | "powderblue" | "purple" | "purple2" | "purple3" | "rebeccapurple" | "red" | "rosybrown" | "royalblue" | "saddlebrown" | "salmon" | "sandybrown" | "seagreen" | "seashell" | "sienna" | "silver" | "skyblue" | "slateblue" | "slategray" | "slategrey" | "snow" | "springgreen" | "steelblue" | "tan" | "teal" | "thistle" | "tomato" | "turquoise" | "violet" | "wheat" | "white" | "whitesmoke" | "yellow" | "yellowgreen">;
+export declare const ColorNamesValueMap: Map<Color, "aliceblue" | "antiquewhite" | "aqua" | "aquamarine" | "azure" | "beige" | "bisque" | "black" | "blanchedalmond" | "blue" | "blueviolet" | "brown" | "burlywood" | "cadetblue" | "chartreuse" | "chocolate" | "coral" | "cornflowerblue" | "cornsilk" | "crimson" | "cyan" | "darkblue" | "darkcyan" | "darkgoldenrod" | "darkgray" | "darkgreen" | "darkgrey" | "darkkhaki" | "darkmagenta" | "darkolivegreen" | "darkorange" | "darkorchid" | "darkred" | "darksalmon" | "darkseagreen" | "darkslateblue" | "darkslategray" | "darkslategrey" | "darkturquoise" | "darkviolet" | "deeppink" | "deepskyblue" | "dimgray" | "dimgrey" | "dodgerblue" | "firebrick" | "floralwhite" | "forestgreen" | "fuchsia" | "gainsboro" | "ghostwhite" | "gold" | "goldenrod" | "gray" | "green" | "greenyellow" | "grey" | "honeydew" | "hotpink" | "indianred" | "indigo" | "ivory" | "khaki" | "lavender" | "lavenderblush" | "lawngreen" | "lemonchiffon" | "lightblue" | "lightcoral" | "lightcyan" | "lightgoldenrodyellow" | "lightgray" | "lightgreen" | "lightgrey" | "lightpink" | "lightsalmon" | "lightseagreen" | "lightskyblue" | "lightslategray" | "lightslategrey" | "lightsteelblue" | "lightyellow" | "lime" | "limegreen" | "linen" | "magenta" | "maroon" | "mediumaquamarine" | "mediumblue" | "mediumorchid" | "mediumpurple" | "mediumseagreen" | "mediumslateblue" | "mediumspringgreen" | "mediumturquoise" | "mediumvioletred" | "midnightblue" | "mintcream" | "mistyrose" | "moccasin" | "navajowhite" | "navy" | "oldlace" | "olive" | "olivedrab" | "orange" | "orangered" | "orchid" | "palegoldenrod" | "palegreen" | "paleturquoise" | "palevioletred" | "papayawhip" | "peachpuff" | "peru" | "pink" | "plum" | "powderblue" | "purple" | "rebeccapurple" | "red" | "rosybrown" | "royalblue" | "saddlebrown" | "salmon" | "sandybrown" | "seagreen" | "seashell" | "sienna" | "silver" | "skyblue" | "slateblue" | "slategray" | "slategrey" | "snow" | "springgreen" | "steelblue" | "tan" | "teal" | "thistle" | "tomato" | "turquoise" | "violet" | "wheat" | "white" | "whitesmoke" | "yellow" | "yellowgreen" | "cornflower" | "laserlemon" | "lightgoldenrod" | "maroon2" | "maroon3" | "purple2" | "purple3">;

package/lib/commonjs/mol-util/color/palette.d.ts

@@ -15,33 +15,33 @@ declare const DefaultGetPaletteProps: {
 declare type GetPaletteProps = typeof DefaultGetPaletteProps;
 export declare function getPaletteParams(props?: Partial<GetPaletteProps>): {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "interpolate" | "set";
-            colors: import("./color").ColorListEntry[];
-        };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate">>;
-};
-declare const DefaultPaletteProps: PD.Values<{
-    palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
         list: {
-            kind: "interpolate" | "set";
+            kind: "set" | "interpolate";
             colors: import("./color").ColorListEntry[];
         };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
+    }>, "colors">>;
+};
+declare const DefaultPaletteProps: PD.Values<{
+    palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate">>;
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "set" | "interpolate";
+            colors: import("./color").ColorListEntry[];
+        };
+    }>, "colors">>;
 }>;
 declare type PaletteProps = typeof DefaultPaletteProps;
 declare const DefaultLabelOptions: {

package/lib/commonjs/mol-util/color/scale.d.ts

@@ -21,7 +21,7 @@ export interface ColorScale {
 export declare const DefaultColorScaleProps: {
     domain: [number, number];
     reverse: boolean;
-    listOrName: "orange-red" | "purple-blue" | "blue-purple" | "oranges" | "blue-green" | "yellow-orange-brown" | "yellow-green" | "reds" | "red-purple" | "greens" | "yellow-green-blue" | "purples" | "green-blue" | "greys" | "yellow-orange-red" | "purple-red" | "blues" | "purple-blue-green" | "spectral" | "red-yellow-green" | "red-blue" | "pink-yellow-green" | "purple-green" | "red-yellow-blue" | "brown-white-green" | "red-grey" | "orange-purple" | "set-2" | "accent" | "set-1" | "set-3" | "dark-2" | "paired" | "pastel-2" | "pastel-1" | "many-distinct" | "magma" | "inferno" | "plasma" | "viridis" | "cividis" | "twilight" | "turbo" | "rainbow" | "red-white-blue" | ColorListEntry[];
+    listOrName: ColorListEntry[] | "orange-red" | "purple-blue" | "blue-purple" | "oranges" | "blue-green" | "yellow-orange-brown" | "yellow-green" | "reds" | "red-purple" | "greens" | "yellow-green-blue" | "purples" | "green-blue" | "greys" | "yellow-orange-red" | "purple-red" | "blues" | "purple-blue-green" | "spectral" | "red-yellow-green" | "red-blue" | "pink-yellow-green" | "purple-green" | "red-yellow-blue" | "brown-white-green" | "red-grey" | "orange-purple" | "set-2" | "accent" | "set-1" | "set-3" | "dark-2" | "paired" | "pastel-2" | "pastel-1" | "many-distinct" | "magma" | "inferno" | "plasma" | "viridis" | "cividis" | "twilight" | "turbo" | "rainbow" | "red-white-blue";
     minLabel: string | undefined;
     maxLabel: string | undefined;
 };

package/lib/commonjs/mol-util/material.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { NumberArray } from './type-helpers';
+import { ParamDefinition as PD } from './param-definition';
+export interface Material {
+    /** Normalized to [0, 1] range */
+    metalness: number;
+    /** Normalized to [0, 1] range */
+    roughness: number;
+    /** Normalized to [0, 1] range */
+    bumpiness: number;
+}
+export declare function Material(values?: Partial<Material>): {
+    metalness: number;
+    roughness: number;
+    bumpiness: number;
+};
+export declare namespace Material {
+    const Zero: Material;
+    function toArray(material: Material, array: NumberArray, offset: number): NumberArray;
+    function toString({ metalness, roughness, bumpiness }: Material): string;
+    function getParam(info?: {
+        isExpanded?: boolean;
+        isFlat?: boolean;
+    }): PD.Group<PD.Normalize<{
+        metalness: number;
+        roughness: number;
+        bumpiness: number;
+    }>>;
+}

package/lib/commonjs/mol-util/material.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Material = void 0;
+var tslib_1 = require("tslib");
+var param_definition_1 = require("./param-definition");
+function Material(values) {
+    return (0, tslib_1.__assign)((0, tslib_1.__assign)({}, Material.Zero), values);
+}
+exports.Material = Material;
+(function (Material) {
+    Material.Zero = { metalness: 0, roughness: 0, bumpiness: 0 };
+    function toArray(material, array, offset) {
+        array[offset] = material.metalness * 255;
+        array[offset + 1] = material.roughness * 255;
+        array[offset + 2] = material.bumpiness * 255;
+        return array;
+    }
+    Material.toArray = toArray;
+    function toString(_a) {
+        var metalness = _a.metalness, roughness = _a.roughness, bumpiness = _a.bumpiness;
+        return "M ".concat(metalness.toFixed(2), " | R ").concat(roughness.toFixed(2), " | B ").concat(bumpiness.toFixed(2));
+    }
+    Material.toString = toString;
+    function getParam(info) {
+        return param_definition_1.ParamDefinition.Group({
+            metalness: param_definition_1.ParamDefinition.Numeric(0, { min: 0, max: 1, step: 0.01 }),
+            roughness: param_definition_1.ParamDefinition.Numeric(1, { min: 0, max: 1, step: 0.01 }),
+            bumpiness: param_definition_1.ParamDefinition.Numeric(0, { min: 0, max: 1, step: 0.01 }),
+        }, (0, tslib_1.__assign)((0, tslib_1.__assign)({}, info), { presets: [
+                [{ metalness: 0, roughness: 1, bumpiness: 0 }, 'Matte'],
+                [{ metalness: 0, roughness: 0.2, bumpiness: 0 }, 'Plastic'],
+                [{ metalness: 0, roughness: 0.6, bumpiness: 0 }, 'Glossy'],
+                [{ metalness: 1.0, roughness: 0.6, bumpiness: 0 }, 'Metallic'],
+            ] }));
+    }
+    Material.getParam = getParam;
+})(Material = exports.Material || (exports.Material = {}));
+//# sourceMappingURL=material.js.map

package/lib/commonjs/mol-util/number-packing.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) 2019-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { NumberArray } from './type-helpers';
+/** encode positive integer as rgb byte triplet into array at offset */
+export declare function packIntToRGBArray(value: number, array: NumberArray, offset: number): NumberArray;
+/** decode positive integer encoded as rgb byte triplet */
+export declare function unpackRGBToInt(r: number, g: number, b: number): number;
+export declare function unpackRGBAToDepth(r: number, g: number, b: number, a: number): number;

package/lib/commonjs/mol-util/number-packing.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Copyright (c) 2019-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unpackRGBAToDepth = exports.unpackRGBToInt = exports.packIntToRGBArray = void 0;
+var interpolate_1 = require("../mol-math/interpolate");
+var linear_algebra_1 = require("../mol-math/linear-algebra");
+/** encode positive integer as rgb byte triplet into array at offset */
+function packIntToRGBArray(value, array, offset) {
+    value = (0, interpolate_1.clamp)(Math.round(value), 0, 16777216 - 1) + 1;
+    array[offset + 2] = value % 256;
+    value = Math.floor(value / 256);
+    array[offset + 1] = value % 256;
+    value = Math.floor(value / 256);
+    array[offset] = value % 256;
+    return array;
+}
+exports.packIntToRGBArray = packIntToRGBArray;
+/** decode positive integer encoded as rgb byte triplet */
+function unpackRGBToInt(r, g, b) {
+    return (Math.floor(r) * 256 * 256 + Math.floor(g) * 256 + Math.floor(b)) - 1;
+}
+exports.unpackRGBToInt = unpackRGBToInt;
+var UnpackDownscale = 255 / 256; // 0..1 -> fraction (excluding 1)
+var PackFactors = linear_algebra_1.Vec3.create(256 * 256 * 256, 256 * 256, 256);
+var UnpackFactors = linear_algebra_1.Vec4.create(UnpackDownscale / PackFactors[0], UnpackDownscale / PackFactors[1], UnpackDownscale / PackFactors[2], UnpackDownscale / 1);
+var tmpDepthRGBA = (0, linear_algebra_1.Vec4)();
+function unpackRGBAToDepth(r, g, b, a) {
+    linear_algebra_1.Vec4.set(tmpDepthRGBA, r / 255, g / 255, b / 255, a / 255);
+    return linear_algebra_1.Vec4.dot(tmpDepthRGBA, UnpackFactors);
+}
+exports.unpackRGBAToDepth = unpackRGBAToDepth;
+//# sourceMappingURL=number-packing.js.map

package/lib/commonjs/mol-util/number.d.ts

@@ -23,3 +23,4 @@ export declare function getArrayDigitCount(xs: ArrayLike<number>, maxDigits: num
 export declare function isInteger(s: string): boolean;
 export declare function getPrecision(v: number): number;
 export declare function toPrecision(v: number, precision: number): number;
+export declare function toFixed(v: number, fractionDigits: number): number;

package/lib/commonjs/mol-util/number.js

@@ -6,7 +6,7 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toPrecision = exports.getPrecision = exports.isInteger = exports.getArrayDigitCount = exports.integerDigitCount = exports.getMantissaMultiplier = void 0;
+exports.toFixed = exports.toPrecision = exports.getPrecision = exports.isInteger = exports.getArrayDigitCount = exports.integerDigitCount = exports.getMantissaMultiplier = void 0;
 /**
  * Determine the number of digits in a floating point number
  * Find a number M such that round(M * v) - M * v <= delta.
@@ -78,4 +78,8 @@ function toPrecision(v, precision) {
     return parseFloat(v.toPrecision(precision));
 }
 exports.toPrecision = toPrecision;
+function toFixed(v, fractionDigits) {
+    return parseFloat(v.toFixed(fractionDigits));
+}
+exports.toFixed = toFixed;
 //# sourceMappingURL=number.js.map

package/lib/commonjs/mol-util/param-definition.d.ts

@@ -165,6 +165,7 @@ export declare namespace ParamDefinition {
     export interface Group<T> extends Base<T> {
         type: 'group';
         params: Params;
+        presets?: Select<T>['options'];
         isExpanded?: boolean;
         isFlat?: boolean;
         pivot?: keyof T;
@@ -174,6 +175,7 @@ export declare namespace ParamDefinition {
         isFlat?: boolean;
         customDefault?: any;
         pivot?: keyof T;
+        presets?: Select<T>['options'];
     }): Group<Normalize<T>>;
     export function EmptyGroup(info?: Info): Group<Normalize<unknown>>;
     export interface NamedParams<T = any, K = string> {

package/lib/commonjs/mol-util/param-definition.js

@@ -150,6 +150,8 @@ var ParamDefinition;
     ParamDefinition.LineGraph = LineGraph;
     function Group(params, info) {
         var ret = setInfo({ type: 'group', defaultValue: (info === null || info === void 0 ? void 0 : info.customDefault) || getDefaultValues(params), params: params }, info);
+        if (info === null || info === void 0 ? void 0 : info.presets)
+            ret.presets = info.presets;
         if (info === null || info === void 0 ? void 0 : info.isExpanded)
             ret.isExpanded = info.isExpanded;
         if (info === null || info === void 0 ? void 0 : info.isFlat)

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

@@ -57,5 +57,6 @@
         <script>
             AlphaOrbitalsExample.init('app')
         </script>
+        <!-- __MOLSTAR_ANALYTICS__ -->
     </body>
 </html>

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

@@ -8,7 +8,7 @@ import { BehaviorSubject } from 'rxjs';
 import { debounceTime, skip } from 'rxjs/operators';
 import { CreateOrbitalDensityVolume, CreateOrbitalRepresentation3D, CreateOrbitalVolume, StaticBasisAndOrbitals } from '../../extensions/alpha-orbitals/transforms';
 import { canComputeGrid3dOnGPU } from '../../mol-gl/compute/grid3d';
-import { createPluginAsync } from '../../mol-plugin-ui';
+import { createPluginUI } from '../../mol-plugin-ui';
 import { DefaultPluginUISpec } from '../../mol-plugin-ui/spec';
 import { PluginCommands } from '../../mol-plugin/commands';
 import { PluginConfig } from '../../mol-plugin/config';
@@ -21,7 +21,7 @@ require('mol-plugin-ui/skin/light.scss');
 var AlphaOrbitalsExample = /** @class */ (function () {
     function AlphaOrbitalsExample() {
         this.params = new BehaviorSubject({});
-        this.state = new BehaviorSubject({ show: { name: 'orbital', params: { index: 32 } }, isoValue: 1, gpuSurface: false });
+        this.state = new BehaviorSubject({ show: { name: 'orbital', params: { index: 32 } }, isoValue: 1, gpuSurface: true });
         this.selectors = void 0;
         this.basis = void 0;
         this.currentParams = __assign({}, this.state.value);
@@ -35,7 +35,7 @@ var AlphaOrbitalsExample = /** @class */ (function () {
                     case 0:
                         defaultSpec = DefaultPluginUISpec();
                         _b = this;
-                        return [4 /*yield*/, createPluginAsync(typeof target === 'string' ? document.getElementById(target) : target, __assign(__assign({}, defaultSpec), { layout: {
+                        return [4 /*yield*/, createPluginUI(typeof target === 'string' ? document.getElementById(target) : target, __assign(__assign({}, defaultSpec), { layout: {
                                     initial: {
                                         isExpanded: false,
                                         showControls: false
@@ -147,12 +147,11 @@ var AlphaOrbitalsExample = /** @class */ (function () {
         return {
             alpha: 0.85,
             color: color,
-            directVolume: this.state.value.gpuSurface,
             kind: kind,
             relativeIsovalue: this.state.value.isoValue,
             pickable: false,
             xrayShaded: true,
-            tryUseGpu: false
+            tryUseGpu: true
         };
     };
     AlphaOrbitalsExample.prototype.load = function (input) {

package/lib/examples/basic-wrapper/index.html

@@ -69,8 +69,9 @@
             $('format').value = format;
             $('format').onchange = function (e) { format = e.target.value; }
 
-            BasicMolStarWrapper.init('app' /** or document.getElementById('app') */);
-            BasicMolStarWrapper.setBackground(0xffffff);
+            BasicMolStarWrapper.init('app' /** or document.getElementById('app') */).then(() => {
+                BasicMolStarWrapper.setBackground(0xffffff);
+            });
 
             addControl('Load Asym Unit', () => BasicMolStarWrapper.load({ url: url, format: format }));
             addControl('Load Assembly', () => BasicMolStarWrapper.load({ url: url, format: format, assemblyId: assemblyId }));