molstar 3.0.0-dev.6 → 3.0.0-dev.7

package/lib/commonjs/mol-gl/shader-code.js

@@ -113,42 +113,70 @@ function replaceCounts(str, defines) {
 function preprocess(str, defines) {
     return unrollLoops(replaceCounts(str, defines));
 }
-function ShaderCode(name, vert, frag, extensions, outTypes) {
+function ShaderCode(name, vert, frag, extensions, outTypes, ignoreDefine) {
     if (extensions === void 0) { extensions = {}; }
     if (outTypes === void 0) { outTypes = {}; }
-    return { id: shaderCodeId(), name: name, vert: addIncludes(vert), frag: addIncludes(frag), extensions: extensions, outTypes: outTypes };
+    return { id: shaderCodeId(), name: name, vert: addIncludes(vert), frag: addIncludes(frag), extensions: extensions, outTypes: outTypes, ignoreDefine: ignoreDefine };
 }
 exports.ShaderCode = ShaderCode;
 // Note: `drawBuffers` need to be 'optional' for wboit
+function ignoreDefine(name, variant, defines) {
+    var _a;
+    if (variant.startsWith('color')) {
+        if (name === 'dLightCount') {
+            return !!((_a = defines.dIgnoreLight) === null || _a === void 0 ? void 0 : _a.ref.value);
+        }
+    }
+    else {
+        return [
+            'dColorType', 'dUsePalette',
+            'dLightCount',
+            'dOverpaintType', 'dOverpaint',
+            'dSubstanceType', 'dSubstance',
+        ].includes(name);
+    }
+    return false;
+}
+;
+function ignoreDefineUnlit(name, variant, defines) {
+    if (name === 'dLightCount')
+        return true;
+    return ignoreDefine(name, variant, defines);
+}
+;
 var points_vert_1 = require("./shader/points.vert");
 var points_frag_1 = require("./shader/points.frag");
-exports.PointsShaderCode = ShaderCode('points', points_vert_1.points_vert, points_frag_1.points_frag, { drawBuffers: 'optional' });
+exports.PointsShaderCode = ShaderCode('points', points_vert_1.points_vert, points_frag_1.points_frag, { drawBuffers: 'optional' }, {}, ignoreDefineUnlit);
 var spheres_vert_1 = require("./shader/spheres.vert");
 var spheres_frag_1 = require("./shader/spheres.frag");
-exports.SpheresShaderCode = ShaderCode('spheres', spheres_vert_1.spheres_vert, spheres_frag_1.spheres_frag, { fragDepth: 'required', drawBuffers: 'optional' });
+exports.SpheresShaderCode = ShaderCode('spheres', spheres_vert_1.spheres_vert, spheres_frag_1.spheres_frag, { fragDepth: 'required', drawBuffers: 'optional' }, {}, ignoreDefine);
 var cylinders_vert_1 = require("./shader/cylinders.vert");
 var cylinders_frag_1 = require("./shader/cylinders.frag");
-exports.CylindersShaderCode = ShaderCode('cylinders', cylinders_vert_1.cylinders_vert, cylinders_frag_1.cylinders_frag, { fragDepth: 'required', drawBuffers: 'optional' });
+exports.CylindersShaderCode = ShaderCode('cylinders', cylinders_vert_1.cylinders_vert, cylinders_frag_1.cylinders_frag, { fragDepth: 'required', drawBuffers: 'optional' }, {}, ignoreDefine);
 var text_vert_1 = require("./shader/text.vert");
 var text_frag_1 = require("./shader/text.frag");
-exports.TextShaderCode = ShaderCode('text', text_vert_1.text_vert, text_frag_1.text_frag, { drawBuffers: 'optional' });
+exports.TextShaderCode = ShaderCode('text', text_vert_1.text_vert, text_frag_1.text_frag, { drawBuffers: 'optional' }, {}, ignoreDefineUnlit);
 var lines_vert_1 = require("./shader/lines.vert");
 var lines_frag_1 = require("./shader/lines.frag");
-exports.LinesShaderCode = ShaderCode('lines', lines_vert_1.lines_vert, lines_frag_1.lines_frag, { drawBuffers: 'optional' });
+exports.LinesShaderCode = ShaderCode('lines', lines_vert_1.lines_vert, lines_frag_1.lines_frag, { drawBuffers: 'optional' }, {}, ignoreDefineUnlit);
 var mesh_vert_1 = require("./shader/mesh.vert");
 var mesh_frag_1 = require("./shader/mesh.frag");
-exports.MeshShaderCode = ShaderCode('mesh', mesh_vert_1.mesh_vert, mesh_frag_1.mesh_frag, { drawBuffers: 'optional' });
+exports.MeshShaderCode = ShaderCode('mesh', mesh_vert_1.mesh_vert, mesh_frag_1.mesh_frag, { drawBuffers: 'optional' }, {}, ignoreDefine);
 var direct_volume_vert_1 = require("./shader/direct-volume.vert");
 var direct_volume_frag_1 = require("./shader/direct-volume.frag");
 exports.DirectVolumeShaderCode = ShaderCode('direct-volume', direct_volume_vert_1.directVolume_vert, direct_volume_frag_1.directVolume_frag, { fragDepth: 'optional', drawBuffers: 'optional' });
 var image_vert_1 = require("./shader/image.vert");
 var image_frag_1 = require("./shader/image.frag");
-exports.ImageShaderCode = ShaderCode('image', image_vert_1.image_vert, image_frag_1.image_frag, { drawBuffers: 'optional' });
-function getDefinesCode(defines) {
+exports.ImageShaderCode = ShaderCode('image', image_vert_1.image_vert, image_frag_1.image_frag, { drawBuffers: 'optional' }, {}, ignoreDefineUnlit);
+function getDefinesCode(defines, ignore) {
+    var _a;
     if (defines === undefined)
         return '';
+    var variant = (((_a = defines.dRenderVariant) === null || _a === void 0 ? void 0 : _a.ref.value) || '');
     var lines = [];
     for (var name_1 in defines) {
+        if (ignore === null || ignore === void 0 ? void 0 : ignore(name_1, variant, defines))
+            continue;
         var define = defines[name_1];
         var v = define.ref.value;
         if (v !== undefined) {
@@ -233,7 +261,8 @@ function transformGlsl300Frag(frag) {
     return frag.replace(/gl_FragData\[([0-9]+)\]/g, 'out_FragData$1');
 }
 function addShaderDefines(gl, extensions, defines, shaders) {
-    var header = getDefinesCode(defines);
+    var vertHeader = getDefinesCode(defines, shaders.ignoreDefine);
+    var fragHeader = getDefinesCode(defines, shaders.ignoreDefine);
     var vertPrefix = (0, compat_1.isWebGL2)(gl) ? glsl300VertPrefix : '';
     var fragPrefix = (0, compat_1.isWebGL2)(gl)
         ? getGlsl300FragPrefix(gl, extensions, shaders.extensions, shaders.outTypes)
@@ -242,8 +271,8 @@ function addShaderDefines(gl, extensions, defines, shaders) {
     return {
         id: shaderCodeId(),
         name: shaders.name,
-        vert: "".concat(vertPrefix).concat(header).concat(preprocess(shaders.vert, defines)),
-        frag: "".concat(fragPrefix).concat(header).concat(preprocess(frag, defines)),
+        vert: "".concat(vertPrefix).concat(vertHeader).concat(preprocess(shaders.vert, defines)),
+        frag: "".concat(fragPrefix).concat(fragHeader).concat(preprocess(frag, defines)),
         extensions: shaders.extensions,
         outTypes: shaders.outTypes
     };

package/lib/commonjs/mol-gl/webgl/render-item.d.ts

@@ -21,18 +21,19 @@ export interface RenderItem<T extends string> {
 declare const GraphicsRenderVariant: {
     colorBlended: string;
     colorWboit: string;
-    pickObject: string;
-    pickInstance: string;
-    pickGroup: string;
+    pick: string;
     depth: string;
-    markingDepth: string;
-    markingMask: string;
+    marking: string;
 };
 export declare type GraphicsRenderVariant = keyof typeof GraphicsRenderVariant;
+export declare const GraphicsRenderVariants: ("depth" | "colorBlended" | "colorWboit" | "pick" | "marking")[];
+export declare const GraphicsRenderVariantsBlended: ("depth" | "colorBlended" | "colorWboit" | "pick" | "marking")[];
+export declare const GraphicsRenderVariantsWboit: ("depth" | "colorBlended" | "colorWboit" | "pick" | "marking")[];
 declare const ComputeRenderVariant: {
     compute: string;
 };
 export declare type ComputeRenderVariant = keyof typeof ComputeRenderVariant;
+export declare const ComputeRenderVariants: "compute"[];
 declare function createValueChanges(): {
     attributes: boolean;
     defines: boolean;
@@ -41,7 +42,7 @@ declare function createValueChanges(): {
 };
 declare type ValueChanges = ReturnType<typeof createValueChanges>;
 export declare type GraphicsRenderItem = RenderItem<GraphicsRenderVariant>;
-export declare function createGraphicsRenderItem(ctx: WebGLContext, drawMode: DrawMode, shaderCode: ShaderCode, schema: RenderableSchema, values: RenderableValues, materialId: number): RenderItem<"depth" | "colorBlended" | "colorWboit" | "pickObject" | "pickInstance" | "pickGroup" | "markingDepth" | "markingMask">;
+export declare function createGraphicsRenderItem(ctx: WebGLContext, drawMode: DrawMode, shaderCode: ShaderCode, schema: RenderableSchema, values: RenderableValues, materialId: number, variants: GraphicsRenderVariant[]): RenderItem<"depth" | "colorBlended" | "colorWboit" | "pick" | "marking">;
 export declare type ComputeRenderItem = RenderItem<ComputeRenderVariant>;
 export declare function createComputeRenderItem(ctx: WebGLContext, drawMode: DrawMode, shaderCode: ShaderCode, schema: RenderableSchema, values: RenderableValues, materialId?: number): RenderItem<"compute">;
 /**

package/lib/commonjs/mol-gl/webgl/render-item.js

@@ -5,7 +5,7 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRenderItem = exports.createComputeRenderItem = exports.createGraphicsRenderItem = exports.getDrawMode = void 0;
+exports.createRenderItem = exports.createComputeRenderItem = exports.createGraphicsRenderItem = exports.ComputeRenderVariants = exports.GraphicsRenderVariantsWboit = exports.GraphicsRenderVariantsBlended = exports.GraphicsRenderVariants = exports.getDrawMode = void 0;
 var tslib_1 = require("tslib");
 var buffer_1 = require("./buffer");
 var texture_1 = require("./texture");
@@ -33,10 +33,12 @@ function getDrawMode(ctx, drawMode) {
 }
 exports.getDrawMode = getDrawMode;
 //
-var GraphicsRenderVariant = { 'colorBlended': '', 'colorWboit': '', 'pickObject': '', 'pickInstance': '', 'pickGroup': '', 'depth': '', 'markingDepth': '', 'markingMask': '' };
-var GraphicsRenderVariants = Object.keys(GraphicsRenderVariant);
-var ComputeRenderVariant = { 'compute': '' };
-var ComputeRenderVariants = Object.keys(ComputeRenderVariant);
+var GraphicsRenderVariant = { colorBlended: '', colorWboit: '', pick: '', depth: '', marking: '' };
+exports.GraphicsRenderVariants = Object.keys(GraphicsRenderVariant);
+exports.GraphicsRenderVariantsBlended = exports.GraphicsRenderVariants.filter(function (v) { return v !== 'colorWboit'; });
+exports.GraphicsRenderVariantsWboit = exports.GraphicsRenderVariants.filter(function (v) { return v !== 'colorBlended'; });
+var ComputeRenderVariant = { compute: '' };
+exports.ComputeRenderVariants = Object.keys(ComputeRenderVariant);
 function createProgramVariant(ctx, variant, defineValues, shaderCode, schema) {
     defineValues = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, defineValues), { dRenderVariant: mol_util_1.ValueCell.create(variant) });
     if (schema.dRenderVariant === undefined) {
@@ -58,13 +60,13 @@ function resetValueChanges(valueChanges) {
     valueChanges.elements = false;
     valueChanges.textures = false;
 }
-function createGraphicsRenderItem(ctx, drawMode, shaderCode, schema, values, materialId) {
-    return createRenderItem(ctx, drawMode, shaderCode, schema, values, materialId, GraphicsRenderVariants);
+function createGraphicsRenderItem(ctx, drawMode, shaderCode, schema, values, materialId, variants) {
+    return createRenderItem(ctx, drawMode, shaderCode, schema, values, materialId, variants);
 }
 exports.createGraphicsRenderItem = createGraphicsRenderItem;
 function createComputeRenderItem(ctx, drawMode, shaderCode, schema, values, materialId) {
     if (materialId === void 0) { materialId = -1; }
-    return createRenderItem(ctx, drawMode, shaderCode, schema, values, materialId, ComputeRenderVariants);
+    return createRenderItem(ctx, drawMode, shaderCode, schema, values, materialId, exports.ComputeRenderVariants);
 }
 exports.createComputeRenderItem = createComputeRenderItem;
 /**

package/lib/commonjs/mol-gl/webgl/resources.js

@@ -51,8 +51,15 @@ function createResources(gl, state, stats, extensions) {
         return wrapCached(shaderCache.get({ type: type, source: source }));
     }
     var programCache = (0, reference_cache_1.createReferenceCache)(function (props) {
+        var _a;
         var array = [props.shaderCode.id];
-        Object.keys(props.defineValues).forEach(function (k) { return array.push((0, util_1.hashString)(k), defineValueHash(props.defineValues[k].ref.value)); });
+        var variant = (((_a = props.defineValues.dRenderVariant) === null || _a === void 0 ? void 0 : _a.ref.value) || '');
+        Object.keys(props.defineValues).forEach(function (k) {
+            var _a, _b;
+            if (!((_b = (_a = props.shaderCode).ignoreDefine) === null || _b === void 0 ? void 0 : _b.call(_a, k, variant, props.defineValues))) {
+                array.push((0, util_1.hashString)(k), defineValueHash(props.defineValues[k].ref.value));
+            }
+        });
         return (0, util_1.hashFnv32a)(array).toString();
     }, function (props) { return wrap('program', (0, program_1.createProgram)(gl, state, extensions, getShader, props)); }, function (program) { program.destroy(); });
     return {

package/lib/commonjs/mol-math/linear-algebra/3d/quat.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2017-2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2017-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
@@ -70,6 +70,14 @@ declare namespace Quat {
     function fromArray(a: Quat, array: NumberArray, offset: number): Quat;
     function copy(out: Quat, a: Quat): Quat;
     function set(out: Quat, x: number, y: number, z: number, w: number): Quat;
+    /**
+     * Returns whether or not the quaternions have exactly the same elements in the same position (when compared with ===)
+     */
+    function exactEquals(a: Quat, b: Quat): boolean;
+    /**
+     * Returns whether or not the quaternions have approximately the same elements in the same position.
+     */
+    function equals(a: Quat, b: Quat): boolean;
     function add(out: Quat, a: Quat, b: Quat): Quat;
     function normalize(out: Quat, a: Quat): Quat;
     function rotationTo(out: Quat, a: Vec3, b: Vec3): Quat;

package/lib/commonjs/mol-math/linear-algebra/3d/quat.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Copyright (c) 2017-2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2017-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
@@ -315,6 +315,25 @@ exports.Quat = Quat;
         return out;
     }
     Quat.set = set;
+    /**
+     * Returns whether or not the quaternions have exactly the same elements in the same position (when compared with ===)
+     */
+    function exactEquals(a, b) {
+        return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3];
+    }
+    Quat.exactEquals = exactEquals;
+    /**
+     * Returns whether or not the quaternions have approximately the same elements in the same position.
+     */
+    function equals(a, b) {
+        var a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3];
+        var b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3];
+        return (Math.abs(a0 - b0) <= common_1.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) &&
+            Math.abs(a1 - b1) <= common_1.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) &&
+            Math.abs(a2 - b2) <= common_1.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) &&
+            Math.abs(a3 - b3) <= common_1.EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)));
+    }
+    Quat.equals = equals;
     function add(out, a, b) {
         out[0] = a[0] + b[0];
         out[1] = a[1] + b[1];

package/lib/commonjs/mol-model-formats/shape/ply.d.ts

@@ -39,6 +39,16 @@ export declare const PlyShapeParams: {
         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;
+        }>[];
+    }>>;
 };
 export declare type PlyShapeParams = typeof PlyShapeParams;
 export declare function shapeFromPly(source: PlyFile, params?: {}): Task<ShapeProvider<PlyFile, Mesh, {
@@ -70,4 +80,14 @@ export declare function shapeFromPly(source: PlyFile, params?: {}): Task<ShapePr
         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;
+        }>[];
+    }>>;
 }>>;

package/lib/commonjs/mol-model-props/computed/representations/interactions-inter-unit-cylinder.d.ts

@@ -34,6 +34,16 @@ export declare const InteractionsInterUnitParams: {
         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;
+        }>[];
+    }>>;
 };
 export declare type InteractionsInterUnitParams = typeof InteractionsInterUnitParams;
 export declare function InteractionsInterUnitVisual(materialId: number): ComplexVisual<InteractionsInterUnitParams>;

package/lib/commonjs/mol-model-props/computed/representations/interactions-intra-unit-cylinder.d.ts

@@ -34,6 +34,16 @@ export declare const InteractionsIntraUnitParams: {
         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;
+        }>[];
+    }>>;
 };
 export declare type InteractionsIntraUnitParams = typeof InteractionsIntraUnitParams;
 export declare function InteractionsIntraUnitVisual(materialId: number): UnitsVisual<InteractionsIntraUnitParams>;

package/lib/commonjs/mol-model-props/computed/representations/interactions.d.ts

@@ -38,6 +38,16 @@ export declare const InteractionsParams: {
         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;
+        }>[];
+    }>>;
 };
 export declare type InteractionsParams = typeof InteractionsParams;
 export declare function getInteractionParams(ctx: ThemeRegistryContext, structure: Structure): {
@@ -70,6 +80,16 @@ export declare function getInteractionParams(ctx: ThemeRegistryContext, structur
         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;
+        }>[];
+    }>>;
 };
 export declare type InteractionRepresentation = StructureRepresentation<InteractionsParams>;
 export declare function InteractionRepresentation(ctx: RepresentationContext, getParams: RepresentationParamsGetter<Structure, InteractionsParams>): InteractionRepresentation;
@@ -103,4 +123,14 @@ export declare const InteractionsRepresentationProvider: StructureRepresentation
         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;
+        }>[];
+    }>>;
 }, "interactions">;

package/lib/commonjs/mol-model-props/integrative/cross-link-restraint/representation.d.ts

@@ -39,6 +39,16 @@ export declare const CrossLinkRestraintCylinderParams: {
         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;
+        }>[];
+    }>>;
 };
 export declare type CrossLinkRestraintCylinderParams = typeof CrossLinkRestraintCylinderParams;
 export declare function CrossLinkRestraintVisual(materialId: number): ComplexVisual<CrossLinkRestraintCylinderParams>;
@@ -71,6 +81,16 @@ export declare const CrossLinkRestraintParams: {
         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;
+        }>[];
+    }>>;
 };
 export declare type CrossLinkRestraintParams = typeof CrossLinkRestraintParams;
 export declare function getCrossLinkRestraintParams(ctx: ThemeRegistryContext, structure: Structure): {
@@ -102,6 +122,16 @@ export declare function getCrossLinkRestraintParams(ctx: ThemeRegistryContext, s
         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;
+        }>[];
+    }>>;
 };
 export declare type CrossLinkRestraintRepresentation = StructureRepresentation<CrossLinkRestraintParams>;
 export declare function CrossLinkRestraintRepresentation(ctx: RepresentationContext, getParams: RepresentationParamsGetter<Structure, CrossLinkRestraintParams>): CrossLinkRestraintRepresentation;
@@ -134,4 +164,14 @@ export declare const CrossLinkRestraintRepresentationProvider: StructureRepresen
         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;
+        }>[];
+    }>>;
 }, CrossLinkRestraint.Tag>;

package/lib/commonjs/mol-plugin/behavior/dynamic/selection/structure-focus-representation.d.ts

@@ -7,6 +7,7 @@
 import { PluginBehavior } from '../../../behavior';
 import { ParamDefinition as PD } from '../../../../mol-util/param-definition';
 import { PluginContext } from '../../../context';
+import { Clip } from '../../../../mol-util/clip';
 declare const StructureFocusRepresentationParams: (plugin: PluginContext) => {
     expandRadius: PD.Numeric;
     targetParams: PD.Group<PD.Normalize<{
@@ -26,6 +27,16 @@ declare const StructureFocusRepresentationParams: (plugin: PluginContext) => {
         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;
+        }>[];
+    }>>;
 };
 declare type StructureFocusRepresentationProps = PD.ValuesFor<ReturnType<typeof StructureFocusRepresentationParams>>;
 export declare enum StructureFocusRepresentationTags {

package/lib/commonjs/mol-plugin/behavior/dynamic/selection/structure-focus-representation.js

@@ -20,6 +20,7 @@ var size_1 = require("../../../../mol-theme/size");
 var param_definition_1 = require("../../../../mol-util/param-definition");
 var commands_1 = require("../../../commands");
 var material_1 = require("../../../../mol-util/material");
+var clip_1 = require("../../../../mol-util/clip");
 var StructureFocusRepresentationParams = function (plugin) {
     var reprParams = transforms_1.StateTransforms.Representation.StructureRepresentation3D.definition.params(void 0, plugin);
     return {
@@ -44,6 +45,7 @@ var StructureFocusRepresentationParams = function (plugin) {
         excludeTargetFromSurroundings: param_definition_1.ParamDefinition.Boolean(false, { label: 'Exclude Target', description: 'Exclude the focus "target" from the surroudings component.' }),
         ignoreHydrogens: param_definition_1.ParamDefinition.Boolean(false),
         material: material_1.Material.getParam(),
+        clip: param_definition_1.ParamDefinition.Group(clip_1.Clip.Params),
     };
 };
 var FocusComponents = ['target', 'surroundings', 'interactions'];
@@ -71,7 +73,7 @@ var StructureFocusRepresentationBehavior = /** @class */ (function (_super) {
     StructureFocusRepresentationBehavior.prototype.getReprParams = function (reprParams) {
         return (0, tslib_1.__assign)((0, tslib_1.__assign)({}, this.params.targetParams), { type: {
                 name: reprParams.type.name,
-                params: (0, tslib_1.__assign)((0, tslib_1.__assign)({}, reprParams.type.params), { ignoreHydrogens: this.params.ignoreHydrogens, material: this.params.material })
+                params: (0, tslib_1.__assign)((0, tslib_1.__assign)({}, reprParams.type.params), { ignoreHydrogens: this.params.ignoreHydrogens, material: this.params.material, clip: this.params.clip })
             } });
     };
     StructureFocusRepresentationBehavior.prototype.ensureShape = function (cell) {

package/lib/commonjs/mol-plugin/commands.d.ts

@@ -272,10 +272,6 @@ export declare const PluginCommands: {
                     }>[];
                     ambientColor: import("../mol-util/color").Color;
                     ambientIntensity: number;
-                    clip: import("../mol-util/param-definition").ParamDefinition.Normalize<{
-                        variant: any;
-                        objects: any;
-                    }>;
                 }>>;
                 trackball: import("../mol-util/param-definition").ParamDefinition.Group<import("../mol-util/param-definition").ParamDefinition.Normalize<{
                     noScroll: boolean;
@@ -334,6 +330,7 @@ export declare const PluginCommands: {
                         bumpAmplitude: any;
                         quality: any;
                         material: any;
+                        clip: any;
                     }>, "on">;
                 }>>;
             }>> | ((old: Canvas3DProps) => Partial<Canvas3DProps> | void);

package/lib/commonjs/mol-plugin/spec.js

@@ -70,6 +70,7 @@ var DefaultPluginSpec = function () { return ({
         PluginSpec.Action(transforms_1.StateTransforms.Representation.UnwindStructureAssemblyRepresentation3D),
         PluginSpec.Action(transforms_1.StateTransforms.Representation.OverpaintStructureRepresentation3DFromScript),
         PluginSpec.Action(transforms_1.StateTransforms.Representation.TransparencyStructureRepresentation3DFromScript),
+        PluginSpec.Action(transforms_1.StateTransforms.Representation.ClippingStructureRepresentation3DFromScript),
         PluginSpec.Action(transforms_1.StateTransforms.Representation.SubstanceStructureRepresentation3DFromScript),
         PluginSpec.Action(volume_1.AssignColorVolume),
         PluginSpec.Action(transforms_1.StateTransforms.Volume.VolumeFromCcp4),

package/lib/commonjs/mol-plugin/util/viewport-screenshot.d.ts

@@ -45,6 +45,10 @@ declare class ViewportScreenshotHelper extends PluginComponent {
                 roughness: number;
                 bumpiness: number;
             }>;
+            clip: PD.Normalize<{
+                variant: any;
+                objects: any;
+            }>;
         }>, "on">>;
     };
     readonly behaviors: {
@@ -73,6 +77,10 @@ declare class ViewportScreenshotHelper extends PluginComponent {
                     roughness: number;
                     bumpiness: number;
                 }>;
+                clip: PD.Normalize<{
+                    variant: any;
+                    objects: any;
+                }>;
             }>, "on">>;
         }>>;
         cropParams: import("rxjs").BehaviorSubject<{
@@ -109,6 +117,10 @@ declare class ViewportScreenshotHelper extends PluginComponent {
                 roughness: number;
                 bumpiness: number;
             }>;
+            clip: PD.Normalize<{
+                variant: any;
+                objects: any;
+            }>;
         }>, "on">>;
     }>;
     get cropParams(): {

package/lib/commonjs/mol-plugin-state/helpers/structure-clipping.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2019-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2019-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  * @author David Sehnal <david.sehnal@gmail.com>

package/lib/commonjs/mol-plugin-state/helpers/structure-clipping.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Copyright (c) 2019-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2019-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  * @author David Sehnal <david.sehnal@gmail.com>

package/lib/commonjs/mol-plugin-state/manager/structure/component.d.ts

@@ -1,7 +1,8 @@
 /**
- * Copyright (c) 2019-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2019-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 import { PluginContext } from '../../../mol-plugin/context';
 import { StateTransformer } from '../../../mol-state';
@@ -13,6 +14,7 @@ import { StatefulPluginComponent } from '../../component';
 import { StructureSelectionQuery } from '../../helpers/structure-selection-query';
 import { StructureRepresentation3D } from '../../transforms/representation';
 import { StructureHierarchyRef, StructureComponentRef, StructureRef, StructureRepresentationRef } from './hierarchy-state';
+import { Clip } from '../../../mol-util/clip';
 export { StructureComponentManager };
 interface StructureComponentManagerState {
     options: StructureComponentManager.Options;
@@ -63,6 +65,16 @@ declare namespace StructureComponentManager {
             roughness: number;
             bumpiness: number;
         }>>;
+        clipObjects: PD.Group<PD.Normalize<{
+            variant: Clip.Variant;
+            objects: PD.Normalize<{
+                type: any;
+                invert: any;
+                position: any;
+                rotation: any;
+                scale: any;
+            }>[];
+        }>>;
         interactions: PD.Group<PD.Normalize<{
             providers: PD.Normalize<{
                 ionic: any;