molstar 3.0.0-dev.0 → 3.0.0-dev.10

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

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

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

@@ -41,9 +41,20 @@ export declare namespace Points {
         pointStyle: PD.Select<"circle" | "square" | "fuzzy">;
         alpha: PD.Numeric;
         quality: PD.Select<"auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest">;
-        material: PD.Converted<import("../../../mol-util/material").Material, PD.Normalize<{
+        material: PD.Group<PD.Normalize<{
             metalness: number;
             roughness: number;
+            bumpiness: number;
+        }>>;
+        clip: PD.Group<PD.Normalize<{
+            variant: import("../../../mol-util/clip").Clip.Variant;
+            objects: PD.Normalize<{
+                type: any;
+                invert: any;
+                position: any;
+                rotation: any;
+                scale: any;
+            }>[];
         }>>;
     };
     type Params = typeof Params;

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.d.ts

@@ -34,11 +34,24 @@ export declare namespace Spheres {
         doubleSided: PD.BooleanParam;
         ignoreLight: PD.BooleanParam;
         xrayShaded: PD.BooleanParam;
+        bumpFrequency: PD.Numeric;
+        bumpAmplitude: PD.Numeric;
         alpha: PD.Numeric;
         quality: PD.Select<"auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest">;
-        material: PD.Converted<import("../../../mol-util/material").Material, PD.Normalize<{
+        material: PD.Group<PD.Normalize<{
             metalness: number;
             roughness: number;
+            bumpiness: number;
+        }>>;
+        clip: PD.Group<PD.Normalize<{
+            variant: import("../../../mol-util/clip").Clip.Variant;
+            objects: PD.Normalize<{
+                type: any;
+                invert: any;
+                position: any;
+                rotation: any;
+                scale: any;
+            }>[];
         }>>;
     };
     type Params = typeof Params;

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

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

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

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

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

@@ -60,9 +60,20 @@ export declare namespace Text {
         fontWeight: PD.Select<import("./font-atlas").FontWeight>;
         alpha: PD.Numeric;
         quality: PD.Select<"auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest">;
-        material: PD.Converted<import("../../../mol-util/material").Material, PD.Normalize<{
+        material: PD.Group<PD.Normalize<{
             metalness: number;
             roughness: number;
+            bumpiness: number;
+        }>>;
+        clip: PD.Group<PD.Normalize<{
+            variant: import("../../../mol-util/clip").Clip.Variant;
+            objects: PD.Normalize<{
+                type: any;
+                invert: any;
+                position: any;
+                rotation: any;
+                scale: any;
+            }>[];
         }>>;
     };
     type Params = typeof Params;

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/color-smoothing.js

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

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

@@ -45,11 +45,24 @@ export declare namespace TextureMesh {
         flatShaded: PD.BooleanParam;
         ignoreLight: PD.BooleanParam;
         xrayShaded: PD.BooleanParam;
+        bumpFrequency: PD.Numeric;
+        bumpAmplitude: PD.Numeric;
         alpha: PD.Numeric;
         quality: PD.Select<"auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest">;
-        material: PD.Converted<import("../../../mol-util/material").Material, PD.Normalize<{
+        material: PD.Group<PD.Normalize<{
             metalness: number;
             roughness: number;
+            bumpiness: number;
+        }>>;
+        clip: PD.Group<PD.Normalize<{
+            variant: import("../../../mol-util/clip").Clip.Variant;
+            objects: PD.Normalize<{
+                type: any;
+                invert: any;
+                position: any;
+                rotation: any;
+                scale: any;
+            }>[];
         }>>;
     };
     type Params = typeof Params;

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

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

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/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,24 +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">;
-    uMetalness: import("./schema").UniformSpec<"f">;
-    uRoughness: import("./schema").UniformSpec<"f">;
-    uVertexCount: import("./schema").UniformSpec<"i">;
-    uInstanceCount: import("./schema").UniformSpec<"i">;
-    uGroupCount: import("./schema").UniformSpec<"i">;
-    uInvariantBoundingSphere: import("./schema").UniformSpec<"v4">;
+    uAlpha: UniformSpec<"f">;
+    uMetalness: UniformSpec<"f">;
+    uRoughness: UniformSpec<"f">;
+    uBumpiness: UniformSpec<"f">;
+    uVertexCount: UniformSpec<"i">;
+    uInstanceCount: UniformSpec<"i">;
+    uGroupCount: UniformSpec<"i">;
+    uInvariantBoundingSphere: UniformSpec<"v4">;
     drawCount: ValueSpec<"number">;
     instanceCount: ValueSpec<"number">;
     alpha: ValueSpec<"number">;
@@ -42,49 +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">;
-    uSubstanceTexDim: import("./schema").UniformSpec<"v2">;
+    uSubstanceTexDim: UniformSpec<"v2">;
     tSubstance: import("./schema").TextureSpec<"image-uint8">;
     dSubstance: DefineSpec<"boolean">;
-    uSubstanceGridDim: import("./schema").UniformSpec<"v3">;
-    uSubstanceGridTransform: import("./schema").UniformSpec<"v4">;
+    uSubstanceGridDim: UniformSpec<"v3">;
+    uSubstanceGridTransform: UniformSpec<"v4">;
     tSubstanceGrid: import("./schema").TextureSpec<"texture">;
     dSubstanceType: DefineSpec<"string">;
-    uTransparencyTexDim: import("./schema").UniformSpec<"v2">;
+    uTransparencyTexDim: UniformSpec<"v2">;
     tTransparency: import("./schema").TextureSpec<"image-uint8">;
     dTransparency: DefineSpec<"boolean">;
     transparencyAverage: ValueSpec<"number">;
-    uTransparencyGridDim: import("./schema").UniformSpec<"v3">;
-    uTransparencyGridTransform: import("./schema").UniformSpec<"v4">;
+    uTransparencyGridDim: UniformSpec<"v3">;
+    uTransparencyGridTransform: UniformSpec<"v4">;
     tTransparencyGrid: import("./schema").TextureSpec<"texture">;
     dTransparencyType: DefineSpec<"string">;
-    uOverpaintTexDim: import("./schema").UniformSpec<"v2">;
+    uOverpaintTexDim: UniformSpec<"v2">;
     tOverpaint: import("./schema").TextureSpec<"image-uint8">;
     dOverpaint: DefineSpec<"boolean">;
-    uOverpaintGridDim: import("./schema").UniformSpec<"v3">;
-    uOverpaintGridTransform: import("./schema").UniformSpec<"v4">;
+    uOverpaintGridDim: UniformSpec<"v3">;
+    uOverpaintGridTransform: UniformSpec<"v4">;
     tOverpaintGrid: import("./schema").TextureSpec<"texture">;
     dOverpaintType: DefineSpec<"string">;
-    uMarker: import("./schema").UniformSpec<"f">;
-    uMarkerTexDim: import("./schema").UniformSpec<"v2">;
+    uMarker: UniformSpec<"f">;
+    uMarkerTexDim: UniformSpec<"v2">;
     tMarker: import("./schema").TextureSpec<"image-uint8">;
-    dMarkerType: DefineSpec<"string">;
     markerAverage: ValueSpec<"number">;
     markerStatus: ValueSpec<"number">;
-    uColor: import("./schema").UniformSpec<"v3">;
-    uColorTexDim: import("./schema").UniformSpec<"v2">;
-    uColorGridDim: import("./schema").UniformSpec<"v3">;
-    uColorGridTransform: import("./schema").UniformSpec<"v4">;
+    uColor: UniformSpec<"v3">;
+    uColorTexDim: UniformSpec<"v2">;
+    uColorGridDim: UniformSpec<"v3">;
+    uColorGridTransform: UniformSpec<"v4">;
     tColor: import("./schema").TextureSpec<"image-uint8">;
     tPalette: import("./schema").TextureSpec<"image-uint8">;
     tColorGrid: import("./schema").TextureSpec<"texture">;
     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>;