molstar 3.0.0-dev.4 → 3.0.0-dev.8

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

@@ -31,7 +31,7 @@ function getOutlinesRenderable(ctx, depthTexture) {
 }
 var SsaoSchema = __assign(__assign({}, QuadSchema), { tDepth: TextureSpec('texture', 'rgba', 'ubyte', 'nearest'), uSamples: UniformSpec('v3[]'), dNSamples: DefineSpec('number'), uProjection: UniformSpec('m4'), uInvProjection: UniformSpec('m4'), uBounds: UniformSpec('v4'), uTexSize: UniformSpec('v2'), uRadius: UniformSpec('f'), uBias: UniformSpec('f') });
 function getSsaoRenderable(ctx, depthTexture) {
-    var values = __assign(__assign({}, QuadValues), { tDepth: ValueCell.create(depthTexture), uSamples: ValueCell.create([0.0, 0.0, 1.0]), dNSamples: ValueCell.create(1), uProjection: ValueCell.create(Mat4.identity()), uInvProjection: ValueCell.create(Mat4.identity()), uBounds: ValueCell.create(Vec4()), uTexSize: ValueCell.create(Vec2.create(ctx.gl.drawingBufferWidth, ctx.gl.drawingBufferHeight)), uRadius: ValueCell.create(8.0), uBias: ValueCell.create(0.025) });
+    var values = __assign(__assign({}, QuadValues), { tDepth: ValueCell.create(depthTexture), uSamples: ValueCell.create([0.0, 0.0, 1.0]), dNSamples: ValueCell.create(32), uProjection: ValueCell.create(Mat4.identity()), uInvProjection: ValueCell.create(Mat4.identity()), uBounds: ValueCell.create(Vec4()), uTexSize: ValueCell.create(Vec2.create(ctx.gl.drawingBufferWidth, ctx.gl.drawingBufferHeight)), uRadius: ValueCell.create(8.0), uBias: ValueCell.create(0.025) });
     var schema = __assign({}, SsaoSchema);
     var shaderCode = ShaderCode('ssao', quad_vert, ssao_frag);
     var renderItem = createComputeRenderItem(ctx, 'triangles', shaderCode, schema, values);
@@ -39,7 +39,7 @@ function getSsaoRenderable(ctx, depthTexture) {
 }
 var SsaoBlurSchema = __assign(__assign({}, QuadSchema), { tSsaoDepth: TextureSpec('texture', 'rgba', 'ubyte', 'nearest'), uTexSize: UniformSpec('v2'), uKernel: UniformSpec('f[]'), dOcclusionKernelSize: DefineSpec('number'), uBlurDirectionX: UniformSpec('f'), uBlurDirectionY: UniformSpec('f'), uMaxPossibleViewZDiff: UniformSpec('f'), uNear: UniformSpec('f'), uFar: UniformSpec('f'), uBounds: UniformSpec('v4'), dOrthographic: DefineSpec('number') });
 function getSsaoBlurRenderable(ctx, ssaoDepthTexture, direction) {
-    var values = __assign(__assign({}, QuadValues), { tSsaoDepth: ValueCell.create(ssaoDepthTexture), uTexSize: ValueCell.create(Vec2.create(ssaoDepthTexture.getWidth(), ssaoDepthTexture.getHeight())), uKernel: ValueCell.create([0.0]), dOcclusionKernelSize: ValueCell.create(1), uBlurDirectionX: ValueCell.create(direction === 'horizontal' ? 1 : 0), uBlurDirectionY: ValueCell.create(direction === 'vertical' ? 1 : 0), uMaxPossibleViewZDiff: ValueCell.create(0.5), uNear: ValueCell.create(0.0), uFar: ValueCell.create(10000.0), uBounds: ValueCell.create(Vec4()), dOrthographic: ValueCell.create(0) });
+    var values = __assign(__assign({}, QuadValues), { tSsaoDepth: ValueCell.create(ssaoDepthTexture), uTexSize: ValueCell.create(Vec2.create(ssaoDepthTexture.getWidth(), ssaoDepthTexture.getHeight())), uKernel: ValueCell.create([0.0]), dOcclusionKernelSize: ValueCell.create(15), uBlurDirectionX: ValueCell.create(direction === 'horizontal' ? 1 : 0), uBlurDirectionY: ValueCell.create(direction === 'vertical' ? 1 : 0), uMaxPossibleViewZDiff: ValueCell.create(0.5), uNear: ValueCell.create(0.0), uFar: ValueCell.create(10000.0), uBounds: ValueCell.create(Vec4()), dOrthographic: ValueCell.create(0) });
     var schema = __assign({}, SsaoBlurSchema);
     var shaderCode = ShaderCode('ssao_blur', quad_vert, ssaoBlur_frag);
     var renderItem = createComputeRenderItem(ctx, 'triangles', shaderCode, schema, values);
@@ -67,7 +67,7 @@ function getSamples(vectorSamples, nSamples) {
 }
 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)), 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 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(true), 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);

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

@@ -135,7 +135,7 @@ function getWeightsRenderable(ctx, edgesTexture) {
     var height = edgesTexture.getHeight();
     var areaTexture = createTexture(ctx.gl, ctx.extensions, 'image-uint8', 'rgb', 'ubyte', 'linear');
     var searchTexture = createTexture(ctx.gl, ctx.extensions, 'image-uint8', 'rgba', 'ubyte', 'nearest');
-    var values = __assign(__assign({}, QuadValues), { tEdges: ValueCell.create(edgesTexture), tArea: ValueCell.create(areaTexture), tSearch: ValueCell.create(searchTexture), uTexSizeInv: ValueCell.create(Vec2.create(1 / width, 1 / height)), uViewport: ValueCell.create(Vec4()), dMaxSearchSteps: ValueCell.create(8) });
+    var values = __assign(__assign({}, QuadValues), { tEdges: ValueCell.create(edgesTexture), tArea: ValueCell.create(areaTexture), tSearch: ValueCell.create(searchTexture), uTexSizeInv: ValueCell.create(Vec2.create(1 / width, 1 / height)), uViewport: ValueCell.create(Vec4()), dMaxSearchSteps: ValueCell.create(16) });
     // Note: loading image textures requires `HTMLImageElement` to be available
     loadImageTexture(getAreaTexture(), values.tArea, areaTexture);
     loadImageTexture(getSearchTexture(), values.tSearch, searchTexture);

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

@@ -10,6 +10,7 @@ import { LocationIterator } from '../util/location-iterator';
 import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { TransformData } from './transform-data';
 import { Theme } from '../../mol-theme/theme';
+import { Clip } from '../../mol-util/clip';
 export declare const VisualQualityInfo: {
     custom: {};
     auto: {};
@@ -48,6 +49,16 @@ export declare namespace BaseGeometry {
             roughness: number;
             bumpiness: number;
         }>>;
+        clip: PD.Group<PD.Normalize<{
+            variant: Clip.Variant;
+            objects: PD.Normalize<{
+                type: any;
+                invert: any;
+                position: any;
+                rotation: any;
+                scale: any;
+            }>[];
+        }>>;
     };
     type Params = typeof Params;
     type Counts = {
@@ -71,6 +82,13 @@ export declare namespace BaseGeometry {
         uRoughness: ValueCell<number, never>;
         uBumpiness: ValueCell<number, never>;
         dLightCount: ValueCell<number, never>;
+        dClipObjectCount: ValueCell<number, never>;
+        dClipVariant: ValueCell<Clip.Variant, never>;
+        uClipObjectType: ValueCell<number[], never>;
+        uClipObjectInvert: ValueCell<boolean[], never>;
+        uClipObjectPosition: ValueCell<number[], never>;
+        uClipObjectRotation: ValueCell<number[], never>;
+        uClipObjectScale: ValueCell<number[], never>;
     };
     function updateValues(values: BaseValues, props: PD.Values<Params>): void;
     function createRenderableState(props?: Partial<PD.Values<Params>>): RenderableState;

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

@@ -13,6 +13,7 @@ import { UniformColorTheme } from '../../mol-theme/color/uniform';
 import { UniformSizeTheme } from '../../mol-theme/size/uniform';
 import { smoothstep } from '../../mol-math/interpolate';
 import { Material } from '../../mol-util/material';
+import { Clip } from '../../mol-util/clip';
 export var VisualQualityInfo = {
     'custom': {},
     'auto': {},
@@ -71,6 +72,7 @@ export var BaseGeometry;
         alpha: PD.Numeric(1, { min: 0, max: 1, step: 0.01 }, { label: 'Opacity', isEssential: true, description: 'How opaque/transparent the representation is rendered.' }),
         quality: PD.Select('auto', VisualQualityOptions, { isEssential: true, description: 'Visual/rendering quality of the representation.' }),
         material: Material.getParam(),
+        clip: PD.Group(Clip.Params),
     };
     function createSimple(colorValue, sizeValue, transform) {
         if (colorValue === void 0) { colorValue = ColorNames.grey; }
@@ -86,6 +88,7 @@ export var BaseGeometry;
     }
     BaseGeometry.createSimple = createSimple;
     function createValues(props, counts) {
+        var clip = Clip.getClip(props.clip);
         return {
             alpha: ValueCell.create(props.alpha),
             uAlpha: ValueCell.create(props.alpha),
@@ -96,6 +99,13 @@ export var BaseGeometry;
             uRoughness: ValueCell.create(props.material.roughness),
             uBumpiness: ValueCell.create(props.material.bumpiness),
             dLightCount: ValueCell.create(1),
+            dClipObjectCount: ValueCell.create(clip.objects.count),
+            dClipVariant: ValueCell.create(clip.variant),
+            uClipObjectType: ValueCell.create(clip.objects.type),
+            uClipObjectInvert: ValueCell.create(clip.objects.invert),
+            uClipObjectPosition: ValueCell.create(clip.objects.position),
+            uClipObjectRotation: ValueCell.create(clip.objects.rotation),
+            uClipObjectScale: ValueCell.create(clip.objects.scale),
         };
     }
     BaseGeometry.createValues = createValues;
@@ -104,6 +114,14 @@ export var BaseGeometry;
         ValueCell.updateIfChanged(values.uMetalness, props.material.metalness);
         ValueCell.updateIfChanged(values.uRoughness, props.material.roughness);
         ValueCell.updateIfChanged(values.uBumpiness, props.material.bumpiness);
+        var clip = Clip.getClip(props.clip);
+        ValueCell.update(values.dClipObjectCount, clip.objects.count);
+        ValueCell.update(values.dClipVariant, clip.variant);
+        ValueCell.update(values.uClipObjectType, clip.objects.type);
+        ValueCell.update(values.uClipObjectInvert, clip.objects.invert);
+        ValueCell.update(values.uClipObjectPosition, clip.objects.position);
+        ValueCell.update(values.uClipObjectRotation, clip.objects.rotation);
+        ValueCell.update(values.uClipObjectScale, clip.objects.scale);
     }
     BaseGeometry.updateValues = updateValues;
     function createRenderableState(props) {
@@ -117,7 +135,6 @@ export var BaseGeometry;
             colorOnly: false,
             opaque: opaque,
             writeDepth: opaque,
-            noClip: false,
         };
     }
     BaseGeometry.createRenderableState = createRenderableState;

package/lib/mol-geo/geometry/clipping-data.d.ts

@@ -1,5 +1,5 @@
 /**
- * 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>
  */
@@ -8,8 +8,6 @@ import { Vec2 } from '../../mol-math/linear-algebra';
 import { TextureImage } from '../../mol-gl/renderable/util';
 import { Clipping } from '../../mol-theme/clipping';
 export declare type ClippingData = {
-    dClipObjectCount: ValueCell<number>;
-    dClipVariant: ValueCell<string>;
     tClipping: ValueCell<TextureImage<Uint8Array>>;
     uClippingTexDim: ValueCell<Vec2>;
     dClipping: ValueCell<boolean>;

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

@@ -1,5 +1,5 @@
 /**
- * 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>
  */
@@ -7,9 +7,7 @@ import { ValueCell } from '../../mol-util/value-cell';
 import { Vec2 } from '../../mol-math/linear-algebra';
 import { createTextureImage } from '../../mol-gl/renderable/util';
 export function applyClippingGroups(array, start, end, groups) {
-    for (var i = start; i < end; ++i) {
-        array[i] = groups;
-    }
+    array.fill(groups, start, end);
     return true;
 }
 export function clearClipping(array, start, end) {
@@ -25,8 +23,6 @@ export function createClipping(count, clippingData) {
     }
     else {
         return {
-            dClipObjectCount: ValueCell.create(0),
-            dClipVariant: ValueCell.create('instance'),
             tClipping: ValueCell.create(clipping),
             uClippingTexDim: ValueCell.create(Vec2.create(clipping.width, clipping.height)),
             dClipping: ValueCell.create(count > 0),
@@ -38,12 +34,11 @@ export function createEmptyClipping(clippingData) {
     if (clippingData) {
         ValueCell.update(clippingData.tClipping, emptyClippingTexture);
         ValueCell.update(clippingData.uClippingTexDim, Vec2.create(1, 1));
+        ValueCell.updateIfChanged(clippingData.dClipping, false);
         return clippingData;
     }
     else {
         return {
-            dClipObjectCount: ValueCell.create(0),
-            dClipVariant: ValueCell.create('instance'),
             tClipping: ValueCell.create(emptyClippingTexture),
             uClippingTexDim: ValueCell.create(Vec2.create(1, 1)),
             dClipping: ValueCell.create(false),

package/lib/mol-geo/geometry/color-data.d.ts

@@ -11,7 +11,7 @@ import { Vec2, Vec3, Vec4 } from '../../mol-math/linear-algebra';
 import { LocationIterator } from '../util/location-iterator';
 import { ColorTheme } from '../../mol-theme/color';
 import { Texture } from '../../mol-gl/webgl/texture';
-export declare type ColorType = 'uniform' | 'instance' | 'group' | 'groupInstance' | 'vertex' | 'vertexInstance' | 'volume' | 'volumeInstance';
+export declare type ColorType = 'uniform' | 'instance' | 'group' | 'groupInstance' | 'vertex' | 'vertexInstance' | 'volume' | 'volumeInstance' | 'direct';
 export declare type ColorData = {
     uColor: ValueCell<Vec3>;
     tColor: ValueCell<TextureImage<Uint8Array>>;

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

@@ -32,6 +32,7 @@ function _createColors(locationIt, positionIt, colorTheme, colorData) {
         case 'vertexInstance': return createVertexInstanceColor(positionIt, colorTheme.color, colorData);
         case 'volume': return createGridColor(colorTheme.grid, 'volume', colorData);
         case 'volumeInstance': return createGridColor(colorTheme.grid, 'volumeInstance', colorData);
+        case 'direct': return createDirectColor(colorData);
     }
 }
 function updatePaletteTexture(palette, cell) {
@@ -203,4 +204,25 @@ export function createGridColor(grid, type, colorData) {
         };
     }
 }
+//
+/** Creates direct color */
+function createDirectColor(colorData) {
+    if (colorData) {
+        ValueCell.updateIfChanged(colorData.dColorType, 'direct');
+        return colorData;
+    }
+    else {
+        return {
+            uColor: ValueCell.create(Vec3()),
+            tColor: ValueCell.create({ array: new Uint8Array(3), width: 1, height: 1 }),
+            tColorGrid: ValueCell.create(createNullTexture()),
+            tPalette: ValueCell.create({ array: new Uint8Array(3), width: 1, height: 1 }),
+            uColorTexDim: ValueCell.create(Vec2.create(1, 1)),
+            uColorGridDim: ValueCell.create(Vec3.create(1, 1, 1)),
+            uColorGridTransform: ValueCell.create(Vec4.create(0, 0, 0, 1)),
+            dColorType: ValueCell.create('direct'),
+            dUsePalette: ValueCell.create(false),
+        };
+    }
+}
 //# sourceMappingURL=color-data.js.map

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

@@ -48,10 +48,20 @@ export declare namespace Cylinders {
         alpha: PD.Numeric;
         quality: PD.Select<"auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest">;
         material: PD.Group<PD.Normalize<{
-            metalness: number;
-            roughness: number; /** Number of cylinders */
+            metalness: number; /** Number of cylinders */
+            roughness: number;
             bumpiness: number;
         }>>;
+        clip: PD.Group<PD.Normalize<{
+            variant: import("../../../mol-util/clip").Clip.Variant;
+            objects: PD.Normalize<{
+                type: any;
+                invert: any;
+                position: any;
+                rotation: any;
+                scale: any;
+            }>[];
+        }>>;
     };
     type Params = typeof Params;
     const Utils: GeometryUtils<Cylinders, Params>;

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

@@ -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), uBumpFrequency: ValueCell.create(props.bumpFrequency), uBumpAmplitude: ValueCell.create(props.bumpAmplitude) });
+        return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ dGeometryType: ValueCell.create('cylinders'), 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), uDoubleSided: 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);
@@ -163,7 +163,7 @@ export var Cylinders;
     function updateValues(values, props) {
         BaseGeometry.updateValues(values, props);
         ValueCell.updateIfChanged(values.uSizeFactor, props.sizeFactor * props.sizeAspectRatio);
-        ValueCell.updateIfChanged(values.dDoubleSided, props.doubleSided);
+        ValueCell.updateIfChanged(values.uDoubleSided, props.doubleSided);
         ValueCell.updateIfChanged(values.dIgnoreLight, props.ignoreLight);
         ValueCell.updateIfChanged(values.dXrayShaded, props.xrayShaded);
         ValueCell.updateIfChanged(values.uBumpFrequency, props.bumpFrequency);

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

@@ -1,11 +1,11 @@
 /**
- * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 import { Texture } from '../../../mol-gl/webgl/texture';
 import { Box3D, Sphere3D } from '../../../mol-math/geometry';
-import { Mat4, Vec2, Vec3, Vec4 } from '../../../mol-math/linear-algebra';
+import { Mat4, Vec3, Vec4 } from '../../../mol-math/linear-algebra';
 import { ValueCell } from '../../../mol-util';
 import { ParamDefinition as PD } from '../../../mol-util/param-definition';
 import { GeometryUtils } from '../geometry';
@@ -24,51 +24,18 @@ export interface DirectVolume {
     readonly unitToCartn: ValueCell<Mat4>;
     readonly cartnToUnit: ValueCell<Mat4>;
     readonly packedGroup: ValueCell<boolean>;
+    readonly axisOrder: ValueCell<Vec3>;
     /** Bounding sphere of the volume */
     readonly boundingSphere: Sphere3D;
     setBoundingSphere(boundingSphere: Sphere3D): void;
 }
 export declare namespace DirectVolume {
-    function create(bbox: Box3D, gridDimension: Vec3, transform: Mat4, unitToCartn: Mat4, cellDim: Vec3, texture: Texture, stats: Grid['stats'], packedGroup: boolean, directVolume?: DirectVolume): DirectVolume;
+    function create(bbox: Box3D, gridDimension: Vec3, transform: Mat4, unitToCartn: Mat4, cellDim: Vec3, texture: Texture, stats: Grid['stats'], packedGroup: boolean, axisOrder: Vec3, directVolume?: DirectVolume): DirectVolume;
     function createEmpty(directVolume?: DirectVolume): DirectVolume;
-    function createRenderModeParam(stats?: Grid['stats']): PD.Mapped<PD.NamedParams<PD.Normalize<{
-        controlPoints: Vec2[];
-        list: {
-            kind: "set" | "interpolate";
-            colors: import("../../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "volume"> | PD.NamedParams<PD.Normalize<{
-        isoValue: Readonly<{
-            kind: "absolute";
-            absoluteValue: number;
-        }> | Readonly<{
-            kind: "relative";
-            relativeValue: number;
-        }>;
-        singleLayer: boolean;
-    }>, "isosurface">>;
     const Params: {
-        doubleSided: PD.BooleanParam;
-        flipSided: PD.BooleanParam;
-        flatShaded: PD.BooleanParam;
         ignoreLight: PD.BooleanParam;
         xrayShaded: PD.BooleanParam;
-        renderMode: PD.Mapped<PD.NamedParams<PD.Normalize<{
-            controlPoints: Vec2[];
-            list: {
-                kind: "set" | "interpolate";
-                colors: import("../../../mol-util/color/color").ColorListEntry[];
-            };
-        }>, "volume"> | PD.NamedParams<PD.Normalize<{
-            isoValue: Readonly<{
-                kind: "absolute";
-                absoluteValue: number;
-            }> | Readonly<{
-                kind: "relative";
-                relativeValue: number;
-            }>;
-            singleLayer: boolean;
-        }>, "isosurface">>;
+        controlPoints: PD.LineGraph;
         stepsPerCell: PD.Numeric;
         jumpLength: PD.Numeric;
         alpha: PD.Numeric;
@@ -78,6 +45,16 @@ export declare namespace DirectVolume {
             roughness: number;
             bumpiness: number;
         }>>;
+        clip: PD.Group<PD.Normalize<{
+            variant: import("../../../mol-util/clip").Clip.Variant;
+            objects: PD.Normalize<{
+                type: any;
+                invert: any;
+                position: any;
+                rotation: any;
+                scale: any;
+            }>[];
+        }>>;
     };
     type Params = typeof Params;
     const Utils: GeometryUtils<DirectVolume, Params>;

package/lib/mol-geo/geometry/direct-volume/direct-volume.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -20,16 +20,15 @@ import { createEmptyOverpaint } from '../overpaint-data';
 import { createEmptyTransparency } from '../transparency-data';
 import { createTransferFunctionTexture, getControlPointsFromVec2Array } from './transfer-function';
 import { createEmptyClipping } from '../clipping-data';
-import { Grid, Volume } from '../../../mol-model/volume';
-import { ColorNames } from '../../../mol-util/color/names';
+import { Grid } from '../../../mol-model/volume';
 import { createEmptySubstance } from '../substance-data';
 var VolumeBox = Box();
 export var DirectVolume;
 (function (DirectVolume) {
-    function create(bbox, gridDimension, transform, unitToCartn, cellDim, texture, stats, packedGroup, directVolume) {
+    function create(bbox, gridDimension, transform, unitToCartn, cellDim, texture, stats, packedGroup, axisOrder, directVolume) {
         return directVolume ?
-            update(bbox, gridDimension, transform, unitToCartn, cellDim, texture, stats, packedGroup, directVolume) :
-            fromData(bbox, gridDimension, transform, unitToCartn, cellDim, texture, stats, packedGroup);
+            update(bbox, gridDimension, transform, unitToCartn, cellDim, texture, stats, packedGroup, axisOrder, directVolume) :
+            fromData(bbox, gridDimension, transform, unitToCartn, cellDim, texture, stats, packedGroup, axisOrder);
     }
     DirectVolume.create = create;
     function hashCode(directVolume) {
@@ -39,7 +38,7 @@ export var DirectVolume;
             directVolume.gridStats.ref.version
         ]);
     }
-    function fromData(bbox, gridDimension, transform, unitToCartn, cellDim, texture, stats, packedGroup) {
+    function fromData(bbox, gridDimension, transform, unitToCartn, cellDim, texture, stats, packedGroup, axisOrder) {
         var boundingSphere = Sphere3D();
         var currentHash = -1;
         var width = texture.getWidth();
@@ -68,6 +67,7 @@ export var DirectVolume;
                 return boundingSphere;
             },
             packedGroup: ValueCell.create(packedGroup),
+            axisOrder: ValueCell.create(axisOrder),
             setBoundingSphere: function (sphere) {
                 Sphere3D.copy(boundingSphere, sphere);
                 currentHash = hashCode(directVolume);
@@ -75,7 +75,7 @@ export var DirectVolume;
         };
         return directVolume;
     }
-    function update(bbox, gridDimension, transform, unitToCartn, cellDim, texture, stats, packedGroup, directVolume) {
+    function update(bbox, gridDimension, transform, unitToCartn, cellDim, texture, stats, packedGroup, axisOrder, directVolume) {
         var width = texture.getWidth();
         var height = texture.getHeight();
         var depth = texture.getDepth();
@@ -91,6 +91,7 @@ export var DirectVolume;
         ValueCell.update(directVolume.unitToCartn, unitToCartn);
         ValueCell.update(directVolume.cartnToUnit, Mat4.invert(Mat4(), unitToCartn));
         ValueCell.updateIfChanged(directVolume.packedGroup, packedGroup);
+        ValueCell.updateIfChanged(directVolume.axisOrder, Vec3.fromArray(directVolume.axisOrder.ref.value, axisOrder, 0));
         return directVolume;
     }
     function createEmpty(directVolume) {
@@ -102,38 +103,14 @@ export var DirectVolume;
         var texture = createNullTexture();
         var stats = Grid.One.stats;
         var packedGroup = false;
-        return create(bbox, gridDimension, transform, unitToCartn, cellDim, texture, stats, packedGroup, directVolume);
+        var axisOrder = Vec3.create(0, 1, 2);
+        return create(bbox, gridDimension, transform, unitToCartn, cellDim, texture, stats, packedGroup, axisOrder, directVolume);
     }
     DirectVolume.createEmpty = createEmpty;
-    function createRenderModeParam(stats) {
-        var isoValueParam = stats
-            ? Volume.createIsoValueParam(Volume.IsoValue.relative(2), stats)
-            : Volume.IsoValueParam;
-        return PD.MappedStatic('volume', {
-            isosurface: PD.Group({
-                isoValue: isoValueParam,
-                singleLayer: PD.Boolean(false, { isEssential: true }),
-            }, { isFlat: true }),
-            volume: PD.Group({
-                controlPoints: PD.LineGraph([
-                    Vec2.create(0.19, 0.0), Vec2.create(0.2, 0.05), Vec2.create(0.25, 0.05), Vec2.create(0.26, 0.0),
-                    Vec2.create(0.79, 0.0), Vec2.create(0.8, 0.05), Vec2.create(0.85, 0.05), Vec2.create(0.86, 0.0),
-                ]),
-                list: PD.ColorList({
-                    kind: 'interpolate',
-                    colors: [
-                        [ColorNames.white, 0],
-                        [ColorNames.red, 0.25],
-                        [ColorNames.white, 0.5],
-                        [ColorNames.blue, 0.75],
-                        [ColorNames.white, 1]
-                    ]
-                }, { offsets: true }),
-            }, { isFlat: true })
-        }, { isEssential: true });
-    }
-    DirectVolume.createRenderModeParam = createRenderModeParam;
-    DirectVolume.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), renderMode: createRenderModeParam(), stepsPerCell: PD.Numeric(5, { min: 1, max: 20, step: 1 }), jumpLength: PD.Numeric(0, { min: 0, max: 20, step: 0.1 }) });
+    DirectVolume.Params = __assign(__assign({}, BaseGeometry.Params), { ignoreLight: PD.Boolean(false, BaseGeometry.ShadingCategory), xrayShaded: PD.Boolean(false, BaseGeometry.ShadingCategory), controlPoints: PD.LineGraph([
+            Vec2.create(0.19, 0.0), Vec2.create(0.2, 0.05), Vec2.create(0.25, 0.05), Vec2.create(0.26, 0.0),
+            Vec2.create(0.79, 0.0), Vec2.create(0.8, 0.05), Vec2.create(0.85, 0.05), Vec2.create(0.86, 0.0),
+        ], { isEssential: true }), stepsPerCell: PD.Numeric(3, { min: 1, max: 10, step: 1 }), jumpLength: PD.Numeric(0, { min: 0, max: 20, step: 0.1 }) });
     DirectVolume.Utils = {
         Params: DirectVolume.Params,
         createEmpty: createEmpty,
@@ -166,12 +143,6 @@ export var DirectVolume;
         };
         return LocationIterator(groupCount, instanceCount, 1, getLocation);
     }
-    function getNormalizedIsoValue(out, isoValue, stats) {
-        var min = stats[0], max = stats[1], mean = stats[2], sigma = stats[3];
-        var value = Volume.IsoValue.toAbsolute(isoValue, { min: min, max: max, mean: mean, sigma: sigma }).absoluteValue;
-        Vec2.set(out, (value - min) / (max - min), (0 - min) / (max - min));
-        return out;
-    }
     function getMaxSteps(gridDim, stepsPerCell) {
         return Math.ceil(Vec3.magnitude(gridDim) * stepsPerCell);
     }
@@ -196,15 +167,9 @@ export var DirectVolume;
         var counts = { drawCount: VolumeBox.indices.length, vertexCount: x * y * z, groupCount: groupCount, instanceCount: instanceCount };
         var invariantBoundingSphere = Sphere3D.clone(directVolume.boundingSphere);
         var boundingSphere = calculateTransformBoundingSphere(invariantBoundingSphere, transform.aTransform.ref.value, instanceCount);
-        var controlPoints = props.renderMode.name === 'volume' ? getControlPointsFromVec2Array(props.renderMode.params.controlPoints) : [];
-        var transferTex = createTransferFunctionTexture(controlPoints, props.renderMode.name === 'volume' ? props.renderMode.params.list.colors : []);
-        var isoValue = props.renderMode.name === 'isosurface'
-            ? props.renderMode.params.isoValue
-            : Volume.IsoValue.relative(2);
-        var singleLayer = props.renderMode.name === 'isosurface'
-            ? props.renderMode.params.singleLayer
-            : false;
-        return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, color), marker), overpaint), transparency), material), clipping), transform), BaseGeometry.createValues(props, counts)), { aPosition: ValueCell.create(VolumeBox.vertices), elements: ValueCell.create(VolumeBox.indices), boundingSphere: ValueCell.create(boundingSphere), invariantBoundingSphere: ValueCell.create(invariantBoundingSphere), uInvariantBoundingSphere: ValueCell.create(Vec4.ofSphere(invariantBoundingSphere)), uIsoValue: ValueCell.create(getNormalizedIsoValue(Vec2(), isoValue, directVolume.gridStats.ref.value)), uBboxMin: bboxMin, uBboxMax: bboxMax, uBboxSize: bboxSize, uMaxSteps: ValueCell.create(getMaxSteps(gridDimension.ref.value, props.stepsPerCell)), uStepScale: ValueCell.create(getStepScale(directVolume.cellDim.ref.value, props.stepsPerCell)), uJumpLength: ValueCell.create(props.jumpLength), uTransform: gridTransform, uGridDim: gridDimension, dRenderMode: ValueCell.create(props.renderMode.name), tTransferTex: transferTex, uTransferScale: ValueCell.create(getTransferScale(props.stepsPerCell)), dGridTexType: ValueCell.create(gridTexture.ref.value.getDepth() > 0 ? '3d' : '2d'), uGridTexDim: gridTextureDim, tGridTex: gridTexture, uGridStats: gridStats, uCellDim: directVolume.cellDim, uCartnToUnit: directVolume.cartnToUnit, uUnitToCartn: directVolume.unitToCartn, dPackedGroup: directVolume.packedGroup, dSingleLayer: ValueCell.create(singleLayer), 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) });
+        var controlPoints = getControlPointsFromVec2Array(props.controlPoints);
+        var transferTex = createTransferFunctionTexture(controlPoints);
+        return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ dGeometryType: ValueCell.create('directVolume') }, color), marker), overpaint), transparency), material), clipping), transform), BaseGeometry.createValues(props, counts)), { aPosition: ValueCell.create(VolumeBox.vertices), elements: ValueCell.create(VolumeBox.indices), boundingSphere: ValueCell.create(boundingSphere), invariantBoundingSphere: ValueCell.create(invariantBoundingSphere), uInvariantBoundingSphere: ValueCell.create(Vec4.ofSphere(invariantBoundingSphere)), uBboxMin: bboxMin, uBboxMax: bboxMax, uBboxSize: bboxSize, uMaxSteps: ValueCell.create(getMaxSteps(gridDimension.ref.value, props.stepsPerCell)), uStepScale: ValueCell.create(getStepScale(directVolume.cellDim.ref.value, props.stepsPerCell)), uJumpLength: ValueCell.create(props.jumpLength), uTransform: gridTransform, uGridDim: gridDimension, tTransferTex: transferTex, uTransferScale: ValueCell.create(getTransferScale(props.stepsPerCell)), dGridTexType: ValueCell.create(gridTexture.ref.value.getDepth() > 0 ? '3d' : '2d'), uGridTexDim: gridTextureDim, tGridTex: gridTexture, uGridStats: gridStats, uCellDim: directVolume.cellDim, uCartnToUnit: directVolume.cartnToUnit, uUnitToCartn: directVolume.unitToCartn, dPackedGroup: directVolume.packedGroup, dAxisOrder: ValueCell.create(directVolume.axisOrder.ref.value.join('')), dIgnoreLight: ValueCell.create(props.ignoreLight), dXrayShaded: ValueCell.create(props.xrayShaded) });
     }
     function createValuesSimple(directVolume, props, colorValue, sizeValue, transform) {
         var s = BaseGeometry.createSimple(colorValue, sizeValue, transform);
@@ -213,20 +178,10 @@ export var DirectVolume;
     }
     function updateValues(values, props) {
         BaseGeometry.updateValues(values, props);
-        ValueCell.updateIfChanged(values.dDoubleSided, props.doubleSided);
-        ValueCell.updateIfChanged(values.dFlatShaded, props.flatShaded);
-        ValueCell.updateIfChanged(values.dFlipSided, props.flipSided);
         ValueCell.updateIfChanged(values.dIgnoreLight, props.ignoreLight);
         ValueCell.updateIfChanged(values.dXrayShaded, props.xrayShaded);
-        ValueCell.updateIfChanged(values.dRenderMode, props.renderMode.name);
-        if (props.renderMode.name === 'isosurface') {
-            ValueCell.updateIfChanged(values.uIsoValue, getNormalizedIsoValue(values.uIsoValue.ref.value, props.renderMode.params.isoValue, values.uGridStats.ref.value));
-            ValueCell.updateIfChanged(values.dSingleLayer, props.renderMode.params.singleLayer);
-        }
-        else if (props.renderMode.name === 'volume') {
-            var controlPoints = getControlPointsFromVec2Array(props.renderMode.params.controlPoints);
-            createTransferFunctionTexture(controlPoints, props.renderMode.params.list.colors, values.tTransferTex);
-        }
+        var controlPoints = getControlPointsFromVec2Array(props.controlPoints);
+        createTransferFunctionTexture(controlPoints, values.tTransferTex);
         ValueCell.updateIfChanged(values.uMaxSteps, getMaxSteps(values.uGridDim.ref.value, props.stepsPerCell));
         ValueCell.updateIfChanged(values.uStepScale, getStepScale(values.uCellDim.ref.value, props.stepsPerCell));
         ValueCell.updateIfChanged(values.uTransferScale, getTransferScale(props.stepsPerCell));
@@ -246,13 +201,13 @@ export var DirectVolume;
     function createRenderableState(props) {
         var state = BaseGeometry.createRenderableState(props);
         state.opaque = false;
-        state.writeDepth = props.renderMode.name === 'isosurface';
+        state.writeDepth = false;
         return state;
     }
     function updateRenderableState(state, props) {
         BaseGeometry.updateRenderableState(state, props);
         state.opaque = false;
-        state.writeDepth = props.renderMode.name === 'isosurface';
+        state.writeDepth = false;
     }
 })(DirectVolume || (DirectVolume = {}));
 //

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

@@ -1,17 +1,15 @@
 /**
- * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 import { TextureImage } from '../../../mol-gl/renderable/util';
 import { ValueCell } from '../../../mol-util';
 import { Vec2 } from '../../../mol-math/linear-algebra';
-import { ColorListName } from '../../../mol-util/color/lists';
-import { ColorListEntry } from '../../../mol-util/color/color';
 export interface ControlPoint {
     x: number;
     alpha: number;
 }
 export declare function getControlPointsFromString(s: string): ControlPoint[];
 export declare function getControlPointsFromVec2Array(array: Vec2[]): ControlPoint[];
-export declare function createTransferFunctionTexture(controlPoints: ControlPoint[], listOrName: ColorListEntry[] | ColorListName, texture?: ValueCell<TextureImage<Uint8Array>>): ValueCell<TextureImage<Uint8Array>>;
+export declare function createTransferFunctionTexture(controlPoints: ControlPoint[], texture?: ValueCell<TextureImage<Uint8Array>>): ValueCell<TextureImage<Uint8Array>>;

package/lib/mol-geo/geometry/direct-volume/transfer-function.js

@@ -1,11 +1,10 @@
 /**
- * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 import { __spreadArray } from "tslib";
 import { spline } from '../../../mol-math/interpolate';
-import { ColorScale } from '../../../mol-util/color';
 import { ValueCell } from '../../../mol-util';
 export function getControlPointsFromString(s) {
     return s.split(/\s*,\s*/).map(function (p) {
@@ -16,7 +15,7 @@ export function getControlPointsFromString(s) {
 export function getControlPointsFromVec2Array(array) {
     return array.map(function (v) { return ({ x: v[0], alpha: v[1] }); });
 }
-export function createTransferFunctionTexture(controlPoints, listOrName, texture) {
+export function createTransferFunctionTexture(controlPoints, texture) {
     var cp = __spreadArray(__spreadArray([
         { x: 0, alpha: 0 },
         { x: 0, alpha: 0 }
@@ -24,9 +23,8 @@ export function createTransferFunctionTexture(controlPoints, listOrName, texture
         { x: 1, alpha: 0 },
         { x: 1, alpha: 0 },
     ], false);
-    var scale = ColorScale.create({ domain: [0, 1], listOrName: listOrName });
     var n = 256;
-    var array = texture ? texture.ref.value.array : new Uint8Array(n * 4);
+    var array = texture ? texture.ref.value.array : new Uint8Array(n);
     var k = 0;
     var x1, x2;
     var a0, a1, a2, a3;
@@ -41,8 +39,7 @@ export function createTransferFunctionTexture(controlPoints, listOrName, texture
         var jl = Math.round((x2 - x1) * n);
         for (var j = 0; j < jl; ++j) {
             var t = j / jl;
-            array[k * 4 + 3] = Math.max(0, spline(a0, a1, a2, a3, t, 0.5) * 255);
-            scale.colorToArray(k / 255, array, k * 4);
+            array[k] = Math.max(0, spline(a0, a1, a2, a3, t, 0.5) * 255);
             ++k;
         }
     }

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

@@ -39,6 +39,16 @@ declare namespace Image {
             roughness: number;
             bumpiness: number;
         }>>;
+        clip: PD.Group<PD.Normalize<{
+            variant: import("../../../mol-util/clip").Clip.Variant;
+            objects: PD.Normalize<{
+                type: any;
+                invert: any;
+                position: any;
+                rotation: any;
+                scale: any;
+            }>[];
+        }>>;
     };
     type Params = typeof Params;
     const Utils: GeometryUtils<Image, Params>;