molstar 2.3.9 → 3.0.0-dev.10

package/lib/mol-gl/compute/marching-cubes/isosurface.d.ts

@@ -7,7 +7,7 @@ import { WebGLContext } from '../../webgl/context';
 import { Texture } from '../../../mol-gl/webgl/texture';
 import { Vec3, Vec2, Mat4 } from '../../../mol-math/linear-algebra';
 import { HistogramPyramid } from '../histogram-pyramid/reduction';
-export declare function createIsosurfaceBuffers(ctx: WebGLContext, activeVoxelsBase: Texture, volumeData: Texture, histogramPyramid: HistogramPyramid, gridDim: Vec3, gridTexDim: Vec3, transform: Mat4, isoValue: number, invert: boolean, packedGroup: boolean, vertexTexture?: Texture, groupTexture?: Texture, normalTexture?: Texture): {
+export declare function createIsosurfaceBuffers(ctx: WebGLContext, activeVoxelsBase: Texture, volumeData: Texture, histogramPyramid: HistogramPyramid, gridDim: Vec3, gridTexDim: Vec3, transform: Mat4, isoValue: number, invert: boolean, packedGroup: boolean, axisOrder: Vec3, vertexTexture?: Texture, groupTexture?: Texture, normalTexture?: Texture): {
     vertexTexture: Texture;
     groupTexture: Texture;
     normalTexture: Texture;
@@ -22,7 +22,7 @@ export declare function createIsosurfaceBuffers(ctx: WebGLContext, activeVoxelsB
  *
  * Implementation based on http://www.miaumiau.cat/2016/10/stream-compaction-in-webgl/
  */
-export declare function extractIsosurface(ctx: WebGLContext, volumeData: Texture, gridDim: Vec3, gridTexDim: Vec3, gridTexScale: Vec2, transform: Mat4, isoValue: number, invert: boolean, packedGroup: boolean, vertexTexture?: Texture, groupTexture?: Texture, normalTexture?: Texture): {
+export declare function extractIsosurface(ctx: WebGLContext, volumeData: Texture, gridDim: Vec3, gridTexDim: Vec3, gridTexScale: Vec2, transform: Mat4, isoValue: number, invert: boolean, packedGroup: boolean, axisOrder: Vec3, vertexTexture?: Texture, groupTexture?: Texture, normalTexture?: Texture): {
     vertexTexture: Texture;
     groupTexture: Texture;
     normalTexture: Texture;

package/lib/mol-gl/compute/marching-cubes/isosurface.js

@@ -16,9 +16,9 @@ import { quad_vert } from '../../../mol-gl/shader/quad.vert';
 import { isosurface_frag } from '../../../mol-gl/shader/marching-cubes/isosurface.frag';
 import { calcActiveVoxels } from './active-voxels';
 import { isWebGL2 } from '../../webgl/compat';
-var IsosurfaceSchema = __assign(__assign({}, QuadSchema), { tTriIndices: TextureSpec('image-uint8', 'alpha', 'ubyte', 'nearest'), tActiveVoxelsPyramid: TextureSpec('texture', 'rgba', 'float', 'nearest'), tActiveVoxelsBase: TextureSpec('texture', 'rgba', 'float', 'nearest'), tVolumeData: TextureSpec('texture', 'rgba', 'ubyte', 'nearest'), uIsoValue: UniformSpec('f'), uSize: UniformSpec('f'), uLevels: UniformSpec('f'), uCount: UniformSpec('f'), uInvert: UniformSpec('b'), uGridDim: UniformSpec('v3'), uGridTexDim: UniformSpec('v3'), uGridTransform: UniformSpec('m4'), uScale: UniformSpec('v2'), dPackedGroup: DefineSpec('boolean') });
+var IsosurfaceSchema = __assign(__assign({}, QuadSchema), { tTriIndices: TextureSpec('image-uint8', 'alpha', 'ubyte', 'nearest'), tActiveVoxelsPyramid: TextureSpec('texture', 'rgba', 'float', 'nearest'), tActiveVoxelsBase: TextureSpec('texture', 'rgba', 'float', 'nearest'), tVolumeData: TextureSpec('texture', 'rgba', 'ubyte', 'nearest'), uIsoValue: UniformSpec('f'), uSize: UniformSpec('f'), uLevels: UniformSpec('f'), uCount: UniformSpec('f'), uInvert: UniformSpec('b'), uGridDim: UniformSpec('v3'), uGridTexDim: UniformSpec('v3'), uGridTransform: UniformSpec('m4'), uScale: UniformSpec('v2'), dPackedGroup: DefineSpec('boolean'), dAxisOrder: DefineSpec('string', ['012', '021', '102', '120', '201', '210']) });
 var IsosurfaceName = 'isosurface';
-function getIsosurfaceRenderable(ctx, activeVoxelsPyramid, activeVoxelsBase, volumeData, gridDim, gridTexDim, transform, isoValue, levels, scale, count, invert, packedGroup) {
+function getIsosurfaceRenderable(ctx, activeVoxelsPyramid, activeVoxelsBase, volumeData, gridDim, gridTexDim, transform, isoValue, levels, scale, count, invert, packedGroup, axisOrder) {
     if (ctx.namedComputeRenderables[IsosurfaceName]) {
         var v = ctx.namedComputeRenderables[IsosurfaceName].values;
         ValueCell.update(v.tActiveVoxelsPyramid, activeVoxelsPyramid);
@@ -34,16 +34,17 @@ function getIsosurfaceRenderable(ctx, activeVoxelsPyramid, activeVoxelsBase, vol
         ValueCell.update(v.uGridTransform, transform);
         ValueCell.update(v.uScale, scale);
         ValueCell.update(v.dPackedGroup, packedGroup);
+        ValueCell.updateIfChanged(v.dAxisOrder, axisOrder.join(''));
         ctx.namedComputeRenderables[IsosurfaceName].update();
     }
     else {
-        ctx.namedComputeRenderables[IsosurfaceName] = createIsosurfaceRenderable(ctx, activeVoxelsPyramid, activeVoxelsBase, volumeData, gridDim, gridTexDim, transform, isoValue, levels, scale, count, invert, packedGroup);
+        ctx.namedComputeRenderables[IsosurfaceName] = createIsosurfaceRenderable(ctx, activeVoxelsPyramid, activeVoxelsBase, volumeData, gridDim, gridTexDim, transform, isoValue, levels, scale, count, invert, packedGroup, axisOrder);
     }
     return ctx.namedComputeRenderables[IsosurfaceName];
 }
-function createIsosurfaceRenderable(ctx, activeVoxelsPyramid, activeVoxelsBase, volumeData, gridDim, gridTexDim, transform, isoValue, levels, scale, count, invert, packedGroup) {
+function createIsosurfaceRenderable(ctx, activeVoxelsPyramid, activeVoxelsBase, volumeData, gridDim, gridTexDim, transform, isoValue, levels, scale, count, invert, packedGroup, axisOrder) {
     // console.log('uSize', Math.pow(2, levels))
-    var values = __assign(__assign({}, QuadValues), { tTriIndices: ValueCell.create(getTriIndices()), tActiveVoxelsPyramid: ValueCell.create(activeVoxelsPyramid), tActiveVoxelsBase: ValueCell.create(activeVoxelsBase), tVolumeData: ValueCell.create(volumeData), uIsoValue: ValueCell.create(isoValue), uSize: ValueCell.create(Math.pow(2, levels)), uLevels: ValueCell.create(levels), uCount: ValueCell.create(count), uInvert: ValueCell.create(invert), uGridDim: ValueCell.create(gridDim), uGridTexDim: ValueCell.create(gridTexDim), uGridTransform: ValueCell.create(transform), uScale: ValueCell.create(scale), dPackedGroup: ValueCell.create(packedGroup) });
+    var values = __assign(__assign({}, QuadValues), { tTriIndices: ValueCell.create(getTriIndices()), tActiveVoxelsPyramid: ValueCell.create(activeVoxelsPyramid), tActiveVoxelsBase: ValueCell.create(activeVoxelsBase), tVolumeData: ValueCell.create(volumeData), uIsoValue: ValueCell.create(isoValue), uSize: ValueCell.create(Math.pow(2, levels)), uLevels: ValueCell.create(levels), uCount: ValueCell.create(count), uInvert: ValueCell.create(invert), uGridDim: ValueCell.create(gridDim), uGridTexDim: ValueCell.create(gridTexDim), uGridTransform: ValueCell.create(transform), uScale: ValueCell.create(scale), dPackedGroup: ValueCell.create(packedGroup), dAxisOrder: ValueCell.create(axisOrder.join('')) });
     var schema = __assign({}, IsosurfaceSchema);
     var shaderCode = ShaderCode('isosurface', quad_vert, isosurface_frag, { drawBuffers: 'required' });
     var renderItem = createComputeRenderItem(ctx, 'triangles', shaderCode, schema, values);
@@ -59,7 +60,10 @@ function setRenderingDefaults(ctx) {
     state.colorMask(true, true, true, true);
     state.clearColor(0, 0, 0, 0);
 }
-export function createIsosurfaceBuffers(ctx, activeVoxelsBase, volumeData, histogramPyramid, gridDim, gridTexDim, transform, isoValue, invert, packedGroup, vertexTexture, groupTexture, normalTexture) {
+export function createIsosurfaceBuffers(ctx, activeVoxelsBase, volumeData, histogramPyramid, gridDim, gridTexDim, transform, isoValue, invert, packedGroup, axisOrder, vertexTexture, groupTexture, normalTexture) {
+    var drawBuffers = ctx.extensions.drawBuffers;
+    if (!drawBuffers)
+        throw new Error('need WebGL draw buffers');
     var gl = ctx.gl, resources = ctx.resources, extensions = ctx.extensions;
     var pyramidTex = histogramPyramid.pyramidTex, height = histogramPyramid.height, levels = histogramPyramid.levels, scale = histogramPyramid.scale, count = histogramPyramid.count;
     var width = pyramidTex.getWidth();
@@ -104,11 +108,8 @@ export function createIsosurfaceBuffers(ctx, activeVoxelsBase, volumeData, histo
     vertexTexture.attachFramebuffer(framebuffer, 0);
     groupTexture.attachFramebuffer(framebuffer, 1);
     normalTexture.attachFramebuffer(framebuffer, 2);
-    var renderable = getIsosurfaceRenderable(ctx, pyramidTex, activeVoxelsBase, volumeData, gridDim, gridTexDim, transform, isoValue, levels, scale, count, invert, packedGroup);
+    var renderable = getIsosurfaceRenderable(ctx, pyramidTex, activeVoxelsBase, volumeData, gridDim, gridTexDim, transform, isoValue, levels, scale, count, invert, packedGroup, axisOrder);
     ctx.state.currentRenderItemId = -1;
-    var drawBuffers = ctx.extensions.drawBuffers;
-    if (!drawBuffers)
-        throw new Error('need WebGL draw buffers');
     framebuffer.bind();
     drawBuffers.drawBuffers([
         drawBuffers.COLOR_ATTACHMENT0,
@@ -132,7 +133,7 @@ export function createIsosurfaceBuffers(ctx, activeVoxelsBase, volumeData, histo
  *
  * Implementation based on http://www.miaumiau.cat/2016/10/stream-compaction-in-webgl/
  */
-export function extractIsosurface(ctx, volumeData, gridDim, gridTexDim, gridTexScale, transform, isoValue, invert, packedGroup, vertexTexture, groupTexture, normalTexture) {
+export function extractIsosurface(ctx, volumeData, gridDim, gridTexDim, gridTexScale, transform, isoValue, invert, packedGroup, axisOrder, vertexTexture, groupTexture, normalTexture) {
     // console.time('calcActiveVoxels');
     var activeVoxelsTex = calcActiveVoxels(ctx, volumeData, gridDim, gridTexDim, isoValue, gridTexScale);
     // ctx.waitForGpuCommandsCompleteSync();
@@ -142,7 +143,7 @@ export function extractIsosurface(ctx, volumeData, gridDim, gridTexDim, gridTexS
     // ctx.waitForGpuCommandsCompleteSync();
     // console.timeEnd('createHistogramPyramid');
     // console.time('createIsosurfaceBuffers');
-    var gv = createIsosurfaceBuffers(ctx, activeVoxelsTex, volumeData, compacted, gridDim, gridTexDim, transform, isoValue, invert, packedGroup, vertexTexture, groupTexture, normalTexture);
+    var gv = createIsosurfaceBuffers(ctx, activeVoxelsTex, volumeData, compacted, gridDim, gridTexDim, transform, isoValue, invert, packedGroup, axisOrder, vertexTexture, groupTexture, normalTexture);
     // ctx.waitForGpuCommandsCompleteSync();
     // console.timeEnd('createIsosurfaceBuffers');
     return gv;

package/lib/mol-gl/compute/util.d.ts

@@ -1,13 +1,12 @@
 /**
- * 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 { WebGLContext } from '../../mol-gl/webgl/context';
 import { Texture } from '../../mol-gl/webgl/texture';
-import { PrintImageOptions } from '../../mol-gl/renderable/util';
-import { ValueSpec, AttributeSpec, UniformSpec, Values } from '../../mol-gl/renderable/schema';
-import { PixelData } from '../../mol-util/image';
+import { ValueSpec, AttributeSpec, UniformSpec, Values, TextureSpec } from '../../mol-gl/renderable/schema';
+import { ComputeRenderable } from '../renderable';
 export declare const QuadPositions: Float32Array;
 export declare const QuadSchema: {
     drawCount: ValueSpec<"number">;
@@ -16,5 +15,25 @@ export declare const QuadSchema: {
     uQuadScale: UniformSpec<"v2">;
 };
 export declare const QuadValues: Values<typeof QuadSchema>;
-export declare function readTexture(ctx: WebGLContext, texture: Texture, width?: number, height?: number): PixelData;
-export declare function printTexture(ctx: WebGLContext, texture: Texture, options?: Partial<PrintImageOptions>): void;
+declare const CopySchema: {
+    tColor: TextureSpec<"texture">;
+    uTexSize: UniformSpec<"v2">;
+    drawCount: ValueSpec<"number">;
+    instanceCount: ValueSpec<"number">;
+    aPosition: AttributeSpec<"float32">;
+    uQuadScale: UniformSpec<"v2">;
+};
+export declare type CopyRenderable = ComputeRenderable<Values<typeof CopySchema>>;
+export declare function createCopyRenderable(ctx: WebGLContext, texture: Texture): CopyRenderable;
+export declare function getSharedCopyRenderable(ctx: WebGLContext, texture: Texture): CopyRenderable;
+export declare function readTexture(ctx: WebGLContext, texture: Texture): {
+    array: Uint8Array;
+    width: number;
+    height: number;
+};
+export declare function readAlphaTexture(ctx: WebGLContext, texture: Texture): {
+    array: Uint8Array;
+    width: number;
+    height: number;
+};
+export {};

package/lib/mol-gl/compute/util.js

@@ -1,13 +1,18 @@
 /**
- * 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 { printTextureImage } from '../../mol-gl/renderable/util';
-import { defaults, ValueCell } from '../../mol-util';
-import { ValueSpec, AttributeSpec, UniformSpec } from '../../mol-gl/renderable/schema';
+import { __assign } from "tslib";
+import { createNullTexture } from '../../mol-gl/webgl/texture';
+import { ValueCell } from '../../mol-util';
+import { ValueSpec, AttributeSpec, UniformSpec, TextureSpec } from '../../mol-gl/renderable/schema';
 import { Vec2 } from '../../mol-math/linear-algebra';
-import { PixelData } from '../../mol-util/image';
+import { ShaderCode } from '../shader-code';
+import { copy_frag } from '../shader/copy.frag';
+import { quad_vert } from '../shader/quad.vert';
+import { createComputeRenderItem } from '../webgl/render-item';
+import { createComputeRenderable } from '../renderable';
 export var QuadPositions = new Float32Array([
     1.0, 1.0, -1.0, 1.0, -1.0, -1.0,
     -1.0, -1.0, 1.0, -1.0, 1.0, 1.0 // Second triangle
@@ -25,29 +30,77 @@ export var QuadValues = {
     uQuadScale: ValueCell.create(Vec2.create(1, 1)),
 };
 //
-function getArrayForTexture(gl, texture, size) {
-    switch (texture.type) {
-        case gl.UNSIGNED_BYTE: return new Uint8Array(size);
-        case gl.FLOAT: return new Float32Array(size);
+var CopySchema = __assign(__assign({}, QuadSchema), { tColor: TextureSpec('texture', 'rgba', 'ubyte', 'nearest'), uTexSize: UniformSpec('v2') });
+var CopyShaderCode = ShaderCode('copy', quad_vert, copy_frag);
+export function createCopyRenderable(ctx, texture) {
+    var values = __assign(__assign({}, QuadValues), { tColor: ValueCell.create(texture), uTexSize: ValueCell.create(Vec2.create(texture.getWidth(), texture.getHeight())) });
+    var schema = __assign({}, CopySchema);
+    var renderItem = createComputeRenderItem(ctx, 'triangles', CopyShaderCode, schema, values);
+    return createComputeRenderable(renderItem, values);
+}
+var SharedCopyName = 'shared-copy';
+export function getSharedCopyRenderable(ctx, texture) {
+    if (!ctx.namedComputeRenderables[SharedCopyName]) {
+        ctx.namedComputeRenderables[SharedCopyName] = createCopyRenderable(ctx, createNullTexture());
     }
-    throw new Error('unknown/unsupported texture type');
+    var copy = ctx.namedComputeRenderables[SharedCopyName];
+    ValueCell.update(copy.values.tColor, texture);
+    ValueCell.update(copy.values.uTexSize, Vec2.set(copy.values.uTexSize.ref.value, texture.getWidth(), texture.getHeight()));
+    copy.update();
+    return copy;
 }
-export function readTexture(ctx, texture, width, height) {
+//
+var ReadTextureName = 'read-texture';
+var ReadAlphaTextureName = 'read-alpha-texture';
+export function readTexture(ctx, texture) {
     var gl = ctx.gl, resources = ctx.resources;
-    width = defaults(width, texture.getWidth());
-    height = defaults(height, texture.getHeight());
-    var size = width * height * 4;
-    var framebuffer = resources.framebuffer();
-    var array = getArrayForTexture(gl, texture, size);
+    if (texture.type !== gl.UNSIGNED_BYTE)
+        throw new Error('unsupported texture type');
+    if (!ctx.namedFramebuffers[ReadTextureName]) {
+        ctx.namedFramebuffers[ReadTextureName] = resources.framebuffer();
+    }
+    var framebuffer = ctx.namedFramebuffers[ReadTextureName];
+    var width = texture.getWidth();
+    var height = texture.getHeight();
+    var array = new Uint8Array(width * height * 4);
     framebuffer.bind();
     texture.attachFramebuffer(framebuffer, 0);
     ctx.readPixels(0, 0, width, height, array);
     return { array: array, width: width, height: height };
 }
-export function printTexture(ctx, texture, options) {
-    if (options === void 0) { options = {}; }
-    var pixelData = readTexture(ctx, texture);
-    PixelData.flipY(pixelData);
-    printTextureImage(pixelData, options);
+export function readAlphaTexture(ctx, texture) {
+    var gl = ctx.gl, state = ctx.state, resources = ctx.resources;
+    if (texture.type !== gl.UNSIGNED_BYTE)
+        throw new Error('unsupported texture type');
+    var width = texture.getWidth();
+    var height = texture.getHeight();
+    var copy = getSharedCopyRenderable(ctx, texture);
+    state.currentRenderItemId = -1;
+    if (!ctx.namedFramebuffers[ReadAlphaTextureName]) {
+        ctx.namedFramebuffers[ReadAlphaTextureName] = resources.framebuffer();
+    }
+    var framebuffer = ctx.namedFramebuffers[ReadAlphaTextureName];
+    framebuffer.bind();
+    if (!ctx.namedTextures[ReadAlphaTextureName]) {
+        ctx.namedTextures[ReadAlphaTextureName] = resources.texture('image-uint8', 'rgba', 'ubyte', 'linear');
+    }
+    var copyTex = ctx.namedTextures[ReadAlphaTextureName];
+    copyTex.define(width, height);
+    copyTex.attachFramebuffer(framebuffer, 0);
+    state.disable(gl.CULL_FACE);
+    state.enable(gl.BLEND);
+    state.disable(gl.DEPTH_TEST);
+    state.enable(gl.SCISSOR_TEST);
+    state.depthMask(false);
+    state.clearColor(0, 0, 0, 0);
+    state.blendFunc(gl.ONE, gl.ONE);
+    state.blendEquation(gl.FUNC_ADD);
+    gl.viewport(0, 0, width, height);
+    gl.scissor(0, 0, width, height);
+    gl.clear(gl.COLOR_BUFFER_BIT);
+    copy.render();
+    var array = new Uint8Array(width * height * 4);
+    ctx.readPixels(0, 0, width, height, array);
+    return { array: array, width: width, height: height };
 }
 //# sourceMappingURL=util.js.map

package/lib/mol-gl/render-object.d.ts

@@ -14,6 +14,7 @@ import { TextValues } from './renderable/text';
 import { TextureMeshValues } from './renderable/texture-mesh';
 import { ImageValues } from './renderable/image';
 import { CylindersValues } from './renderable/cylinders';
+import { GraphicsRenderVariant } from './webgl/render-item';
 export declare const getNextMaterialId: () => number;
 export interface GraphicsRenderObject<T extends RenderObjectType = RenderObjectType> {
     readonly id: number;
@@ -25,4 +26,4 @@ export interface GraphicsRenderObject<T extends RenderObjectType = RenderObjectT
 export declare type RenderObjectType = 'mesh' | 'points' | 'spheres' | 'cylinders' | 'text' | 'lines' | 'direct-volume' | 'image' | 'texture-mesh';
 export declare type RenderObjectValues<T extends RenderObjectType> = T extends 'mesh' ? MeshValues : T extends 'points' ? PointsValues : T extends 'spheres' ? SpheresValues : T extends 'cylinders' ? CylindersValues : T extends 'text' ? TextValues : T extends 'lines' ? LinesValues : T extends 'direct-volume' ? DirectVolumeValues : T extends 'image' ? ImageValues : T extends 'texture-mesh' ? TextureMeshValues : never;
 export declare function createRenderObject<T extends RenderObjectType>(type: T, values: RenderObjectValues<T>, state: RenderableState, materialId: number): GraphicsRenderObject<T>;
-export declare function createRenderable<T extends RenderObjectType>(ctx: WebGLContext, o: GraphicsRenderObject<T>): Renderable<any>;
+export declare function createRenderable<T extends RenderObjectType>(ctx: WebGLContext, o: GraphicsRenderObject<T>, variants: GraphicsRenderVariant[]): Renderable<any>;

package/lib/mol-gl/render-object.js

@@ -19,17 +19,17 @@ export var getNextMaterialId = idFactory(0, 0x7FFFFFFF);
 export function createRenderObject(type, values, state, materialId) {
     return { id: getNextId(), type: type, values: values, state: state, materialId: materialId };
 }
-export function createRenderable(ctx, o) {
+export function createRenderable(ctx, o, variants) {
     switch (o.type) {
-        case 'mesh': return MeshRenderable(ctx, o.id, o.values, o.state, o.materialId);
-        case 'points': return PointsRenderable(ctx, o.id, o.values, o.state, o.materialId);
-        case 'spheres': return SpheresRenderable(ctx, o.id, o.values, o.state, o.materialId);
-        case 'cylinders': return CylindersRenderable(ctx, o.id, o.values, o.state, o.materialId);
-        case 'text': return TextRenderable(ctx, o.id, o.values, o.state, o.materialId);
-        case 'lines': return LinesRenderable(ctx, o.id, o.values, o.state, o.materialId);
-        case 'direct-volume': return DirectVolumeRenderable(ctx, o.id, o.values, o.state, o.materialId);
-        case 'image': return ImageRenderable(ctx, o.id, o.values, o.state, o.materialId);
-        case 'texture-mesh': return TextureMeshRenderable(ctx, o.id, o.values, o.state, o.materialId);
+        case 'mesh': return MeshRenderable(ctx, o.id, o.values, o.state, o.materialId, variants);
+        case 'points': return PointsRenderable(ctx, o.id, o.values, o.state, o.materialId, variants);
+        case 'spheres': return SpheresRenderable(ctx, o.id, o.values, o.state, o.materialId, variants);
+        case 'cylinders': return CylindersRenderable(ctx, o.id, o.values, o.state, o.materialId, variants);
+        case 'text': return TextRenderable(ctx, o.id, o.values, o.state, o.materialId, variants);
+        case 'lines': return LinesRenderable(ctx, o.id, o.values, o.state, o.materialId, variants);
+        case 'direct-volume': return DirectVolumeRenderable(ctx, o.id, o.values, o.state, o.materialId, variants);
+        case 'image': return ImageRenderable(ctx, o.id, o.values, o.state, o.materialId, variants);
+        case 'texture-mesh': return TextureMeshRenderable(ctx, o.id, o.values, o.state, o.materialId, variants);
     }
     throw new Error('unsupported type');
 }

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

@@ -1,11 +1,12 @@
 /**
- * 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 { GraphicsRenderVariant } from '../webgl/render-item';
+import { AttributeSpec, Values, ElementsSpec, ValueSpec, DefineSpec, UniformSpec } from './schema';
 export declare const CylindersSchema: {
     aGroup: AttributeSpec<"float32">;
     aStart: AttributeSpec<"float32">;
@@ -15,21 +16,34 @@ export declare const CylindersSchema: {
     aCap: AttributeSpec<"float32">;
     elements: ElementsSpec<"uint32">;
     padding: ValueSpec<"number">;
-    dDoubleSided: DefineSpec<"boolean">;
+    uDoubleSided: UniformSpec<"b">;
     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">;
+    dClipObjectCount: DefineSpec<"number">;
+    dClipVariant: DefineSpec<"string">;
+    uClipObjectType: UniformSpec<"i[]">;
+    uClipObjectInvert: UniformSpec<"b[]">;
+    uClipObjectPosition: UniformSpec<"v3[]">;
+    uClipObjectRotation: UniformSpec<"v4[]">;
+    uClipObjectScale: UniformSpec<"v3[]">;
     aInstance: AttributeSpec<"float32">;
     aTransform: AttributeSpec<"float32">;
-    uAlpha: 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">;
@@ -39,34 +53,47 @@ export declare const CylindersSchema: {
     hasReflection: ValueSpec<"boolean">;
     boundingSphere: ValueSpec<"sphere">;
     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">;
-    uTransparencyTexDim: import("./schema").UniformSpec<"v2">;
+    uSubstanceTexDim: UniformSpec<"v2">;
+    tSubstance: import("./schema").TextureSpec<"image-uint8">;
+    dSubstance: DefineSpec<"boolean">;
+    uSubstanceGridDim: UniformSpec<"v3">;
+    uSubstanceGridTransform: UniformSpec<"v4">;
+    tSubstanceGrid: import("./schema").TextureSpec<"texture">;
+    dSubstanceType: DefineSpec<"string">;
+    uTransparencyTexDim: UniformSpec<"v2">;
     tTransparency: import("./schema").TextureSpec<"image-uint8">;
     dTransparency: DefineSpec<"boolean">;
     transparencyAverage: ValueSpec<"number">;
-    uOverpaintTexDim: import("./schema").UniformSpec<"v2">;
+    uTransparencyGridDim: UniformSpec<"v3">;
+    uTransparencyGridTransform: UniformSpec<"v4">;
+    tTransparencyGrid: import("./schema").TextureSpec<"texture">;
+    dTransparencyType: DefineSpec<"string">;
+    uOverpaintTexDim: UniformSpec<"v2">;
     tOverpaint: import("./schema").TextureSpec<"image-uint8">;
     dOverpaint: DefineSpec<"boolean">;
-    uMarker: import("./schema").UniformSpec<"f">;
-    uMarkerTexDim: import("./schema").UniformSpec<"v2">;
+    uOverpaintGridDim: UniformSpec<"v3">;
+    uOverpaintGridTransform: UniformSpec<"v4">;
+    tOverpaintGrid: import("./schema").TextureSpec<"texture">;
+    dOverpaintType: DefineSpec<"string">;
+    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">;
     dColorType: DefineSpec<"string">;
     dUsePalette: DefineSpec<"boolean">;
+    dGeometryType: DefineSpec<"string">;
 };
 export declare type CylindersSchema = typeof CylindersSchema;
 export declare type CylindersValues = Values<CylindersSchema>;
-export declare function CylindersRenderable(ctx: WebGLContext, id: number, values: CylindersValues, state: RenderableState, materialId: number): Renderable<CylindersValues>;
+export declare function CylindersRenderable(ctx: WebGLContext, id: number, values: CylindersValues, state: RenderableState, materialId: number, variants: GraphicsRenderVariant[]): Renderable<CylindersValues>;

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

@@ -1,22 +1,22 @@
 /**
- * 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 function CylindersRenderable(ctx, id, values, state, materialId) {
+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'), uDoubleSided: UniformSpec('b'), dIgnoreLight: DefineSpec('boolean'), dXrayShaded: DefineSpec('boolean'), uBumpFrequency: UniformSpec('f'), uBumpAmplitude: UniformSpec('f') });
+export function CylindersRenderable(ctx, id, values, state, materialId, variants) {
     var schema = __assign(__assign(__assign(__assign({}, GlobalUniformSchema), GlobalTextureSchema), InternalSchema), CylindersSchema);
     var internalValues = {
         uObjectId: ValueCell.create(id),
     };
     var shaderCode = CylindersShaderCode;
-    var renderItem = createGraphicsRenderItem(ctx, 'triangles', shaderCode, schema, __assign(__assign({}, values), internalValues), materialId);
+    var renderItem = createGraphicsRenderItem(ctx, 'triangles', shaderCode, schema, __assign(__assign({}, values), internalValues), materialId, variants);
     return createRenderable(renderItem, values, state);
 }
 //# sourceMappingURL=cylinders.js.map

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

@@ -5,15 +5,11 @@
  */
 import { Renderable, RenderableState } from '../renderable';
 import { WebGLContext } from '../webgl/context';
+import { GraphicsRenderVariant } from '../webgl/render-item';
 import { AttributeSpec, Values, UniformSpec, TextureSpec, ElementsSpec, DefineSpec } from './schema';
 export declare const DirectVolumeSchema: {
     aPosition: AttributeSpec<"float32">;
     elements: ElementsSpec<"uint32">;
-    uColor: UniformSpec<"v3">;
-    uColorTexDim: UniformSpec<"v2">;
-    tColor: TextureSpec<"image-uint8">;
-    dColorType: DefineSpec<"string">;
-    uIsoValue: UniformSpec<"v2">;
     uBboxMin: UniformSpec<"v3">;
     uBboxMax: UniformSpec<"v3">;
     uBboxSize: UniformSpec<"v3">;
@@ -22,8 +18,6 @@ export declare const DirectVolumeSchema: {
     uJumpLength: UniformSpec<"f">;
     uTransform: UniformSpec<"m4">;
     uGridDim: UniformSpec<"v3">;
-    dRenderMode: DefineSpec<"string">;
-    dSingleLayer: DefineSpec<"boolean">;
     tTransferTex: TextureSpec<"image-uint8">;
     uTransferScale: UniformSpec<"f">;
     dGridTexType: DefineSpec<"string">;
@@ -34,14 +28,23 @@ export declare const DirectVolumeSchema: {
     uCartnToUnit: UniformSpec<"m4">;
     uUnitToCartn: UniformSpec<"m4">;
     dPackedGroup: DefineSpec<"boolean">;
-    dDoubleSided: DefineSpec<"boolean">;
-    dFlipSided: DefineSpec<"boolean">;
-    dFlatShaded: DefineSpec<"boolean">;
+    dAxisOrder: DefineSpec<"string">;
     dIgnoreLight: DefineSpec<"boolean">;
     dXrayShaded: DefineSpec<"boolean">;
+    dLightCount: DefineSpec<"number">;
+    dClipObjectCount: DefineSpec<"number">;
+    dClipVariant: DefineSpec<"string">;
+    uClipObjectType: UniformSpec<"i[]">;
+    uClipObjectInvert: UniformSpec<"b[]">;
+    uClipObjectPosition: UniformSpec<"v3[]">;
+    uClipObjectRotation: UniformSpec<"v4[]">;
+    uClipObjectScale: UniformSpec<"v3[]">;
     aInstance: AttributeSpec<"float32">;
     aTransform: AttributeSpec<"float32">;
     uAlpha: UniformSpec<"f">;
+    uMetalness: UniformSpec<"f">;
+    uRoughness: UniformSpec<"f">;
+    uBumpiness: UniformSpec<"f">;
     uVertexCount: UniformSpec<"i">;
     uInstanceCount: UniformSpec<"i">;
     uGroupCount: UniformSpec<"i">;
@@ -55,30 +58,47 @@ export declare const DirectVolumeSchema: {
     hasReflection: import("./schema").ValueSpec<"boolean">;
     boundingSphere: import("./schema").ValueSpec<"sphere">;
     invariantBoundingSphere: import("./schema").ValueSpec<"sphere">;
-    dClipObjectCount: DefineSpec<"number">;
-    dClipVariant: DefineSpec<"string">;
     uClippingTexDim: UniformSpec<"v2">;
     tClipping: TextureSpec<"image-uint8">;
     dClipping: DefineSpec<"boolean">;
+    uSubstanceTexDim: UniformSpec<"v2">;
+    tSubstance: TextureSpec<"image-uint8">;
+    dSubstance: DefineSpec<"boolean">;
+    uSubstanceGridDim: UniformSpec<"v3">;
+    uSubstanceGridTransform: UniformSpec<"v4">;
+    tSubstanceGrid: TextureSpec<"texture">;
+    dSubstanceType: DefineSpec<"string">;
     uTransparencyTexDim: UniformSpec<"v2">;
     tTransparency: TextureSpec<"image-uint8">;
     dTransparency: DefineSpec<"boolean">;
     transparencyAverage: import("./schema").ValueSpec<"number">;
+    uTransparencyGridDim: UniformSpec<"v3">;
+    uTransparencyGridTransform: UniformSpec<"v4">;
+    tTransparencyGrid: TextureSpec<"texture">;
+    dTransparencyType: DefineSpec<"string">;
     uOverpaintTexDim: UniformSpec<"v2">;
     tOverpaint: TextureSpec<"image-uint8">;
     dOverpaint: DefineSpec<"boolean">;
+    uOverpaintGridDim: UniformSpec<"v3">;
+    uOverpaintGridTransform: UniformSpec<"v4">;
+    tOverpaintGrid: TextureSpec<"texture">;
+    dOverpaintType: DefineSpec<"string">;
     uMarker: UniformSpec<"f">;
     uMarkerTexDim: UniformSpec<"v2">;
     tMarker: TextureSpec<"image-uint8">;
-    dMarkerType: DefineSpec<"string">;
     markerAverage: import("./schema").ValueSpec<"number">;
     markerStatus: import("./schema").ValueSpec<"number">;
+    uColor: UniformSpec<"v3">;
+    uColorTexDim: UniformSpec<"v2">;
     uColorGridDim: UniformSpec<"v3">;
     uColorGridTransform: UniformSpec<"v4">;
+    tColor: TextureSpec<"image-uint8">;
     tPalette: TextureSpec<"image-uint8">;
     tColorGrid: TextureSpec<"texture">;
+    dColorType: DefineSpec<"string">;
     dUsePalette: DefineSpec<"boolean">;
+    dGeometryType: DefineSpec<"string">;
 };
 export declare type DirectVolumeSchema = typeof DirectVolumeSchema;
 export declare type DirectVolumeValues = Values<DirectVolumeSchema>;
-export declare function DirectVolumeRenderable(ctx: WebGLContext, id: number, values: DirectVolumeValues, state: RenderableState, materialId: number): Renderable<DirectVolumeValues>;
+export declare function DirectVolumeRenderable(ctx: WebGLContext, id: number, values: DirectVolumeValues, state: RenderableState, materialId: number, variants: GraphicsRenderVariant[]): Renderable<DirectVolumeValues>;

package/lib/mol-gl/renderable/direct-volume.js

@@ -9,8 +9,8 @@ import { createGraphicsRenderItem } from '../webgl/render-item';
 import { AttributeSpec, UniformSpec, GlobalUniformSchema, InternalSchema, TextureSpec, ElementsSpec, DefineSpec, GlobalTextureSchema, BaseSchema } from './schema';
 import { DirectVolumeShaderCode } from '../shader-code';
 import { ValueCell } from '../../mol-util';
-export var DirectVolumeSchema = __assign(__assign({}, BaseSchema), { aPosition: AttributeSpec('float32', 3, 0), elements: ElementsSpec('uint32'), uColor: UniformSpec('v3'), uColorTexDim: UniformSpec('v2'), tColor: TextureSpec('image-uint8', 'rgb', 'ubyte', 'nearest'), dColorType: DefineSpec('string', ['uniform', 'attribute', 'instance', 'group', 'groupInstance', 'vertex', 'vertexInstance']), uIsoValue: UniformSpec('v2'), uBboxMin: UniformSpec('v3'), uBboxMax: UniformSpec('v3'), uBboxSize: UniformSpec('v3'), uMaxSteps: UniformSpec('i'), uStepScale: UniformSpec('f'), uJumpLength: UniformSpec('f'), uTransform: UniformSpec('m4'), uGridDim: UniformSpec('v3'), dRenderMode: DefineSpec('string', ['isosurface', 'volume']), dSingleLayer: DefineSpec('boolean'), tTransferTex: TextureSpec('image-uint8', 'rgba', 'ubyte', 'linear'), uTransferScale: UniformSpec('f'), dGridTexType: DefineSpec('string', ['2d', '3d']), uGridTexDim: UniformSpec('v3'), tGridTex: TextureSpec('texture', 'rgba', 'ubyte', 'linear'), uGridStats: UniformSpec('v4'), uCellDim: UniformSpec('v3'), uCartnToUnit: UniformSpec('m4'), uUnitToCartn: UniformSpec('m4'), dPackedGroup: DefineSpec('boolean'), dDoubleSided: DefineSpec('boolean'), dFlipSided: DefineSpec('boolean'), dFlatShaded: DefineSpec('boolean'), dIgnoreLight: DefineSpec('boolean'), dXrayShaded: DefineSpec('boolean') });
-export function DirectVolumeRenderable(ctx, id, values, state, materialId) {
+export var DirectVolumeSchema = __assign(__assign({}, BaseSchema), { aPosition: AttributeSpec('float32', 3, 0), elements: ElementsSpec('uint32'), uBboxMin: UniformSpec('v3'), uBboxMax: UniformSpec('v3'), uBboxSize: UniformSpec('v3'), uMaxSteps: UniformSpec('i'), uStepScale: UniformSpec('f'), uJumpLength: UniformSpec('f'), uTransform: UniformSpec('m4'), uGridDim: UniformSpec('v3'), tTransferTex: TextureSpec('image-uint8', 'alpha', 'ubyte', 'linear'), uTransferScale: UniformSpec('f'), dGridTexType: DefineSpec('string', ['2d', '3d']), uGridTexDim: UniformSpec('v3'), tGridTex: TextureSpec('texture', 'rgba', 'ubyte', 'linear'), uGridStats: UniformSpec('v4'), uCellDim: UniformSpec('v3'), uCartnToUnit: UniformSpec('m4'), uUnitToCartn: UniformSpec('m4'), dPackedGroup: DefineSpec('boolean'), dAxisOrder: DefineSpec('string', ['012', '021', '102', '120', '201', '210']), dIgnoreLight: DefineSpec('boolean'), dXrayShaded: DefineSpec('boolean') });
+export function DirectVolumeRenderable(ctx, id, values, state, materialId, variants) {
     var schema = __assign(__assign(__assign(__assign({}, GlobalUniformSchema), GlobalTextureSchema), InternalSchema), DirectVolumeSchema);
     if (!ctx.isWebGL2) {
         // workaround for webgl1 limitation that loop counters need to be `const`
@@ -20,7 +20,7 @@ export function DirectVolumeRenderable(ctx, id, values, state, materialId) {
         uObjectId: ValueCell.create(id),
     };
     var shaderCode = DirectVolumeShaderCode;
-    var renderItem = createGraphicsRenderItem(ctx, 'triangles', shaderCode, schema, __assign(__assign({}, values), internalValues), materialId);
+    var renderItem = createGraphicsRenderItem(ctx, 'triangles', shaderCode, schema, __assign(__assign({}, values), internalValues), materialId, variants);
     return createRenderable(renderItem, values, state);
 }
 //# sourceMappingURL=direct-volume.js.map