molstar 3.0.0-dev.7 → 3.0.1

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.js

@@ -115,7 +115,7 @@ var Image;
         var counts = { drawCount: QuadIndices.length, vertexCount: QuadPositions.length / 3, groupCount: groupCount, instanceCount: instanceCount };
         var invariantBoundingSphere = Sphere3D.clone(image.boundingSphere);
         var boundingSphere = calculateTransformBoundingSphere(invariantBoundingSphere, transform.aTransform.ref.value, instanceCount);
-        return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, color), marker), overpaint), transparency), material), clipping), transform), BaseGeometry.createValues(props, counts)), { aPosition: image.cornerBuffer, aUv: ValueCell.create(QuadUvs), elements: ValueCell.create(QuadIndices), 
+        return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ dGeometryType: ValueCell.create('image') }, color), marker), overpaint), transparency), material), clipping), transform), BaseGeometry.createValues(props, counts)), { aPosition: image.cornerBuffer, aUv: ValueCell.create(QuadUvs), elements: ValueCell.create(QuadIndices), 
             // aGroup is used as a vertex index here, group id is in tGroupTex
             aGroup: ValueCell.create(fillSerial(new Float32Array(4))), boundingSphere: ValueCell.create(boundingSphere), invariantBoundingSphere: ValueCell.create(invariantBoundingSphere), uInvariantBoundingSphere: ValueCell.create(Vec4.ofSphere(invariantBoundingSphere)), dInterpolation: ValueCell.create(props.interpolation), uImageTexDim: image.imageTextureDim, tImageTex: image.imageTexture, tGroupTex: image.groupTexture });
     }

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

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

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

@@ -165,7 +165,7 @@ export var Lines;
         var counts = { drawCount: lines.lineCount * 2 * 3, vertexCount: lines.lineCount * 4, groupCount: groupCount, instanceCount: instanceCount };
         var invariantBoundingSphere = Sphere3D.clone(lines.boundingSphere);
         var boundingSphere = calculateTransformBoundingSphere(invariantBoundingSphere, transform.aTransform.ref.value, instanceCount);
-        return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ aMapping: lines.mappingBuffer, aGroup: lines.groupBuffer, aStart: lines.startBuffer, aEnd: lines.endBuffer, elements: lines.indexBuffer, boundingSphere: ValueCell.create(boundingSphere), invariantBoundingSphere: ValueCell.create(invariantBoundingSphere), uInvariantBoundingSphere: ValueCell.create(Vec4.ofSphere(invariantBoundingSphere)) }, color), size), marker), overpaint), transparency), material), clipping), transform), BaseGeometry.createValues(props, counts)), { uSizeFactor: ValueCell.create(props.sizeFactor), dLineSizeAttenuation: ValueCell.create(props.lineSizeAttenuation), uDoubleSided: ValueCell.create(true), dFlipSided: ValueCell.create(false) });
+        return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ dGeometryType: ValueCell.create('lines'), aMapping: lines.mappingBuffer, aGroup: lines.groupBuffer, aStart: lines.startBuffer, aEnd: lines.endBuffer, elements: lines.indexBuffer, boundingSphere: ValueCell.create(boundingSphere), invariantBoundingSphere: ValueCell.create(invariantBoundingSphere), uInvariantBoundingSphere: ValueCell.create(Vec4.ofSphere(invariantBoundingSphere)) }, color), size), marker), overpaint), transparency), material), clipping), transform), BaseGeometry.createValues(props, counts)), { uSizeFactor: ValueCell.create(props.sizeFactor), dLineSizeAttenuation: ValueCell.create(props.lineSizeAttenuation), uDoubleSided: ValueCell.create(true), dFlipSided: ValueCell.create(false) });
     }
     function createValuesSimple(lines, props, colorValue, sizeValue, transform) {
         var s = BaseGeometry.createSimple(colorValue, sizeValue, transform);

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

@@ -35,12 +35,20 @@ export function getMarkersAverage(array, count) {
     var viewEnd = (count - 4) >> 2;
     var backStart = 4 * viewEnd;
     var sum = 0;
-    for (var i = 0; i < viewEnd; ++i) {
-        var v = view[i];
-        sum += MarkerCountLut[v & 0xFFFF] + MarkerCountLut[v >> 16];
+    if (viewEnd < 0) {
+        // avoid edge cases with small arrays
+        for (var i = 0; i < count; ++i) {
+            sum += array[i] && 1;
+        }
     }
-    for (var i = backStart; i < count; ++i) {
-        sum += array[i] && 1;
+    else {
+        for (var i = 0; i < viewEnd; ++i) {
+            var v = view[i];
+            sum += MarkerCountLut[v & 0xFFFF] + MarkerCountLut[v >> 16];
+        }
+        for (var i = backStart; i < count; ++i) {
+            sum += array[i] && 1;
+        }
     }
     return sum / count;
 }

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

@@ -593,7 +593,7 @@ export var Mesh;
         var counts = { drawCount: mesh.triangleCount * 3, vertexCount: mesh.vertexCount, groupCount: groupCount, instanceCount: instanceCount };
         var invariantBoundingSphere = Sphere3D.clone(mesh.boundingSphere);
         var boundingSphere = calculateTransformBoundingSphere(invariantBoundingSphere, transform.aTransform.ref.value, instanceCount);
-        return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ aPosition: mesh.vertexBuffer, aNormal: mesh.normalBuffer, aGroup: mesh.groupBuffer, elements: mesh.indexBuffer, boundingSphere: ValueCell.create(boundingSphere), invariantBoundingSphere: ValueCell.create(invariantBoundingSphere), uInvariantBoundingSphere: ValueCell.create(Vec4.ofSphere(invariantBoundingSphere)) }, color), marker), overpaint), transparency), material), clipping), transform), BaseGeometry.createValues(props, counts)), { uDoubleSided: ValueCell.create(props.doubleSided), dFlatShaded: ValueCell.create(props.flatShaded), dFlipSided: ValueCell.create(props.flipSided), dIgnoreLight: ValueCell.create(props.ignoreLight), dXrayShaded: ValueCell.create(props.xrayShaded), uBumpFrequency: ValueCell.create(props.bumpFrequency), uBumpAmplitude: ValueCell.create(props.bumpAmplitude), meta: ValueCell.create(mesh.meta) });
+        return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ dGeometryType: ValueCell.create('mesh'), aPosition: mesh.vertexBuffer, aNormal: mesh.normalBuffer, aGroup: mesh.groupBuffer, elements: mesh.indexBuffer, boundingSphere: ValueCell.create(boundingSphere), invariantBoundingSphere: ValueCell.create(invariantBoundingSphere), uInvariantBoundingSphere: ValueCell.create(Vec4.ofSphere(invariantBoundingSphere)) }, color), marker), overpaint), transparency), material), clipping), transform), BaseGeometry.createValues(props, counts)), { uDoubleSided: ValueCell.create(props.doubleSided), dFlatShaded: ValueCell.create(props.flatShaded), dFlipSided: ValueCell.create(props.flipSided), dIgnoreLight: ValueCell.create(props.ignoreLight), dXrayShaded: ValueCell.create(props.xrayShaded), uBumpFrequency: ValueCell.create(props.bumpFrequency), uBumpAmplitude: ValueCell.create(props.bumpAmplitude), meta: ValueCell.create(mesh.meta) });
     }
     function createValuesSimple(mesh, props, colorValue, sizeValue, transform) {
         var s = BaseGeometry.createSimple(colorValue, sizeValue, transform);

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

@@ -43,7 +43,7 @@ export declare namespace Points {
         quality: PD.Select<"auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest">;
         material: PD.Group<PD.Normalize<{
             metalness: number;
-            roughness: number;
+            roughness: number; /** Number of vertices in the point cloud */
             bumpiness: number;
         }>>;
         clip: PD.Group<PD.Normalize<{

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

@@ -134,7 +134,7 @@ export var Points;
         var counts = { drawCount: points.pointCount, vertexCount: points.pointCount, groupCount: groupCount, instanceCount: instanceCount };
         var invariantBoundingSphere = Sphere3D.clone(points.boundingSphere);
         var boundingSphere = calculateTransformBoundingSphere(invariantBoundingSphere, transform.aTransform.ref.value, instanceCount);
-        return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ aPosition: points.centerBuffer, aGroup: points.groupBuffer, boundingSphere: ValueCell.create(boundingSphere), invariantBoundingSphere: ValueCell.create(invariantBoundingSphere), uInvariantBoundingSphere: ValueCell.create(Vec4.ofSphere(invariantBoundingSphere)) }, color), size), marker), overpaint), transparency), material), clipping), transform), BaseGeometry.createValues(props, counts)), { uSizeFactor: ValueCell.create(props.sizeFactor), dPointSizeAttenuation: ValueCell.create(props.pointSizeAttenuation), dPointStyle: ValueCell.create(props.pointStyle) });
+        return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ dGeometryType: ValueCell.create('points'), aPosition: points.centerBuffer, aGroup: points.groupBuffer, boundingSphere: ValueCell.create(boundingSphere), invariantBoundingSphere: ValueCell.create(invariantBoundingSphere), uInvariantBoundingSphere: ValueCell.create(Vec4.ofSphere(invariantBoundingSphere)) }, color), size), marker), overpaint), transparency), material), clipping), transform), BaseGeometry.createValues(props, counts)), { uSizeFactor: ValueCell.create(props.sizeFactor), dPointSizeAttenuation: ValueCell.create(props.pointSizeAttenuation), dPointStyle: ValueCell.create(props.pointStyle) });
     }
     function createValuesSimple(points, props, colorValue, sizeValue, transform) {
         var s = BaseGeometry.createSimple(colorValue, sizeValue, transform);

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

@@ -9,7 +9,7 @@ import { Vec2 } from '../../mol-math/linear-algebra';
 import { createTextureImage } from '../../mol-gl/renderable/util';
 import { NullLocation } from '../../mol-model/location';
 import { Geometry } from './geometry';
-import { decodeFloatRGB, encodeFloatRGBtoArray } from '../../mol-util/float-packing';
+import { unpackRGBToInt, packIntToRGBArray } from '../../mol-util/number-packing';
 export function createSizes(locationIt, sizeTheme, sizeData) {
     switch (Geometry.getGranularity(locationIt, sizeTheme.granularity)) {
         case 'uniform': return createUniformSize(locationIt, sizeTheme.size, sizeData);
@@ -30,7 +30,7 @@ export function getMaxSize(sizeData) {
             var maxSize = 0;
             var array = sizeData.tSize.ref.value.array;
             for (var i = 0, il = array.length; i < il; i += 3) {
-                var value = decodeFloatRGB(array[i], array[i + 1], array[i + 2]);
+                var value = unpackRGBToInt(array[i], array[i + 1], array[i + 2]);
                 if (maxSize < value)
                     maxSize = value;
             }
@@ -81,7 +81,7 @@ export function createInstanceSize(locationIt, sizeFn, sizeData) {
     locationIt.reset();
     while (locationIt.hasNext && !locationIt.isNextNewInstance) {
         var v = locationIt.move();
-        encodeFloatRGBtoArray(sizeFn(v.location) * sizeDataFactor, sizes.array, v.instanceIndex * 3);
+        packIntToRGBArray(sizeFn(v.location) * sizeDataFactor, sizes.array, v.instanceIndex * 3);
         locationIt.skipInstance();
     }
     return createTextureSize(sizes, 'instance', sizeData);
@@ -93,7 +93,7 @@ export function createGroupSize(locationIt, sizeFn, sizeData) {
     locationIt.reset();
     while (locationIt.hasNext && !locationIt.isNextNewInstance) {
         var v = locationIt.move();
-        encodeFloatRGBtoArray(sizeFn(v.location) * sizeDataFactor, sizes.array, v.groupIndex * 3);
+        packIntToRGBArray(sizeFn(v.location) * sizeDataFactor, sizes.array, v.groupIndex * 3);
     }
     return createTextureSize(sizes, 'group', sizeData);
 }
@@ -105,7 +105,7 @@ export function createGroupInstanceSize(locationIt, sizeFn, sizeData) {
     locationIt.reset();
     while (locationIt.hasNext) {
         var v = locationIt.move();
-        encodeFloatRGBtoArray(sizeFn(v.location) * sizeDataFactor, sizes.array, v.index * 3);
+        packIntToRGBArray(sizeFn(v.location) * sizeDataFactor, sizes.array, v.index * 3);
     }
     return createTextureSize(sizes, 'groupInstance', sizeData);
 }

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

@@ -132,7 +132,7 @@ export var Spheres;
         var padding = spheres.boundingSphere.radius ? getMaxSize(size) * props.sizeFactor : 0;
         var invariantBoundingSphere = Sphere3D.expand(Sphere3D(), spheres.boundingSphere, padding);
         var boundingSphere = calculateTransformBoundingSphere(invariantBoundingSphere, transform.aTransform.ref.value, instanceCount);
-        return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ aPosition: spheres.centerBuffer, aMapping: spheres.mappingBuffer, aGroup: spheres.groupBuffer, elements: spheres.indexBuffer, boundingSphere: ValueCell.create(boundingSphere), invariantBoundingSphere: ValueCell.create(invariantBoundingSphere), uInvariantBoundingSphere: ValueCell.create(Vec4.ofSphere(invariantBoundingSphere)) }, color), size), marker), overpaint), transparency), material), clipping), transform), { padding: ValueCell.create(padding) }), BaseGeometry.createValues(props, counts)), { uSizeFactor: ValueCell.create(props.sizeFactor), 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) });
+        return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ dGeometryType: ValueCell.create('spheres'), aPosition: spheres.centerBuffer, aMapping: spheres.mappingBuffer, aGroup: spheres.groupBuffer, elements: spheres.indexBuffer, boundingSphere: ValueCell.create(boundingSphere), invariantBoundingSphere: ValueCell.create(invariantBoundingSphere), uInvariantBoundingSphere: ValueCell.create(Vec4.ofSphere(invariantBoundingSphere)) }, color), size), marker), overpaint), transparency), material), clipping), transform), { padding: ValueCell.create(padding) }), BaseGeometry.createValues(props, counts)), { uSizeFactor: ValueCell.create(props.sizeFactor), 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(spheres, props, colorValue, sizeValue, transform) {
         var s = BaseGeometry.createSimple(colorValue, sizeValue, transform);

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

@@ -148,7 +148,7 @@ export var Text;
         var padding = getPadding(text.mappingBuffer.ref.value, text.depthBuffer.ref.value, text.charCount, getMaxSize(size));
         var invariantBoundingSphere = Sphere3D.expand(Sphere3D(), text.boundingSphere, padding);
         var boundingSphere = calculateTransformBoundingSphere(invariantBoundingSphere, transform.aTransform.ref.value, instanceCount);
-        return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ aPosition: text.centerBuffer, aMapping: text.mappingBuffer, aDepth: text.depthBuffer, aGroup: text.groupBuffer, elements: text.indexBuffer, boundingSphere: ValueCell.create(boundingSphere), invariantBoundingSphere: ValueCell.create(invariantBoundingSphere), uInvariantBoundingSphere: ValueCell.create(Vec4.ofSphere(invariantBoundingSphere)) }, color), size), marker), overpaint), transparency), substance), clipping), transform), { aTexCoord: text.tcoordBuffer, tFont: text.fontTexture, padding: ValueCell.create(padding) }), BaseGeometry.createValues(props, counts)), { uSizeFactor: ValueCell.create(props.sizeFactor), uBorderWidth: ValueCell.create(clamp(props.borderWidth, 0, 0.5)), uBorderColor: ValueCell.create(Color.toArrayNormalized(props.borderColor, Vec3.zero(), 0)), uOffsetX: ValueCell.create(props.offsetX), uOffsetY: ValueCell.create(props.offsetY), uOffsetZ: ValueCell.create(props.offsetZ), uBackgroundColor: ValueCell.create(Color.toArrayNormalized(props.backgroundColor, Vec3.zero(), 0)), uBackgroundOpacity: ValueCell.create(props.backgroundOpacity) });
+        return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ dGeometryType: ValueCell.create('text'), aPosition: text.centerBuffer, aMapping: text.mappingBuffer, aDepth: text.depthBuffer, aGroup: text.groupBuffer, elements: text.indexBuffer, boundingSphere: ValueCell.create(boundingSphere), invariantBoundingSphere: ValueCell.create(invariantBoundingSphere), uInvariantBoundingSphere: ValueCell.create(Vec4.ofSphere(invariantBoundingSphere)) }, color), size), marker), overpaint), transparency), substance), clipping), transform), { aTexCoord: text.tcoordBuffer, tFont: text.fontTexture, padding: ValueCell.create(padding) }), BaseGeometry.createValues(props, counts)), { uSizeFactor: ValueCell.create(props.sizeFactor), uBorderWidth: ValueCell.create(clamp(props.borderWidth, 0, 0.5)), uBorderColor: ValueCell.create(Color.toArrayNormalized(props.borderColor, Vec3.zero(), 0)), uOffsetX: ValueCell.create(props.offsetX), uOffsetY: ValueCell.create(props.offsetY), uOffsetZ: ValueCell.create(props.offsetZ), uBackgroundColor: ValueCell.create(Color.toArrayNormalized(props.backgroundColor, Vec3.zero(), 0)), uBackgroundOpacity: ValueCell.create(props.backgroundOpacity) });
     }
     function createValuesSimple(text, props, colorValue, sizeValue, transform) {
         var s = BaseGeometry.createSimple(colorValue, sizeValue, transform);

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

@@ -110,7 +110,7 @@ export var TextureMesh;
         var counts = { drawCount: textureMesh.vertexCount, vertexCount: textureMesh.vertexCount, groupCount: groupCount, instanceCount: instanceCount };
         var invariantBoundingSphere = Sphere3D.clone(textureMesh.boundingSphere);
         var boundingSphere = calculateTransformBoundingSphere(invariantBoundingSphere, transform.aTransform.ref.value, instanceCount);
-        return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ uGeoTexDim: textureMesh.geoTextureDim, tPosition: textureMesh.vertexTexture, tGroup: textureMesh.groupTexture, tNormal: textureMesh.normalTexture, boundingSphere: ValueCell.create(boundingSphere), invariantBoundingSphere: ValueCell.create(invariantBoundingSphere), uInvariantBoundingSphere: ValueCell.create(Vec4.ofSphere(invariantBoundingSphere)) }, color), marker), overpaint), transparency), substance), clipping), transform), BaseGeometry.createValues(props, counts)), { uDoubleSided: ValueCell.create(props.doubleSided), dFlatShaded: ValueCell.create(props.flatShaded), dFlipSided: ValueCell.create(props.flipSided), dIgnoreLight: ValueCell.create(props.ignoreLight), dXrayShaded: ValueCell.create(props.xrayShaded), uBumpFrequency: ValueCell.create(props.bumpFrequency), uBumpAmplitude: ValueCell.create(props.bumpAmplitude), dGeoTexture: ValueCell.create(true), meta: ValueCell.create(textureMesh.meta) });
+        return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ dGeometryType: ValueCell.create('textureMesh'), uGeoTexDim: textureMesh.geoTextureDim, tPosition: textureMesh.vertexTexture, tGroup: textureMesh.groupTexture, tNormal: textureMesh.normalTexture, boundingSphere: ValueCell.create(boundingSphere), invariantBoundingSphere: ValueCell.create(invariantBoundingSphere), uInvariantBoundingSphere: ValueCell.create(Vec4.ofSphere(invariantBoundingSphere)) }, color), marker), overpaint), transparency), substance), clipping), transform), BaseGeometry.createValues(props, counts)), { uDoubleSided: ValueCell.create(props.doubleSided), dFlatShaded: ValueCell.create(props.flatShaded), dFlipSided: ValueCell.create(props.flipSided), dIgnoreLight: ValueCell.create(props.ignoreLight), dXrayShaded: ValueCell.create(props.xrayShaded), uBumpFrequency: ValueCell.create(props.bumpFrequency), uBumpAmplitude: ValueCell.create(props.bumpAmplitude), meta: ValueCell.create(textureMesh.meta) });
     }
     function createValuesSimple(textureMesh, props, colorValue, sizeValue, transform) {
         var s = BaseGeometry.createSimple(colorValue, sizeValue, transform);

package/lib/mol-gl/compute/histogram-pyramid/sum.js

@@ -9,7 +9,7 @@ import { createComputeRenderItem } from '../../webgl/render-item';
 import { TextureSpec } from '../../renderable/schema';
 import { ShaderCode } from '../../../mol-gl/shader-code';
 import { ValueCell } from '../../../mol-util';
-import { decodeFloatRGB } from '../../../mol-util/float-packing';
+import { unpackRGBToInt } from '../../../mol-util/number-packing';
 import { QuadSchema, QuadValues } from '../util';
 import { quad_vert } from '../../../mol-gl/shader/quad.vert';
 import { sum_frag } from '../../../mol-gl/shader/histogram-pyramid/sum.frag';
@@ -70,6 +70,6 @@ export function getHistopyramidSum(ctx, pyramidTopTexture) {
     ctx.unbindFramebuffer();
     return isWebGL2(gl)
         ? sumInts[0]
-        : decodeFloatRGB(sumBytes[0], sumBytes[1], sumBytes[2]);
+        : unpackRGBToInt(sumBytes[0], sumBytes[1], sumBytes[2]);
 }
 //# sourceMappingURL=sum.js.map

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,7 @@ 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');
@@ -107,7 +108,7 @@ 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;
     framebuffer.bind();
     drawBuffers.drawBuffers([
@@ -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/renderable/cylinders.d.ts

@@ -92,6 +92,7 @@ export declare const CylindersSchema: {
     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>;

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

@@ -10,11 +10,6 @@ import { AttributeSpec, Values, UniformSpec, TextureSpec, ElementsSpec, DefineSp
 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">;
@@ -23,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">;
@@ -35,9 +28,7 @@ export declare const DirectVolumeSchema: {
     uCartnToUnit: UniformSpec<"m4">;
     uUnitToCartn: UniformSpec<"m4">;
     dPackedGroup: DefineSpec<"boolean">;
-    uDoubleSided: UniformSpec<"b">;
-    dFlipSided: DefineSpec<"boolean">;
-    dFlatShaded: DefineSpec<"boolean">;
+    dAxisOrder: DefineSpec<"string">;
     dIgnoreLight: DefineSpec<"boolean">;
     dXrayShaded: DefineSpec<"boolean">;
     dLightCount: DefineSpec<"number">;
@@ -97,11 +88,16 @@ export declare const DirectVolumeSchema: {
     tMarker: TextureSpec<"image-uint8">;
     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>;

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

@@ -9,7 +9,7 @@ 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'), uDoubleSided: UniformSpec('b'), dFlipSided: DefineSpec('boolean'), dFlatShaded: DefineSpec('boolean'), dIgnoreLight: DefineSpec('boolean'), dXrayShaded: DefineSpec('boolean') });
+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) {

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

@@ -82,6 +82,7 @@ export declare const ImageSchema: {
     tColorGrid: TextureSpec<"texture">;
     dColorType: DefineSpec<"string">;
     dUsePalette: DefineSpec<"boolean">;
+    dGeometryType: DefineSpec<"string">;
 };
 export declare type ImageSchema = typeof ImageSchema;
 export declare type ImageValues = Values<ImageSchema>;

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

@@ -87,6 +87,7 @@ export declare const LinesSchema: {
     tColorGrid: import("./schema").TextureSpec<"texture">;
     dColorType: DefineSpec<"string">;
     dUsePalette: DefineSpec<"boolean">;
+    dGeometryType: DefineSpec<"string">;
 };
 export declare type LinesSchema = typeof LinesSchema;
 export declare type LinesValues = Values<LinesSchema>;

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

@@ -86,6 +86,7 @@ export declare const MeshSchema: {
     readonly tColorGrid: import("./schema").TextureSpec<"texture">;
     readonly dColorType: DefineSpec<"string">;
     readonly dUsePalette: DefineSpec<"boolean">;
+    readonly dGeometryType: DefineSpec<"string">;
 };
 export declare type MeshSchema = typeof MeshSchema;
 export declare type MeshValues = Values<MeshSchema>;

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

@@ -83,6 +83,7 @@ export declare const PointsSchema: {
     tColorGrid: import("./schema").TextureSpec<"texture">;
     dColorType: DefineSpec<"string">;
     dUsePalette: DefineSpec<"boolean">;
+    dGeometryType: DefineSpec<"string">;
 };
 export declare type PointsSchema = typeof PointsSchema;
 export declare type PointsValues = Values<PointsSchema>;

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

@@ -289,6 +289,7 @@ export declare const BaseSchema: {
     readonly tColorGrid: TextureSpec<"texture">;
     readonly dColorType: DefineSpec<"string">;
     readonly dUsePalette: DefineSpec<"boolean">;
+    readonly dGeometryType: DefineSpec<"string">;
 };
 export declare type BaseSchema = typeof BaseSchema;
 export declare type BaseValues = Values<BaseSchema>;

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

@@ -114,7 +114,7 @@ export var ColorSchema = {
     tColor: TextureSpec('image-uint8', 'rgb', 'ubyte', 'nearest'),
     tPalette: TextureSpec('image-uint8', 'rgb', 'ubyte', 'nearest'),
     tColorGrid: TextureSpec('texture', 'rgb', 'ubyte', 'linear'),
-    dColorType: DefineSpec('string', ['uniform', 'attribute', 'instance', 'group', 'groupInstance', 'vertex', 'vertexInstance', 'volume', 'volumeInstance']),
+    dColorType: DefineSpec('string', ['uniform', 'attribute', 'instance', 'group', 'groupInstance', 'vertex', 'vertexInstance', 'volume', 'volumeInstance', 'direct']),
     dUsePalette: DefineSpec('boolean'),
 };
 export var SizeSchema = {
@@ -165,7 +165,7 @@ export var ClippingSchema = {
     tClipping: TextureSpec('image-uint8', 'alpha', 'ubyte', 'nearest'),
     dClipping: DefineSpec('boolean'),
 };
-export var BaseSchema = __assign(__assign(__assign(__assign(__assign(__assign(__assign({}, ColorSchema), MarkerSchema), OverpaintSchema), TransparencySchema), SubstanceSchema), ClippingSchema), { dLightCount: DefineSpec('number'), dClipObjectCount: DefineSpec('number'), dClipVariant: DefineSpec('string', ['instance', 'pixel']), uClipObjectType: UniformSpec('i[]'), uClipObjectInvert: UniformSpec('b[]'), uClipObjectPosition: UniformSpec('v3[]'), uClipObjectRotation: UniformSpec('v4[]'), uClipObjectScale: UniformSpec('v3[]'), aInstance: AttributeSpec('float32', 1, 1), 
+export var BaseSchema = __assign(__assign(__assign(__assign(__assign(__assign(__assign({ dGeometryType: DefineSpec('string', ['cylinders', 'directVolume', 'image', 'lines', 'mesh', 'points', 'spheres', 'text', 'textureMesh']) }, ColorSchema), MarkerSchema), OverpaintSchema), TransparencySchema), SubstanceSchema), ClippingSchema), { dLightCount: DefineSpec('number'), dClipObjectCount: DefineSpec('number'), dClipVariant: DefineSpec('string', ['instance', 'pixel']), uClipObjectType: UniformSpec('i[]'), uClipObjectInvert: UniformSpec('b[]'), uClipObjectPosition: UniformSpec('v3[]'), uClipObjectRotation: UniformSpec('v4[]'), uClipObjectScale: UniformSpec('v3[]'), aInstance: AttributeSpec('float32', 1, 1), 
     /**
      * final per-instance transform calculated for instance `i` as
      * `aTransform[i] = matrix * transform[i] * extraTransform[i]`

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

@@ -89,6 +89,7 @@ export declare const SpheresSchema: {
     tColorGrid: import("./schema").TextureSpec<"texture">;
     dColorType: DefineSpec<"string">;
     dUsePalette: DefineSpec<"boolean">;
+    dGeometryType: DefineSpec<"string">;
 };
 export declare type SpheresSchema = typeof SpheresSchema;
 export declare type SpheresValues = Values<SpheresSchema>;

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

@@ -94,6 +94,7 @@ export declare const TextSchema: {
     tColorGrid: TextureSpec<"texture">;
     dColorType: import("./schema").DefineSpec<"string">;
     dUsePalette: import("./schema").DefineSpec<"boolean">;
+    dGeometryType: import("./schema").DefineSpec<"string">;
 };
 export declare type TextSchema = typeof TextSchema;
 export declare type TextValues = Values<TextSchema>;

package/lib/mol-gl/renderable/texture-mesh.d.ts

@@ -17,7 +17,6 @@ export declare const TextureMeshSchema: {
     dFlipSided: DefineSpec<"boolean">;
     dIgnoreLight: DefineSpec<"boolean">;
     dXrayShaded: DefineSpec<"boolean">;
-    dGeoTexture: DefineSpec<"boolean">;
     uBumpFrequency: UniformSpec<"f">;
     uBumpAmplitude: UniformSpec<"f">;
     meta: ValueSpec<"unknown">;
@@ -87,6 +86,7 @@ export declare const TextureMeshSchema: {
     tColorGrid: TextureSpec<"texture">;
     dColorType: DefineSpec<"string">;
     dUsePalette: DefineSpec<"boolean">;
+    dGeometryType: DefineSpec<"string">;
 };
 export declare type TextureMeshSchema = typeof TextureMeshSchema;
 export declare type TextureMeshValues = Values<TextureMeshSchema>;

package/lib/mol-gl/renderable/texture-mesh.js

@@ -9,7 +9,7 @@ import { createGraphicsRenderItem } from '../webgl/render-item';
 import { GlobalUniformSchema, BaseSchema, DefineSpec, InternalSchema, UniformSpec, TextureSpec, GlobalTextureSchema, ValueSpec } from './schema';
 import { MeshShaderCode } from '../shader-code';
 import { ValueCell } from '../../mol-util';
-export var TextureMeshSchema = __assign(__assign({}, BaseSchema), { uGeoTexDim: UniformSpec('v2', 'buffered'), tPosition: TextureSpec('texture', 'rgb', 'float', 'nearest'), tGroup: TextureSpec('texture', 'alpha', 'float', 'nearest'), tNormal: TextureSpec('texture', 'rgb', 'float', 'nearest'), dFlatShaded: DefineSpec('boolean'), uDoubleSided: UniformSpec('b'), dFlipSided: DefineSpec('boolean'), dIgnoreLight: DefineSpec('boolean'), dXrayShaded: DefineSpec('boolean'), dGeoTexture: DefineSpec('boolean'), uBumpFrequency: UniformSpec('f'), uBumpAmplitude: UniformSpec('f'), meta: ValueSpec('unknown') });
+export var TextureMeshSchema = __assign(__assign({}, BaseSchema), { uGeoTexDim: UniformSpec('v2', 'buffered'), tPosition: TextureSpec('texture', 'rgb', 'float', 'nearest'), tGroup: TextureSpec('texture', 'alpha', 'float', 'nearest'), tNormal: TextureSpec('texture', 'rgb', 'float', 'nearest'), dFlatShaded: DefineSpec('boolean'), uDoubleSided: UniformSpec('b'), dFlipSided: DefineSpec('boolean'), dIgnoreLight: DefineSpec('boolean'), dXrayShaded: DefineSpec('boolean'), uBumpFrequency: UniformSpec('f'), uBumpAmplitude: UniformSpec('f'), meta: ValueSpec('unknown') });
 export function TextureMeshRenderable(ctx, id, values, state, materialId, variants) {
     var schema = __assign(__assign(__assign(__assign({}, GlobalUniformSchema), GlobalTextureSchema), InternalSchema), TextureMeshSchema);
     var internalValues = {

package/lib/mol-gl/renderer.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -37,7 +37,7 @@ export declare const enum MarkingType {
 interface Renderer {
     readonly stats: RendererStats;
     readonly props: Readonly<RendererProps>;
-    clear: (toBackgroundColor: boolean) => void;
+    clear: (toBackgroundColor: boolean, ignoreTransparentBackground?: boolean) => void;
     clearDepth: () => void;
     update: (camera: ICamera) => void;
     renderPick: (group: Scene.Group, camera: ICamera, variant: GraphicsRenderVariant, depthTexture: Texture | null, pickType: PickType) => void;