molstar 3.0.0-dev.0 → 3.0.0-dev.10

package/lib/commonjs/mol-theme/color/molecule-type.js

@@ -1,58 +1,77 @@
 "use strict";
 /**
- * Copyright (c) 2018-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MoleculeTypeColorThemeProvider = exports.MoleculeTypeColorTheme = exports.moleculeTypeColor = exports.getMoleculeTypeColorThemeParams = exports.MoleculeTypeColorThemeParams = exports.MoleculeTypeColors = void 0;
+exports.MoleculeTypeColorThemeProvider = exports.MoleculeTypeColorTheme = exports.moleculeTypeColor = exports.getMoleculeTypeColorThemeParams = exports.MoleculeTypeColorThemeParams = void 0;
 var color_1 = require("../../mol-util/color");
 var structure_1 = require("../../mol-model/structure");
 var util_1 = require("../../mol-model/structure/util");
 var param_definition_1 = require("../../mol-util/param-definition");
 var legend_1 = require("../../mol-util/legend");
-var color_2 = require("../../mol-util/color/color");
-exports.MoleculeTypeColors = (0, color_1.ColorMap)({
-    water: 0x386cb0,
-    ion: 0xf0027f,
-    protein: 0xbeaed4,
-    RNA: 0xfdc086,
-    DNA: 0xbf5b17,
-    PNA: 0x42A49A,
-    saccharide: 0x7fc97f,
-});
 var DefaultMoleculeTypeColor = (0, color_1.Color)(0xffff99);
 var Description = 'Assigns a color based on the molecule type of a residue.';
 exports.MoleculeTypeColorThemeParams = {
     saturation: param_definition_1.ParamDefinition.Numeric(0, { min: -6, max: 6, step: 0.1 }),
-    lightness: param_definition_1.ParamDefinition.Numeric(0, { min: -6, max: 6, step: 0.1 })
+    lightness: param_definition_1.ParamDefinition.Numeric(0, { min: -6, max: 6, step: 0.1 }),
+    colors: param_definition_1.ParamDefinition.Group({
+        water: param_definition_1.ParamDefinition.Color((0, color_1.Color)(0x386cb0)),
+        ion: param_definition_1.ParamDefinition.Color((0, color_1.Color)(0xf0027f)),
+        protein: param_definition_1.ParamDefinition.Color((0, color_1.Color)(0xbeaed4)),
+        rna: param_definition_1.ParamDefinition.Color((0, color_1.Color)(0xfdc086)),
+        dna: param_definition_1.ParamDefinition.Color((0, color_1.Color)(0xbf5b17)),
+        pna: param_definition_1.ParamDefinition.Color((0, color_1.Color)(0x42A49A)),
+        saccharide: param_definition_1.ParamDefinition.Color((0, color_1.Color)(0x7fc97f)),
+        lipid: param_definition_1.ParamDefinition.Color((0, color_1.Color)(0xcccccc)),
+    })
 };
 function getMoleculeTypeColorThemeParams(ctx) {
     return exports.MoleculeTypeColorThemeParams; // TODO return copy
 }
 exports.getMoleculeTypeColorThemeParams = getMoleculeTypeColorThemeParams;
-function moleculeTypeColor(colorMap, unit, element) {
+function moleculeTypeColor(props, unit, element) {
+    var c = DefaultMoleculeTypeColor;
     var moleculeType = (0, util_1.getElementMoleculeType)(unit, element);
     switch (moleculeType) {
-        case 2 /* Water */: return colorMap.water;
-        case 3 /* Ion */: return colorMap.ion;
-        case 5 /* Protein */: return colorMap.protein;
-        case 6 /* RNA */: return colorMap.RNA;
-        case 7 /* DNA */: return colorMap.DNA;
-        case 8 /* PNA */: return colorMap.PNA;
-        case 9 /* Saccharide */: return colorMap.saccharide;
+        case 2 /* Water */:
+            c = props.colors.water;
+            break;
+        case 3 /* Ion */:
+            c = props.colors.ion;
+            break;
+        case 5 /* Protein */:
+            c = props.colors.protein;
+            break;
+        case 6 /* RNA */:
+            c = props.colors.rna;
+            break;
+        case 7 /* DNA */:
+            c = props.colors.dna;
+            break;
+        case 8 /* PNA */:
+            c = props.colors.pna;
+            break;
+        case 9 /* Saccharide */:
+            c = props.colors.saccharide;
+            break;
+        case 4 /* Lipid */:
+            c = props.colors.lipid;
+            break;
     }
-    return DefaultMoleculeTypeColor;
+    c = color_1.Color.saturate(c, props.saturation);
+    c = color_1.Color.darken(c, -props.lightness);
+    return c;
 }
 exports.moleculeTypeColor = moleculeTypeColor;
 function MoleculeTypeColorTheme(ctx, props) {
-    var colorMap = (0, color_2.getAdjustedColorMap)(exports.MoleculeTypeColors, props.saturation, props.lightness);
     function color(location) {
         if (structure_1.StructureElement.Location.is(location)) {
-            return moleculeTypeColor(colorMap, location.unit, location.element);
+            return moleculeTypeColor(props, location.unit, location.element);
         }
         else if (structure_1.Bond.isLocation(location)) {
-            return moleculeTypeColor(colorMap, location.aUnit, location.aUnit.elements[location.aIndex]);
+            return moleculeTypeColor(props, location.aUnit, location.aUnit.elements[location.aIndex]);
         }
         return DefaultMoleculeTypeColor;
     }
@@ -62,8 +81,8 @@ function MoleculeTypeColorTheme(ctx, props) {
         color: color,
         props: props,
         description: Description,
-        legend: (0, legend_1.TableLegend)(Object.keys(exports.MoleculeTypeColors).map(function (name) {
-            return [name, exports.MoleculeTypeColors[name]];
+        legend: (0, legend_1.TableLegend)(Object.keys(props.colors).map(function (name) {
+            return [name, props.colors[name]];
         }).concat([['Other/unknown', DefaultMoleculeTypeColor]]))
     };
 }

package/lib/commonjs/mol-theme/color/volume-value.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { ColorTheme } from '../color';
+import { ParamDefinition as PD } from '../../mol-util/param-definition';
+import { ThemeDataContext } from '../theme';
+export declare const VolumeValueColorThemeParams: {
+    colorList: PD.ColorList;
+};
+export declare type VolumeValueColorThemeParams = typeof VolumeValueColorThemeParams;
+export declare function getVolumeValueColorThemeParams(ctx: ThemeDataContext): {
+    colorList: PD.ColorList;
+};
+export declare function VolumeValueColorTheme(ctx: ThemeDataContext, props: PD.Values<VolumeValueColorThemeParams>): ColorTheme<VolumeValueColorThemeParams>;
+export declare const VolumeValueColorThemeProvider: ColorTheme.Provider<VolumeValueColorThemeParams, 'volume-value'>;

package/lib/commonjs/mol-theme/color/volume-value.js

@@ -0,0 +1,57 @@
+"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.VolumeValueColorThemeProvider = exports.VolumeValueColorTheme = exports.getVolumeValueColorThemeParams = exports.VolumeValueColorThemeParams = void 0;
+var color_1 = require("../../mol-util/color");
+var param_definition_1 = require("../../mol-util/param-definition");
+var names_1 = require("../../mol-util/color/names");
+var DefaultColor = (0, color_1.Color)(0xCCCCCC);
+var Description = 'Assign color based on the given value of a volume cell.';
+exports.VolumeValueColorThemeParams = {
+    colorList: param_definition_1.ParamDefinition.ColorList({
+        kind: 'interpolate',
+        colors: [
+            [names_1.ColorNames.white, 0],
+            [names_1.ColorNames.red, 0.25],
+            [names_1.ColorNames.white, 0.5],
+            [names_1.ColorNames.blue, 0.75],
+            [names_1.ColorNames.white, 1]
+        ]
+    }, { offsets: true, isEssential: true }),
+};
+function getVolumeValueColorThemeParams(ctx) {
+    return exports.VolumeValueColorThemeParams; // TODO return copy
+}
+exports.getVolumeValueColorThemeParams = getVolumeValueColorThemeParams;
+function VolumeValueColorTheme(ctx, props) {
+    var scale = color_1.ColorScale.create({ domain: [0, 1], listOrName: props.colorList.colors });
+    var colors = [];
+    for (var i = 0; i < 256; ++i) {
+        colors[i] = scale.color(i / 255);
+    }
+    var palette = { colors: colors, filter: 'linear' };
+    return {
+        factory: VolumeValueColorTheme,
+        granularity: 'direct',
+        color: function () { return DefaultColor; },
+        props: props,
+        description: Description,
+        legend: scale.legend,
+        palette: palette,
+    };
+}
+exports.VolumeValueColorTheme = VolumeValueColorTheme;
+exports.VolumeValueColorThemeProvider = {
+    name: 'volume-value',
+    label: 'Volume Value',
+    category: "Miscellaneous" /* Misc */,
+    factory: VolumeValueColorTheme,
+    getParams: getVolumeValueColorThemeParams,
+    defaultValues: param_definition_1.ParamDefinition.getDefaultValues(exports.VolumeValueColorThemeParams),
+    isApplicable: function (ctx) { return !!ctx.volume; },
+};
+//# sourceMappingURL=volume-value.js.map

package/lib/commonjs/mol-theme/color.d.ts

@@ -164,20 +164,57 @@ declare namespace ColorTheme {
             scale: PD.Select<"DGwif" | "DGwoct" | "Oct-IF">;
         }, "hydrophobicity">;
         illustrative: Provider<{
-            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-                maxCount: number;
-                hue: [number, number];
-                chroma: [number, number];
-                luminance: [number, number];
-                clusteringStepCount: number;
-                minSampleCount: number;
-            }>, "generate"> | PD.NamedParams<PD.Normalize<{
-                list: {
-                    kind: "set" | "interpolate";
-                    colors: import("../mol-util/color/color").ColorListEntry[];
-                };
-            }>, "colors">>;
-            asymId: PD.Select<"label" | "auth">;
+            style: PD.Mapped<PD.NamedParams<PD.Normalize<{
+                value: Color;
+            }>, "uniform"> | PD.NamedParams<PD.Normalize<{
+                palette: PD.NamedParams<PD.Normalize<{
+                    maxCount: any;
+                    hue: any;
+                    chroma: any;
+                    luminance: any;
+                    clusteringStepCount: any;
+                    minSampleCount: any;
+                }>, "generate"> | PD.NamedParams<PD.Normalize<{
+                    list: any;
+                }>, "colors">;
+                asymId: "label" | "auth";
+            }>, "chain-id"> | PD.NamedParams<PD.Normalize<{
+                saturation: number;
+                lightness: number;
+                colors: PD.Normalize<{
+                    water: any;
+                    ion: any;
+                    protein: any;
+                    rna: any;
+                    dna: any;
+                    pna: any;
+                    saccharide: any;
+                    lipid: any;
+                }>;
+            }>, "molecule-type"> | PD.NamedParams<PD.Normalize<{
+                palette: PD.NamedParams<PD.Normalize<{
+                    maxCount: any;
+                    hue: any;
+                    chroma: any;
+                    luminance: any;
+                    clusteringStepCount: any;
+                    minSampleCount: any;
+                }>, "generate"> | PD.NamedParams<PD.Normalize<{
+                    list: any;
+                }>, "colors">;
+            }>, "entity-source"> | PD.NamedParams<PD.Normalize<{
+                palette: PD.NamedParams<PD.Normalize<{
+                    maxCount: any;
+                    hue: any;
+                    chroma: any;
+                    luminance: any;
+                    clusteringStepCount: any;
+                    minSampleCount: any;
+                }>, "generate"> | PD.NamedParams<PD.Normalize<{
+                    list: any;
+                }>, "colors">;
+            }>, "entity-id">>;
+            carbonLightness: PD.Numeric;
         }, "illustrative">;
         'model-index': Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
@@ -197,6 +234,16 @@ declare namespace ColorTheme {
         'molecule-type': Provider<{
             saturation: PD.Numeric;
             lightness: PD.Numeric;
+            colors: PD.Group<PD.Normalize<{
+                water: Color;
+                ion: Color;
+                protein: Color;
+                rna: Color;
+                dna: Color;
+                pna: Color;
+                saccharide: Color;
+                lipid: Color;
+            }>>;
         }, "molecule-type">;
         occupancy: Provider<{
             domain: PD.Interval;
@@ -300,6 +347,9 @@ declare namespace ColorTheme {
         uniform: Provider<{
             value: PD.Color;
         }, "uniform">;
+        'volume-value': Provider<{
+            colorList: PD.ColorList;
+        }, "volume-value">;
     };
     type _BuiltIn = typeof BuiltIn;
     export type BuiltIn = keyof _BuiltIn;

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

@@ -33,6 +33,7 @@ var operator_hkl_1 = require("./color/operator-hkl");
 var partial_charge_1 = require("./color/partial-charge");
 var atom_id_1 = require("./color/atom-id");
 var entity_id_1 = require("./color/entity-id");
+var volume_value_1 = require("./color/volume-value");
 var ColorTheme;
 (function (ColorTheme) {
     ColorTheme.PaletteScale = (1 << 24) - 1;
@@ -78,6 +79,7 @@ var ColorTheme;
         'uncertainty': uncertainty_1.UncertaintyColorThemeProvider,
         'unit-index': unit_index_1.UnitIndexColorThemeProvider,
         'uniform': uniform_1.UniformColorThemeProvider,
+        'volume-value': volume_value_1.VolumeValueColorThemeProvider,
     };
 })(ColorTheme || (ColorTheme = {}));
 exports.ColorTheme = ColorTheme;

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

@@ -10,6 +10,7 @@ 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 };
 }
@@ -24,7 +25,7 @@ exports.Substance = Substance;
         for (var i = 0, il = sA.layers.length; i < il; ++i) {
             if (sA.layers[i].clear !== sB.layers[i].clear)
                 return false;
-            if (sA.layers[i].material !== sB.layers[i].material)
+            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;
@@ -53,6 +54,7 @@ exports.Substance = 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) {
@@ -60,18 +62,25 @@ exports.Substance = Substance;
             loci = structure_1.StructureElement.Loci.subtract(loci, shadowed);
             shadowed = structure_1.StructureElement.Loci.union(loci, shadowed);
             if (!structure_1.StructureElement.Loci.isEmpty(loci)) {
-                var materialOrClear = clear ? -1 : material;
-                if (map.has(materialOrClear)) {
-                    loci = structure_1.StructureElement.Loci.union(loci, map.get(materialOrClear));
+                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);
                 }
-                map.set(materialOrClear, loci);
             }
         }
         var layers = [];
-        map.forEach(function (loci, materialOrClear) {
-            var clear = materialOrClear === -1;
-            var material = clear ? (0, material_1.Material)(0) : materialOrClear;
-            layers.push({ loci: loci, material: material, clear: clear });
+        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 };
     }

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/material.d.ts

@@ -5,28 +5,29 @@
  */
 import { NumberArray } from './type-helpers';
 import { ParamDefinition as PD } from './param-definition';
-/** Material properties expressed as a single number */
-export declare type Material = {
-    readonly '@type': 'material';
-} & number;
-export declare function Material(hex: number): Material;
+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 {
-    function fromNormalized(metalness: number, roughness: number): Material;
-    function fromObjectNormalized(v: {
-        metalness: number;
-        roughness: number;
-    }): Material;
-    function toObjectNormalized(material: Material, fractionDigits?: number): {
-        metalness: number;
-        roughness: number;
-    };
+    const Zero: Material;
     function toArray(material: Material, array: NumberArray, offset: number): NumberArray;
-    function toString(material: Material): string;
+    function toString({ metalness, roughness, bumpiness }: Material): string;
     function getParam(info?: {
         isExpanded?: boolean;
         isFlat?: boolean;
-    }): PD.Converted<Material, PD.Normalize<{
+    }): PD.Group<PD.Normalize<{
         metalness: number;
         roughness: number;
+        bumpiness: number;
     }>>;
 }

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

@@ -6,45 +6,37 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Material = void 0;
+var tslib_1 = require("tslib");
 var param_definition_1 = require("./param-definition");
-var number_1 = require("./number");
-function Material(hex) { return hex; }
+function Material(values) {
+    return (0, tslib_1.__assign)((0, tslib_1.__assign)({}, Material.Zero), values);
+}
 exports.Material = Material;
 (function (Material) {
-    function fromNormalized(metalness, roughness) {
-        return (((metalness * 255) << 16) | ((roughness * 255) << 8));
-    }
-    Material.fromNormalized = fromNormalized;
-    function fromObjectNormalized(v) {
-        return fromNormalized(v.metalness, v.roughness);
-    }
-    Material.fromObjectNormalized = fromObjectNormalized;
-    function toObjectNormalized(material, fractionDigits) {
-        var metalness = (material >> 16 & 255) / 255;
-        var roughness = (material >> 8 & 255) / 255;
-        return {
-            metalness: fractionDigits ? (0, number_1.toFixed)(metalness, fractionDigits) : metalness,
-            roughness: fractionDigits ? (0, number_1.toFixed)(roughness, fractionDigits) : roughness
-        };
-    }
-    Material.toObjectNormalized = toObjectNormalized;
+    Material.Zero = { metalness: 0, roughness: 0, bumpiness: 0 };
     function toArray(material, array, offset) {
-        array[offset] = (material >> 16 & 255);
-        array[offset + 1] = (material >> 8 & 255);
+        array[offset] = material.metalness * 255;
+        array[offset + 1] = material.roughness * 255;
+        array[offset + 2] = material.bumpiness * 255;
         return array;
     }
     Material.toArray = toArray;
-    function toString(material) {
-        var metalness = (material >> 16 & 255) / 255;
-        var roughness = (material >> 8 & 255) / 255;
-        return "M ".concat(metalness, " | R ").concat(roughness);
+    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.Converted(function (v) { return toObjectNormalized(v, 2); }, function (v) { return fromObjectNormalized(v); }, param_definition_1.ParamDefinition.Group({
+        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 }),
-        }, info));
+            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 = {}));

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;