molstar 3.0.0-dev.2 → 3.0.0-dev.6

package/lib/mol-canvas3d/helper/handle-helper.d.ts

@@ -24,10 +24,13 @@ export declare const HandleHelperParams: {
         flipSided: boolean;
         flatShaded: boolean;
         xrayShaded: boolean;
+        bumpFrequency: number;
+        bumpAmplitude: number;
         quality: "auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest";
         material: PD.Normalize<{
             metalness: number;
             roughness: number;
+            bumpiness: number;
         }>;
     }>, "on">>;
 };

package/lib/mol-canvas3d/helper/helper.d.ts

@@ -33,6 +33,8 @@ export declare const HelperParams: {
             flipSided: any;
             flatShaded: any;
             xrayShaded: any;
+            bumpFrequency: any;
+            bumpAmplitude: any;
             quality: any;
             material: any;
         }>, "on">;
@@ -62,6 +64,8 @@ export declare const DefaultHelperProps: PD.Values<{
             flipSided: any;
             flatShaded: any;
             xrayShaded: any;
+            bumpFrequency: any;
+            bumpAmplitude: any;
             quality: any;
             material: any;
         }>, "on">;

package/lib/mol-canvas3d/passes/image.d.ts

@@ -27,6 +27,7 @@ export declare const ImageParams: {
         outline: PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
             scale: any;
             threshold: any;
+            color: any;
         }>, "on">;
         antialiasing: PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
             edgeThreshold: any;
@@ -58,6 +59,8 @@ export declare const ImageParams: {
             flipSided: any;
             flatShaded: any;
             xrayShaded: any;
+            bumpFrequency: any;
+            bumpAmplitude: any;
             quality: any;
             material: any;
         }>, "on">;

package/lib/mol-canvas3d/passes/multi-sample.d.ts

@@ -43,7 +43,8 @@ export declare class MultiSampleHelper {
     private multiSamplePass;
     private sampleIndex;
     update(changed: boolean, props: MultiSampleProps): boolean;
-    render(renderer: Renderer, camera: Camera | StereoCamera, scene: Scene, helper: Helper, toDrawingBuffer: boolean, transparentBackground: boolean, props: Props): void;
+    /** Return `true` while more samples are needed */
+    render(renderer: Renderer, camera: Camera | StereoCamera, scene: Scene, helper: Helper, toDrawingBuffer: boolean, transparentBackground: boolean, props: Props): boolean;
     constructor(multiSamplePass: MultiSamplePass);
 }
 export {};

package/lib/mol-canvas3d/passes/multi-sample.js

@@ -24,8 +24,8 @@ function getComposeRenderable(ctx, colorTexture) {
     return createComputeRenderable(renderItem, values);
 }
 export var MultiSampleParams = {
-    mode: PD.Select('off', [['off', 'Off'], ['on', 'On'], ['temporal', 'Temporal']]),
-    sampleLevel: PD.Numeric(2, { min: 0, max: 5, step: 1 }),
+    mode: PD.Select('temporal', [['off', 'Off'], ['on', 'On'], ['temporal', 'Temporal']]),
+    sampleLevel: PD.Numeric(2, { min: 0, max: 5, step: 1 }, { description: 'Take level^2 samples.' }),
 };
 var MultiSamplePass = /** @class */ (function () {
     function MultiSamplePass(webgl, drawPass) {
@@ -263,8 +263,10 @@ var MultiSampleHelper = /** @class */ (function () {
             this.sampleIndex = -1;
         return props.mode === 'temporal' ? this.sampleIndex !== -2 : false;
     };
+    /** Return `true` while more samples are needed */
     MultiSampleHelper.prototype.render = function (renderer, camera, scene, helper, toDrawingBuffer, transparentBackground, props) {
         this.sampleIndex = this.multiSamplePass.render(this.sampleIndex, renderer, camera, scene, helper, toDrawingBuffer, transparentBackground, props);
+        return this.sampleIndex < 0;
     };
     return MultiSampleHelper;
 }());

package/lib/mol-canvas3d/passes/postprocessing.d.ts

@@ -20,6 +20,7 @@ export declare const PostprocessingParams: {
     outline: PD.Mapped<PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
         scale: number;
         threshold: number;
+        color: Color;
     }>, "on">>;
     antialiasing: PD.Mapped<PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
         edgeThreshold: number;

package/lib/mol-canvas3d/passes/postprocessing.js

@@ -65,9 +65,9 @@ function getSamples(vectorSamples, nSamples) {
     }
     return samples;
 }
-var PostprocessingSchema = __assign(__assign({}, QuadSchema), { tSsaoDepth: TextureSpec('texture', 'rgba', 'ubyte', 'nearest'), tColor: TextureSpec('texture', 'rgba', 'ubyte', 'nearest'), tDepth: TextureSpec('texture', 'rgba', 'ubyte', 'nearest'), tOutlines: TextureSpec('texture', 'rgba', 'ubyte', 'nearest'), uTexSize: UniformSpec('v2'), dOrthographic: DefineSpec('number'), uNear: UniformSpec('f'), uFar: UniformSpec('f'), uFogNear: UniformSpec('f'), uFogFar: UniformSpec('f'), uFogColor: UniformSpec('v3'), uTransparentBackground: UniformSpec('b'), uMaxPossibleViewZDiff: UniformSpec('f'), dOcclusionEnable: DefineSpec('boolean'), dOutlineEnable: DefineSpec('boolean'), dOutlineScale: DefineSpec('number'), uOutlineThreshold: UniformSpec('f') });
+var PostprocessingSchema = __assign(__assign({}, QuadSchema), { tSsaoDepth: TextureSpec('texture', 'rgba', 'ubyte', 'nearest'), tColor: TextureSpec('texture', 'rgba', 'ubyte', 'nearest'), tDepth: TextureSpec('texture', 'rgba', 'ubyte', 'nearest'), tOutlines: TextureSpec('texture', 'rgba', 'ubyte', 'nearest'), uTexSize: UniformSpec('v2'), dOrthographic: DefineSpec('number'), uNear: UniformSpec('f'), uFar: UniformSpec('f'), uFogNear: UniformSpec('f'), uFogFar: UniformSpec('f'), uFogColor: UniformSpec('v3'), uOutlineColor: UniformSpec('v3'), uTransparentBackground: UniformSpec('b'), uMaxPossibleViewZDiff: UniformSpec('f'), dOcclusionEnable: DefineSpec('boolean'), dOutlineEnable: DefineSpec('boolean'), dOutlineScale: DefineSpec('number'), uOutlineThreshold: UniformSpec('f') });
 function getPostprocessingRenderable(ctx, colorTexture, depthTexture, outlinesTexture, ssaoDepthTexture) {
-    var values = __assign(__assign({}, QuadValues), { tSsaoDepth: ValueCell.create(ssaoDepthTexture), tColor: ValueCell.create(colorTexture), tDepth: ValueCell.create(depthTexture), tOutlines: ValueCell.create(outlinesTexture), uTexSize: ValueCell.create(Vec2.create(colorTexture.getWidth(), colorTexture.getHeight())), dOrthographic: ValueCell.create(0), uNear: ValueCell.create(1), uFar: ValueCell.create(10000), uFogNear: ValueCell.create(10000), uFogFar: ValueCell.create(10000), uFogColor: ValueCell.create(Vec3.create(1, 1, 1)), uTransparentBackground: ValueCell.create(false), uMaxPossibleViewZDiff: ValueCell.create(0.5), dOcclusionEnable: ValueCell.create(false), dOutlineEnable: ValueCell.create(false), dOutlineScale: ValueCell.create(1), uOutlineThreshold: ValueCell.create(0.33) });
+    var values = __assign(__assign({}, QuadValues), { tSsaoDepth: ValueCell.create(ssaoDepthTexture), tColor: ValueCell.create(colorTexture), tDepth: ValueCell.create(depthTexture), tOutlines: ValueCell.create(outlinesTexture), uTexSize: ValueCell.create(Vec2.create(colorTexture.getWidth(), colorTexture.getHeight())), dOrthographic: ValueCell.create(0), uNear: ValueCell.create(1), uFar: ValueCell.create(10000), uFogNear: ValueCell.create(10000), uFogFar: ValueCell.create(10000), uFogColor: ValueCell.create(Vec3.create(1, 1, 1)), uOutlineColor: ValueCell.create(Vec3.create(0, 0, 0)), uTransparentBackground: ValueCell.create(false), uMaxPossibleViewZDiff: ValueCell.create(0.5), dOcclusionEnable: ValueCell.create(false), dOutlineEnable: ValueCell.create(false), dOutlineScale: ValueCell.create(1), uOutlineThreshold: ValueCell.create(0.33) });
     var schema = __assign({}, PostprocessingSchema);
     var shaderCode = ShaderCode('postprocessing', quad_vert, postprocessing_frag);
     var renderItem = createComputeRenderItem(ctx, 'triangles', shaderCode, schema, values);
@@ -87,6 +87,7 @@ export var PostprocessingParams = {
         on: PD.Group({
             scale: PD.Numeric(1, { min: 1, max: 5, step: 1 }),
             threshold: PD.Numeric(0.33, { min: 0.01, max: 1, step: 0.01 }),
+            color: PD.Color(Color(0x000000)),
         }),
         off: PD.Group({})
     }, { cycle: true, description: 'Draw outline around 3D objects' }),
@@ -220,6 +221,7 @@ var PostprocessingPass = /** @class */ (function () {
             ValueCell.updateIfChanged(this.outlinesRenderable.values.uNear, camera.near);
             ValueCell.updateIfChanged(this.outlinesRenderable.values.uFar, camera.far);
             ValueCell.updateIfChanged(this.outlinesRenderable.values.uMaxPossibleViewZDiff, maxPossibleViewZDiff);
+            ValueCell.update(this.renderable.values.uOutlineColor, Color.toVec3Normalized(this.renderable.values.uOutlineColor.ref.value, props.outline.params.color));
             ValueCell.updateIfChanged(this.renderable.values.uMaxPossibleViewZDiff, maxPossibleViewZDiff);
             if (this.renderable.values.dOutlineScale.ref.value !== outlineScale) {
                 needsUpdateMain = true;

package/lib/mol-geo/geometry/base.d.ts

@@ -46,6 +46,7 @@ export declare namespace BaseGeometry {
         material: PD.Group<PD.Normalize<{
             metalness: number;
             roughness: number;
+            bumpiness: number;
         }>>;
     };
     type Params = typeof Params;
@@ -68,6 +69,7 @@ export declare namespace BaseGeometry {
         drawCount: ValueCell<number, never>;
         uMetalness: ValueCell<number, never>;
         uRoughness: ValueCell<number, never>;
+        uBumpiness: ValueCell<number, never>;
         dLightCount: ValueCell<number, never>;
     };
     function updateValues(values: BaseValues, props: PD.Values<Params>): void;

package/lib/mol-geo/geometry/base.js

@@ -94,6 +94,7 @@ export var BaseGeometry;
             drawCount: ValueCell.create(counts.drawCount),
             uMetalness: ValueCell.create(props.material.metalness),
             uRoughness: ValueCell.create(props.material.roughness),
+            uBumpiness: ValueCell.create(props.material.bumpiness),
             dLightCount: ValueCell.create(1),
         };
     }
@@ -102,6 +103,7 @@ export var BaseGeometry;
         ValueCell.updateIfChanged(values.alpha, props.alpha); // `uAlpha` is set in renderable.render
         ValueCell.updateIfChanged(values.uMetalness, props.material.metalness);
         ValueCell.updateIfChanged(values.uRoughness, props.material.roughness);
+        ValueCell.updateIfChanged(values.uBumpiness, props.material.bumpiness);
     }
     BaseGeometry.updateValues = updateValues;
     function createRenderableState(props) {

package/lib/mol-geo/geometry/cylinders/cylinders.d.ts

@@ -43,11 +43,14 @@ export declare namespace Cylinders {
         doubleSided: PD.BooleanParam;
         ignoreLight: PD.BooleanParam;
         xrayShaded: PD.BooleanParam;
+        bumpFrequency: PD.Numeric;
+        bumpAmplitude: PD.Numeric;
         alpha: PD.Numeric;
         quality: PD.Select<"auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest">;
         material: PD.Group<PD.Normalize<{
-            metalness: number;
+            metalness: number; /** Number of cylinders */
             roughness: number;
+            bumpiness: number;
         }>>;
     };
     type Params = typeof Params;

package/lib/mol-geo/geometry/cylinders/cylinders.js

@@ -107,7 +107,7 @@ export var Cylinders;
     }
     Cylinders.transform = transform;
     //
-    Cylinders.Params = __assign(__assign({}, BaseGeometry.Params), { sizeFactor: PD.Numeric(1, { min: 0, max: 10, step: 0.1 }), sizeAspectRatio: PD.Numeric(1, { min: 0, max: 3, step: 0.01 }), doubleSided: PD.Boolean(false, BaseGeometry.CustomQualityParamInfo), ignoreLight: PD.Boolean(false, BaseGeometry.ShadingCategory), xrayShaded: PD.Boolean(false, BaseGeometry.ShadingCategory) });
+    Cylinders.Params = __assign(__assign({}, BaseGeometry.Params), { sizeFactor: PD.Numeric(1, { min: 0, max: 10, step: 0.1 }), sizeAspectRatio: PD.Numeric(1, { min: 0, max: 3, step: 0.01 }), doubleSided: PD.Boolean(false, BaseGeometry.CustomQualityParamInfo), ignoreLight: PD.Boolean(false, BaseGeometry.ShadingCategory), xrayShaded: PD.Boolean(false, BaseGeometry.ShadingCategory), bumpFrequency: PD.Numeric(0, { min: 0, max: 10, step: 0.1 }, BaseGeometry.ShadingCategory), bumpAmplitude: PD.Numeric(1, { min: 0, max: 5, step: 0.1 }, BaseGeometry.ShadingCategory) });
     Cylinders.Utils = {
         Params: Cylinders.Params,
         createEmpty: createEmpty,
@@ -153,7 +153,7 @@ export var Cylinders;
         var padding = getMaxSize(size) * props.sizeFactor;
         var invariantBoundingSphere = Sphere3D.clone(cylinders.boundingSphere);
         var boundingSphere = calculateTransformBoundingSphere(invariantBoundingSphere, transform.aTransform.ref.value, instanceCount);
-        return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ aMapping: cylinders.mappingBuffer, aGroup: cylinders.groupBuffer, aStart: cylinders.startBuffer, aEnd: cylinders.endBuffer, aScale: cylinders.scaleBuffer, aCap: cylinders.capBuffer, elements: cylinders.indexBuffer, boundingSphere: ValueCell.create(boundingSphere), invariantBoundingSphere: ValueCell.create(invariantBoundingSphere), uInvariantBoundingSphere: ValueCell.create(Vec4.ofSphere(invariantBoundingSphere)) }, color), size), marker), overpaint), transparency), material), clipping), transform), { padding: ValueCell.create(padding) }), BaseGeometry.createValues(props, counts)), { uSizeFactor: ValueCell.create(props.sizeFactor * props.sizeAspectRatio), dDoubleSided: ValueCell.create(props.doubleSided), dIgnoreLight: ValueCell.create(props.ignoreLight), dXrayShaded: ValueCell.create(props.xrayShaded) });
+        return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ aMapping: cylinders.mappingBuffer, aGroup: cylinders.groupBuffer, aStart: cylinders.startBuffer, aEnd: cylinders.endBuffer, aScale: cylinders.scaleBuffer, aCap: cylinders.capBuffer, elements: cylinders.indexBuffer, boundingSphere: ValueCell.create(boundingSphere), invariantBoundingSphere: ValueCell.create(invariantBoundingSphere), uInvariantBoundingSphere: ValueCell.create(Vec4.ofSphere(invariantBoundingSphere)) }, color), size), marker), overpaint), transparency), material), clipping), transform), { padding: ValueCell.create(padding) }), BaseGeometry.createValues(props, counts)), { uSizeFactor: ValueCell.create(props.sizeFactor * props.sizeAspectRatio), dDoubleSided: ValueCell.create(props.doubleSided), dIgnoreLight: ValueCell.create(props.ignoreLight), dXrayShaded: ValueCell.create(props.xrayShaded), uBumpFrequency: ValueCell.create(props.bumpFrequency), uBumpAmplitude: ValueCell.create(props.bumpAmplitude) });
     }
     function createValuesSimple(cylinders, props, colorValue, sizeValue, transform) {
         var s = BaseGeometry.createSimple(colorValue, sizeValue, transform);
@@ -166,6 +166,8 @@ export var Cylinders;
         ValueCell.updateIfChanged(values.dDoubleSided, props.doubleSided);
         ValueCell.updateIfChanged(values.dIgnoreLight, props.ignoreLight);
         ValueCell.updateIfChanged(values.dXrayShaded, props.xrayShaded);
+        ValueCell.updateIfChanged(values.uBumpFrequency, props.bumpFrequency);
+        ValueCell.updateIfChanged(values.uBumpAmplitude, props.bumpAmplitude);
     }
     function updateBoundingSphere(values, cylinders) {
         var invariantBoundingSphere = Sphere3D.clone(cylinders.boundingSphere);

package/lib/mol-geo/geometry/direct-volume/direct-volume.d.ts

@@ -76,6 +76,7 @@ export declare namespace DirectVolume {
         material: PD.Group<PD.Normalize<{
             metalness: number;
             roughness: number;
+            bumpiness: number;
         }>>;
     };
     type Params = typeof Params;

package/lib/mol-geo/geometry/image/image.d.ts

@@ -37,6 +37,7 @@ declare namespace Image {
         material: PD.Group<PD.Normalize<{
             metalness: number;
             roughness: number;
+            bumpiness: number;
         }>>;
     };
     type Params = typeof Params;

package/lib/mol-geo/geometry/lines/lines.d.ts

@@ -44,6 +44,8 @@ export declare namespace Lines {
         material: PD.Group<PD.Normalize<{
             metalness: number;
             roughness: number;
+            /** Number of lines */
+            bumpiness: number;
         }>>;
     };
     type Params = typeof Params;

package/lib/mol-geo/geometry/mesh/color-smoothing.js

@@ -298,7 +298,7 @@ export function applyMeshSubstanceSmoothing(values, resolution, stride, webgl, c
         colorType: values.dSubstanceType.ref.value,
         boundingSphere: values.boundingSphere.ref.value,
         invariantBoundingSphere: values.invariantBoundingSphere.ref.value,
-        itemSize: 3
+        itemSize: 4
     }, resolution, stride, webgl, colorTexture);
     if (smoothingData.kind === 'volume') {
         ValueCell.updateIfChanged(values.dSubstanceType, smoothingData.type);

package/lib/mol-geo/geometry/mesh/mesh.d.ts

@@ -62,11 +62,14 @@ export declare namespace Mesh {
         flatShaded: PD.BooleanParam;
         ignoreLight: PD.BooleanParam;
         xrayShaded: PD.BooleanParam;
+        bumpFrequency: PD.Numeric;
+        bumpAmplitude: PD.Numeric;
         alpha: PD.Numeric;
         quality: PD.Select<"auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest">;
         material: PD.Group<PD.Normalize<{
             metalness: number;
             roughness: number;
+            bumpiness: number;
         }>>;
     };
     type Params = typeof Params;

package/lib/mol-geo/geometry/mesh/mesh.js

@@ -551,7 +551,7 @@ export var Mesh;
     }
     Mesh.smoothEdges = smoothEdges;
     //
-    Mesh.Params = __assign(__assign({}, BaseGeometry.Params), { doubleSided: PD.Boolean(false, BaseGeometry.CustomQualityParamInfo), flipSided: PD.Boolean(false, BaseGeometry.ShadingCategory), flatShaded: PD.Boolean(false, BaseGeometry.ShadingCategory), ignoreLight: PD.Boolean(false, BaseGeometry.ShadingCategory), xrayShaded: PD.Boolean(false, BaseGeometry.ShadingCategory) });
+    Mesh.Params = __assign(__assign({}, BaseGeometry.Params), { doubleSided: PD.Boolean(false, BaseGeometry.CustomQualityParamInfo), flipSided: PD.Boolean(false, BaseGeometry.ShadingCategory), flatShaded: PD.Boolean(false, BaseGeometry.ShadingCategory), ignoreLight: PD.Boolean(false, BaseGeometry.ShadingCategory), xrayShaded: PD.Boolean(false, BaseGeometry.ShadingCategory), bumpFrequency: PD.Numeric(0, { min: 0, max: 10, step: 0.1 }, BaseGeometry.ShadingCategory), bumpAmplitude: PD.Numeric(1, { min: 0, max: 5, step: 0.1 }, BaseGeometry.ShadingCategory) });
     Mesh.Utils = {
         Params: Mesh.Params,
         createEmpty: createEmpty,
@@ -593,7 +593,7 @@ export var Mesh;
         var counts = { drawCount: mesh.triangleCount * 3, vertexCount: mesh.vertexCount, groupCount: groupCount, instanceCount: instanceCount };
         var invariantBoundingSphere = Sphere3D.clone(mesh.boundingSphere);
         var boundingSphere = calculateTransformBoundingSphere(invariantBoundingSphere, transform.aTransform.ref.value, instanceCount);
-        return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ aPosition: mesh.vertexBuffer, aNormal: mesh.normalBuffer, aGroup: mesh.groupBuffer, elements: mesh.indexBuffer, boundingSphere: ValueCell.create(boundingSphere), invariantBoundingSphere: ValueCell.create(invariantBoundingSphere), uInvariantBoundingSphere: ValueCell.create(Vec4.ofSphere(invariantBoundingSphere)) }, color), marker), overpaint), transparency), material), clipping), transform), BaseGeometry.createValues(props, counts)), { dDoubleSided: ValueCell.create(props.doubleSided), dFlatShaded: ValueCell.create(props.flatShaded), dFlipSided: ValueCell.create(props.flipSided), dIgnoreLight: ValueCell.create(props.ignoreLight), dXrayShaded: ValueCell.create(props.xrayShaded), meta: ValueCell.create(mesh.meta) });
+        return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ aPosition: mesh.vertexBuffer, aNormal: mesh.normalBuffer, aGroup: mesh.groupBuffer, elements: mesh.indexBuffer, boundingSphere: ValueCell.create(boundingSphere), invariantBoundingSphere: ValueCell.create(invariantBoundingSphere), uInvariantBoundingSphere: ValueCell.create(Vec4.ofSphere(invariantBoundingSphere)) }, color), marker), overpaint), transparency), material), clipping), transform), BaseGeometry.createValues(props, counts)), { dDoubleSided: ValueCell.create(props.doubleSided), dFlatShaded: ValueCell.create(props.flatShaded), dFlipSided: ValueCell.create(props.flipSided), dIgnoreLight: ValueCell.create(props.ignoreLight), dXrayShaded: ValueCell.create(props.xrayShaded), uBumpFrequency: ValueCell.create(props.bumpFrequency), uBumpAmplitude: ValueCell.create(props.bumpAmplitude), meta: ValueCell.create(mesh.meta) });
     }
     function createValuesSimple(mesh, props, colorValue, sizeValue, transform) {
         var s = BaseGeometry.createSimple(colorValue, sizeValue, transform);
@@ -607,6 +607,8 @@ export var Mesh;
         ValueCell.updateIfChanged(values.dFlipSided, props.flipSided);
         ValueCell.updateIfChanged(values.dIgnoreLight, props.ignoreLight);
         ValueCell.updateIfChanged(values.dXrayShaded, props.xrayShaded);
+        ValueCell.updateIfChanged(values.uBumpFrequency, props.bumpFrequency);
+        ValueCell.updateIfChanged(values.uBumpAmplitude, props.bumpAmplitude);
     }
     function updateBoundingSphere(values, mesh) {
         var invariantBoundingSphere = Sphere3D.clone(mesh.boundingSphere);

package/lib/mol-geo/geometry/points/points.d.ts

@@ -44,6 +44,7 @@ export declare namespace Points {
         material: PD.Group<PD.Normalize<{
             metalness: number;
             roughness: number;
+            bumpiness: number;
         }>>;
     };
     type Params = typeof Params;

package/lib/mol-geo/geometry/spheres/spheres.d.ts

@@ -34,11 +34,14 @@ export declare namespace Spheres {
         doubleSided: PD.BooleanParam;
         ignoreLight: PD.BooleanParam;
         xrayShaded: PD.BooleanParam;
+        bumpFrequency: PD.Numeric;
+        bumpAmplitude: PD.Numeric;
         alpha: PD.Numeric;
         quality: PD.Select<"auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest">;
         material: PD.Group<PD.Normalize<{
             metalness: number;
             roughness: number;
+            bumpiness: number;
         }>>;
     };
     type Params = typeof Params;

package/lib/mol-geo/geometry/spheres/spheres.js

@@ -88,7 +88,7 @@ export var Spheres;
         ValueCell.update(spheres.groupBuffer, groups);
         return spheres;
     }
-    Spheres.Params = __assign(__assign({}, BaseGeometry.Params), { sizeFactor: PD.Numeric(1, { min: 0, max: 10, step: 0.1 }), doubleSided: PD.Boolean(false, BaseGeometry.CustomQualityParamInfo), ignoreLight: PD.Boolean(false, BaseGeometry.ShadingCategory), xrayShaded: PD.Boolean(false, BaseGeometry.ShadingCategory) });
+    Spheres.Params = __assign(__assign({}, BaseGeometry.Params), { sizeFactor: PD.Numeric(1, { min: 0, max: 10, step: 0.1 }), doubleSided: PD.Boolean(false, BaseGeometry.CustomQualityParamInfo), ignoreLight: PD.Boolean(false, BaseGeometry.ShadingCategory), xrayShaded: PD.Boolean(false, BaseGeometry.ShadingCategory), bumpFrequency: PD.Numeric(0, { min: 0, max: 10, step: 0.1 }, BaseGeometry.ShadingCategory), bumpAmplitude: PD.Numeric(1, { min: 0, max: 5, step: 0.1 }, BaseGeometry.ShadingCategory) });
     Spheres.Utils = {
         Params: Spheres.Params,
         createEmpty: createEmpty,
@@ -132,7 +132,7 @@ export var Spheres;
         var padding = spheres.boundingSphere.radius ? getMaxSize(size) * props.sizeFactor : 0;
         var invariantBoundingSphere = Sphere3D.expand(Sphere3D(), spheres.boundingSphere, padding);
         var boundingSphere = calculateTransformBoundingSphere(invariantBoundingSphere, transform.aTransform.ref.value, instanceCount);
-        return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ aPosition: spheres.centerBuffer, aMapping: spheres.mappingBuffer, aGroup: spheres.groupBuffer, elements: spheres.indexBuffer, boundingSphere: ValueCell.create(boundingSphere), invariantBoundingSphere: ValueCell.create(invariantBoundingSphere), uInvariantBoundingSphere: ValueCell.create(Vec4.ofSphere(invariantBoundingSphere)) }, color), size), marker), overpaint), transparency), material), clipping), transform), { padding: ValueCell.create(padding) }), BaseGeometry.createValues(props, counts)), { uSizeFactor: ValueCell.create(props.sizeFactor), dDoubleSided: ValueCell.create(props.doubleSided), dIgnoreLight: ValueCell.create(props.ignoreLight), dXrayShaded: ValueCell.create(props.xrayShaded) });
+        return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ aPosition: spheres.centerBuffer, aMapping: spheres.mappingBuffer, aGroup: spheres.groupBuffer, elements: spheres.indexBuffer, boundingSphere: ValueCell.create(boundingSphere), invariantBoundingSphere: ValueCell.create(invariantBoundingSphere), uInvariantBoundingSphere: ValueCell.create(Vec4.ofSphere(invariantBoundingSphere)) }, color), size), marker), overpaint), transparency), material), clipping), transform), { padding: ValueCell.create(padding) }), BaseGeometry.createValues(props, counts)), { uSizeFactor: ValueCell.create(props.sizeFactor), dDoubleSided: ValueCell.create(props.doubleSided), dIgnoreLight: ValueCell.create(props.ignoreLight), dXrayShaded: ValueCell.create(props.xrayShaded), uBumpFrequency: ValueCell.create(props.bumpFrequency), uBumpAmplitude: ValueCell.create(props.bumpAmplitude) });
     }
     function createValuesSimple(spheres, props, colorValue, sizeValue, transform) {
         var s = BaseGeometry.createSimple(colorValue, sizeValue, transform);
@@ -145,6 +145,8 @@ export var Spheres;
         ValueCell.updateIfChanged(values.dDoubleSided, props.doubleSided);
         ValueCell.updateIfChanged(values.dIgnoreLight, props.ignoreLight);
         ValueCell.updateIfChanged(values.dXrayShaded, props.xrayShaded);
+        ValueCell.updateIfChanged(values.uBumpFrequency, props.bumpFrequency);
+        ValueCell.updateIfChanged(values.uBumpAmplitude, props.bumpAmplitude);
     }
     function updateBoundingSphere(values, spheres) {
         var padding = spheres.boundingSphere.radius

package/lib/mol-geo/geometry/substance-data.js

@@ -10,13 +10,13 @@ import { createNullTexture } from '../../mol-gl/webgl/texture';
 import { Material } from '../../mol-util/material';
 export function applySubstanceMaterial(array, start, end, material) {
     for (var i = start; i < end; ++i) {
-        Material.toArray(material, array, i * 3);
-        array[i * 3 + 2] = 255;
+        Material.toArray(material, array, i * 4);
+        array[i * 4 + 3] = 255;
     }
     return true;
 }
 export function clearSubstance(array, start, end) {
-    array.fill(0, start * 3, end * 3);
+    array.fill(0, start * 4, end * 4);
     return true;
 }
 export function createSubstance(count, substanceData) {

package/lib/mol-geo/geometry/text/text.d.ts

@@ -63,6 +63,7 @@ export declare namespace Text {
         material: PD.Group<PD.Normalize<{
             metalness: number;
             roughness: number;
+            bumpiness: number;
         }>>;
     };
     type Params = typeof Params;

package/lib/mol-geo/geometry/texture-mesh/color-smoothing.js

@@ -397,10 +397,10 @@ export function applyTextureMeshSubstanceSmoothing(values, resolution, stride, w
     if (!isSupportedSubstanceType(values.dSubstanceType.ref.value))
         return;
     stride *= 3; // triple because TextureMesh is never indexed (no elements buffer)
-    if (!webgl.namedTextures[ColorSmoothingRgbName]) {
-        webgl.namedTextures[ColorSmoothingRgbName] = webgl.resources.texture('image-uint8', 'rgb', 'ubyte', 'nearest');
+    if (!webgl.namedTextures[ColorSmoothingRgbaName]) {
+        webgl.namedTextures[ColorSmoothingRgbaName] = webgl.resources.texture('image-uint8', 'rgba', 'ubyte', 'nearest');
     }
-    var colorData = webgl.namedTextures[ColorSmoothingRgbName];
+    var colorData = webgl.namedTextures[ColorSmoothingRgbaName];
     colorData.load(values.tSubstance.ref.value);
     var smoothingData = calcTextureMeshColorSmoothing({
         vertexCount: values.uVertexCount.ref.value,

package/lib/mol-geo/geometry/texture-mesh/texture-mesh.d.ts

@@ -45,11 +45,14 @@ export declare namespace TextureMesh {
         flatShaded: PD.BooleanParam;
         ignoreLight: PD.BooleanParam;
         xrayShaded: PD.BooleanParam;
+        bumpFrequency: PD.Numeric;
+        bumpAmplitude: PD.Numeric;
         alpha: PD.Numeric;
         quality: PD.Select<"auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest">;
         material: PD.Group<PD.Normalize<{
             metalness: number;
             roughness: number;
+            bumpiness: number;
         }>>;
     };
     type Params = typeof Params;

package/lib/mol-geo/geometry/texture-mesh/texture-mesh.js

@@ -86,7 +86,7 @@ export var TextureMesh;
         return create(0, 0, vt, gt, nt, bs, textureMesh);
     }
     TextureMesh.createEmpty = createEmpty;
-    TextureMesh.Params = __assign(__assign({}, BaseGeometry.Params), { doubleSided: PD.Boolean(false, BaseGeometry.CustomQualityParamInfo), flipSided: PD.Boolean(false, BaseGeometry.ShadingCategory), flatShaded: PD.Boolean(false, BaseGeometry.ShadingCategory), ignoreLight: PD.Boolean(false, BaseGeometry.ShadingCategory), xrayShaded: PD.Boolean(false, BaseGeometry.ShadingCategory) });
+    TextureMesh.Params = __assign(__assign({}, BaseGeometry.Params), { doubleSided: PD.Boolean(false, BaseGeometry.CustomQualityParamInfo), flipSided: PD.Boolean(false, BaseGeometry.ShadingCategory), flatShaded: PD.Boolean(false, BaseGeometry.ShadingCategory), ignoreLight: PD.Boolean(false, BaseGeometry.ShadingCategory), xrayShaded: PD.Boolean(false, BaseGeometry.ShadingCategory), bumpFrequency: PD.Numeric(0, { min: 0, max: 10, step: 0.1 }, BaseGeometry.ShadingCategory), bumpAmplitude: PD.Numeric(1, { min: 0, max: 5, step: 0.1 }, BaseGeometry.ShadingCategory) });
     TextureMesh.Utils = {
         Params: TextureMesh.Params,
         createEmpty: createEmpty,
@@ -110,7 +110,7 @@ export var TextureMesh;
         var counts = { drawCount: textureMesh.vertexCount, vertexCount: textureMesh.vertexCount, groupCount: groupCount, instanceCount: instanceCount };
         var invariantBoundingSphere = Sphere3D.clone(textureMesh.boundingSphere);
         var boundingSphere = calculateTransformBoundingSphere(invariantBoundingSphere, transform.aTransform.ref.value, instanceCount);
-        return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ uGeoTexDim: textureMesh.geoTextureDim, tPosition: textureMesh.vertexTexture, tGroup: textureMesh.groupTexture, tNormal: textureMesh.normalTexture, boundingSphere: ValueCell.create(boundingSphere), invariantBoundingSphere: ValueCell.create(invariantBoundingSphere), uInvariantBoundingSphere: ValueCell.create(Vec4.ofSphere(invariantBoundingSphere)) }, color), marker), overpaint), transparency), substance), clipping), transform), BaseGeometry.createValues(props, counts)), { dDoubleSided: ValueCell.create(props.doubleSided), dFlatShaded: ValueCell.create(props.flatShaded), dFlipSided: ValueCell.create(props.flipSided), dIgnoreLight: ValueCell.create(props.ignoreLight), dXrayShaded: ValueCell.create(props.xrayShaded), dGeoTexture: ValueCell.create(true), meta: ValueCell.create(textureMesh.meta) });
+        return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ uGeoTexDim: textureMesh.geoTextureDim, tPosition: textureMesh.vertexTexture, tGroup: textureMesh.groupTexture, tNormal: textureMesh.normalTexture, boundingSphere: ValueCell.create(boundingSphere), invariantBoundingSphere: ValueCell.create(invariantBoundingSphere), uInvariantBoundingSphere: ValueCell.create(Vec4.ofSphere(invariantBoundingSphere)) }, color), marker), overpaint), transparency), substance), clipping), transform), BaseGeometry.createValues(props, counts)), { dDoubleSided: ValueCell.create(props.doubleSided), dFlatShaded: ValueCell.create(props.flatShaded), dFlipSided: ValueCell.create(props.flipSided), dIgnoreLight: ValueCell.create(props.ignoreLight), dXrayShaded: ValueCell.create(props.xrayShaded), uBumpFrequency: ValueCell.create(props.bumpFrequency), uBumpAmplitude: ValueCell.create(props.bumpAmplitude), dGeoTexture: ValueCell.create(true), meta: ValueCell.create(textureMesh.meta) });
     }
     function createValuesSimple(textureMesh, props, colorValue, sizeValue, transform) {
         var s = BaseGeometry.createSimple(colorValue, sizeValue, transform);
@@ -124,6 +124,8 @@ export var TextureMesh;
         ValueCell.updateIfChanged(values.dFlipSided, props.flipSided);
         ValueCell.updateIfChanged(values.dIgnoreLight, props.ignoreLight);
         ValueCell.updateIfChanged(values.dXrayShaded, props.xrayShaded);
+        ValueCell.updateIfChanged(values.uBumpFrequency, props.bumpFrequency);
+        ValueCell.updateIfChanged(values.uBumpAmplitude, props.bumpAmplitude);
     }
     function updateBoundingSphere(values, textureMesh) {
         var invariantBoundingSphere = Sphere3D.clone(textureMesh.boundingSphere);

package/lib/mol-gl/renderable/cylinders.d.ts

@@ -1,11 +1,11 @@
 /**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 import { Renderable, RenderableState } from '../renderable';
 import { WebGLContext } from '../webgl/context';
-import { AttributeSpec, Values, ElementsSpec, ValueSpec, DefineSpec } from './schema';
+import { AttributeSpec, Values, ElementsSpec, ValueSpec, DefineSpec, UniformSpec } from './schema';
 export declare const CylindersSchema: {
     aGroup: AttributeSpec<"float32">;
     aStart: AttributeSpec<"float32">;
@@ -18,21 +18,24 @@ export declare const CylindersSchema: {
     dDoubleSided: DefineSpec<"boolean">;
     dIgnoreLight: DefineSpec<"boolean">;
     dXrayShaded: DefineSpec<"boolean">;
-    uSize: import("./schema").UniformSpec<"f">;
-    uSizeTexDim: import("./schema").UniformSpec<"v2">;
+    uBumpFrequency: UniformSpec<"f">;
+    uBumpAmplitude: UniformSpec<"f">;
+    uSize: UniformSpec<"f">;
+    uSizeTexDim: UniformSpec<"v2">;
     tSize: import("./schema").TextureSpec<"image-uint8">;
     dSizeType: DefineSpec<"string">;
-    uSizeFactor: import("./schema").UniformSpec<"f">;
+    uSizeFactor: UniformSpec<"f">;
     dLightCount: DefineSpec<"number">;
     aInstance: AttributeSpec<"float32">;
     aTransform: AttributeSpec<"float32">;
-    uAlpha: import("./schema").UniformSpec<"f">;
-    uMetalness: import("./schema").UniformSpec<"f">;
-    uRoughness: import("./schema").UniformSpec<"f">;
-    uVertexCount: import("./schema").UniformSpec<"i">;
-    uInstanceCount: import("./schema").UniformSpec<"i">;
-    uGroupCount: import("./schema").UniformSpec<"i">;
-    uInvariantBoundingSphere: import("./schema").UniformSpec<"v4">;
+    uAlpha: UniformSpec<"f">;
+    uMetalness: UniformSpec<"f">;
+    uRoughness: UniformSpec<"f">;
+    uBumpiness: UniformSpec<"f">;
+    uVertexCount: UniformSpec<"i">;
+    uInstanceCount: UniformSpec<"i">;
+    uGroupCount: UniformSpec<"i">;
+    uInvariantBoundingSphere: UniformSpec<"v4">;
     drawCount: ValueSpec<"number">;
     instanceCount: ValueSpec<"number">;
     alpha: ValueSpec<"number">;
@@ -44,41 +47,41 @@ export declare const CylindersSchema: {
     invariantBoundingSphere: ValueSpec<"sphere">;
     dClipObjectCount: DefineSpec<"number">;
     dClipVariant: DefineSpec<"string">;
-    uClippingTexDim: import("./schema").UniformSpec<"v2">;
+    uClippingTexDim: UniformSpec<"v2">;
     tClipping: import("./schema").TextureSpec<"image-uint8">;
     dClipping: DefineSpec<"boolean">;
-    uSubstanceTexDim: import("./schema").UniformSpec<"v2">;
+    uSubstanceTexDim: UniformSpec<"v2">;
     tSubstance: import("./schema").TextureSpec<"image-uint8">;
     dSubstance: DefineSpec<"boolean">;
-    uSubstanceGridDim: import("./schema").UniformSpec<"v3">;
-    uSubstanceGridTransform: import("./schema").UniformSpec<"v4">;
+    uSubstanceGridDim: UniformSpec<"v3">;
+    uSubstanceGridTransform: UniformSpec<"v4">;
     tSubstanceGrid: import("./schema").TextureSpec<"texture">;
     dSubstanceType: DefineSpec<"string">;
-    uTransparencyTexDim: import("./schema").UniformSpec<"v2">;
+    uTransparencyTexDim: UniformSpec<"v2">;
     tTransparency: import("./schema").TextureSpec<"image-uint8">;
     dTransparency: DefineSpec<"boolean">;
     transparencyAverage: ValueSpec<"number">;
-    uTransparencyGridDim: import("./schema").UniformSpec<"v3">;
-    uTransparencyGridTransform: import("./schema").UniformSpec<"v4">;
+    uTransparencyGridDim: UniformSpec<"v3">;
+    uTransparencyGridTransform: UniformSpec<"v4">;
     tTransparencyGrid: import("./schema").TextureSpec<"texture">;
     dTransparencyType: DefineSpec<"string">;
-    uOverpaintTexDim: import("./schema").UniformSpec<"v2">;
+    uOverpaintTexDim: UniformSpec<"v2">;
     tOverpaint: import("./schema").TextureSpec<"image-uint8">;
     dOverpaint: DefineSpec<"boolean">;
-    uOverpaintGridDim: import("./schema").UniformSpec<"v3">;
-    uOverpaintGridTransform: import("./schema").UniformSpec<"v4">;
+    uOverpaintGridDim: UniformSpec<"v3">;
+    uOverpaintGridTransform: UniformSpec<"v4">;
     tOverpaintGrid: import("./schema").TextureSpec<"texture">;
     dOverpaintType: DefineSpec<"string">;
-    uMarker: import("./schema").UniformSpec<"f">;
-    uMarkerTexDim: import("./schema").UniformSpec<"v2">;
+    uMarker: UniformSpec<"f">;
+    uMarkerTexDim: UniformSpec<"v2">;
     tMarker: import("./schema").TextureSpec<"image-uint8">;
     dMarkerType: DefineSpec<"string">;
     markerAverage: ValueSpec<"number">;
     markerStatus: ValueSpec<"number">;
-    uColor: import("./schema").UniformSpec<"v3">;
-    uColorTexDim: import("./schema").UniformSpec<"v2">;
-    uColorGridDim: import("./schema").UniformSpec<"v3">;
-    uColorGridTransform: import("./schema").UniformSpec<"v4">;
+    uColor: UniformSpec<"v3">;
+    uColorTexDim: UniformSpec<"v2">;
+    uColorGridDim: UniformSpec<"v3">;
+    uColorGridTransform: UniformSpec<"v4">;
     tColor: import("./schema").TextureSpec<"image-uint8">;
     tPalette: import("./schema").TextureSpec<"image-uint8">;
     tColorGrid: import("./schema").TextureSpec<"texture">;

package/lib/mol-gl/renderable/cylinders.js

@@ -1,15 +1,15 @@
 /**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 import { __assign } from "tslib";
 import { createRenderable } from '../renderable';
 import { createGraphicsRenderItem } from '../webgl/render-item';
-import { GlobalUniformSchema, BaseSchema, AttributeSpec, InternalSchema, SizeSchema, ElementsSpec, ValueSpec, DefineSpec, GlobalTextureSchema } from './schema';
+import { GlobalUniformSchema, BaseSchema, AttributeSpec, InternalSchema, SizeSchema, ElementsSpec, ValueSpec, DefineSpec, GlobalTextureSchema, UniformSpec } from './schema';
 import { CylindersShaderCode } from '../shader-code';
 import { ValueCell } from '../../mol-util';
-export var CylindersSchema = __assign(__assign(__assign({}, BaseSchema), SizeSchema), { aGroup: AttributeSpec('float32', 1, 0), aStart: AttributeSpec('float32', 3, 0), aEnd: AttributeSpec('float32', 3, 0), aMapping: AttributeSpec('float32', 3, 0), aScale: AttributeSpec('float32', 1, 0), aCap: AttributeSpec('float32', 1, 0), elements: ElementsSpec('uint32'), padding: ValueSpec('number'), dDoubleSided: DefineSpec('boolean'), dIgnoreLight: DefineSpec('boolean'), dXrayShaded: DefineSpec('boolean') });
+export var CylindersSchema = __assign(__assign(__assign({}, BaseSchema), SizeSchema), { aGroup: AttributeSpec('float32', 1, 0), aStart: AttributeSpec('float32', 3, 0), aEnd: AttributeSpec('float32', 3, 0), aMapping: AttributeSpec('float32', 3, 0), aScale: AttributeSpec('float32', 1, 0), aCap: AttributeSpec('float32', 1, 0), elements: ElementsSpec('uint32'), padding: ValueSpec('number'), dDoubleSided: DefineSpec('boolean'), dIgnoreLight: DefineSpec('boolean'), dXrayShaded: DefineSpec('boolean'), uBumpFrequency: UniformSpec('f'), uBumpAmplitude: UniformSpec('f') });
 export function CylindersRenderable(ctx, id, values, state, materialId) {
     var schema = __assign(__assign(__assign(__assign({}, GlobalUniformSchema), GlobalTextureSchema), InternalSchema), CylindersSchema);
     var internalValues = {

package/lib/mol-gl/renderable/direct-volume.d.ts

@@ -45,6 +45,7 @@ export declare const DirectVolumeSchema: {
     uAlpha: UniformSpec<"f">;
     uMetalness: UniformSpec<"f">;
     uRoughness: UniformSpec<"f">;
+    uBumpiness: UniformSpec<"f">;
     uVertexCount: UniformSpec<"i">;
     uInstanceCount: UniformSpec<"i">;
     uGroupCount: UniformSpec<"i">;

package/lib/mol-gl/renderable/image.d.ts

@@ -21,6 +21,7 @@ export declare const ImageSchema: {
     uAlpha: UniformSpec<"f">;
     uMetalness: UniformSpec<"f">;
     uRoughness: UniformSpec<"f">;
+    uBumpiness: UniformSpec<"f">;
     uVertexCount: UniformSpec<"i">;
     uInstanceCount: UniformSpec<"i">;
     uGroupCount: UniformSpec<"i">;

package/lib/mol-gl/renderable/lines.d.ts

@@ -26,6 +26,7 @@ export declare const LinesSchema: {
     uAlpha: import("./schema").UniformSpec<"f">;
     uMetalness: import("./schema").UniformSpec<"f">;
     uRoughness: import("./schema").UniformSpec<"f">;
+    uBumpiness: import("./schema").UniformSpec<"f">;
     uVertexCount: import("./schema").UniformSpec<"i">;
     uInstanceCount: import("./schema").UniformSpec<"i">;
     uGroupCount: import("./schema").UniformSpec<"i">;