molstar 3.7.0 → 3.8.0

package/lib/commonjs/mol-gl/renderer.js

@@ -67,7 +67,9 @@ var Renderer;
         var drawingBufferSize = linear_algebra_1.Vec2.create(gl.drawingBufferWidth, gl.drawingBufferHeight);
         var bgColor = color_1.Color.toVec3Normalized((0, linear_algebra_1.Vec3)(), p.backgroundColor);
         var transparentBackground = false;
-        var emptyDepthTexture = ctx.resources.texture('image-depth', 'depth', 'ushort', 'nearest');
+        var emptyDepthTexture = ctx.resources.texture('image-uint8', 'rgba', 'ubyte', 'nearest');
+        emptyDepthTexture.define(1, 1);
+        emptyDepthTexture.load({ array: new Uint8Array([255, 255, 255, 255]), width: 1, height: 1 });
         var sharedTexturesList = [
             ['tDepth', emptyDepthTexture]
         ];
@@ -104,7 +106,7 @@ var Renderer;
             uFogNear: mol_util_1.ValueCell.create(1),
             uFogFar: mol_util_1.ValueCell.create(10000),
             uFogColor: mol_util_1.ValueCell.create(bgColor),
-            uRenderWboit: mol_util_1.ValueCell.create(false),
+            uRenderMask: mol_util_1.ValueCell.create(0),
             uMarkingDepthTest: mol_util_1.ValueCell.create(false),
             uPickType: mol_util_1.ValueCell.create(0 /* None */),
             uMarkingType: mol_util_1.ValueCell.create(0 /* None */),
@@ -223,14 +225,14 @@ var Renderer;
             mol_util_1.ValueCell.updateIfChanged(globalUniforms.uFogNear, camera.fogNear);
             mol_util_1.ValueCell.updateIfChanged(globalUniforms.uTransparentBackground, transparentBackground);
         };
-        var updateInternal = function (group, camera, depthTexture, renderWboit, markingDepthTest) {
+        var updateInternal = function (group, camera, depthTexture, renderMask, markingDepthTest) {
             (0, array_1.arrayMapUpsert)(sharedTexturesList, 'tDepth', depthTexture || emptyDepthTexture);
             mol_util_1.ValueCell.update(globalUniforms.uModel, group.view);
             mol_util_1.ValueCell.update(globalUniforms.uModelView, linear_algebra_1.Mat4.mul(modelView, group.view, camera.view));
             mol_util_1.ValueCell.update(globalUniforms.uInvModelView, linear_algebra_1.Mat4.invert(invModelView, modelView));
             mol_util_1.ValueCell.update(globalUniforms.uModelViewProjection, linear_algebra_1.Mat4.mul(modelViewProjection, modelView, camera.projection));
             mol_util_1.ValueCell.update(globalUniforms.uInvModelViewProjection, linear_algebra_1.Mat4.invert(invModelViewProjection, modelViewProjection));
-            mol_util_1.ValueCell.updateIfChanged(globalUniforms.uRenderWboit, renderWboit);
+            mol_util_1.ValueCell.updateIfChanged(globalUniforms.uRenderMask, renderMask);
             mol_util_1.ValueCell.updateIfChanged(globalUniforms.uMarkingDepthTest, markingDepthTest);
             state.enable(gl.SCISSOR_TEST);
             state.colorMask(true, true, true, true);
@@ -244,7 +246,7 @@ var Renderer;
             state.disable(gl.BLEND);
             state.enable(gl.DEPTH_TEST);
             state.depthMask(true);
-            updateInternal(group, camera, depthTexture, false, false);
+            updateInternal(group, camera, depthTexture, 0 /* All */, false);
             mol_util_1.ValueCell.updateIfChanged(globalUniforms.uPickType, pickType);
             var renderables = group.renderables;
             for (var i = 0, il = renderables.length; i < il; ++i) {
@@ -257,17 +259,45 @@ var Renderer;
             state.disable(gl.BLEND);
             state.enable(gl.DEPTH_TEST);
             state.depthMask(true);
-            updateInternal(group, camera, depthTexture, false, false);
+            updateInternal(group, camera, depthTexture, 0 /* All */, false);
             var renderables = group.renderables;
             for (var i = 0, il = renderables.length; i < il; ++i) {
                 renderObject(renderables[i], 'depth', 0 /* None */);
             }
         };
+        var renderDepthOpaque = function (group, camera, depthTexture) {
+            var _a;
+            state.disable(gl.BLEND);
+            state.enable(gl.DEPTH_TEST);
+            state.depthMask(true);
+            updateInternal(group, camera, depthTexture, 1 /* Opaque */, false);
+            var renderables = group.renderables;
+            for (var i = 0, il = renderables.length; i < il; ++i) {
+                var r = renderables[i];
+                if (r.state.opaque && r.values.transparencyAverage.ref.value !== 1 && !((_a = r.values.dXrayShaded) === null || _a === void 0 ? void 0 : _a.ref.value)) {
+                    renderObject(r, 'depth', 0 /* None */);
+                }
+            }
+        };
+        var renderDepthTransparent = function (group, camera, depthTexture) {
+            var _a;
+            state.disable(gl.BLEND);
+            state.enable(gl.DEPTH_TEST);
+            state.depthMask(true);
+            updateInternal(group, camera, depthTexture, 2 /* Transparent */, false);
+            var renderables = group.renderables;
+            for (var i = 0, il = renderables.length; i < il; ++i) {
+                var r = renderables[i];
+                if (!r.state.opaque || r.values.transparencyAverage.ref.value > 0 || ((_a = r.values.dXrayShaded) === null || _a === void 0 ? void 0 : _a.ref.value)) {
+                    renderObject(r, 'depth', 0 /* None */);
+                }
+            }
+        };
         var renderMarkingDepth = function (group, camera, depthTexture) {
             state.disable(gl.BLEND);
             state.enable(gl.DEPTH_TEST);
             state.depthMask(true);
-            updateInternal(group, camera, depthTexture, false, false);
+            updateInternal(group, camera, depthTexture, 0 /* All */, false);
             mol_util_1.ValueCell.updateIfChanged(globalUniforms.uMarkingType, 1 /* Depth */);
             var renderables = group.renderables;
             for (var i = 0, il = renderables.length; i < il; ++i) {
@@ -281,7 +311,7 @@ var Renderer;
             state.disable(gl.BLEND);
             state.enable(gl.DEPTH_TEST);
             state.depthMask(true);
-            updateInternal(group, camera, depthTexture, false, !!depthTexture);
+            updateInternal(group, camera, depthTexture, 0 /* All */, !!depthTexture);
             mol_util_1.ValueCell.updateIfChanged(globalUniforms.uMarkingType, 2 /* Mask */);
             var renderables = group.renderables;
             for (var i = 0, il = renderables.length; i < il; ++i) {
@@ -300,14 +330,14 @@ var Renderer;
             state.disable(gl.BLEND);
             state.enable(gl.DEPTH_TEST);
             state.depthMask(true);
-            updateInternal(group, camera, depthTexture, false, false);
+            updateInternal(group, camera, depthTexture, 1 /* Opaque */, false);
             var renderables = group.renderables;
             for (var i = 0, il = renderables.length; i < il; ++i) {
                 var r = renderables[i];
                 if (r.state.opaque) {
                     renderObject(r, 'colorBlended', 0 /* None */);
                 }
-                else if (((_a = r.values.uDoubleSided) === null || _a === void 0 ? void 0 : _a.ref.value) && ((_b = r.values.dOpaqueBackfaces) === null || _b === void 0 ? void 0 : _b.ref.value)) {
+                else if (((_a = r.values.uDoubleSided) === null || _a === void 0 ? void 0 : _a.ref.value) && ((_b = r.values.dTransparentBackfaces) === null || _b === void 0 ? void 0 : _b.ref.value) === 'opaque') {
                     renderObject(r, 'colorBlended', 2 /* BlendedBack */);
                 }
             }
@@ -315,7 +345,7 @@ var Renderer;
         var renderBlendedTransparent = function (group, camera, depthTexture) {
             var _a, _b;
             state.enable(gl.DEPTH_TEST);
-            updateInternal(group, camera, depthTexture, false, false);
+            updateInternal(group, camera, depthTexture, 2 /* Transparent */, false);
             var renderables = group.renderables;
             if (transparentBackground) {
                 state.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
@@ -334,10 +364,10 @@ var Renderer;
             state.depthMask(false);
             for (var i = 0, il = renderables.length; i < il; ++i) {
                 var r = renderables[i];
-                if (!r.state.opaque && !r.state.writeDepth) {
+                if ((!r.state.opaque && !r.state.writeDepth) || r.values.transparencyAverage.ref.value > 0) {
                     if ((_a = r.values.uDoubleSided) === null || _a === void 0 ? void 0 : _a.ref.value) {
                         // render frontfaces and backfaces separately to avoid artefacts
-                        if (!((_b = r.values.dOpaqueBackfaces) === null || _b === void 0 ? void 0 : _b.ref.value)) {
+                        if (((_b = r.values.dTransparentBackfaces) === null || _b === void 0 ? void 0 : _b.ref.value) !== 'opaque') {
                             renderObject(r, 'colorBlended', 2 /* BlendedBack */);
                         }
                         renderObject(r, 'colorBlended', 1 /* BlendedFront */);
@@ -348,34 +378,14 @@ var Renderer;
                 }
             }
         };
-        var renderBlendedVolumeOpaque = function (group, camera, depthTexture) {
-            var _a;
+        var renderBlendedVolume = function (group, camera, depthTexture) {
             state.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
             state.enable(gl.BLEND);
-            updateInternal(group, camera, depthTexture, false, false);
+            updateInternal(group, camera, depthTexture, 2 /* Transparent */, false);
             var renderables = group.renderables;
             for (var i = 0, il = renderables.length; i < il; ++i) {
                 var r = renderables[i];
-                // TODO: simplify, handle in renderable.state???
-                // uAlpha is updated in "render" so we need to recompute it here
-                var alpha = (0, interpolate_1.clamp)(r.values.alpha.ref.value * r.state.alphaFactor, 0, 1);
-                if (alpha === 1 && r.values.transparencyAverage.ref.value !== 1 && !((_a = r.values.dXrayShaded) === null || _a === void 0 ? void 0 : _a.ref.value)) {
-                    renderObject(r, 'colorBlended', 0 /* None */);
-                }
-            }
-        };
-        var renderBlendedVolumeTransparent = function (group, camera, depthTexture) {
-            var _a;
-            state.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
-            state.enable(gl.BLEND);
-            updateInternal(group, camera, depthTexture, false, false);
-            var renderables = group.renderables;
-            for (var i = 0, il = renderables.length; i < il; ++i) {
-                var r = renderables[i];
-                // TODO: simplify, handle in renderable.state???
-                // uAlpha is updated in "render" so we need to recompute it here
-                var alpha = (0, interpolate_1.clamp)(r.values.alpha.ref.value * r.state.alphaFactor, 0, 1);
-                if (alpha < 1 || r.values.transparencyAverage.ref.value > 0 || ((_a = r.values.dXrayShaded) === null || _a === void 0 ? void 0 : _a.ref.value)) {
+                if (r.values.dGeometryType.ref.value === 'directVolume') {
                     renderObject(r, 'colorBlended', 0 /* None */);
                 }
             }
@@ -385,21 +395,21 @@ var Renderer;
             state.disable(gl.BLEND);
             state.enable(gl.DEPTH_TEST);
             state.depthMask(true);
-            updateInternal(group, camera, depthTexture, false, false);
+            updateInternal(group, camera, depthTexture, 1 /* Opaque */, false);
             var renderables = group.renderables;
             for (var i = 0, il = renderables.length; i < il; ++i) {
                 var r = renderables[i];
                 // TODO: simplify, handle in renderable.state???
                 // uAlpha is updated in "render" so we need to recompute it here
                 var alpha = (0, interpolate_1.clamp)(r.values.alpha.ref.value * r.state.alphaFactor, 0, 1);
-                if ((alpha === 1 && r.values.transparencyAverage.ref.value !== 1 && r.values.dGeometryType.ref.value !== 'directVolume' && ((_a = r.values.dPointStyle) === null || _a === void 0 ? void 0 : _a.ref.value) !== 'fuzzy' && !((_b = r.values.dXrayShaded) === null || _b === void 0 ? void 0 : _b.ref.value)) || ((_c = r.values.dOpaqueBackfaces) === null || _c === void 0 ? void 0 : _c.ref.value)) {
+                if ((alpha === 1 && r.values.transparencyAverage.ref.value !== 1 && r.values.dGeometryType.ref.value !== 'directVolume' && ((_a = r.values.dPointStyle) === null || _a === void 0 ? void 0 : _a.ref.value) !== 'fuzzy' && !((_b = r.values.dXrayShaded) === null || _b === void 0 ? void 0 : _b.ref.value)) || ((_c = r.values.dTransparentBackfaces) === null || _c === void 0 ? void 0 : _c.ref.value) === 'opaque') {
                     renderObject(r, 'colorWboit', 0 /* None */);
                 }
             }
         };
         var renderWboitTransparent = function (group, camera, depthTexture) {
             var _a, _b;
-            updateInternal(group, camera, depthTexture, true, false);
+            updateInternal(group, camera, depthTexture, 2 /* Transparent */, false);
             var renderables = group.renderables;
             for (var i = 0, il = renderables.length; i < il; ++i) {
                 var r = renderables[i];
@@ -428,22 +438,31 @@ var Renderer;
                 }
                 gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
             },
-            clearDepth: function () {
+            clearDepth: function (packed) {
+                if (packed === void 0) { packed = false; }
                 state.enable(gl.SCISSOR_TEST);
-                state.enable(gl.DEPTH_TEST);
-                state.depthMask(true);
-                gl.clear(gl.DEPTH_BUFFER_BIT);
+                if (packed) {
+                    state.colorMask(true, true, true, true);
+                    state.clearColor(1, 1, 1, 1);
+                    gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
+                }
+                else {
+                    state.enable(gl.DEPTH_TEST);
+                    state.depthMask(true);
+                    gl.clear(gl.DEPTH_BUFFER_BIT);
+                }
             },
             update: update,
             renderPick: renderPick,
             renderDepth: renderDepth,
+            renderDepthOpaque: renderDepthOpaque,
+            renderDepthTransparent: renderDepthTransparent,
             renderMarkingDepth: renderMarkingDepth,
             renderMarkingMask: renderMarkingMask,
             renderBlended: renderBlended,
             renderBlendedOpaque: renderBlendedOpaque,
             renderBlendedTransparent: renderBlendedTransparent,
-            renderBlendedVolumeOpaque: renderBlendedVolumeOpaque,
-            renderBlendedVolumeTransparent: renderBlendedVolumeTransparent,
+            renderBlendedVolume: renderBlendedVolume,
             renderWboitOpaque: renderWboitOpaque,
             renderWboitTransparent: renderWboitTransparent,
             setProps: function (props) {

package/lib/commonjs/mol-gl/scene.d.ts

@@ -27,6 +27,7 @@ interface Scene extends Object3D {
     clear: () => void;
     forEach: (callbackFn: (value: GraphicsRenderable, key: GraphicsRenderObject) => void) => void;
     getMarkerAverage: () => number;
+    getOpacityAverage: () => number;
 }
 declare namespace Scene {
     interface Group extends Object3D {

package/lib/commonjs/mol-gl/scene.js

@@ -16,6 +16,7 @@ var array_1 = require("../mol-util/array");
 var boundary_helper_1 = require("../mol-math/geometry/boundary-helper");
 var util_1 = require("../mol-data/util");
 var render_item_1 = require("./webgl/render-item");
+var interpolate_1 = require("../mol-math/interpolate");
 var boundaryHelper = new boundary_helper_1.BoundaryHelper('98');
 function calculateBoundingSphere(renderables, boundingSphere, onlyVisible) {
     boundaryHelper.reset();
@@ -221,14 +222,38 @@ var Scene;
             getMarkerAverage: function () {
                 if (primitives.length === 0 && volumes.length === 0)
                     return 0;
+                var count = 0;
                 var markerAverage = 0;
                 for (var i = 0, il = primitives.length; i < il; ++i) {
+                    if (!primitives[i].state.visible)
+                        continue;
                     markerAverage += primitives[i].values.markerAverage.ref.value;
+                    count += 1;
                 }
                 for (var i = 0, il = volumes.length; i < il; ++i) {
+                    if (!volumes[i].state.visible)
+                        continue;
                     markerAverage += volumes[i].values.markerAverage.ref.value;
+                    count += 1;
                 }
-                return markerAverage / (primitives.length + volumes.length);
+                return count > 0 ? markerAverage / count : 0;
+            },
+            getOpacityAverage: function () {
+                if (primitives.length === 0)
+                    return 0;
+                var count = 0;
+                var opacityAverage = 0;
+                for (var i = 0, il = primitives.length; i < il; ++i) {
+                    var p = primitives[i];
+                    if (!p.state.visible)
+                        continue;
+                    // TODO: simplify, handle in renderable.state???
+                    // uAlpha is updated in "render" so we need to recompute it here
+                    var alpha = (0, interpolate_1.clamp)(p.values.alpha.ref.value * p.state.alphaFactor, 0, 1);
+                    opacityAverage += (1 - p.values.transparencyAverage.ref.value) * alpha;
+                    count += 1;
+                }
+                return count > 0 ? opacityAverage / count : 0;
             },
         };
     }

package/lib/commonjs/mol-gl/shader/chunks/apply-interior-color.glsl.d.ts

@@ -1 +1 @@
-export declare const apply_interior_color = "\nif (interior) {\n    if (uInteriorColorFlag) {\n        gl_FragColor.rgb = uInteriorColor;\n    } else {\n        gl_FragColor.rgb *= 1.0 - uInteriorDarkening;\n    }\n\n    #ifdef dOpaqueBackfaces\n        gl_FragColor.a = 1.0;\n    #endif\n}\n";
+export declare const apply_interior_color = "\nif (interior) {\n    if (uInteriorColorFlag) {\n        gl_FragColor.rgb = uInteriorColor;\n    } else {\n        gl_FragColor.rgb *= 1.0 - uInteriorDarkening;\n    }\n\n    #ifdef dTransparentBackfaces_opaque\n        gl_FragColor.a = 1.0;\n    #endif\n}\n";

package/lib/commonjs/mol-gl/shader/chunks/apply-interior-color.glsl.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.apply_interior_color = void 0;
-exports.apply_interior_color = "\nif (interior) {\n    if (uInteriorColorFlag) {\n        gl_FragColor.rgb = uInteriorColor;\n    } else {\n        gl_FragColor.rgb *= 1.0 - uInteriorDarkening;\n    }\n\n    #ifdef dOpaqueBackfaces\n        gl_FragColor.a = 1.0;\n    #endif\n}\n";
+exports.apply_interior_color = "\nif (interior) {\n    if (uInteriorColorFlag) {\n        gl_FragColor.rgb = uInteriorColor;\n    } else {\n        gl_FragColor.rgb *= 1.0 - uInteriorDarkening;\n    }\n\n    #ifdef dTransparentBackfaces_opaque\n        gl_FragColor.a = 1.0;\n    #endif\n}\n";

package/lib/commonjs/mol-gl/shader/chunks/assign-material-color.glsl.d.ts

@@ -1 +1 @@
-export declare const assign_material_color = "\n#if defined(dRenderVariant_color) || defined(dRenderVariant_marking)\n    float marker = uMarker;\n    if (uMarker == -1.0) {\n        marker = floor(vMarker * 255.0 + 0.5); // rounding required to work on some cards on win\n    }\n#endif\n\n#if defined(dRenderVariant_color)\n    #if defined(dUsePalette)\n        vec4 material = vec4(texture2D(tPalette, vec2(vPaletteV, 0.5)).rgb, uAlpha);\n    #elif defined(dColorType_uniform)\n        vec4 material = vec4(uColor, uAlpha);\n    #elif defined(dColorType_varying)\n        vec4 material = vec4(vColor.rgb, uAlpha);\n    #endif\n\n    // mix material with overpaint\n    #if defined(dOverpaint)\n        material.rgb = mix(material.rgb, vOverpaint.rgb, vOverpaint.a);\n    #endif\n\n    float metalness = uMetalness;\n    float roughness = uRoughness;\n    float bumpiness = uBumpiness;\n    #ifdef dSubstance\n        metalness = mix(metalness, vSubstance.r, vSubstance.a);\n        roughness = mix(roughness, vSubstance.g, vSubstance.a);\n        bumpiness = mix(bumpiness, vSubstance.b, vSubstance.a);\n    #endif\n#elif defined(dRenderVariant_pick)\n    vec4 material = vColor;\n#elif defined(dRenderVariant_depth)\n    #ifdef enabledFragDepth\n        vec4 material = packDepthToRGBA(gl_FragDepthEXT);\n    #else\n        vec4 material = packDepthToRGBA(gl_FragCoord.z);\n    #endif\n#elif defined(dRenderVariant_marking)\n    vec4 material;\n    if(uMarkingType == 1) {\n        if (marker > 0.0)\n            discard;\n        #ifdef enabledFragDepth\n            material = packDepthToRGBA(gl_FragDepthEXT);\n        #else\n            material = packDepthToRGBA(gl_FragCoord.z);\n        #endif\n    } else {\n        if (marker == 0.0)\n            discard;\n        float depthTest = 1.0;\n        if (uMarkingDepthTest) {\n            depthTest = (fragmentDepth >= getDepth(gl_FragCoord.xy / uDrawingBufferSize)) ? 1.0 : 0.0;\n        }\n        bool isHighlight = intMod(marker, 2.0) > 0.1;\n        float viewZ = depthToViewZ(uIsOrtho, fragmentDepth, uNear, uFar);\n        float fogFactor = smoothstep(uFogNear, uFogFar, abs(viewZ));\n        if (fogFactor == 1.0)\n            discard;\n        material = vec4(0.0, depthTest, isHighlight ? 1.0 : 0.0, 1.0 - fogFactor);\n    }\n#endif\n\n// apply screendoor transparency\n#if defined(dTransparency)\n    float ta = 1.0 - vTransparency;\n    #if defined(dRenderVariant_colorWboit)\n        if (vTransparency < 0.2) ta = 1.0; // hard cutoff looks better with wboit\n    #endif\n\n    #if defined(dRenderVariant_pick)\n        if (ta < uPickingAlphaThreshold)\n            discard; // ignore so the element below can be picked\n    #else\n        #if defined(dRenderVariant_colorBlended)\n            float at = 0.0;\n\n            // shift by view-offset during multi-sample rendering to allow for blending\n            vec2 coord = gl_FragCoord.xy + uViewOffset * 0.25;\n\n            const mat4 thresholdMatrix = mat4(\n                1.0 / 17.0,  9.0 / 17.0,  3.0 / 17.0, 11.0 / 17.0,\n                13.0 / 17.0,  5.0 / 17.0, 15.0 / 17.0,  7.0 / 17.0,\n                4.0 / 17.0, 12.0 / 17.0,  2.0 / 17.0, 10.0 / 17.0,\n                16.0 / 17.0,  8.0 / 17.0, 14.0 / 17.0,  6.0 / 17.0\n            );\n            int ci = int(intMod(coord.x, 4.0));\n            int ri = int(intMod(coord.y, 4.0));\n            #if __VERSION__ == 100\n                vec4 i = vec4(float(ci * 4 + ri));\n                vec4 v = thresholdMatrix[0] * vec4(equal(i, vec4(0.0, 1.0, 2.0, 3.0))) +\n                    thresholdMatrix[1] * vec4(equal(i, vec4(4.0, 5.0, 6.0, 7.0))) +\n                    thresholdMatrix[2] * vec4(equal(i, vec4(8.0, 9.0, 10.0, 11.0))) +\n                    thresholdMatrix[3] * vec4(equal(i, vec4(12.0, 13.0, 14.0, 15.0)));\n                at = v.x + v.y + v.z + v.w;\n            #else\n                at = thresholdMatrix[ci][ri];\n            #endif\n\n            if (ta < 0.99 && (ta < 0.01 || ta < at)) {\n                discard;\n            }\n        #elif defined(dRenderVariant_colorWboit)\n            material.a *= ta;\n        #endif\n    #endif\n#endif\n";
+export declare const assign_material_color = "\n#if defined(dRenderVariant_color) || defined(dRenderVariant_marking)\n    float marker = uMarker;\n    if (uMarker == -1.0) {\n        marker = floor(vMarker * 255.0 + 0.5); // rounding required to work on some cards on win\n    }\n#endif\n\n#if defined(dRenderVariant_color)\n    #if defined(dUsePalette)\n        vec4 material = vec4(texture2D(tPalette, vec2(vPaletteV, 0.5)).rgb, uAlpha);\n    #elif defined(dColorType_uniform)\n        vec4 material = vec4(uColor, uAlpha);\n    #elif defined(dColorType_varying)\n        vec4 material = vec4(vColor.rgb, uAlpha);\n    #endif\n\n    // mix material with overpaint\n    #if defined(dOverpaint)\n        material.rgb = mix(material.rgb, vOverpaint.rgb, vOverpaint.a);\n    #endif\n\n    float metalness = uMetalness;\n    float roughness = uRoughness;\n    float bumpiness = uBumpiness;\n    #ifdef dSubstance\n        metalness = mix(metalness, vSubstance.r, vSubstance.a);\n        roughness = mix(roughness, vSubstance.g, vSubstance.a);\n        bumpiness = mix(bumpiness, vSubstance.b, vSubstance.a);\n    #endif\n#elif defined(dRenderVariant_pick)\n    vec4 material = vColor;\n#elif defined(dRenderVariant_depth)\n    if (fragmentDepth > getDepth(gl_FragCoord.xy / uDrawingBufferSize)) {\n        discard;\n    }\n\n    #ifndef dXrayShaded\n        #if defined(dTransparency)\n            float dta = 1.0 - vTransparency;\n            if (vTransparency < 0.2) dta = 1.0; // hard cutoff looks better\n\n            if (uRenderMask == MaskTransparent && uAlpha * dta == 1.0) {\n                discard;\n            } else if (uRenderMask == MaskOpaque && uAlpha * dta < 1.0) {\n                discard;\n            }\n        #else\n            if (uRenderMask == MaskTransparent && uAlpha == 1.0) {\n                discard;\n            } else if (uRenderMask == MaskOpaque && uAlpha < 1.0) {\n                discard;\n            }\n        #endif\n    #else\n        if (uRenderMask == MaskOpaque) {\n            discard;\n        }\n    #endif\n\n    vec4 material = packDepthToRGBA(fragmentDepth);\n#elif defined(dRenderVariant_marking)\n    vec4 material;\n    if(uMarkingType == 1) {\n        if (marker > 0.0)\n            discard;\n        #ifdef enabledFragDepth\n            material = packDepthToRGBA(gl_FragDepthEXT);\n        #else\n            material = packDepthToRGBA(gl_FragCoord.z);\n        #endif\n    } else {\n        if (marker == 0.0)\n            discard;\n        float depthTest = 1.0;\n        if (uMarkingDepthTest) {\n            depthTest = (fragmentDepth >= getDepthPacked(gl_FragCoord.xy / uDrawingBufferSize)) ? 1.0 : 0.0;\n        }\n        bool isHighlight = intMod(marker, 2.0) > 0.1;\n        float viewZ = depthToViewZ(uIsOrtho, fragmentDepth, uNear, uFar);\n        float fogFactor = smoothstep(uFogNear, uFogFar, abs(viewZ));\n        if (fogFactor == 1.0)\n            discard;\n        material = vec4(0.0, depthTest, isHighlight ? 1.0 : 0.0, 1.0 - fogFactor);\n    }\n#endif\n\n// apply per-group transparency\n#if defined(dTransparency) && (defined(dRenderVariant_pick) || defined(dRenderVariant_color))\n    float ta = 1.0 - vTransparency;\n    if (vTransparency < 0.2) ta = 1.0; // hard cutoff looks better\n\n    #if defined(dRenderVariant_pick)\n        if (ta < uPickingAlphaThreshold)\n            discard; // ignore so the element below can be picked\n    #elif defined(dRenderVariant_color)\n        material.a *= ta;\n\n        #if defined(dRenderVariant_colorBlended)\n            #if defined(dTransparentBackfaces_off)\n                if ((uRenderMask == MaskOpaque && material.a < 1.0) ||\n                    (uRenderMask == MaskTransparent && material.a == 1.0) ||\n                    (interior && material.a < 1.0)\n                ) {\n                    discard;\n                }\n            #elif defined(dTransparentBackfaces_on)\n                if ((uRenderMask == MaskOpaque && material.a < 1.0) ||\n                    (uRenderMask == MaskTransparent && material.a == 1.0)\n                ) {\n                    discard;\n                }\n            #elif defined(dTransparentBackfaces_opaque)\n                if (interior) {\n                    material.a = 1.0;\n                } else if (\n                    (uRenderMask == MaskOpaque && material.a < 1.0) ||\n                    (uRenderMask == MaskTransparent && material.a == 1.0)\n                ) {\n                    discard;\n                }\n            #endif\n        #endif\n    #endif\n#endif\n";

package/lib/commonjs/mol-gl/shader/chunks/assign-material-color.glsl.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assign_material_color = void 0;
-exports.assign_material_color = "\n#if defined(dRenderVariant_color) || defined(dRenderVariant_marking)\n    float marker = uMarker;\n    if (uMarker == -1.0) {\n        marker = floor(vMarker * 255.0 + 0.5); // rounding required to work on some cards on win\n    }\n#endif\n\n#if defined(dRenderVariant_color)\n    #if defined(dUsePalette)\n        vec4 material = vec4(texture2D(tPalette, vec2(vPaletteV, 0.5)).rgb, uAlpha);\n    #elif defined(dColorType_uniform)\n        vec4 material = vec4(uColor, uAlpha);\n    #elif defined(dColorType_varying)\n        vec4 material = vec4(vColor.rgb, uAlpha);\n    #endif\n\n    // mix material with overpaint\n    #if defined(dOverpaint)\n        material.rgb = mix(material.rgb, vOverpaint.rgb, vOverpaint.a);\n    #endif\n\n    float metalness = uMetalness;\n    float roughness = uRoughness;\n    float bumpiness = uBumpiness;\n    #ifdef dSubstance\n        metalness = mix(metalness, vSubstance.r, vSubstance.a);\n        roughness = mix(roughness, vSubstance.g, vSubstance.a);\n        bumpiness = mix(bumpiness, vSubstance.b, vSubstance.a);\n    #endif\n#elif defined(dRenderVariant_pick)\n    vec4 material = vColor;\n#elif defined(dRenderVariant_depth)\n    #ifdef enabledFragDepth\n        vec4 material = packDepthToRGBA(gl_FragDepthEXT);\n    #else\n        vec4 material = packDepthToRGBA(gl_FragCoord.z);\n    #endif\n#elif defined(dRenderVariant_marking)\n    vec4 material;\n    if(uMarkingType == 1) {\n        if (marker > 0.0)\n            discard;\n        #ifdef enabledFragDepth\n            material = packDepthToRGBA(gl_FragDepthEXT);\n        #else\n            material = packDepthToRGBA(gl_FragCoord.z);\n        #endif\n    } else {\n        if (marker == 0.0)\n            discard;\n        float depthTest = 1.0;\n        if (uMarkingDepthTest) {\n            depthTest = (fragmentDepth >= getDepth(gl_FragCoord.xy / uDrawingBufferSize)) ? 1.0 : 0.0;\n        }\n        bool isHighlight = intMod(marker, 2.0) > 0.1;\n        float viewZ = depthToViewZ(uIsOrtho, fragmentDepth, uNear, uFar);\n        float fogFactor = smoothstep(uFogNear, uFogFar, abs(viewZ));\n        if (fogFactor == 1.0)\n            discard;\n        material = vec4(0.0, depthTest, isHighlight ? 1.0 : 0.0, 1.0 - fogFactor);\n    }\n#endif\n\n// apply screendoor transparency\n#if defined(dTransparency)\n    float ta = 1.0 - vTransparency;\n    #if defined(dRenderVariant_colorWboit)\n        if (vTransparency < 0.2) ta = 1.0; // hard cutoff looks better with wboit\n    #endif\n\n    #if defined(dRenderVariant_pick)\n        if (ta < uPickingAlphaThreshold)\n            discard; // ignore so the element below can be picked\n    #else\n        #if defined(dRenderVariant_colorBlended)\n            float at = 0.0;\n\n            // shift by view-offset during multi-sample rendering to allow for blending\n            vec2 coord = gl_FragCoord.xy + uViewOffset * 0.25;\n\n            const mat4 thresholdMatrix = mat4(\n                1.0 / 17.0,  9.0 / 17.0,  3.0 / 17.0, 11.0 / 17.0,\n                13.0 / 17.0,  5.0 / 17.0, 15.0 / 17.0,  7.0 / 17.0,\n                4.0 / 17.0, 12.0 / 17.0,  2.0 / 17.0, 10.0 / 17.0,\n                16.0 / 17.0,  8.0 / 17.0, 14.0 / 17.0,  6.0 / 17.0\n            );\n            int ci = int(intMod(coord.x, 4.0));\n            int ri = int(intMod(coord.y, 4.0));\n            #if __VERSION__ == 100\n                vec4 i = vec4(float(ci * 4 + ri));\n                vec4 v = thresholdMatrix[0] * vec4(equal(i, vec4(0.0, 1.0, 2.0, 3.0))) +\n                    thresholdMatrix[1] * vec4(equal(i, vec4(4.0, 5.0, 6.0, 7.0))) +\n                    thresholdMatrix[2] * vec4(equal(i, vec4(8.0, 9.0, 10.0, 11.0))) +\n                    thresholdMatrix[3] * vec4(equal(i, vec4(12.0, 13.0, 14.0, 15.0)));\n                at = v.x + v.y + v.z + v.w;\n            #else\n                at = thresholdMatrix[ci][ri];\n            #endif\n\n            if (ta < 0.99 && (ta < 0.01 || ta < at)) {\n                discard;\n            }\n        #elif defined(dRenderVariant_colorWboit)\n            material.a *= ta;\n        #endif\n    #endif\n#endif\n";
+exports.assign_material_color = "\n#if defined(dRenderVariant_color) || defined(dRenderVariant_marking)\n    float marker = uMarker;\n    if (uMarker == -1.0) {\n        marker = floor(vMarker * 255.0 + 0.5); // rounding required to work on some cards on win\n    }\n#endif\n\n#if defined(dRenderVariant_color)\n    #if defined(dUsePalette)\n        vec4 material = vec4(texture2D(tPalette, vec2(vPaletteV, 0.5)).rgb, uAlpha);\n    #elif defined(dColorType_uniform)\n        vec4 material = vec4(uColor, uAlpha);\n    #elif defined(dColorType_varying)\n        vec4 material = vec4(vColor.rgb, uAlpha);\n    #endif\n\n    // mix material with overpaint\n    #if defined(dOverpaint)\n        material.rgb = mix(material.rgb, vOverpaint.rgb, vOverpaint.a);\n    #endif\n\n    float metalness = uMetalness;\n    float roughness = uRoughness;\n    float bumpiness = uBumpiness;\n    #ifdef dSubstance\n        metalness = mix(metalness, vSubstance.r, vSubstance.a);\n        roughness = mix(roughness, vSubstance.g, vSubstance.a);\n        bumpiness = mix(bumpiness, vSubstance.b, vSubstance.a);\n    #endif\n#elif defined(dRenderVariant_pick)\n    vec4 material = vColor;\n#elif defined(dRenderVariant_depth)\n    if (fragmentDepth > getDepth(gl_FragCoord.xy / uDrawingBufferSize)) {\n        discard;\n    }\n\n    #ifndef dXrayShaded\n        #if defined(dTransparency)\n            float dta = 1.0 - vTransparency;\n            if (vTransparency < 0.2) dta = 1.0; // hard cutoff looks better\n\n            if (uRenderMask == MaskTransparent && uAlpha * dta == 1.0) {\n                discard;\n            } else if (uRenderMask == MaskOpaque && uAlpha * dta < 1.0) {\n                discard;\n            }\n        #else\n            if (uRenderMask == MaskTransparent && uAlpha == 1.0) {\n                discard;\n            } else if (uRenderMask == MaskOpaque && uAlpha < 1.0) {\n                discard;\n            }\n        #endif\n    #else\n        if (uRenderMask == MaskOpaque) {\n            discard;\n        }\n    #endif\n\n    vec4 material = packDepthToRGBA(fragmentDepth);\n#elif defined(dRenderVariant_marking)\n    vec4 material;\n    if(uMarkingType == 1) {\n        if (marker > 0.0)\n            discard;\n        #ifdef enabledFragDepth\n            material = packDepthToRGBA(gl_FragDepthEXT);\n        #else\n            material = packDepthToRGBA(gl_FragCoord.z);\n        #endif\n    } else {\n        if (marker == 0.0)\n            discard;\n        float depthTest = 1.0;\n        if (uMarkingDepthTest) {\n            depthTest = (fragmentDepth >= getDepthPacked(gl_FragCoord.xy / uDrawingBufferSize)) ? 1.0 : 0.0;\n        }\n        bool isHighlight = intMod(marker, 2.0) > 0.1;\n        float viewZ = depthToViewZ(uIsOrtho, fragmentDepth, uNear, uFar);\n        float fogFactor = smoothstep(uFogNear, uFogFar, abs(viewZ));\n        if (fogFactor == 1.0)\n            discard;\n        material = vec4(0.0, depthTest, isHighlight ? 1.0 : 0.0, 1.0 - fogFactor);\n    }\n#endif\n\n// apply per-group transparency\n#if defined(dTransparency) && (defined(dRenderVariant_pick) || defined(dRenderVariant_color))\n    float ta = 1.0 - vTransparency;\n    if (vTransparency < 0.2) ta = 1.0; // hard cutoff looks better\n\n    #if defined(dRenderVariant_pick)\n        if (ta < uPickingAlphaThreshold)\n            discard; // ignore so the element below can be picked\n    #elif defined(dRenderVariant_color)\n        material.a *= ta;\n\n        #if defined(dRenderVariant_colorBlended)\n            #if defined(dTransparentBackfaces_off)\n                if ((uRenderMask == MaskOpaque && material.a < 1.0) ||\n                    (uRenderMask == MaskTransparent && material.a == 1.0) ||\n                    (interior && material.a < 1.0)\n                ) {\n                    discard;\n                }\n            #elif defined(dTransparentBackfaces_on)\n                if ((uRenderMask == MaskOpaque && material.a < 1.0) ||\n                    (uRenderMask == MaskTransparent && material.a == 1.0)\n                ) {\n                    discard;\n                }\n            #elif defined(dTransparentBackfaces_opaque)\n                if (interior) {\n                    material.a = 1.0;\n                } else if (\n                    (uRenderMask == MaskOpaque && material.a < 1.0) ||\n                    (uRenderMask == MaskTransparent && material.a == 1.0)\n                ) {\n                    discard;\n                }\n            #endif\n        #endif\n    #endif\n#endif\n";

package/lib/commonjs/mol-gl/shader/chunks/check-picking-alpha.glsl.d.ts

@@ -1 +1 @@
-export declare const check_picking_alpha = "\nfloat viewZ = depthToViewZ(uIsOrtho, fragmentDepth, uNear, uFar);\nfloat fogFactor = smoothstep(uFogNear, uFogFar, abs(viewZ));\nfloat alpha = (1.0 - fogFactor) * uAlpha;\n// if not opaque enough ignore so the element below can be picked\nif (uAlpha < uPickingAlphaThreshold || alpha < 0.1) {\n    #ifdef dOpaqueBackfaces\n        if (!interior) discard;\n    #else\n        discard;\n    #endif\n}\n";
+export declare const check_picking_alpha = "\nfloat viewZ = depthToViewZ(uIsOrtho, fragmentDepth, uNear, uFar);\nfloat fogFactor = smoothstep(uFogNear, uFogFar, abs(viewZ));\nfloat alpha = (1.0 - fogFactor) * uAlpha;\n// if not opaque enough ignore so the element below can be picked\nif (uAlpha < uPickingAlphaThreshold || alpha < 0.1) {\n    #ifdef dTransparentBackfaces_opaque\n        if (!interior) discard;\n    #else\n        discard;\n    #endif\n}\n";

package/lib/commonjs/mol-gl/shader/chunks/check-picking-alpha.glsl.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.check_picking_alpha = void 0;
-exports.check_picking_alpha = "\nfloat viewZ = depthToViewZ(uIsOrtho, fragmentDepth, uNear, uFar);\nfloat fogFactor = smoothstep(uFogNear, uFogFar, abs(viewZ));\nfloat alpha = (1.0 - fogFactor) * uAlpha;\n// if not opaque enough ignore so the element below can be picked\nif (uAlpha < uPickingAlphaThreshold || alpha < 0.1) {\n    #ifdef dOpaqueBackfaces\n        if (!interior) discard;\n    #else\n        discard;\n    #endif\n}\n";
+exports.check_picking_alpha = "\nfloat viewZ = depthToViewZ(uIsOrtho, fragmentDepth, uNear, uFar);\nfloat fogFactor = smoothstep(uFogNear, uFogFar, abs(viewZ));\nfloat alpha = (1.0 - fogFactor) * uAlpha;\n// if not opaque enough ignore so the element below can be picked\nif (uAlpha < uPickingAlphaThreshold || alpha < 0.1) {\n    #ifdef dTransparentBackfaces_opaque\n        if (!interior) discard;\n    #else\n        discard;\n    #endif\n}\n";

package/lib/commonjs/mol-gl/shader/chunks/common-frag-params.glsl.d.ts

@@ -1 +1 @@
-export declare const common_frag_params = "\nuniform int uObjectId;\nuniform int uInstanceCount;\nuniform int uGroupCount;\n\nuniform int uPickType;\nuniform int uMarkingType;\n\n#if dClipObjectCount != 0\n    uniform int uClipObjectType[dClipObjectCount];\n    uniform bool uClipObjectInvert[dClipObjectCount];\n    uniform vec3 uClipObjectPosition[dClipObjectCount];\n    uniform vec4 uClipObjectRotation[dClipObjectCount];\n    uniform vec3 uClipObjectScale[dClipObjectCount];\n\n    #if defined(dClipping)\n        #if __VERSION__ == 100\n            varying float vClipping;\n        #else\n            flat in float vClipping;\n        #endif\n    #endif\n#endif\n\nuniform vec3 uHighlightColor;\nuniform vec3 uSelectColor;\nuniform float uHighlightStrength;\nuniform float uSelectStrength;\nuniform int uMarkerPriority;\n\n#if defined(dRenderVariant_color) || defined(dRenderVariant_marking)\n    uniform float uMarker;\n    #if __VERSION__ == 100\n        varying float vMarker;\n    #else\n        flat in float vMarker;\n    #endif\n#endif\n\nvarying vec3 vModelPosition;\nvarying vec3 vViewPosition;\n\nuniform vec2 uViewOffset;\n\nuniform float uNear;\nuniform float uFar;\nuniform float uIsOrtho;\n\nuniform float uFogNear;\nuniform float uFogFar;\nuniform vec3 uFogColor;\n\nuniform float uAlpha;\nuniform float uPickingAlphaThreshold;\nuniform bool uTransparentBackground;\n\nuniform bool uDoubleSided;\nuniform float uInteriorDarkening;\nuniform bool uInteriorColorFlag;\nuniform vec3 uInteriorColor;\nbool interior;\n\nuniform float uXrayEdgeFalloff;\n\nuniform mat4 uProjection;\n\nuniform bool uRenderWboit;\nuniform bool uMarkingDepthTest;\n\nuniform sampler2D tDepth;\nuniform vec2 uDrawingBufferSize;\n\nfloat getDepth(const in vec2 coords) {\n    // always packed due to merged depth from primitives and volumes\n    return unpackRGBAToDepth(texture2D(tDepth, coords));\n}\n\nfloat calcDepth(const in vec3 pos) {\n    vec2 clipZW = pos.z * uProjection[2].zw + uProjection[3].zw;\n    return 0.5 + 0.5 * clipZW.x / clipZW.y;\n}\n\n// \"Bump Mapping Unparametrized Surfaces on the GPU\" Morten S. Mikkelsen\n// https://mmikk.github.io/papers3d/mm_sfgrad_bump.pdf\nvec3 perturbNormal(in vec3 position, in vec3 normal, in float height, in float scale) {\n    vec3 sigmaS = dFdx(position);\n    vec3 sigmaT = dFdy(position);\n\n    vec3 r1 = cross(sigmaT, normal);\n    vec3 r2 = cross(normal, sigmaS);\n    float det = dot(sigmaS, r1);\n\n    float bs = dFdx(height);\n    float bt = dFdy(height);\n\n    vec3 surfGrad = sign(det) * (bs * r1 + bt * r2);\n    return normalize(abs(det) * normal - scale * surfGrad);\n}\n\nfloat hash(in float h) {\n    return fract(sin(h) * 43758.5453123);\n}\n\nfloat noise(in vec3 x) {\n    vec3 p = floor(x);\n    vec3 f = fract(x);\n    f = f * f * (3.0 - 2.0 * f);\n\n    float n = p.x + p.y * 157.0 + 113.0 * p.z;\n    return mix(\n        mix(mix(hash(n + 0.0), hash(n + 1.0), f.x),\n            mix(hash(n + 157.0), hash(n + 158.0), f.x), f.y),\n        mix(mix(hash(n + 113.0), hash(n + 114.0), f.x),\n            mix(hash(n + 270.0), hash(n + 271.0), f.x), f.y), f.z);\n}\n\nfloat fbm(in vec3 p) {\n    float f = 0.0;\n    f += 0.5 * noise(p);\n    p *= 2.01;\n    f += 0.25 * noise(p);\n    p *= 2.02;\n    f += 0.125 * noise(p);\n\n    return f;\n}\n";
+export declare const common_frag_params = "\nuniform int uObjectId;\nuniform int uInstanceCount;\nuniform int uGroupCount;\n\nuniform int uPickType;\nuniform int uMarkingType;\n\n#if dClipObjectCount != 0\n    uniform int uClipObjectType[dClipObjectCount];\n    uniform bool uClipObjectInvert[dClipObjectCount];\n    uniform vec3 uClipObjectPosition[dClipObjectCount];\n    uniform vec4 uClipObjectRotation[dClipObjectCount];\n    uniform vec3 uClipObjectScale[dClipObjectCount];\n\n    #if defined(dClipping)\n        #if __VERSION__ == 100\n            varying float vClipping;\n        #else\n            flat in float vClipping;\n        #endif\n    #endif\n#endif\n\nuniform vec3 uHighlightColor;\nuniform vec3 uSelectColor;\nuniform float uHighlightStrength;\nuniform float uSelectStrength;\nuniform int uMarkerPriority;\n\n#if defined(dRenderVariant_color) || defined(dRenderVariant_marking)\n    uniform float uMarker;\n    #if __VERSION__ == 100\n        varying float vMarker;\n    #else\n        flat in float vMarker;\n    #endif\n#endif\n\nvarying vec3 vModelPosition;\nvarying vec3 vViewPosition;\n\nuniform vec2 uViewOffset;\n\nuniform float uNear;\nuniform float uFar;\nuniform float uIsOrtho;\n\nuniform float uFogNear;\nuniform float uFogFar;\nuniform vec3 uFogColor;\n\nuniform float uAlpha;\nuniform float uPickingAlphaThreshold;\nuniform bool uTransparentBackground;\n\nuniform bool uDoubleSided;\nuniform float uInteriorDarkening;\nuniform bool uInteriorColorFlag;\nuniform vec3 uInteriorColor;\nbool interior;\n\nuniform float uXrayEdgeFalloff;\n\nuniform mat4 uProjection;\n\nuniform int uRenderMask;\nuniform bool uMarkingDepthTest;\n\nuniform sampler2D tDepth;\nuniform vec2 uDrawingBufferSize;\n\nfloat getDepthPacked(const in vec2 coords) {\n    return unpackRGBAToDepth(texture2D(tDepth, coords));\n}\n\nfloat getDepth(const in vec2 coords) {\n    #ifdef depthTextureSupport\n        return texture2D(tDepth, coords).r;\n    #else\n        return unpackRGBAToDepth(texture2D(tDepth, coords));\n    #endif\n}\n\nfloat calcDepth(const in vec3 pos) {\n    vec2 clipZW = pos.z * uProjection[2].zw + uProjection[3].zw;\n    return 0.5 + 0.5 * clipZW.x / clipZW.y;\n}\n\n// \"Bump Mapping Unparametrized Surfaces on the GPU\" Morten S. Mikkelsen\n// https://mmikk.github.io/papers3d/mm_sfgrad_bump.pdf\nvec3 perturbNormal(in vec3 position, in vec3 normal, in float height, in float scale) {\n    vec3 sigmaS = dFdx(position);\n    vec3 sigmaT = dFdy(position);\n\n    vec3 r1 = cross(sigmaT, normal);\n    vec3 r2 = cross(normal, sigmaS);\n    float det = dot(sigmaS, r1);\n\n    float bs = dFdx(height);\n    float bt = dFdy(height);\n\n    vec3 surfGrad = sign(det) * (bs * r1 + bt * r2);\n    return normalize(abs(det) * normal - scale * surfGrad);\n}\n\nfloat hash(in float h) {\n    return fract(sin(h) * 43758.5453123);\n}\n\nfloat noise(in vec3 x) {\n    vec3 p = floor(x);\n    vec3 f = fract(x);\n    f = f * f * (3.0 - 2.0 * f);\n\n    float n = p.x + p.y * 157.0 + 113.0 * p.z;\n    return mix(\n        mix(mix(hash(n + 0.0), hash(n + 1.0), f.x),\n            mix(hash(n + 157.0), hash(n + 158.0), f.x), f.y),\n        mix(mix(hash(n + 113.0), hash(n + 114.0), f.x),\n            mix(hash(n + 270.0), hash(n + 271.0), f.x), f.y), f.z);\n}\n\nfloat fbm(in vec3 p) {\n    float f = 0.0;\n    f += 0.5 * noise(p);\n    p *= 2.01;\n    f += 0.25 * noise(p);\n    p *= 2.02;\n    f += 0.125 * noise(p);\n\n    return f;\n}\n";

package/lib/commonjs/mol-gl/shader/chunks/common-frag-params.glsl.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.common_frag_params = void 0;
-exports.common_frag_params = "\nuniform int uObjectId;\nuniform int uInstanceCount;\nuniform int uGroupCount;\n\nuniform int uPickType;\nuniform int uMarkingType;\n\n#if dClipObjectCount != 0\n    uniform int uClipObjectType[dClipObjectCount];\n    uniform bool uClipObjectInvert[dClipObjectCount];\n    uniform vec3 uClipObjectPosition[dClipObjectCount];\n    uniform vec4 uClipObjectRotation[dClipObjectCount];\n    uniform vec3 uClipObjectScale[dClipObjectCount];\n\n    #if defined(dClipping)\n        #if __VERSION__ == 100\n            varying float vClipping;\n        #else\n            flat in float vClipping;\n        #endif\n    #endif\n#endif\n\nuniform vec3 uHighlightColor;\nuniform vec3 uSelectColor;\nuniform float uHighlightStrength;\nuniform float uSelectStrength;\nuniform int uMarkerPriority;\n\n#if defined(dRenderVariant_color) || defined(dRenderVariant_marking)\n    uniform float uMarker;\n    #if __VERSION__ == 100\n        varying float vMarker;\n    #else\n        flat in float vMarker;\n    #endif\n#endif\n\nvarying vec3 vModelPosition;\nvarying vec3 vViewPosition;\n\nuniform vec2 uViewOffset;\n\nuniform float uNear;\nuniform float uFar;\nuniform float uIsOrtho;\n\nuniform float uFogNear;\nuniform float uFogFar;\nuniform vec3 uFogColor;\n\nuniform float uAlpha;\nuniform float uPickingAlphaThreshold;\nuniform bool uTransparentBackground;\n\nuniform bool uDoubleSided;\nuniform float uInteriorDarkening;\nuniform bool uInteriorColorFlag;\nuniform vec3 uInteriorColor;\nbool interior;\n\nuniform float uXrayEdgeFalloff;\n\nuniform mat4 uProjection;\n\nuniform bool uRenderWboit;\nuniform bool uMarkingDepthTest;\n\nuniform sampler2D tDepth;\nuniform vec2 uDrawingBufferSize;\n\nfloat getDepth(const in vec2 coords) {\n    // always packed due to merged depth from primitives and volumes\n    return unpackRGBAToDepth(texture2D(tDepth, coords));\n}\n\nfloat calcDepth(const in vec3 pos) {\n    vec2 clipZW = pos.z * uProjection[2].zw + uProjection[3].zw;\n    return 0.5 + 0.5 * clipZW.x / clipZW.y;\n}\n\n// \"Bump Mapping Unparametrized Surfaces on the GPU\" Morten S. Mikkelsen\n// https://mmikk.github.io/papers3d/mm_sfgrad_bump.pdf\nvec3 perturbNormal(in vec3 position, in vec3 normal, in float height, in float scale) {\n    vec3 sigmaS = dFdx(position);\n    vec3 sigmaT = dFdy(position);\n\n    vec3 r1 = cross(sigmaT, normal);\n    vec3 r2 = cross(normal, sigmaS);\n    float det = dot(sigmaS, r1);\n\n    float bs = dFdx(height);\n    float bt = dFdy(height);\n\n    vec3 surfGrad = sign(det) * (bs * r1 + bt * r2);\n    return normalize(abs(det) * normal - scale * surfGrad);\n}\n\nfloat hash(in float h) {\n    return fract(sin(h) * 43758.5453123);\n}\n\nfloat noise(in vec3 x) {\n    vec3 p = floor(x);\n    vec3 f = fract(x);\n    f = f * f * (3.0 - 2.0 * f);\n\n    float n = p.x + p.y * 157.0 + 113.0 * p.z;\n    return mix(\n        mix(mix(hash(n + 0.0), hash(n + 1.0), f.x),\n            mix(hash(n + 157.0), hash(n + 158.0), f.x), f.y),\n        mix(mix(hash(n + 113.0), hash(n + 114.0), f.x),\n            mix(hash(n + 270.0), hash(n + 271.0), f.x), f.y), f.z);\n}\n\nfloat fbm(in vec3 p) {\n    float f = 0.0;\n    f += 0.5 * noise(p);\n    p *= 2.01;\n    f += 0.25 * noise(p);\n    p *= 2.02;\n    f += 0.125 * noise(p);\n\n    return f;\n}\n";
+exports.common_frag_params = "\nuniform int uObjectId;\nuniform int uInstanceCount;\nuniform int uGroupCount;\n\nuniform int uPickType;\nuniform int uMarkingType;\n\n#if dClipObjectCount != 0\n    uniform int uClipObjectType[dClipObjectCount];\n    uniform bool uClipObjectInvert[dClipObjectCount];\n    uniform vec3 uClipObjectPosition[dClipObjectCount];\n    uniform vec4 uClipObjectRotation[dClipObjectCount];\n    uniform vec3 uClipObjectScale[dClipObjectCount];\n\n    #if defined(dClipping)\n        #if __VERSION__ == 100\n            varying float vClipping;\n        #else\n            flat in float vClipping;\n        #endif\n    #endif\n#endif\n\nuniform vec3 uHighlightColor;\nuniform vec3 uSelectColor;\nuniform float uHighlightStrength;\nuniform float uSelectStrength;\nuniform int uMarkerPriority;\n\n#if defined(dRenderVariant_color) || defined(dRenderVariant_marking)\n    uniform float uMarker;\n    #if __VERSION__ == 100\n        varying float vMarker;\n    #else\n        flat in float vMarker;\n    #endif\n#endif\n\nvarying vec3 vModelPosition;\nvarying vec3 vViewPosition;\n\nuniform vec2 uViewOffset;\n\nuniform float uNear;\nuniform float uFar;\nuniform float uIsOrtho;\n\nuniform float uFogNear;\nuniform float uFogFar;\nuniform vec3 uFogColor;\n\nuniform float uAlpha;\nuniform float uPickingAlphaThreshold;\nuniform bool uTransparentBackground;\n\nuniform bool uDoubleSided;\nuniform float uInteriorDarkening;\nuniform bool uInteriorColorFlag;\nuniform vec3 uInteriorColor;\nbool interior;\n\nuniform float uXrayEdgeFalloff;\n\nuniform mat4 uProjection;\n\nuniform int uRenderMask;\nuniform bool uMarkingDepthTest;\n\nuniform sampler2D tDepth;\nuniform vec2 uDrawingBufferSize;\n\nfloat getDepthPacked(const in vec2 coords) {\n    return unpackRGBAToDepth(texture2D(tDepth, coords));\n}\n\nfloat getDepth(const in vec2 coords) {\n    #ifdef depthTextureSupport\n        return texture2D(tDepth, coords).r;\n    #else\n        return unpackRGBAToDepth(texture2D(tDepth, coords));\n    #endif\n}\n\nfloat calcDepth(const in vec3 pos) {\n    vec2 clipZW = pos.z * uProjection[2].zw + uProjection[3].zw;\n    return 0.5 + 0.5 * clipZW.x / clipZW.y;\n}\n\n// \"Bump Mapping Unparametrized Surfaces on the GPU\" Morten S. Mikkelsen\n// https://mmikk.github.io/papers3d/mm_sfgrad_bump.pdf\nvec3 perturbNormal(in vec3 position, in vec3 normal, in float height, in float scale) {\n    vec3 sigmaS = dFdx(position);\n    vec3 sigmaT = dFdy(position);\n\n    vec3 r1 = cross(sigmaT, normal);\n    vec3 r2 = cross(normal, sigmaS);\n    float det = dot(sigmaS, r1);\n\n    float bs = dFdx(height);\n    float bt = dFdy(height);\n\n    vec3 surfGrad = sign(det) * (bs * r1 + bt * r2);\n    return normalize(abs(det) * normal - scale * surfGrad);\n}\n\nfloat hash(in float h) {\n    return fract(sin(h) * 43758.5453123);\n}\n\nfloat noise(in vec3 x) {\n    vec3 p = floor(x);\n    vec3 f = fract(x);\n    f = f * f * (3.0 - 2.0 * f);\n\n    float n = p.x + p.y * 157.0 + 113.0 * p.z;\n    return mix(\n        mix(mix(hash(n + 0.0), hash(n + 1.0), f.x),\n            mix(hash(n + 157.0), hash(n + 158.0), f.x), f.y),\n        mix(mix(hash(n + 113.0), hash(n + 114.0), f.x),\n            mix(hash(n + 270.0), hash(n + 271.0), f.x), f.y), f.z);\n}\n\nfloat fbm(in vec3 p) {\n    float f = 0.0;\n    f += 0.5 * noise(p);\n    p *= 2.01;\n    f += 0.25 * noise(p);\n    p *= 2.02;\n    f += 0.125 * noise(p);\n\n    return f;\n}\n";

package/lib/commonjs/mol-gl/shader/chunks/common.glsl.d.ts

@@ -1 +1 @@
-export declare const common = "\n// TODO find a better place for these convenience defines\n\n#if defined(dRenderVariant_colorBlended) || defined(dRenderVariant_colorWboit)\n    #define dRenderVariant_color\n#endif\n\n#if defined(dColorType_instance) || defined(dColorType_group) || defined(dColorType_groupInstance) || defined(dColorType_vertex) || defined(dColorType_vertexInstance)\n    #define dColorType_texture\n#endif\n\n#if defined(dColorType_volume) || defined(dColorType_volumeInstance)\n    #define dColorType_grid\n#endif\n\n#if defined(dColorType_attribute) || defined(dColorType_texture) || defined(dColorType_grid)\n    #define dColorType_varying\n#endif\n\n//\n\n#define PI 3.14159265\n#define RECIPROCAL_PI 0.31830988618\n#define EPSILON 1e-6\n\n#define saturate(a) clamp(a, 0.0, 1.0)\n\n#if __VERSION__ == 100\n    #define round(x) floor((x) + 0.5)\n#endif\n\nfloat intDiv(const in float a, const in float b) { return float(int(a) / int(b)); }\nvec2 ivec2Div(const in vec2 a, const in vec2 b) { return vec2(ivec2(a) / ivec2(b)); }\nfloat intMod(const in float a, const in float b) { return a - b * float(int(a) / int(b)); }\nint imod(const in int a, const in int b) { return a - b * (a / b); }\n\nfloat pow2(const in float x) { return x * x; }\n\nvec3 packIntToRGB(in float value) {\n    value = clamp(round(value), 0.0, 16777216.0 - 1.0) + 1.0;\n    vec3 c = vec3(0.0);\n    c.b = mod(value, 256.0);\n    value = floor(value / 256.0);\n    c.g = mod(value, 256.0);\n    value = floor(value / 256.0);\n    c.r = mod(value, 256.0);\n    return c / 255.0;\n}\nfloat unpackRGBToInt(const in vec3 rgb) {\n    return (floor(rgb.r * 255.0 + 0.5) * 256.0 * 256.0 + floor(rgb.g * 255.0 + 0.5) * 256.0 + floor(rgb.b * 255.0 + 0.5)) - 1.0;\n}\n\nvec2 packUnitIntervalToRG(const in float v) {\n    vec2 enc;\n    enc.xy = vec2(fract(v * 256.0), v);\n    enc.y -= enc.x * (1.0 / 256.0);\n    enc.xy *=  256.0 / 255.0;\n\n    return enc;\n}\n\nfloat unpackRGToUnitInterval(const in vec2 enc) {\n    return dot(enc, vec2(255.0 / (256.0 * 256.0), 255.0 / 256.0));\n}\n\nvec3 screenSpaceToViewSpace(const in vec3 ssPos, const in mat4 invProjection) {\n    vec4 p = vec4(ssPos * 2.0 - 1.0, 1.0);\n    p = invProjection * p;\n    return p.xyz / p.w;\n}\n\nconst float PackUpscale = 256.0 / 255.0; // fraction -> 0..1 (including 1)\nconst float UnpackDownscale = 255.0 / 256.0; // 0..1 -> fraction (excluding 1)\nconst vec3 PackFactors = vec3(256.0 * 256.0 * 256.0, 256.0 * 256.0,  256.0);\nconst vec4 UnpackFactors = UnpackDownscale / vec4(PackFactors, 1.0);\nconst float ShiftRight8 = 1.0 / 256.0;\n\nvec4 packDepthToRGBA(const in float v) {\n    vec4 r = vec4(fract(v * PackFactors), v);\n    r.yzw -= r.xyz * ShiftRight8; // tidy overflow\n    return r * PackUpscale;\n}\nfloat unpackRGBAToDepth(const in vec4 v) {\n    return dot(v, UnpackFactors);\n}\n\nvec4 sRGBToLinear(const in vec4 c) {\n    return vec4(mix(pow(c.rgb * 0.9478672986 + vec3(0.0521327014), vec3(2.4)), c.rgb * 0.0773993808, vec3(lessThanEqual(c.rgb, vec3(0.04045)))), c.a);\n}\nvec4 linearTosRGB(const in vec4 c) {\n    return vec4(mix(pow(c.rgb, vec3(0.41666)) * 1.055 - vec3(0.055), c.rgb * 12.92, vec3(lessThanEqual(c.rgb, vec3(0.0031308)))), c.a);\n}\n\nfloat linearizeDepth(const in float depth, const in float near, const in float far) {\n    return (2.0 * near) / (far + near - depth * (far - near));\n}\n\nfloat perspectiveDepthToViewZ(const in float invClipZ, const in float near, const in float far) {\n    return (near * far) / ((far - near) * invClipZ - far);\n}\n\nfloat orthographicDepthToViewZ(const in float linearClipZ, const in float near, const in float far) {\n    return linearClipZ * (near - far) - near;\n}\n\nfloat depthToViewZ(const in float isOrtho, const in float linearClipZ, const in float near, const in float far) {\n    return isOrtho == 1.0 ? orthographicDepthToViewZ(linearClipZ, near, far) : perspectiveDepthToViewZ(linearClipZ, near, far);\n}\n\n#if __VERSION__ == 100\n    // transpose\n\n    float transpose(const in float m) {\n        return m;\n    }\n\n    mat2 transpose2(const in mat2 m) {\n        return mat2(\n            m[0][0], m[1][0],\n            m[0][1], m[1][1]\n        );\n    }\n\n    mat3 transpose3(const in mat3 m) {\n        return mat3(\n            m[0][0], m[1][0], m[2][0],\n            m[0][1], m[1][1], m[2][1],\n            m[0][2], m[1][2], m[2][2]\n        );\n    }\n\n    mat4 transpose4(const in mat4 m) {\n        return mat4(\n            m[0][0], m[1][0], m[2][0], m[3][0],\n            m[0][1], m[1][1], m[2][1], m[3][1],\n            m[0][2], m[1][2], m[2][2], m[3][2],\n            m[0][3], m[1][3], m[2][3], m[3][3]\n        );\n    }\n\n    // inverse\n\n    float inverse(const in float m) {\n        return 1.0 / m;\n    }\n\n    mat2 inverse2(const in mat2 m) {\n        return mat2(m[1][1],-m[0][1],\n                -m[1][0], m[0][0]) / (m[0][0]*m[1][1] - m[0][1]*m[1][0]);\n    }\n\n    mat3 inverse3(const in mat3 m) {\n        float a00 = m[0][0], a01 = m[0][1], a02 = m[0][2];\n        float a10 = m[1][0], a11 = m[1][1], a12 = m[1][2];\n        float a20 = m[2][0], a21 = m[2][1], a22 = m[2][2];\n\n        float b01 = a22 * a11 - a12 * a21;\n        float b11 = -a22 * a10 + a12 * a20;\n        float b21 = a21 * a10 - a11 * a20;\n\n        float det = a00 * b01 + a01 * b11 + a02 * b21;\n\n        return mat3(b01, (-a22 * a01 + a02 * a21), (a12 * a01 - a02 * a11),\n                    b11, (a22 * a00 - a02 * a20), (-a12 * a00 + a02 * a10),\n                    b21, (-a21 * a00 + a01 * a20), (a11 * a00 - a01 * a10)) / det;\n    }\n\n    mat4 inverse4(const in mat4 m) {\n        float\n            a00 = m[0][0], a01 = m[0][1], a02 = m[0][2], a03 = m[0][3],\n            a10 = m[1][0], a11 = m[1][1], a12 = m[1][2], a13 = m[1][3],\n            a20 = m[2][0], a21 = m[2][1], a22 = m[2][2], a23 = m[2][3],\n            a30 = m[3][0], a31 = m[3][1], a32 = m[3][2], a33 = m[3][3],\n\n            b00 = a00 * a11 - a01 * a10,\n            b01 = a00 * a12 - a02 * a10,\n            b02 = a00 * a13 - a03 * a10,\n            b03 = a01 * a12 - a02 * a11,\n            b04 = a01 * a13 - a03 * a11,\n            b05 = a02 * a13 - a03 * a12,\n            b06 = a20 * a31 - a21 * a30,\n            b07 = a20 * a32 - a22 * a30,\n            b08 = a20 * a33 - a23 * a30,\n            b09 = a21 * a32 - a22 * a31,\n            b10 = a21 * a33 - a23 * a31,\n            b11 = a22 * a33 - a23 * a32,\n\n            det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;\n\n        return mat4(\n            a11 * b11 - a12 * b10 + a13 * b09,\n            a02 * b10 - a01 * b11 - a03 * b09,\n            a31 * b05 - a32 * b04 + a33 * b03,\n            a22 * b04 - a21 * b05 - a23 * b03,\n            a12 * b08 - a10 * b11 - a13 * b07,\n            a00 * b11 - a02 * b08 + a03 * b07,\n            a32 * b02 - a30 * b05 - a33 * b01,\n            a20 * b05 - a22 * b02 + a23 * b01,\n            a10 * b10 - a11 * b08 + a13 * b06,\n            a01 * b08 - a00 * b10 - a03 * b06,\n            a30 * b04 - a31 * b02 + a33 * b00,\n            a21 * b02 - a20 * b04 - a23 * b00,\n            a11 * b07 - a10 * b09 - a12 * b06,\n            a00 * b09 - a01 * b07 + a02 * b06,\n            a31 * b01 - a30 * b03 - a32 * b00,\n            a20 * b03 - a21 * b01 + a22 * b00) / det;\n    }\n\n    #define isNaN(x) ((x) != (x))\n    #define isInf(x) ((x) == (x) + 1.0)\n#else\n    #define transpose2(m) transpose(m)\n    #define transpose3(m) transpose(m)\n    #define transpose4(m) transpose(m)\n\n    #define inverse2(m) inverse(m)\n    #define inverse3(m) inverse(m)\n    #define inverse4(m) inverse(m)\n\n    #define isNaN isnan\n    #define isInf isinf\n#endif\n";
+export declare const common = "\n// TODO find a better place for these convenience defines\n\n#if defined(dRenderVariant_colorBlended) || defined(dRenderVariant_colorWboit)\n    #define dRenderVariant_color\n#endif\n\n#if defined(dColorType_instance) || defined(dColorType_group) || defined(dColorType_groupInstance) || defined(dColorType_vertex) || defined(dColorType_vertexInstance)\n    #define dColorType_texture\n#endif\n\n#if defined(dColorType_volume) || defined(dColorType_volumeInstance)\n    #define dColorType_grid\n#endif\n\n#if defined(dColorType_attribute) || defined(dColorType_texture) || defined(dColorType_grid)\n    #define dColorType_varying\n#endif\n\n#define MaskAll 0\n#define MaskOpaque 1\n#define MaskTransparent 2\n\n//\n\n#define PI 3.14159265\n#define RECIPROCAL_PI 0.31830988618\n#define EPSILON 1e-6\n\n#define saturate(a) clamp(a, 0.0, 1.0)\n\n#if __VERSION__ == 100\n    #define round(x) floor((x) + 0.5)\n#endif\n\nfloat intDiv(const in float a, const in float b) { return float(int(a) / int(b)); }\nvec2 ivec2Div(const in vec2 a, const in vec2 b) { return vec2(ivec2(a) / ivec2(b)); }\nfloat intMod(const in float a, const in float b) { return a - b * float(int(a) / int(b)); }\nint imod(const in int a, const in int b) { return a - b * (a / b); }\n\nfloat pow2(const in float x) { return x * x; }\n\nvec3 packIntToRGB(in float value) {\n    value = clamp(round(value), 0.0, 16777216.0 - 1.0) + 1.0;\n    vec3 c = vec3(0.0);\n    c.b = mod(value, 256.0);\n    value = floor(value / 256.0);\n    c.g = mod(value, 256.0);\n    value = floor(value / 256.0);\n    c.r = mod(value, 256.0);\n    return c / 255.0;\n}\nfloat unpackRGBToInt(const in vec3 rgb) {\n    return (floor(rgb.r * 255.0 + 0.5) * 256.0 * 256.0 + floor(rgb.g * 255.0 + 0.5) * 256.0 + floor(rgb.b * 255.0 + 0.5)) - 1.0;\n}\n\nvec2 packUnitIntervalToRG(const in float v) {\n    vec2 enc;\n    enc.xy = vec2(fract(v * 256.0), v);\n    enc.y -= enc.x * (1.0 / 256.0);\n    enc.xy *=  256.0 / 255.0;\n\n    return enc;\n}\n\nfloat unpackRGToUnitInterval(const in vec2 enc) {\n    return dot(enc, vec2(255.0 / (256.0 * 256.0), 255.0 / 256.0));\n}\n\nvec3 screenSpaceToViewSpace(const in vec3 ssPos, const in mat4 invProjection) {\n    vec4 p = vec4(ssPos * 2.0 - 1.0, 1.0);\n    p = invProjection * p;\n    return p.xyz / p.w;\n}\n\nconst float PackUpscale = 256.0 / 255.0; // fraction -> 0..1 (including 1)\nconst float UnpackDownscale = 255.0 / 256.0; // 0..1 -> fraction (excluding 1)\nconst vec3 PackFactors = vec3(256.0 * 256.0 * 256.0, 256.0 * 256.0,  256.0);\nconst vec4 UnpackFactors = UnpackDownscale / vec4(PackFactors, 1.0);\nconst float ShiftRight8 = 1.0 / 256.0;\n\nvec4 packDepthToRGBA(const in float v) {\n    vec4 r = vec4(fract(v * PackFactors), v);\n    r.yzw -= r.xyz * ShiftRight8; // tidy overflow\n    return r * PackUpscale;\n}\nfloat unpackRGBAToDepth(const in vec4 v) {\n    return dot(v, UnpackFactors);\n}\n\nvec4 sRGBToLinear(const in vec4 c) {\n    return vec4(mix(pow(c.rgb * 0.9478672986 + vec3(0.0521327014), vec3(2.4)), c.rgb * 0.0773993808, vec3(lessThanEqual(c.rgb, vec3(0.04045)))), c.a);\n}\nvec4 linearTosRGB(const in vec4 c) {\n    return vec4(mix(pow(c.rgb, vec3(0.41666)) * 1.055 - vec3(0.055), c.rgb * 12.92, vec3(lessThanEqual(c.rgb, vec3(0.0031308)))), c.a);\n}\n\nfloat linearizeDepth(const in float depth, const in float near, const in float far) {\n    return (2.0 * near) / (far + near - depth * (far - near));\n}\n\nfloat perspectiveDepthToViewZ(const in float invClipZ, const in float near, const in float far) {\n    return (near * far) / ((far - near) * invClipZ - far);\n}\n\nfloat orthographicDepthToViewZ(const in float linearClipZ, const in float near, const in float far) {\n    return linearClipZ * (near - far) - near;\n}\n\nfloat depthToViewZ(const in float isOrtho, const in float linearClipZ, const in float near, const in float far) {\n    return isOrtho == 1.0 ? orthographicDepthToViewZ(linearClipZ, near, far) : perspectiveDepthToViewZ(linearClipZ, near, far);\n}\n\n#if __VERSION__ == 100\n    // transpose\n\n    float transpose(const in float m) {\n        return m;\n    }\n\n    mat2 transpose2(const in mat2 m) {\n        return mat2(\n            m[0][0], m[1][0],\n            m[0][1], m[1][1]\n        );\n    }\n\n    mat3 transpose3(const in mat3 m) {\n        return mat3(\n            m[0][0], m[1][0], m[2][0],\n            m[0][1], m[1][1], m[2][1],\n            m[0][2], m[1][2], m[2][2]\n        );\n    }\n\n    mat4 transpose4(const in mat4 m) {\n        return mat4(\n            m[0][0], m[1][0], m[2][0], m[3][0],\n            m[0][1], m[1][1], m[2][1], m[3][1],\n            m[0][2], m[1][2], m[2][2], m[3][2],\n            m[0][3], m[1][3], m[2][3], m[3][3]\n        );\n    }\n\n    // inverse\n\n    float inverse(const in float m) {\n        return 1.0 / m;\n    }\n\n    mat2 inverse2(const in mat2 m) {\n        return mat2(m[1][1],-m[0][1],\n                -m[1][0], m[0][0]) / (m[0][0]*m[1][1] - m[0][1]*m[1][0]);\n    }\n\n    mat3 inverse3(const in mat3 m) {\n        float a00 = m[0][0], a01 = m[0][1], a02 = m[0][2];\n        float a10 = m[1][0], a11 = m[1][1], a12 = m[1][2];\n        float a20 = m[2][0], a21 = m[2][1], a22 = m[2][2];\n\n        float b01 = a22 * a11 - a12 * a21;\n        float b11 = -a22 * a10 + a12 * a20;\n        float b21 = a21 * a10 - a11 * a20;\n\n        float det = a00 * b01 + a01 * b11 + a02 * b21;\n\n        return mat3(b01, (-a22 * a01 + a02 * a21), (a12 * a01 - a02 * a11),\n                    b11, (a22 * a00 - a02 * a20), (-a12 * a00 + a02 * a10),\n                    b21, (-a21 * a00 + a01 * a20), (a11 * a00 - a01 * a10)) / det;\n    }\n\n    mat4 inverse4(const in mat4 m) {\n        float\n            a00 = m[0][0], a01 = m[0][1], a02 = m[0][2], a03 = m[0][3],\n            a10 = m[1][0], a11 = m[1][1], a12 = m[1][2], a13 = m[1][3],\n            a20 = m[2][0], a21 = m[2][1], a22 = m[2][2], a23 = m[2][3],\n            a30 = m[3][0], a31 = m[3][1], a32 = m[3][2], a33 = m[3][3],\n\n            b00 = a00 * a11 - a01 * a10,\n            b01 = a00 * a12 - a02 * a10,\n            b02 = a00 * a13 - a03 * a10,\n            b03 = a01 * a12 - a02 * a11,\n            b04 = a01 * a13 - a03 * a11,\n            b05 = a02 * a13 - a03 * a12,\n            b06 = a20 * a31 - a21 * a30,\n            b07 = a20 * a32 - a22 * a30,\n            b08 = a20 * a33 - a23 * a30,\n            b09 = a21 * a32 - a22 * a31,\n            b10 = a21 * a33 - a23 * a31,\n            b11 = a22 * a33 - a23 * a32,\n\n            det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;\n\n        return mat4(\n            a11 * b11 - a12 * b10 + a13 * b09,\n            a02 * b10 - a01 * b11 - a03 * b09,\n            a31 * b05 - a32 * b04 + a33 * b03,\n            a22 * b04 - a21 * b05 - a23 * b03,\n            a12 * b08 - a10 * b11 - a13 * b07,\n            a00 * b11 - a02 * b08 + a03 * b07,\n            a32 * b02 - a30 * b05 - a33 * b01,\n            a20 * b05 - a22 * b02 + a23 * b01,\n            a10 * b10 - a11 * b08 + a13 * b06,\n            a01 * b08 - a00 * b10 - a03 * b06,\n            a30 * b04 - a31 * b02 + a33 * b00,\n            a21 * b02 - a20 * b04 - a23 * b00,\n            a11 * b07 - a10 * b09 - a12 * b06,\n            a00 * b09 - a01 * b07 + a02 * b06,\n            a31 * b01 - a30 * b03 - a32 * b00,\n            a20 * b03 - a21 * b01 + a22 * b00) / det;\n    }\n\n    #define isNaN(x) ((x) != (x))\n    #define isInf(x) ((x) == (x) + 1.0)\n#else\n    #define transpose2(m) transpose(m)\n    #define transpose3(m) transpose(m)\n    #define transpose4(m) transpose(m)\n\n    #define inverse2(m) inverse(m)\n    #define inverse3(m) inverse(m)\n    #define inverse4(m) inverse(m)\n\n    #define isNaN isnan\n    #define isInf isinf\n#endif\n";

package/lib/commonjs/mol-gl/shader/chunks/common.glsl.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.common = void 0;
-exports.common = "\n// TODO find a better place for these convenience defines\n\n#if defined(dRenderVariant_colorBlended) || defined(dRenderVariant_colorWboit)\n    #define dRenderVariant_color\n#endif\n\n#if defined(dColorType_instance) || defined(dColorType_group) || defined(dColorType_groupInstance) || defined(dColorType_vertex) || defined(dColorType_vertexInstance)\n    #define dColorType_texture\n#endif\n\n#if defined(dColorType_volume) || defined(dColorType_volumeInstance)\n    #define dColorType_grid\n#endif\n\n#if defined(dColorType_attribute) || defined(dColorType_texture) || defined(dColorType_grid)\n    #define dColorType_varying\n#endif\n\n//\n\n#define PI 3.14159265\n#define RECIPROCAL_PI 0.31830988618\n#define EPSILON 1e-6\n\n#define saturate(a) clamp(a, 0.0, 1.0)\n\n#if __VERSION__ == 100\n    #define round(x) floor((x) + 0.5)\n#endif\n\nfloat intDiv(const in float a, const in float b) { return float(int(a) / int(b)); }\nvec2 ivec2Div(const in vec2 a, const in vec2 b) { return vec2(ivec2(a) / ivec2(b)); }\nfloat intMod(const in float a, const in float b) { return a - b * float(int(a) / int(b)); }\nint imod(const in int a, const in int b) { return a - b * (a / b); }\n\nfloat pow2(const in float x) { return x * x; }\n\nvec3 packIntToRGB(in float value) {\n    value = clamp(round(value), 0.0, 16777216.0 - 1.0) + 1.0;\n    vec3 c = vec3(0.0);\n    c.b = mod(value, 256.0);\n    value = floor(value / 256.0);\n    c.g = mod(value, 256.0);\n    value = floor(value / 256.0);\n    c.r = mod(value, 256.0);\n    return c / 255.0;\n}\nfloat unpackRGBToInt(const in vec3 rgb) {\n    return (floor(rgb.r * 255.0 + 0.5) * 256.0 * 256.0 + floor(rgb.g * 255.0 + 0.5) * 256.0 + floor(rgb.b * 255.0 + 0.5)) - 1.0;\n}\n\nvec2 packUnitIntervalToRG(const in float v) {\n    vec2 enc;\n    enc.xy = vec2(fract(v * 256.0), v);\n    enc.y -= enc.x * (1.0 / 256.0);\n    enc.xy *=  256.0 / 255.0;\n\n    return enc;\n}\n\nfloat unpackRGToUnitInterval(const in vec2 enc) {\n    return dot(enc, vec2(255.0 / (256.0 * 256.0), 255.0 / 256.0));\n}\n\nvec3 screenSpaceToViewSpace(const in vec3 ssPos, const in mat4 invProjection) {\n    vec4 p = vec4(ssPos * 2.0 - 1.0, 1.0);\n    p = invProjection * p;\n    return p.xyz / p.w;\n}\n\nconst float PackUpscale = 256.0 / 255.0; // fraction -> 0..1 (including 1)\nconst float UnpackDownscale = 255.0 / 256.0; // 0..1 -> fraction (excluding 1)\nconst vec3 PackFactors = vec3(256.0 * 256.0 * 256.0, 256.0 * 256.0,  256.0);\nconst vec4 UnpackFactors = UnpackDownscale / vec4(PackFactors, 1.0);\nconst float ShiftRight8 = 1.0 / 256.0;\n\nvec4 packDepthToRGBA(const in float v) {\n    vec4 r = vec4(fract(v * PackFactors), v);\n    r.yzw -= r.xyz * ShiftRight8; // tidy overflow\n    return r * PackUpscale;\n}\nfloat unpackRGBAToDepth(const in vec4 v) {\n    return dot(v, UnpackFactors);\n}\n\nvec4 sRGBToLinear(const in vec4 c) {\n    return vec4(mix(pow(c.rgb * 0.9478672986 + vec3(0.0521327014), vec3(2.4)), c.rgb * 0.0773993808, vec3(lessThanEqual(c.rgb, vec3(0.04045)))), c.a);\n}\nvec4 linearTosRGB(const in vec4 c) {\n    return vec4(mix(pow(c.rgb, vec3(0.41666)) * 1.055 - vec3(0.055), c.rgb * 12.92, vec3(lessThanEqual(c.rgb, vec3(0.0031308)))), c.a);\n}\n\nfloat linearizeDepth(const in float depth, const in float near, const in float far) {\n    return (2.0 * near) / (far + near - depth * (far - near));\n}\n\nfloat perspectiveDepthToViewZ(const in float invClipZ, const in float near, const in float far) {\n    return (near * far) / ((far - near) * invClipZ - far);\n}\n\nfloat orthographicDepthToViewZ(const in float linearClipZ, const in float near, const in float far) {\n    return linearClipZ * (near - far) - near;\n}\n\nfloat depthToViewZ(const in float isOrtho, const in float linearClipZ, const in float near, const in float far) {\n    return isOrtho == 1.0 ? orthographicDepthToViewZ(linearClipZ, near, far) : perspectiveDepthToViewZ(linearClipZ, near, far);\n}\n\n#if __VERSION__ == 100\n    // transpose\n\n    float transpose(const in float m) {\n        return m;\n    }\n\n    mat2 transpose2(const in mat2 m) {\n        return mat2(\n            m[0][0], m[1][0],\n            m[0][1], m[1][1]\n        );\n    }\n\n    mat3 transpose3(const in mat3 m) {\n        return mat3(\n            m[0][0], m[1][0], m[2][0],\n            m[0][1], m[1][1], m[2][1],\n            m[0][2], m[1][2], m[2][2]\n        );\n    }\n\n    mat4 transpose4(const in mat4 m) {\n        return mat4(\n            m[0][0], m[1][0], m[2][0], m[3][0],\n            m[0][1], m[1][1], m[2][1], m[3][1],\n            m[0][2], m[1][2], m[2][2], m[3][2],\n            m[0][3], m[1][3], m[2][3], m[3][3]\n        );\n    }\n\n    // inverse\n\n    float inverse(const in float m) {\n        return 1.0 / m;\n    }\n\n    mat2 inverse2(const in mat2 m) {\n        return mat2(m[1][1],-m[0][1],\n                -m[1][0], m[0][0]) / (m[0][0]*m[1][1] - m[0][1]*m[1][0]);\n    }\n\n    mat3 inverse3(const in mat3 m) {\n        float a00 = m[0][0], a01 = m[0][1], a02 = m[0][2];\n        float a10 = m[1][0], a11 = m[1][1], a12 = m[1][2];\n        float a20 = m[2][0], a21 = m[2][1], a22 = m[2][2];\n\n        float b01 = a22 * a11 - a12 * a21;\n        float b11 = -a22 * a10 + a12 * a20;\n        float b21 = a21 * a10 - a11 * a20;\n\n        float det = a00 * b01 + a01 * b11 + a02 * b21;\n\n        return mat3(b01, (-a22 * a01 + a02 * a21), (a12 * a01 - a02 * a11),\n                    b11, (a22 * a00 - a02 * a20), (-a12 * a00 + a02 * a10),\n                    b21, (-a21 * a00 + a01 * a20), (a11 * a00 - a01 * a10)) / det;\n    }\n\n    mat4 inverse4(const in mat4 m) {\n        float\n            a00 = m[0][0], a01 = m[0][1], a02 = m[0][2], a03 = m[0][3],\n            a10 = m[1][0], a11 = m[1][1], a12 = m[1][2], a13 = m[1][3],\n            a20 = m[2][0], a21 = m[2][1], a22 = m[2][2], a23 = m[2][3],\n            a30 = m[3][0], a31 = m[3][1], a32 = m[3][2], a33 = m[3][3],\n\n            b00 = a00 * a11 - a01 * a10,\n            b01 = a00 * a12 - a02 * a10,\n            b02 = a00 * a13 - a03 * a10,\n            b03 = a01 * a12 - a02 * a11,\n            b04 = a01 * a13 - a03 * a11,\n            b05 = a02 * a13 - a03 * a12,\n            b06 = a20 * a31 - a21 * a30,\n            b07 = a20 * a32 - a22 * a30,\n            b08 = a20 * a33 - a23 * a30,\n            b09 = a21 * a32 - a22 * a31,\n            b10 = a21 * a33 - a23 * a31,\n            b11 = a22 * a33 - a23 * a32,\n\n            det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;\n\n        return mat4(\n            a11 * b11 - a12 * b10 + a13 * b09,\n            a02 * b10 - a01 * b11 - a03 * b09,\n            a31 * b05 - a32 * b04 + a33 * b03,\n            a22 * b04 - a21 * b05 - a23 * b03,\n            a12 * b08 - a10 * b11 - a13 * b07,\n            a00 * b11 - a02 * b08 + a03 * b07,\n            a32 * b02 - a30 * b05 - a33 * b01,\n            a20 * b05 - a22 * b02 + a23 * b01,\n            a10 * b10 - a11 * b08 + a13 * b06,\n            a01 * b08 - a00 * b10 - a03 * b06,\n            a30 * b04 - a31 * b02 + a33 * b00,\n            a21 * b02 - a20 * b04 - a23 * b00,\n            a11 * b07 - a10 * b09 - a12 * b06,\n            a00 * b09 - a01 * b07 + a02 * b06,\n            a31 * b01 - a30 * b03 - a32 * b00,\n            a20 * b03 - a21 * b01 + a22 * b00) / det;\n    }\n\n    #define isNaN(x) ((x) != (x))\n    #define isInf(x) ((x) == (x) + 1.0)\n#else\n    #define transpose2(m) transpose(m)\n    #define transpose3(m) transpose(m)\n    #define transpose4(m) transpose(m)\n\n    #define inverse2(m) inverse(m)\n    #define inverse3(m) inverse(m)\n    #define inverse4(m) inverse(m)\n\n    #define isNaN isnan\n    #define isInf isinf\n#endif\n";
+exports.common = "\n// TODO find a better place for these convenience defines\n\n#if defined(dRenderVariant_colorBlended) || defined(dRenderVariant_colorWboit)\n    #define dRenderVariant_color\n#endif\n\n#if defined(dColorType_instance) || defined(dColorType_group) || defined(dColorType_groupInstance) || defined(dColorType_vertex) || defined(dColorType_vertexInstance)\n    #define dColorType_texture\n#endif\n\n#if defined(dColorType_volume) || defined(dColorType_volumeInstance)\n    #define dColorType_grid\n#endif\n\n#if defined(dColorType_attribute) || defined(dColorType_texture) || defined(dColorType_grid)\n    #define dColorType_varying\n#endif\n\n#define MaskAll 0\n#define MaskOpaque 1\n#define MaskTransparent 2\n\n//\n\n#define PI 3.14159265\n#define RECIPROCAL_PI 0.31830988618\n#define EPSILON 1e-6\n\n#define saturate(a) clamp(a, 0.0, 1.0)\n\n#if __VERSION__ == 100\n    #define round(x) floor((x) + 0.5)\n#endif\n\nfloat intDiv(const in float a, const in float b) { return float(int(a) / int(b)); }\nvec2 ivec2Div(const in vec2 a, const in vec2 b) { return vec2(ivec2(a) / ivec2(b)); }\nfloat intMod(const in float a, const in float b) { return a - b * float(int(a) / int(b)); }\nint imod(const in int a, const in int b) { return a - b * (a / b); }\n\nfloat pow2(const in float x) { return x * x; }\n\nvec3 packIntToRGB(in float value) {\n    value = clamp(round(value), 0.0, 16777216.0 - 1.0) + 1.0;\n    vec3 c = vec3(0.0);\n    c.b = mod(value, 256.0);\n    value = floor(value / 256.0);\n    c.g = mod(value, 256.0);\n    value = floor(value / 256.0);\n    c.r = mod(value, 256.0);\n    return c / 255.0;\n}\nfloat unpackRGBToInt(const in vec3 rgb) {\n    return (floor(rgb.r * 255.0 + 0.5) * 256.0 * 256.0 + floor(rgb.g * 255.0 + 0.5) * 256.0 + floor(rgb.b * 255.0 + 0.5)) - 1.0;\n}\n\nvec2 packUnitIntervalToRG(const in float v) {\n    vec2 enc;\n    enc.xy = vec2(fract(v * 256.0), v);\n    enc.y -= enc.x * (1.0 / 256.0);\n    enc.xy *=  256.0 / 255.0;\n\n    return enc;\n}\n\nfloat unpackRGToUnitInterval(const in vec2 enc) {\n    return dot(enc, vec2(255.0 / (256.0 * 256.0), 255.0 / 256.0));\n}\n\nvec3 screenSpaceToViewSpace(const in vec3 ssPos, const in mat4 invProjection) {\n    vec4 p = vec4(ssPos * 2.0 - 1.0, 1.0);\n    p = invProjection * p;\n    return p.xyz / p.w;\n}\n\nconst float PackUpscale = 256.0 / 255.0; // fraction -> 0..1 (including 1)\nconst float UnpackDownscale = 255.0 / 256.0; // 0..1 -> fraction (excluding 1)\nconst vec3 PackFactors = vec3(256.0 * 256.0 * 256.0, 256.0 * 256.0,  256.0);\nconst vec4 UnpackFactors = UnpackDownscale / vec4(PackFactors, 1.0);\nconst float ShiftRight8 = 1.0 / 256.0;\n\nvec4 packDepthToRGBA(const in float v) {\n    vec4 r = vec4(fract(v * PackFactors), v);\n    r.yzw -= r.xyz * ShiftRight8; // tidy overflow\n    return r * PackUpscale;\n}\nfloat unpackRGBAToDepth(const in vec4 v) {\n    return dot(v, UnpackFactors);\n}\n\nvec4 sRGBToLinear(const in vec4 c) {\n    return vec4(mix(pow(c.rgb * 0.9478672986 + vec3(0.0521327014), vec3(2.4)), c.rgb * 0.0773993808, vec3(lessThanEqual(c.rgb, vec3(0.04045)))), c.a);\n}\nvec4 linearTosRGB(const in vec4 c) {\n    return vec4(mix(pow(c.rgb, vec3(0.41666)) * 1.055 - vec3(0.055), c.rgb * 12.92, vec3(lessThanEqual(c.rgb, vec3(0.0031308)))), c.a);\n}\n\nfloat linearizeDepth(const in float depth, const in float near, const in float far) {\n    return (2.0 * near) / (far + near - depth * (far - near));\n}\n\nfloat perspectiveDepthToViewZ(const in float invClipZ, const in float near, const in float far) {\n    return (near * far) / ((far - near) * invClipZ - far);\n}\n\nfloat orthographicDepthToViewZ(const in float linearClipZ, const in float near, const in float far) {\n    return linearClipZ * (near - far) - near;\n}\n\nfloat depthToViewZ(const in float isOrtho, const in float linearClipZ, const in float near, const in float far) {\n    return isOrtho == 1.0 ? orthographicDepthToViewZ(linearClipZ, near, far) : perspectiveDepthToViewZ(linearClipZ, near, far);\n}\n\n#if __VERSION__ == 100\n    // transpose\n\n    float transpose(const in float m) {\n        return m;\n    }\n\n    mat2 transpose2(const in mat2 m) {\n        return mat2(\n            m[0][0], m[1][0],\n            m[0][1], m[1][1]\n        );\n    }\n\n    mat3 transpose3(const in mat3 m) {\n        return mat3(\n            m[0][0], m[1][0], m[2][0],\n            m[0][1], m[1][1], m[2][1],\n            m[0][2], m[1][2], m[2][2]\n        );\n    }\n\n    mat4 transpose4(const in mat4 m) {\n        return mat4(\n            m[0][0], m[1][0], m[2][0], m[3][0],\n            m[0][1], m[1][1], m[2][1], m[3][1],\n            m[0][2], m[1][2], m[2][2], m[3][2],\n            m[0][3], m[1][3], m[2][3], m[3][3]\n        );\n    }\n\n    // inverse\n\n    float inverse(const in float m) {\n        return 1.0 / m;\n    }\n\n    mat2 inverse2(const in mat2 m) {\n        return mat2(m[1][1],-m[0][1],\n                -m[1][0], m[0][0]) / (m[0][0]*m[1][1] - m[0][1]*m[1][0]);\n    }\n\n    mat3 inverse3(const in mat3 m) {\n        float a00 = m[0][0], a01 = m[0][1], a02 = m[0][2];\n        float a10 = m[1][0], a11 = m[1][1], a12 = m[1][2];\n        float a20 = m[2][0], a21 = m[2][1], a22 = m[2][2];\n\n        float b01 = a22 * a11 - a12 * a21;\n        float b11 = -a22 * a10 + a12 * a20;\n        float b21 = a21 * a10 - a11 * a20;\n\n        float det = a00 * b01 + a01 * b11 + a02 * b21;\n\n        return mat3(b01, (-a22 * a01 + a02 * a21), (a12 * a01 - a02 * a11),\n                    b11, (a22 * a00 - a02 * a20), (-a12 * a00 + a02 * a10),\n                    b21, (-a21 * a00 + a01 * a20), (a11 * a00 - a01 * a10)) / det;\n    }\n\n    mat4 inverse4(const in mat4 m) {\n        float\n            a00 = m[0][0], a01 = m[0][1], a02 = m[0][2], a03 = m[0][3],\n            a10 = m[1][0], a11 = m[1][1], a12 = m[1][2], a13 = m[1][3],\n            a20 = m[2][0], a21 = m[2][1], a22 = m[2][2], a23 = m[2][3],\n            a30 = m[3][0], a31 = m[3][1], a32 = m[3][2], a33 = m[3][3],\n\n            b00 = a00 * a11 - a01 * a10,\n            b01 = a00 * a12 - a02 * a10,\n            b02 = a00 * a13 - a03 * a10,\n            b03 = a01 * a12 - a02 * a11,\n            b04 = a01 * a13 - a03 * a11,\n            b05 = a02 * a13 - a03 * a12,\n            b06 = a20 * a31 - a21 * a30,\n            b07 = a20 * a32 - a22 * a30,\n            b08 = a20 * a33 - a23 * a30,\n            b09 = a21 * a32 - a22 * a31,\n            b10 = a21 * a33 - a23 * a31,\n            b11 = a22 * a33 - a23 * a32,\n\n            det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;\n\n        return mat4(\n            a11 * b11 - a12 * b10 + a13 * b09,\n            a02 * b10 - a01 * b11 - a03 * b09,\n            a31 * b05 - a32 * b04 + a33 * b03,\n            a22 * b04 - a21 * b05 - a23 * b03,\n            a12 * b08 - a10 * b11 - a13 * b07,\n            a00 * b11 - a02 * b08 + a03 * b07,\n            a32 * b02 - a30 * b05 - a33 * b01,\n            a20 * b05 - a22 * b02 + a23 * b01,\n            a10 * b10 - a11 * b08 + a13 * b06,\n            a01 * b08 - a00 * b10 - a03 * b06,\n            a30 * b04 - a31 * b02 + a33 * b00,\n            a21 * b02 - a20 * b04 - a23 * b00,\n            a11 * b07 - a10 * b09 - a12 * b06,\n            a00 * b09 - a01 * b07 + a02 * b06,\n            a31 * b01 - a30 * b03 - a32 * b00,\n            a20 * b03 - a21 * b01 + a22 * b00) / det;\n    }\n\n    #define isNaN(x) ((x) != (x))\n    #define isInf(x) ((x) == (x) + 1.0)\n#else\n    #define transpose2(m) transpose(m)\n    #define transpose3(m) transpose(m)\n    #define transpose4(m) transpose(m)\n\n    #define inverse2(m) inverse(m)\n    #define inverse3(m) inverse(m)\n    #define inverse4(m) inverse(m)\n\n    #define isNaN isnan\n    #define isInf isinf\n#endif\n";

package/lib/commonjs/mol-gl/shader/chunks/wboit-write.glsl.d.ts

@@ -4,4 +4,4 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  * @author Áron Samuel Kovács <aron.kovacs@mail.muni.cz>
  */
-export declare const wboit_write = "\n#if defined(dRenderVariant_colorWboit)\n    if (!uRenderWboit) {\n        if (preFogAlpha < 1.0) {\n            discard;\n        }\n    } else if (uRenderWboit) {\n        // the 'fragmentDepth > 0.99' check is to handle precision issues with packed depth\n        if (preFogAlpha != 1.0 && (fragmentDepth < getDepth(gl_FragCoord.xy / uDrawingBufferSize) || fragmentDepth > 0.99)) {\n            float alpha = gl_FragColor.a;\n            float wboitWeight = alpha * clamp(pow(1.0 - fragmentDepth, 2.0), 0.01, 1.0);\n            gl_FragColor = vec4(gl_FragColor.rgb * alpha * wboitWeight, alpha);\n            // extra alpha is to handle pre-multiplied alpha\n            #ifndef dGeometryType_directVolume\n                gl_FragData[1] = vec4((uTransparentBackground ? alpha : 1.0) * alpha * wboitWeight);\n            #else\n                gl_FragData[1] = vec4(alpha * alpha * wboitWeight);\n            #endif\n        } else {\n            discard;\n        }\n    }\n#endif\n";
+export declare const wboit_write = "\n#if defined(dRenderVariant_colorWboit)\n    if (uRenderMask == MaskOpaque) {\n        if (preFogAlpha < 1.0) {\n            discard;\n        }\n    } else if (uRenderMask == MaskTransparent) {\n        // the 'fragmentDepth > 0.99' check is to handle precision issues with packed depth\n        if (preFogAlpha != 1.0 && (fragmentDepth < getDepth(gl_FragCoord.xy / uDrawingBufferSize) || fragmentDepth > 0.99)) {\n            #ifdef dTransparentBackfaces_off\n                if (interior) discard;\n            #endif\n            float alpha = gl_FragColor.a;\n            float wboitWeight = alpha * clamp(pow(1.0 - fragmentDepth, 2.0), 0.01, 1.0);\n            gl_FragColor = vec4(gl_FragColor.rgb * alpha * wboitWeight, alpha);\n            // extra alpha is to handle pre-multiplied alpha\n            #ifndef dGeometryType_directVolume\n                gl_FragData[1] = vec4((uTransparentBackground ? alpha : 1.0) * alpha * wboitWeight);\n            #else\n                gl_FragData[1] = vec4(alpha * alpha * wboitWeight);\n            #endif\n        } else {\n            discard;\n        }\n    }\n#endif\n";

package/lib/commonjs/mol-gl/shader/chunks/wboit-write.glsl.js

@@ -7,4 +7,4 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.wboit_write = void 0;
-exports.wboit_write = "\n#if defined(dRenderVariant_colorWboit)\n    if (!uRenderWboit) {\n        if (preFogAlpha < 1.0) {\n            discard;\n        }\n    } else if (uRenderWboit) {\n        // the 'fragmentDepth > 0.99' check is to handle precision issues with packed depth\n        if (preFogAlpha != 1.0 && (fragmentDepth < getDepth(gl_FragCoord.xy / uDrawingBufferSize) || fragmentDepth > 0.99)) {\n            float alpha = gl_FragColor.a;\n            float wboitWeight = alpha * clamp(pow(1.0 - fragmentDepth, 2.0), 0.01, 1.0);\n            gl_FragColor = vec4(gl_FragColor.rgb * alpha * wboitWeight, alpha);\n            // extra alpha is to handle pre-multiplied alpha\n            #ifndef dGeometryType_directVolume\n                gl_FragData[1] = vec4((uTransparentBackground ? alpha : 1.0) * alpha * wboitWeight);\n            #else\n                gl_FragData[1] = vec4(alpha * alpha * wboitWeight);\n            #endif\n        } else {\n            discard;\n        }\n    }\n#endif\n";
+exports.wboit_write = "\n#if defined(dRenderVariant_colorWboit)\n    if (uRenderMask == MaskOpaque) {\n        if (preFogAlpha < 1.0) {\n            discard;\n        }\n    } else if (uRenderMask == MaskTransparent) {\n        // the 'fragmentDepth > 0.99' check is to handle precision issues with packed depth\n        if (preFogAlpha != 1.0 && (fragmentDepth < getDepth(gl_FragCoord.xy / uDrawingBufferSize) || fragmentDepth > 0.99)) {\n            #ifdef dTransparentBackfaces_off\n                if (interior) discard;\n            #endif\n            float alpha = gl_FragColor.a;\n            float wboitWeight = alpha * clamp(pow(1.0 - fragmentDepth, 2.0), 0.01, 1.0);\n            gl_FragColor = vec4(gl_FragColor.rgb * alpha * wboitWeight, alpha);\n            // extra alpha is to handle pre-multiplied alpha\n            #ifndef dGeometryType_directVolume\n                gl_FragData[1] = vec4((uTransparentBackground ? alpha : 1.0) * alpha * wboitWeight);\n            #else\n                gl_FragData[1] = vec4(alpha * alpha * wboitWeight);\n            #endif\n        } else {\n            discard;\n        }\n    }\n#endif\n";

package/lib/commonjs/mol-gl/shader/direct-volume.frag.d.ts

@@ -4,4 +4,4 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  * @author Michael Krone <michael.krone@uni-tuebingen.de>
  */
-export declare const directVolume_frag = "\nprecision highp float;\nprecision highp int;\n\n#include common\n#include light_frag_params\n\n#if dClipObjectCount != 0\n    uniform int uClipObjectType[dClipObjectCount];\n    uniform bool uClipObjectInvert[dClipObjectCount];\n    uniform vec3 uClipObjectPosition[dClipObjectCount];\n    uniform vec4 uClipObjectRotation[dClipObjectCount];\n    uniform vec3 uClipObjectScale[dClipObjectCount];\n#endif\n#include common_clip\n\n#include read_from_texture\n#include texture3d_from_1d_trilinear\n#include texture3d_from_2d_nearest\n#include texture3d_from_2d_linear\n\nuniform mat4 uProjection, uTransform, uModelView, uModel, uView;\nuniform vec3 uCameraDir;\n\nuniform sampler2D tDepth;\nuniform vec2 uDrawingBufferSize;\n\nvarying vec3 vOrigPos;\nvarying float vInstance;\nvarying vec4 vBoundingSphere;\nvarying mat4 vTransform;\n\nuniform mat4 uInvView;\nuniform vec3 uGridDim;\nuniform vec3 uBboxSize;\nuniform sampler2D tTransferTex;\nuniform float uTransferScale;\nuniform float uStepScale;\nuniform float uJumpLength;\n\nuniform int uObjectId;\nuniform int uVertexCount;\nuniform int uInstanceCount;\nuniform int uGroupCount;\n\nuniform vec3 uHighlightColor;\nuniform vec3 uSelectColor;\nuniform float uHighlightStrength;\nuniform float uSelectStrength;\nuniform int uMarkerPriority;\n\nuniform float uMarker;\nuniform vec2 uMarkerTexDim;\nuniform sampler2D tMarker;\n\nuniform float uMetalness;\nuniform float uRoughness;\n\nuniform float uFogNear;\nuniform float uFogFar;\nuniform vec3 uFogColor;\n\nuniform float uAlpha;\nuniform float uPickingAlphaThreshold;\nuniform bool uTransparentBackground;\nuniform float uXrayEdgeFalloff;\n\nuniform bool uRenderWboit;\n\nuniform float uNear;\nuniform float uFar;\nuniform float uIsOrtho;\n\nuniform vec3 uCellDim;\nuniform vec3 uCameraPosition;\nuniform mat4 uCartnToUnit;\n\n#if __VERSION__ != 100\n    // for webgl1 this is given as a 'define'\n    uniform int uMaxSteps;\n#endif\n\n#if defined(dGridTexType_2d)\n    precision highp sampler2D;\n    uniform sampler2D tGridTex;\n    uniform vec3 uGridTexDim;\n#elif defined(dGridTexType_3d)\n    precision highp sampler3D;\n    uniform sampler3D tGridTex;\n#endif\n\n#if defined(dColorType_uniform)\n    uniform vec3 uColor;\n#elif defined(dColorType_texture)\n    uniform vec2 uColorTexDim;\n    uniform sampler2D tColor;\n#endif\n\n#ifdef dOverpaint\n    #if defined(dOverpaintType_groupInstance) || defined(dOverpaintType_vertexInstance)\n        uniform vec2 uOverpaintTexDim;\n        uniform sampler2D tOverpaint;\n    #endif\n#endif\n\n#ifdef dUsePalette\n    uniform sampler2D tPalette;\n#endif\n\n#if defined(dGridTexType_2d)\n    vec4 textureVal(vec3 pos) {\n        return texture3dFrom2dLinear(tGridTex, pos + (vec3(0.5, 0.5, 0.0) / uGridDim), uGridDim, uGridTexDim.xy);\n    }\n    vec4 textureGroup(vec3 pos) {\n        return texture3dFrom2dNearest(tGridTex, pos + (vec3(0.5, 0.5, 0.0) / uGridDim), uGridDim, uGridTexDim.xy);\n    }\n#elif defined(dGridTexType_3d)\n    vec4 textureVal(vec3 pos) {\n        return texture(tGridTex, pos + (vec3(0.5) / uGridDim));\n    }\n    vec4 textureGroup(vec3 pos) {\n        return texelFetch(tGridTex, ivec3(pos * uGridDim), 0);\n    }\n#endif\n\nfloat calcDepth(const in vec3 pos) {\n    vec2 clipZW = pos.z * uProjection[2].zw + uProjection[3].zw;\n    return 0.5 + 0.5 * clipZW.x / clipZW.y;\n}\n\nfloat transferFunction(float value) {\n    return texture2D(tTransferTex, vec2(value, 0.0)).a;\n}\n\nfloat getDepth(const in vec2 coords) {\n    #ifdef depthTextureSupport\n        if (!uRenderWboit) {\n            // in case of opaque volumes (and depth texture support)\n            return texture2D(tDepth, coords).r;\n        } else {\n            return unpackRGBAToDepth(texture2D(tDepth, coords));\n        }\n    #else\n        return unpackRGBAToDepth(texture2D(tDepth, coords));\n    #endif\n}\n\nconst float gradOffset = 0.5;\n\nvec3 v3m4(vec3 p, mat4 m) {\n    return (m * vec4(p, 1.0)).xyz;\n}\n\nfloat preFogAlphaBlended = 0.0;\n\nvec4 raymarch(vec3 startLoc, vec3 step, vec3 rayDir) {\n    mat3 normalMatrix = transpose3(inverse3(mat3(uModelView * vTransform)));\n    mat4 cartnToUnit = uCartnToUnit * inverse4(vTransform);\n    #if defined(dClipVariant_pixel) && dClipObjectCount != 0\n        mat4 modelTransform = uModel * vTransform * uTransform;\n    #endif\n    mat4 modelViewTransform = uModelView * vTransform * uTransform;\n\n    vec3 scaleVol = vec3(1.0) / uGridDim;\n    vec3 pos = startLoc;\n    vec4 cell;\n    float prevValue = -1.0;\n    float value = 0.0;\n    vec4 src = vec4(0.0);\n    vec4 dst = vec4(0.0);\n    float fragmentDepth;\n\n    vec3 posMin = vec3(0.0);\n    vec3 posMax = vec3(1.0) - vec3(1.0) / uGridDim;\n\n    vec3 unitPos;\n\n    vec3 nextPos;\n    float nextValue;\n\n    vec4 material;\n    vec4 overpaint;\n    float metalness = uMetalness;\n    float roughness = uRoughness;\n\n    vec3 gradient = vec3(1.0);\n    vec3 dx = vec3(gradOffset * scaleVol.x, 0.0, 0.0);\n    vec3 dy = vec3(0.0, gradOffset * scaleVol.y, 0.0);\n    vec3 dz = vec3(0.0, 0.0, gradOffset * scaleVol.z);\n\n    float maxDist = min(vBoundingSphere.w * 2.0, uFar - uNear);\n    float maxDistSq = maxDist * maxDist;\n\n    for (int i = 0; i < uMaxSteps; ++i) {\n        // break when beyond bounding-sphere or far-plane\n        vec3 distVec = startLoc - pos;\n        if (dot(distVec, distVec) > maxDistSq) break;\n\n        unitPos = v3m4(pos, cartnToUnit);\n\n        // continue when outside of grid\n        if (unitPos.x > posMax.x || unitPos.y > posMax.y || unitPos.z > posMax.z ||\n            unitPos.x < posMin.x || unitPos.y < posMin.y || unitPos.z < posMin.z\n        ) {\n            prevValue = value;\n            pos += step;\n            continue;\n        }\n\n        cell = textureVal(unitPos);\n        value = cell.a; // current voxel value\n\n        if (uJumpLength > 0.0 && value < 0.01) {\n            nextPos = pos + rayDir * uJumpLength;\n            nextValue = textureVal(v3m4(nextPos, cartnToUnit)).a;\n            if (nextValue < 0.01) {\n                prevValue = nextValue;\n                pos = nextPos;\n                continue;\n            }\n        }\n\n        vec4 mvPosition = modelViewTransform * vec4(unitPos * uGridDim, 1.0);\n        if (calcDepth(mvPosition.xyz) > getDepth(gl_FragCoord.xy / uDrawingBufferSize))\n            break;\n\n        #if defined(dClipVariant_pixel) && dClipObjectCount != 0\n            vec3 vModelPosition = v3m4(unitPos * uGridDim, modelTransform);\n            if (clipTest(vec4(vModelPosition, 0.0), 0)) {\n                prevValue = value;\n                pos += step;\n                continue;\n            }\n        #endif\n\n        vec3 vViewPosition = mvPosition.xyz;\n        material.a = transferFunction(value);\n\n        #ifdef dPackedGroup\n            float group = unpackRGBToInt(textureGroup(floor(unitPos * uGridDim + 0.5) / uGridDim).rgb);\n        #else\n            vec3 g = floor(unitPos * uGridDim + 0.5);\n            // note that we swap x and z because the texture is flipped around y\n            #if defined(dAxisOrder_012)\n                float group = g.z + g.y * uGridDim.z + g.x * uGridDim.z * uGridDim.y; // 210\n            #elif defined(dAxisOrder_021)\n                float group = g.y + g.z * uGridDim.y + g.x * uGridDim.y * uGridDim.z; // 120\n            #elif defined(dAxisOrder_102)\n                float group = g.z + g.x * uGridDim.z + g.y * uGridDim.z * uGridDim.x; // 201\n            #elif defined(dAxisOrder_120)\n                float group = g.x + g.z * uGridDim.x + g.y * uGridDim.x * uGridDim.z; // 021\n            #elif defined(dAxisOrder_201)\n                float group = g.y + g.x * uGridDim.y + g.z * uGridDim.y * uGridDim.x; // 102\n            #elif defined(dAxisOrder_210)\n                float group = g.x + g.y * uGridDim.x + g.z * uGridDim.x * uGridDim.y; // 012\n            #endif\n        #endif\n\n        #if defined(dColorType_direct) && defined(dUsePalette)\n            material.rgb = texture2D(tPalette, vec2(value, 0.0)).rgb;\n        #elif defined(dColorType_uniform)\n            material.rgb = uColor;\n        #elif defined(dColorType_instance)\n            material.rgb = readFromTexture(tColor, vInstance, uColorTexDim).rgb;\n        #elif defined(dColorType_group)\n            material.rgb = readFromTexture(tColor, group, uColorTexDim).rgb;\n        #elif defined(dColorType_groupInstance)\n            material.rgb = readFromTexture(tColor, vInstance * float(uGroupCount) + group, uColorTexDim).rgb;\n        #elif defined(dColorType_vertex)\n            material.rgb = texture3dFrom1dTrilinear(tColor, isoPos, uGridDim, uColorTexDim, 0.0).rgb;\n        #elif defined(dColorType_vertexInstance)\n            material.rgb = texture3dFrom1dTrilinear(tColor, isoPos, uGridDim, uColorTexDim, vInstance * float(uVertexCount)).rgb;\n        #endif\n\n        #ifdef dOverpaint\n            #if defined(dOverpaintType_groupInstance)\n                overpaint = readFromTexture(tOverpaint, vInstance * float(uGroupCount) + group, uOverpaintTexDim);\n            #elif defined(dOverpaintType_vertexInstance)\n                overpaint = texture3dFrom1dTrilinear(tOverpaint, isoPos, uGridDim, uOverpaintTexDim, vInstance * float(uVertexCount));\n            #endif\n\n            material.rgb = mix(material.rgb, overpaint.rgb, overpaint.a);\n        #endif\n\n        if (material.a >= 0.01) {\n            #ifdef dPackedGroup\n                // compute gradient by central differences\n                gradient.x = textureVal(unitPos - dx).a - textureVal(unitPos + dx).a;\n                gradient.y = textureVal(unitPos - dy).a - textureVal(unitPos + dy).a;\n                gradient.z = textureVal(unitPos - dz).a - textureVal(unitPos + dz).a;\n            #else\n                gradient = cell.xyz * 2.0 - 1.0;\n            #endif\n            vec3 normal = -normalize(normalMatrix * normalize(gradient));\n            #include apply_light_color\n        } else {\n            gl_FragColor.rgb = material.rgb;\n        }\n\n        gl_FragColor.a = material.a * uAlpha * uTransferScale;\n\n        float marker = uMarker;\n        if (uMarker == -1.0) {\n            marker = readFromTexture(tMarker, vInstance * float(uGroupCount) + group, uMarkerTexDim).a;\n            marker = floor(marker * 255.0 + 0.5); // rounding required to work on some cards on win\n        }\n        #include apply_marker_color\n\n        preFogAlphaBlended = (1.0 - preFogAlphaBlended) * gl_FragColor.a + preFogAlphaBlended;\n        fragmentDepth = calcDepth(mvPosition.xyz);\n        #include apply_fog\n\n        src = gl_FragColor;\n\n        if (!uTransparentBackground) {\n            // done in 'apply_fog' otherwise\n            src.rgb *= src.a;\n        }\n        dst = (1.0 - dst.a) * src + dst; // standard blending\n\n        // break if the color is opaque enough\n        if (dst.a > 0.95)\n            break;\n\n        pos += step;\n    }\n\n    return dst;\n}\n\n// TODO: support float texture for higher precision values???\n// TODO: support clipping exclusion texture support\n\nvoid main() {\n    if (gl_FrontFacing)\n        discard;\n\n    vec3 rayDir = mix(normalize(vOrigPos - uCameraPosition), uCameraDir, uIsOrtho);\n    vec3 step = rayDir * uStepScale;\n\n    float boundingSphereNear = distance(vBoundingSphere.xyz, uCameraPosition) - vBoundingSphere.w;\n    float d = max(uNear, boundingSphereNear) - mix(0.0, distance(vOrigPos, uCameraPosition), uIsOrtho);\n    vec3 start = mix(uCameraPosition, vOrigPos, uIsOrtho) + (d * rayDir);\n    gl_FragColor = raymarch(start, step, rayDir);\n\n    float fragmentDepth = calcDepth((uModelView * vec4(start, 1.0)).xyz);\n    float preFogAlpha = clamp(preFogAlphaBlended, 0.0, 1.0);\n    #include wboit_write\n}\n";
+export declare const directVolume_frag = "\nprecision highp float;\nprecision highp int;\n\n#include common\n#include light_frag_params\n\n#if dClipObjectCount != 0\n    uniform int uClipObjectType[dClipObjectCount];\n    uniform bool uClipObjectInvert[dClipObjectCount];\n    uniform vec3 uClipObjectPosition[dClipObjectCount];\n    uniform vec4 uClipObjectRotation[dClipObjectCount];\n    uniform vec3 uClipObjectScale[dClipObjectCount];\n#endif\n#include common_clip\n\n#include read_from_texture\n#include texture3d_from_1d_trilinear\n#include texture3d_from_2d_nearest\n#include texture3d_from_2d_linear\n\nuniform mat4 uProjection, uTransform, uModelView, uModel, uView;\nuniform vec3 uCameraDir;\n\nuniform sampler2D tDepth;\nuniform vec2 uDrawingBufferSize;\n\nvarying vec3 vOrigPos;\nvarying float vInstance;\nvarying vec4 vBoundingSphere;\nvarying mat4 vTransform;\n\nuniform mat4 uInvView;\nuniform vec3 uGridDim;\nuniform vec3 uBboxSize;\nuniform sampler2D tTransferTex;\nuniform float uTransferScale;\nuniform float uStepScale;\nuniform float uJumpLength;\n\nuniform int uObjectId;\nuniform int uVertexCount;\nuniform int uInstanceCount;\nuniform int uGroupCount;\n\nuniform vec3 uHighlightColor;\nuniform vec3 uSelectColor;\nuniform float uHighlightStrength;\nuniform float uSelectStrength;\nuniform int uMarkerPriority;\n\nuniform float uMarker;\nuniform vec2 uMarkerTexDim;\nuniform sampler2D tMarker;\n\nuniform float uMetalness;\nuniform float uRoughness;\n\nuniform float uFogNear;\nuniform float uFogFar;\nuniform vec3 uFogColor;\n\nuniform float uAlpha;\nuniform float uPickingAlphaThreshold;\nuniform bool uTransparentBackground;\nuniform float uXrayEdgeFalloff;\n\nuniform int uRenderMask;\n\nuniform float uNear;\nuniform float uFar;\nuniform float uIsOrtho;\n\nuniform vec3 uCellDim;\nuniform vec3 uCameraPosition;\nuniform mat4 uCartnToUnit;\n\n#if __VERSION__ != 100\n    // for webgl1 this is given as a 'define'\n    uniform int uMaxSteps;\n#endif\n\n#if defined(dGridTexType_2d)\n    precision highp sampler2D;\n    uniform sampler2D tGridTex;\n    uniform vec3 uGridTexDim;\n#elif defined(dGridTexType_3d)\n    precision highp sampler3D;\n    uniform sampler3D tGridTex;\n#endif\n\n#if defined(dColorType_uniform)\n    uniform vec3 uColor;\n#elif defined(dColorType_texture)\n    uniform vec2 uColorTexDim;\n    uniform sampler2D tColor;\n#endif\n\n#ifdef dOverpaint\n    #if defined(dOverpaintType_groupInstance) || defined(dOverpaintType_vertexInstance)\n        uniform vec2 uOverpaintTexDim;\n        uniform sampler2D tOverpaint;\n    #endif\n#endif\n\n#ifdef dUsePalette\n    uniform sampler2D tPalette;\n#endif\n\n#if defined(dGridTexType_2d)\n    vec4 textureVal(vec3 pos) {\n        return texture3dFrom2dLinear(tGridTex, pos + (vec3(0.5, 0.5, 0.0) / uGridDim), uGridDim, uGridTexDim.xy);\n    }\n    vec4 textureGroup(vec3 pos) {\n        return texture3dFrom2dNearest(tGridTex, pos + (vec3(0.5, 0.5, 0.0) / uGridDim), uGridDim, uGridTexDim.xy);\n    }\n#elif defined(dGridTexType_3d)\n    vec4 textureVal(vec3 pos) {\n        return texture(tGridTex, pos + (vec3(0.5) / uGridDim));\n    }\n    vec4 textureGroup(vec3 pos) {\n        return texelFetch(tGridTex, ivec3(pos * uGridDim), 0);\n    }\n#endif\n\nfloat calcDepth(const in vec3 pos) {\n    vec2 clipZW = pos.z * uProjection[2].zw + uProjection[3].zw;\n    return 0.5 + 0.5 * clipZW.x / clipZW.y;\n}\n\nfloat transferFunction(float value) {\n    return texture2D(tTransferTex, vec2(value, 0.0)).a;\n}\n\nfloat getDepth(const in vec2 coords) {\n    #ifdef depthTextureSupport\n        return texture2D(tDepth, coords).r;\n    #else\n        return unpackRGBAToDepth(texture2D(tDepth, coords));\n    #endif\n}\n\nconst float gradOffset = 0.5;\n\nvec3 v3m4(vec3 p, mat4 m) {\n    return (m * vec4(p, 1.0)).xyz;\n}\n\nfloat preFogAlphaBlended = 0.0;\n\nvec4 raymarch(vec3 startLoc, vec3 step, vec3 rayDir) {\n    mat3 normalMatrix = transpose3(inverse3(mat3(uModelView * vTransform)));\n    mat4 cartnToUnit = uCartnToUnit * inverse4(vTransform);\n    #if defined(dClipVariant_pixel) && dClipObjectCount != 0\n        mat4 modelTransform = uModel * vTransform * uTransform;\n    #endif\n    mat4 modelViewTransform = uModelView * vTransform * uTransform;\n\n    vec3 scaleVol = vec3(1.0) / uGridDim;\n    vec3 pos = startLoc;\n    vec4 cell;\n    float prevValue = -1.0;\n    float value = 0.0;\n    vec4 src = vec4(0.0);\n    vec4 dst = vec4(0.0);\n    float fragmentDepth;\n\n    vec3 posMin = vec3(0.0);\n    vec3 posMax = vec3(1.0) - vec3(1.0) / uGridDim;\n\n    vec3 unitPos;\n\n    vec3 nextPos;\n    float nextValue;\n\n    vec4 material;\n    vec4 overpaint;\n    float metalness = uMetalness;\n    float roughness = uRoughness;\n\n    vec3 gradient = vec3(1.0);\n    vec3 dx = vec3(gradOffset * scaleVol.x, 0.0, 0.0);\n    vec3 dy = vec3(0.0, gradOffset * scaleVol.y, 0.0);\n    vec3 dz = vec3(0.0, 0.0, gradOffset * scaleVol.z);\n\n    float maxDist = min(vBoundingSphere.w * 2.0, uFar - uNear);\n    float maxDistSq = maxDist * maxDist;\n\n    for (int i = 0; i < uMaxSteps; ++i) {\n        // break when beyond bounding-sphere or far-plane\n        vec3 distVec = startLoc - pos;\n        if (dot(distVec, distVec) > maxDistSq) break;\n\n        unitPos = v3m4(pos, cartnToUnit);\n\n        // continue when outside of grid\n        if (unitPos.x > posMax.x || unitPos.y > posMax.y || unitPos.z > posMax.z ||\n            unitPos.x < posMin.x || unitPos.y < posMin.y || unitPos.z < posMin.z\n        ) {\n            prevValue = value;\n            pos += step;\n            continue;\n        }\n\n        cell = textureVal(unitPos);\n        value = cell.a; // current voxel value\n\n        if (uJumpLength > 0.0 && value < 0.01) {\n            nextPos = pos + rayDir * uJumpLength;\n            nextValue = textureVal(v3m4(nextPos, cartnToUnit)).a;\n            if (nextValue < 0.01) {\n                prevValue = nextValue;\n                pos = nextPos;\n                continue;\n            }\n        }\n\n        vec4 mvPosition = modelViewTransform * vec4(unitPos * uGridDim, 1.0);\n        if (calcDepth(mvPosition.xyz) > getDepth(gl_FragCoord.xy / uDrawingBufferSize))\n            break;\n\n        #if defined(dClipVariant_pixel) && dClipObjectCount != 0\n            vec3 vModelPosition = v3m4(unitPos * uGridDim, modelTransform);\n            if (clipTest(vec4(vModelPosition, 0.0), 0)) {\n                prevValue = value;\n                pos += step;\n                continue;\n            }\n        #endif\n\n        vec3 vViewPosition = mvPosition.xyz;\n        material.a = transferFunction(value);\n\n        #ifdef dPackedGroup\n            float group = unpackRGBToInt(textureGroup(floor(unitPos * uGridDim + 0.5) / uGridDim).rgb);\n        #else\n            vec3 g = floor(unitPos * uGridDim + 0.5);\n            // note that we swap x and z because the texture is flipped around y\n            #if defined(dAxisOrder_012)\n                float group = g.z + g.y * uGridDim.z + g.x * uGridDim.z * uGridDim.y; // 210\n            #elif defined(dAxisOrder_021)\n                float group = g.y + g.z * uGridDim.y + g.x * uGridDim.y * uGridDim.z; // 120\n            #elif defined(dAxisOrder_102)\n                float group = g.z + g.x * uGridDim.z + g.y * uGridDim.z * uGridDim.x; // 201\n            #elif defined(dAxisOrder_120)\n                float group = g.x + g.z * uGridDim.x + g.y * uGridDim.x * uGridDim.z; // 021\n            #elif defined(dAxisOrder_201)\n                float group = g.y + g.x * uGridDim.y + g.z * uGridDim.y * uGridDim.x; // 102\n            #elif defined(dAxisOrder_210)\n                float group = g.x + g.y * uGridDim.x + g.z * uGridDim.x * uGridDim.y; // 012\n            #endif\n        #endif\n\n        #if defined(dColorType_direct) && defined(dUsePalette)\n            material.rgb = texture2D(tPalette, vec2(value, 0.0)).rgb;\n        #elif defined(dColorType_uniform)\n            material.rgb = uColor;\n        #elif defined(dColorType_instance)\n            material.rgb = readFromTexture(tColor, vInstance, uColorTexDim).rgb;\n        #elif defined(dColorType_group)\n            material.rgb = readFromTexture(tColor, group, uColorTexDim).rgb;\n        #elif defined(dColorType_groupInstance)\n            material.rgb = readFromTexture(tColor, vInstance * float(uGroupCount) + group, uColorTexDim).rgb;\n        #elif defined(dColorType_vertex)\n            material.rgb = texture3dFrom1dTrilinear(tColor, isoPos, uGridDim, uColorTexDim, 0.0).rgb;\n        #elif defined(dColorType_vertexInstance)\n            material.rgb = texture3dFrom1dTrilinear(tColor, isoPos, uGridDim, uColorTexDim, vInstance * float(uVertexCount)).rgb;\n        #endif\n\n        #ifdef dOverpaint\n            #if defined(dOverpaintType_groupInstance)\n                overpaint = readFromTexture(tOverpaint, vInstance * float(uGroupCount) + group, uOverpaintTexDim);\n            #elif defined(dOverpaintType_vertexInstance)\n                overpaint = texture3dFrom1dTrilinear(tOverpaint, isoPos, uGridDim, uOverpaintTexDim, vInstance * float(uVertexCount));\n            #endif\n\n            material.rgb = mix(material.rgb, overpaint.rgb, overpaint.a);\n        #endif\n\n        #ifdef dIgnoreLight\n            gl_FragColor.rgb = material.rgb;\n        #else\n            if (material.a >= 0.01) {\n                #ifdef dPackedGroup\n                    // compute gradient by central differences\n                    gradient.x = textureVal(unitPos - dx).a - textureVal(unitPos + dx).a;\n                    gradient.y = textureVal(unitPos - dy).a - textureVal(unitPos + dy).a;\n                    gradient.z = textureVal(unitPos - dz).a - textureVal(unitPos + dz).a;\n                #else\n                    gradient = cell.xyz * 2.0 - 1.0;\n                #endif\n                vec3 normal = -normalize(normalMatrix * normalize(gradient));\n                #include apply_light_color\n            } else {\n                gl_FragColor.rgb = material.rgb;\n            }\n        #endif\n\n        gl_FragColor.a = material.a * uAlpha * uTransferScale;\n\n        float marker = uMarker;\n        if (uMarker == -1.0) {\n            marker = readFromTexture(tMarker, vInstance * float(uGroupCount) + group, uMarkerTexDim).a;\n            marker = floor(marker * 255.0 + 0.5); // rounding required to work on some cards on win\n        }\n        #include apply_marker_color\n\n        preFogAlphaBlended = (1.0 - preFogAlphaBlended) * gl_FragColor.a + preFogAlphaBlended;\n        fragmentDepth = calcDepth(mvPosition.xyz);\n        #include apply_fog\n\n        src = gl_FragColor;\n\n        if (!uTransparentBackground) {\n            // done in 'apply_fog' otherwise\n            src.rgb *= src.a;\n        }\n        dst = (1.0 - dst.a) * src + dst; // standard blending\n\n        // break if the color is opaque enough\n        if (dst.a > 0.95)\n            break;\n\n        pos += step;\n    }\n\n    return dst;\n}\n\n// TODO: support float texture for higher precision values???\n// TODO: support clipping exclusion texture support\n\nvoid main() {\n    if (gl_FrontFacing)\n        discard;\n\n    vec3 rayDir = mix(normalize(vOrigPos - uCameraPosition), uCameraDir, uIsOrtho);\n    vec3 step = rayDir * uStepScale;\n\n    float boundingSphereNear = distance(vBoundingSphere.xyz, uCameraPosition) - vBoundingSphere.w;\n    float d = max(uNear, boundingSphereNear) - mix(0.0, distance(vOrigPos, uCameraPosition), uIsOrtho);\n    vec3 start = mix(uCameraPosition, vOrigPos, uIsOrtho) + (d * rayDir);\n    gl_FragColor = raymarch(start, step, rayDir);\n\n    float fragmentDepth = calcDepth((uModelView * vec4(start, 1.0)).xyz);\n    float preFogAlpha = clamp(preFogAlphaBlended, 0.0, 1.0);\n    #include wboit_write\n}\n";