npm - molstar - Versions diffs - 2.4.1 → 3.0.0-dev.4 - Mend

molstar 2.4.1 → 3.0.0-dev.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3179) hide show

package/lib/mol-gl/shader/chunks/common-clip.glsl.d.ts CHANGED Viewed

@@ -4,4 +4,4 @@
  * @author Ludovic Autin <autin@scripps.edu>
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
-export declare const common_clip = "\n#if dClipObjectCount != 0\n    vec3 quaternionTransform(vec4 q, vec3 v) {\n        vec3 t = 2.0 * cross(q.xyz, v);\n        return v + q.w * t + cross(q.xyz, t);\n    }\n\n    vec4 computePlane(vec3 normal, vec3 inPoint) {\n        return vec4(normalize(normal), -dot(normal, inPoint));\n    }\n\n    float planeSD(vec4 plane, vec3 center) {\n        return -dot(plane.xyz, center - plane.xyz * -plane.w);\n    }\n\n    float sphereSD(vec3 position, vec4 rotation, vec3 size, vec3 center) {\n        return (\n            length(quaternionTransform(vec4(-rotation.x, -rotation.y, -rotation.z, rotation.w), center - position) / size) - 1.0\n        ) * min(min(size.x, size.y), size.z);\n    }\n\n    float cubeSD(vec3 position, vec4 rotation, vec3 size, vec3 center) {\n        vec3 d = abs(quaternionTransform(vec4(-rotation.x, -rotation.y, -rotation.z, rotation.w), center - position)) - size;\n        return min(max(d.x, max(d.y, d.z)), 0.0) + length(max(d, 0.0));\n    }\n\n    float cylinderSD(vec3 position, vec4 rotation, vec3 size, vec3 center) {\n        vec3 t = quaternionTransform(vec4(-rotation.x, -rotation.y, -rotation.z, rotation.w), center - position);\n\n        vec2 d = abs(vec2(length(t.xz), t.y)) - size.xy;\n        return min(max(d.x, d.y), 0.0) + length(max(d, 0.0));\n    }\n\n    float infiniteConeSD(vec3 position, vec4 rotation, vec3 size, vec3 center) {\n        vec3 t = quaternionTransform(vec4(-rotation.x, -rotation.y, -rotation.z, rotation.w), center - position);\n\n        float q = length(t.xy);\n        return dot(size.xy, vec2(q, t.z));\n    }\n\n    float getSignedDistance(vec3 center, int type, vec3 position, vec4 rotation, vec3 scale) {\n        if (type == 1) {\n            vec3 normal = quaternionTransform(rotation, vec3(0.0, 1.0, 0.0));\n            vec4 plane = computePlane(normal, position);\n            return planeSD(plane, center);\n        } else if (type == 2) {\n            return sphereSD(position, rotation, scale * 0.5, center);\n        } else if (type == 3) {\n            return cubeSD(position, rotation, scale * 0.5, center);\n        } else if (type == 4) {\n            return cylinderSD(position, rotation, scale * 0.5, center);\n        } else if (type == 5) {\n            return infiniteConeSD(position, rotation, scale * 0.5, center);\n        } else {\n            return 0.1;\n        }\n    }\n\n    #if __VERSION__ == 100\n        // 8-bit\n        int bitwiseAnd(int a, int b) {\n            int d = 128;\n            int result = 0;\n            for (int i = 0; i < 8; ++i) {\n                if (d <= 0) break;\n                if (a >= d && b >= d) result += d;\n                if (a >= d) a -= d;\n                if (b >= d) b -= d;\n                d /= 2;\n            }\n            return result;\n        }\n\n        bool hasBit(int mask, int bit) {\n            return bitwiseAnd(mask, bit) == 0;\n        }\n    #else\n        bool hasBit(int mask, int bit) {\n            return (mask & bit) == 0;\n        }\n    #endif\n\n    // flag is a bit-flag for clip-objects to ignore (note, object ids start at 1 not 0)\n    bool clipTest(vec4 sphere, int flag) {\n        for (int i = 0; i < dClipObjectCount; ++i) {\n            if (flag == 0 || hasBit(flag, i + 1)) {\n                // TODO take sphere radius into account?\n                bool test = getSignedDistance(sphere.xyz, uClipObjectType[i], uClipObjectPosition[i], uClipObjectRotation[i], uClipObjectScale[i]) <= 0.0;\n                if ((!uClipObjectInvert[i] && test) || (uClipObjectInvert[i] && !test)) {\n                    return true;\n                }\n            }\n        }\n        return false;\n    }\n#endif\n";
+export declare const common_clip = "\n#if dClipObjectCount != 0\n    vec3 quaternionTransform(vec4 q, vec3 v) {\n        vec3 t = 2.0 * cross(q.xyz, v);\n        return v + q.w * t + cross(q.xyz, t);\n    }\n\n    vec4 computePlane(vec3 normal, vec3 inPoint) {\n        return vec4(normalize(normal), -dot(normal, inPoint));\n    }\n\n    float planeSD(vec4 plane, vec3 center) {\n        return -dot(plane.xyz, center - plane.xyz * -plane.w);\n    }\n\n    float sphereSD(vec3 position, vec4 rotation, vec3 size, vec3 center) {\n        return (\n            length(quaternionTransform(vec4(-rotation.x, -rotation.y, -rotation.z, rotation.w), center - position) / size) - 1.0\n        ) * min(min(size.x, size.y), size.z);\n    }\n\n    float cubeSD(vec3 position, vec4 rotation, vec3 size, vec3 center) {\n        vec3 d = abs(quaternionTransform(vec4(-rotation.x, -rotation.y, -rotation.z, rotation.w), center - position)) - size;\n        return min(max(d.x, max(d.y, d.z)), 0.0) + length(max(d, 0.0));\n    }\n\n    float cylinderSD(vec3 position, vec4 rotation, vec3 size, vec3 center) {\n        vec3 t = quaternionTransform(vec4(-rotation.x, -rotation.y, -rotation.z, rotation.w), center - position);\n\n        vec2 d = abs(vec2(length(t.xz), t.y)) - size.xy;\n        return min(max(d.x, d.y), 0.0) + length(max(d, 0.0));\n    }\n\n    float infiniteConeSD(vec3 position, vec4 rotation, vec3 size, vec3 center) {\n        vec3 t = quaternionTransform(vec4(-rotation.x, -rotation.y, -rotation.z, rotation.w), center - position);\n\n        float q = length(t.xy);\n        return dot(size.xy, vec2(q, t.z));\n    }\n\n    float getSignedDistance(vec3 center, int type, vec3 position, vec4 rotation, vec3 scale) {\n        if (type == 1) {\n            vec3 normal = quaternionTransform(rotation, vec3(0.0, 1.0, 0.0));\n            vec4 plane = computePlane(normal, position);\n            return planeSD(plane, center);\n        } else if (type == 2) {\n            return sphereSD(position, rotation, scale * 0.5, center);\n        } else if (type == 3) {\n            return cubeSD(position, rotation, scale * 0.5, center);\n        } else if (type == 4) {\n            return cylinderSD(position, rotation, scale * 0.5, center);\n        } else if (type == 5) {\n            return infiniteConeSD(position, rotation, scale * 0.5, center);\n        } else {\n            return 0.1;\n        }\n    }\n\n    #if __VERSION__ == 100\n        // 8-bit\n        int bitwiseAnd(int a, int b) {\n            int d = 128;\n            int result = 0;\n            for (int i = 0; i < 8; ++i) {\n                if (d <= 0) break;\n                if (a >= d && b >= d) result += d;\n                if (a >= d) a -= d;\n                if (b >= d) b -= d;\n                d /= 2;\n            }\n            return result;\n        }\n\n        bool hasBit(int mask, int bit) {\n            return bitwiseAnd(mask, bit) == 0;\n        }\n    #else\n        bool hasBit(int mask, int bit) {\n            return (mask & bit) == 0;\n        }\n    #endif\n\n    // flag is a bit-flag for clip-objects to ignore (note, object ids start at 1 not 0)\n    bool clipTest(vec4 sphere, int flag) {\n        #pragma unroll_loop_start\n        for (int i = 0; i < dClipObjectCount; ++i) {\n            if (flag == 0 || hasBit(flag, UNROLLED_LOOP_INDEX + 1)) {\n                // TODO take sphere radius into account?\n                bool test = getSignedDistance(sphere.xyz, uClipObjectType[i], uClipObjectPosition[i], uClipObjectRotation[i], uClipObjectScale[i]) <= 0.0;\n                if ((!uClipObjectInvert[i] && test) || (uClipObjectInvert[i] && !test)) {\n                    return true;\n                }\n            }\n        }\n        #pragma unroll_loop_end\n        return false;\n    }\n#endif\n";

package/lib/mol-gl/shader/chunks/common-clip.glsl.js CHANGED Viewed

@@ -4,5 +4,5 @@
  * @author Ludovic Autin <autin@scripps.edu>
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
-export var common_clip = "\n#if dClipObjectCount != 0\n    vec3 quaternionTransform(vec4 q, vec3 v) {\n        vec3 t = 2.0 * cross(q.xyz, v);\n        return v + q.w * t + cross(q.xyz, t);\n    }\n\n    vec4 computePlane(vec3 normal, vec3 inPoint) {\n        return vec4(normalize(normal), -dot(normal, inPoint));\n    }\n\n    float planeSD(vec4 plane, vec3 center) {\n        return -dot(plane.xyz, center - plane.xyz * -plane.w);\n    }\n\n    float sphereSD(vec3 position, vec4 rotation, vec3 size, vec3 center) {\n        return (\n            length(quaternionTransform(vec4(-rotation.x, -rotation.y, -rotation.z, rotation.w), center - position) / size) - 1.0\n        ) * min(min(size.x, size.y), size.z);\n    }\n\n    float cubeSD(vec3 position, vec4 rotation, vec3 size, vec3 center) {\n        vec3 d = abs(quaternionTransform(vec4(-rotation.x, -rotation.y, -rotation.z, rotation.w), center - position)) - size;\n        return min(max(d.x, max(d.y, d.z)), 0.0) + length(max(d, 0.0));\n    }\n\n    float cylinderSD(vec3 position, vec4 rotation, vec3 size, vec3 center) {\n        vec3 t = quaternionTransform(vec4(-rotation.x, -rotation.y, -rotation.z, rotation.w), center - position);\n\n        vec2 d = abs(vec2(length(t.xz), t.y)) - size.xy;\n        return min(max(d.x, d.y), 0.0) + length(max(d, 0.0));\n    }\n\n    float infiniteConeSD(vec3 position, vec4 rotation, vec3 size, vec3 center) {\n        vec3 t = quaternionTransform(vec4(-rotation.x, -rotation.y, -rotation.z, rotation.w), center - position);\n\n        float q = length(t.xy);\n        return dot(size.xy, vec2(q, t.z));\n    }\n\n    float getSignedDistance(vec3 center, int type, vec3 position, vec4 rotation, vec3 scale) {\n        if (type == 1) {\n            vec3 normal = quaternionTransform(rotation, vec3(0.0, 1.0, 0.0));\n            vec4 plane = computePlane(normal, position);\n            return planeSD(plane, center);\n        } else if (type == 2) {\n            return sphereSD(position, rotation, scale * 0.5, center);\n        } else if (type == 3) {\n            return cubeSD(position, rotation, scale * 0.5, center);\n        } else if (type == 4) {\n            return cylinderSD(position, rotation, scale * 0.5, center);\n        } else if (type == 5) {\n            return infiniteConeSD(position, rotation, scale * 0.5, center);\n        } else {\n            return 0.1;\n        }\n    }\n\n    #if __VERSION__ == 100\n        // 8-bit\n        int bitwiseAnd(int a, int b) {\n            int d = 128;\n            int result = 0;\n            for (int i = 0; i < 8; ++i) {\n                if (d <= 0) break;\n                if (a >= d && b >= d) result += d;\n                if (a >= d) a -= d;\n                if (b >= d) b -= d;\n                d /= 2;\n            }\n            return result;\n        }\n\n        bool hasBit(int mask, int bit) {\n            return bitwiseAnd(mask, bit) == 0;\n        }\n    #else\n        bool hasBit(int mask, int bit) {\n            return (mask & bit) == 0;\n        }\n    #endif\n\n    // flag is a bit-flag for clip-objects to ignore (note, object ids start at 1 not 0)\n    bool clipTest(vec4 sphere, int flag) {\n        for (int i = 0; i < dClipObjectCount; ++i) {\n            if (flag == 0 || hasBit(flag, i + 1)) {\n                // TODO take sphere radius into account?\n                bool test = getSignedDistance(sphere.xyz, uClipObjectType[i], uClipObjectPosition[i], uClipObjectRotation[i], uClipObjectScale[i]) <= 0.0;\n                if ((!uClipObjectInvert[i] && test) || (uClipObjectInvert[i] && !test)) {\n                    return true;\n                }\n            }\n        }\n        return false;\n    }\n#endif\n";
+export var common_clip = "\n#if dClipObjectCount != 0\n    vec3 quaternionTransform(vec4 q, vec3 v) {\n        vec3 t = 2.0 * cross(q.xyz, v);\n        return v + q.w * t + cross(q.xyz, t);\n    }\n\n    vec4 computePlane(vec3 normal, vec3 inPoint) {\n        return vec4(normalize(normal), -dot(normal, inPoint));\n    }\n\n    float planeSD(vec4 plane, vec3 center) {\n        return -dot(plane.xyz, center - plane.xyz * -plane.w);\n    }\n\n    float sphereSD(vec3 position, vec4 rotation, vec3 size, vec3 center) {\n        return (\n            length(quaternionTransform(vec4(-rotation.x, -rotation.y, -rotation.z, rotation.w), center - position) / size) - 1.0\n        ) * min(min(size.x, size.y), size.z);\n    }\n\n    float cubeSD(vec3 position, vec4 rotation, vec3 size, vec3 center) {\n        vec3 d = abs(quaternionTransform(vec4(-rotation.x, -rotation.y, -rotation.z, rotation.w), center - position)) - size;\n        return min(max(d.x, max(d.y, d.z)), 0.0) + length(max(d, 0.0));\n    }\n\n    float cylinderSD(vec3 position, vec4 rotation, vec3 size, vec3 center) {\n        vec3 t = quaternionTransform(vec4(-rotation.x, -rotation.y, -rotation.z, rotation.w), center - position);\n\n        vec2 d = abs(vec2(length(t.xz), t.y)) - size.xy;\n        return min(max(d.x, d.y), 0.0) + length(max(d, 0.0));\n    }\n\n    float infiniteConeSD(vec3 position, vec4 rotation, vec3 size, vec3 center) {\n        vec3 t = quaternionTransform(vec4(-rotation.x, -rotation.y, -rotation.z, rotation.w), center - position);\n\n        float q = length(t.xy);\n        return dot(size.xy, vec2(q, t.z));\n    }\n\n    float getSignedDistance(vec3 center, int type, vec3 position, vec4 rotation, vec3 scale) {\n        if (type == 1) {\n            vec3 normal = quaternionTransform(rotation, vec3(0.0, 1.0, 0.0));\n            vec4 plane = computePlane(normal, position);\n            return planeSD(plane, center);\n        } else if (type == 2) {\n            return sphereSD(position, rotation, scale * 0.5, center);\n        } else if (type == 3) {\n            return cubeSD(position, rotation, scale * 0.5, center);\n        } else if (type == 4) {\n            return cylinderSD(position, rotation, scale * 0.5, center);\n        } else if (type == 5) {\n            return infiniteConeSD(position, rotation, scale * 0.5, center);\n        } else {\n            return 0.1;\n        }\n    }\n\n    #if __VERSION__ == 100\n        // 8-bit\n        int bitwiseAnd(int a, int b) {\n            int d = 128;\n            int result = 0;\n            for (int i = 0; i < 8; ++i) {\n                if (d <= 0) break;\n                if (a >= d && b >= d) result += d;\n                if (a >= d) a -= d;\n                if (b >= d) b -= d;\n                d /= 2;\n            }\n            return result;\n        }\n\n        bool hasBit(int mask, int bit) {\n            return bitwiseAnd(mask, bit) == 0;\n        }\n    #else\n        bool hasBit(int mask, int bit) {\n            return (mask & bit) == 0;\n        }\n    #endif\n\n    // flag is a bit-flag for clip-objects to ignore (note, object ids start at 1 not 0)\n    bool clipTest(vec4 sphere, int flag) {\n        #pragma unroll_loop_start\n        for (int i = 0; i < dClipObjectCount; ++i) {\n            if (flag == 0 || hasBit(flag, UNROLLED_LOOP_INDEX + 1)) {\n                // TODO take sphere radius into account?\n                bool test = getSignedDistance(sphere.xyz, uClipObjectType[i], uClipObjectPosition[i], uClipObjectRotation[i], uClipObjectScale[i]) <= 0.0;\n                if ((!uClipObjectInvert[i] && test) || (uClipObjectInvert[i] && !test)) {\n                    return true;\n                }\n            }\n        }\n        #pragma unroll_loop_end\n        return false;\n    }\n#endif\n";
 //# sourceMappingURL=common-clip.glsl.js.map

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

	@@ -1 +1 @@
1	- export declare const common_frag_params = "\nuniform int uObjectId;\nuniform int uInstanceCount;\nuniform int uGroupCount;\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(dMarkerType_uniform)\n uniform float uMarker;\n#elif defined(dMarkerType_groupInstance)\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 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";
1	+ export declare const common_frag_params = "\nuniform int uObjectId;\nuniform int uInstanceCount;\nuniform int uGroupCount;\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(dMarkerType_uniform)\n uniform float uMarker;\n#elif defined(dMarkerType_groupInstance)\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 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";

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

@@ -1,2 +1,2 @@
-export var common_frag_params = "\nuniform int uObjectId;\nuniform int uInstanceCount;\nuniform int uGroupCount;\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(dMarkerType_uniform)\n    uniform float uMarker;\n#elif defined(dMarkerType_groupInstance)\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 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";
+export var common_frag_params = "\nuniform int uObjectId;\nuniform int uInstanceCount;\nuniform int uGroupCount;\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(dMarkerType_uniform)\n    uniform float uMarker;\n#elif defined(dMarkerType_groupInstance)\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 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";
 //# sourceMappingURL=common-frag-params.glsl.js.map

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

	@@ -1 +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(dRenderVariant_pickObject) \|\| defined(dRenderVariant_pickInstance) \|\| defined(dRenderVariant_pickGroup)\n #define dRenderVariant_pick\n#endif\n\n#if defined(dRenderVariant_markingDepth) \|\| defined(dRenderVariant_markingMask)\n #define dRenderVariant_marking\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\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\nconst float maxFloat = 10000.0; // NOTE constant also set in TypeScript\nconst float floatLogFactor = 9.210440366976517; // log(maxFloat + 1.0);\nfloat encodeFloatLog(const in float value) { return log(value + 1.0) / floatLogFactor; }\nfloat decodeFloatLog(const in float value) { return exp(value * floatLogFactor) - 1.0; }\n\nvec3 encodeFloatRGB(in float value) {\n value = clamp(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 decodeFloatRGB(const in vec3 rgb) {\n return (rgb.r * 256.0 * 256.0 * 255.0 + rgb.g * 256.0 * 255.0 + rgb.b * 255.0) - 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#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#endif\n";
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(dRenderVariant_pickObject) \|\| defined(dRenderVariant_pickInstance) \|\| defined(dRenderVariant_pickGroup)\n #define dRenderVariant_pick\n#endif\n\n#if defined(dRenderVariant_markingDepth) \|\| defined(dRenderVariant_markingMask)\n #define dRenderVariant_marking\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\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\nconst float maxFloat = 10000.0; // NOTE constant also set in TypeScript\nconst float floatLogFactor = 9.210440366976517; // log(maxFloat + 1.0);\nfloat encodeFloatLog(const in float value) { return log(value + 1.0) / floatLogFactor; }\nfloat decodeFloatLog(const in float value) { return exp(value * floatLogFactor) - 1.0; }\n\nvec3 encodeFloatRGB(in float value) {\n value = clamp(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 decodeFloatRGB(const in vec3 rgb) {\n return (rgb.r * 256.0 * 256.0 * 255.0 + rgb.g * 256.0 * 255.0 + rgb.b * 255.0) - 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. )\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/mol-gl/shader/chunks/common.glsl.js CHANGED Viewed

@@ -1,2 +1,2 @@
-export var 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(dRenderVariant_pickObject) || defined(dRenderVariant_pickInstance) || defined(dRenderVariant_pickGroup)\n    #define dRenderVariant_pick\n#endif\n\n#if defined(dRenderVariant_markingDepth) || defined(dRenderVariant_markingMask)\n    #define dRenderVariant_marking\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\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\nconst float maxFloat = 10000.0; // NOTE constant also set in TypeScript\nconst float floatLogFactor = 9.210440366976517; // log(maxFloat + 1.0);\nfloat encodeFloatLog(const in float value) { return log(value + 1.0) / floatLogFactor; }\nfloat decodeFloatLog(const in float value) { return exp(value * floatLogFactor) - 1.0; }\n\nvec3 encodeFloatRGB(in float value) {\n    value = clamp(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 decodeFloatRGB(const in vec3 rgb) {\n    return (rgb.r * 256.0 * 256.0 * 255.0 + rgb.g * 256.0 * 255.0 + rgb.b * 255.0) - 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#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#endif\n";
+export var 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(dRenderVariant_pickObject) || defined(dRenderVariant_pickInstance) || defined(dRenderVariant_pickGroup)\n    #define dRenderVariant_pick\n#endif\n\n#if defined(dRenderVariant_markingDepth) || defined(dRenderVariant_markingMask)\n    #define dRenderVariant_marking\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\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\nconst float maxFloat = 10000.0; // NOTE constant also set in TypeScript\nconst float floatLogFactor = 9.210440366976517; // log(maxFloat + 1.0);\nfloat encodeFloatLog(const in float value) { return log(value + 1.0) / floatLogFactor; }\nfloat decodeFloatLog(const in float value) { return exp(value * floatLogFactor) - 1.0; }\n\nvec3 encodeFloatRGB(in float value) {\n    value = clamp(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 decodeFloatRGB(const in vec3 rgb) {\n    return (rgb.r * 256.0 * 256.0 * 255.0 + rgb.g * 256.0 * 255.0 + rgb.b * 255.0) - 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. )\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";
 //# sourceMappingURL=common.glsl.js.map

package/lib/mol-gl/shader/chunks/light-frag-params.glsl.d.ts CHANGED Viewed

@@ -1,9 +1,9 @@
 /**
- * Copyright (c) 2017-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2017-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  *
  * adapted from three.js (https://github.com/mrdoob/three.js/)
- * which under the MIT License, Copyright © 2010-2019 three.js authors
+ * which under the MIT License, Copyright © 2010-2021 three.js authors
  */
-export declare const light_frag_params = "\nuniform float uLightIntensity;\nuniform float uAmbientIntensity;\nuniform float uReflectivity;\nuniform float uMetalness;\nuniform float uRoughness;\n\nstruct PhysicalMaterial {\n    vec3 diffuseColor;\n    float specularRoughness;\n    vec3 specularColor;\n};\n\nstruct IncidentLight {\n    vec3 color;\n    vec3 direction;\n};\n\nstruct ReflectedLight {\n    vec3 directDiffuse;\n    vec3 directSpecular;\n    vec3 indirectDiffuse;\n};\n\nstruct GeometricContext {\n    vec3 position;\n    vec3 normal;\n    vec3 viewDir;\n};\n\nvec3 F_Schlick(const in vec3 specularColor, const in float dotLH) {\n    // Original approximation by Christophe Schlick '94\n    // float fresnel = pow( 1.0 - dotLH, 5.0 );\n    // Optimized variant (presented by Epic at SIGGRAPH '13)\n    // https://cdn2.unrealengine.com/Resources/files/2013SiggraphPresentationsNotes-26915738.pdf\n    float fresnel = exp2((-5.55473 * dotLH - 6.98316) * dotLH);\n    return (1.0 - specularColor) * fresnel + specularColor;\n}\n\n// Moving Frostbite to Physically Based Rendering 3.0 - page 12, listing 2\n// https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf\nfloat G_GGX_SmithCorrelated(const in float alpha, const in float dotNL, const in float dotNV) {\n    float a2 = pow2(alpha);\n    // dotNL and dotNV are explicitly swapped. This is not a mistake.\n    float gv = dotNL * sqrt(a2 + (1.0 - a2) * pow2(dotNV));\n    float gl = dotNV * sqrt(a2 + (1.0 - a2) * pow2(dotNL));\n    return 0.5 / max(gv + gl, EPSILON);\n}\n\n// Microfacet Models for Refraction through Rough Surfaces - equation (33)\n// http://graphicrants.blogspot.com/2013/08/specular-brdf-reference.html\n// alpha is \"roughness squared\" in Disney\u2019s reparameterization\nfloat D_GGX(const in float alpha, const in float dotNH) {\n    float a2 = pow2(alpha);\n    float denom = pow2(dotNH) * (a2 - 1.0) + 1.0; // avoid alpha = 0 with dotNH = 1\n    return RECIPROCAL_PI * a2 / pow2(denom);\n}\n\nvec3 BRDF_Diffuse_Lambert(const in vec3 diffuseColor) {\n    return RECIPROCAL_PI * diffuseColor;\n}\n\n// GGX Distribution, Schlick Fresnel, GGX-Smith Visibility\nvec3 BRDF_Specular_GGX(const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float roughness) {\n    float alpha = pow2(roughness); // UE4's roughness\n    vec3 halfDir = normalize(incidentLight.direction + geometry.viewDir);\n\n    float dotNL = saturate(dot(geometry.normal, incidentLight.direction));\n    float dotNV = saturate(dot(geometry.normal, geometry.viewDir));\n    float dotNH = saturate(dot(geometry.normal, halfDir));\n    float dotLH = saturate(dot(incidentLight.direction, halfDir));\n\n    vec3 F = F_Schlick(specularColor, dotLH);\n    float G = G_GGX_SmithCorrelated(alpha, dotNL, dotNV);\n    float D = D_GGX(alpha, dotNH);\n    return F * (G * D);\n}\n\n// ref: https://www.unrealengine.com/blog/physically-based-shading-on-mobile - environmentBRDF for GGX on mobile\nvec3 BRDF_Specular_GGX_Environment(const in GeometricContext geometry, const in vec3 specularColor, const in float roughness) {\n    float dotNV = saturate(dot(geometry.normal, geometry.viewDir));\n    const vec4 c0 = vec4(-1, -0.0275, -0.572, 0.022);\n    const vec4 c1 = vec4(1, 0.0425, 1.04, -0.04);\n    vec4 r = roughness * c0 + c1;\n    float a004 = min(r.x * r.x, exp2(-9.28 * dotNV)) * r.x + r.y;\n    vec2 AB = vec2(-1.04, 1.04) * a004 + r.zw;\n    return specularColor * AB.x + AB.y;\n}\n\nvoid RE_Direct_Physical(const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\n    float dotNL = saturate(dot(geometry.normal, directLight.direction));\n    vec3 irradiance = dotNL * directLight.color;\n    irradiance *= PI; // punctual light\n\n    reflectedLight.directSpecular += irradiance * BRDF_Specular_GGX(directLight, geometry, material.specularColor, material.specularRoughness);\n    reflectedLight.directDiffuse += irradiance * BRDF_Diffuse_Lambert(material.diffuseColor);\n}\n\nvoid RE_IndirectDiffuse_Physical(const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\n    reflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert(material.diffuseColor);\n}\n";
+export declare const light_frag_params = "\n#if dLightCount != 0\n    uniform vec3 uLightDirection[dLightCount];\n    uniform vec3 uLightColor[dLightCount];\n#endif\nuniform vec3 uAmbientColor;\n\nstruct PhysicalMaterial {\n    vec3 diffuseColor;\n    float roughness;\n    vec3 specularColor;\n    float specularF90;\n};\n\nstruct IncidentLight {\n    vec3 color;\n    vec3 direction;\n};\n\nstruct ReflectedLight {\n    vec3 directDiffuse;\n    vec3 directSpecular;\n    vec3 indirectDiffuse;\n    vec3 indirectSpecular;\n};\n\nstruct GeometricContext {\n    vec3 position;\n    vec3 normal;\n    vec3 viewDir;\n};\n\nvec3 BRDF_Lambert(const in vec3 diffuseColor) {\n    return RECIPROCAL_PI * diffuseColor;\n}\n\nvec3 F_Schlick(const in vec3 f0, const in float f90, const in float dotVH) {\n    // Original approximation by Christophe Schlick '94\n    // float fresnel = pow( 1.0 - dotVH, 5.0 );\n    // Optimized variant (presented by Epic at SIGGRAPH '13)\n    // https://cdn2.unrealengine.com/Resources/files/2013SiggraphPresentationsNotes-26915738.pdf\n    float fresnel = exp2((-5.55473 * dotVH - 6.98316) * dotVH);\n    return f0 * (1.0 - fresnel) + (f90 * fresnel);\n}\n\n// Moving Frostbite to Physically Based Rendering 3.0 - page 12, listing 2\n// https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf\nfloat V_GGX_SmithCorrelated(const in float alpha, const in float dotNL, const in float dotNV) {\n    float a2 = pow2(alpha);\n    float gv = dotNL * sqrt(a2 + (1.0 - a2) * pow2(dotNV));\n    float gl = dotNV * sqrt(a2 + (1.0 - a2) * pow2(dotNL));\n    return 0.5 / max(gv + gl, EPSILON);\n}\n\n// Microfacet Models for Refraction through Rough Surfaces - equation (33)\n// http://graphicrants.blogspot.com/2013/08/specular-brdf-reference.html\n// alpha is \"roughness squared\" in Disney\u2019s reparameterization\nfloat D_GGX(const in float alpha, const in float dotNH) {\n    float a2 = pow2(alpha);\n    float denom = pow2(dotNH) * (a2 - 1.0) + 1.0; // avoid alpha = 0 with dotNH = 1\n    return RECIPROCAL_PI * a2 / pow2(denom);\n}\n\n// GGX Distribution, Schlick Fresnel, GGX_SmithCorrelated Visibility\nvec3 BRDF_GGX(const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 f0, const in float f90, const in float roughness) {\n    float alpha = pow2(roughness); // UE4's roughness\n    vec3 halfDir = normalize( lightDir + viewDir);\n    float dotNL = saturate(dot(normal, lightDir));\n    float dotNV = saturate(dot(normal, viewDir));\n    float dotNH = saturate(dot(normal, halfDir));\n    float dotVH = saturate(dot(viewDir, halfDir));\n    vec3 F = F_Schlick(f0, f90, dotVH);\n    float V = V_GGX_SmithCorrelated(alpha, dotNL, dotNV);\n    float D = D_GGX(alpha, dotNH);\n    return F * (V * D);\n}\n\n// Analytical approximation of the DFG LUT, one half of the\n// split-sum approximation used in indirect specular lighting.\n// via 'environmentBRDF' from \"Physically Based Shading on Mobile\"\n// https://www.unrealengine.com/blog/physically-based-shading-on-mobile\nvec2 DFGApprox(const in vec3 normal, const in vec3 viewDir, const in float roughness) {\n    float dotNV = saturate(dot(normal, viewDir));\n    const vec4 c0 = vec4(-1, -0.0275, -0.572, 0.022);\n    const vec4 c1 = vec4(1, 0.0425, 1.04, -0.04);\n    vec4 r = roughness * c0 + c1;\n    float a004 = min(r.x * r.x, exp2(-9.28 * dotNV)) * r.x + r.y;\n    vec2 fab = vec2(-1.04, 1.04) * a004 + r.zw;\n    return fab;\n}\n\n// Fdez-Ag\u00FCera's \"Multiple-Scattering Microfacet Model for Real-Time Image Based Lighting\"\n// Approximates multiscattering in order to preserve energy.\n// http://www.jcgt.org/published/0008/01/03/\nvoid computeMultiscattering(const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter) {\n    vec2 fab = DFGApprox(normal, viewDir, roughness);\n    vec3 FssEss = specularColor * fab.x + specularF90 * fab.y;\n    float Ess = fab.x + fab.y;\n    float Ems = 1.0 - Ess;\n    vec3 Favg = specularColor + (1.0 - specularColor) * 0.047619; // 1/21\n    vec3 Fms = FssEss * Favg / (1.0 - Ems * Favg);\n    singleScatter += FssEss;\n    multiScatter += Fms * Ems;\n}\n\nvoid RE_Direct_Physical(const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\n    float dotNL = saturate(dot(geometry.normal, directLight.direction));\n    vec3 irradiance = dotNL * directLight.color;\n    reflectedLight.directSpecular += irradiance * BRDF_GGX(directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularF90, material.roughness);\n    reflectedLight.directDiffuse += irradiance * BRDF_Lambert(material.diffuseColor);\n}\n\nvoid RE_IndirectDiffuse_Physical(const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\n    reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert(material.diffuseColor);\n}\n\nvoid RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\n    // Both indirect specular and indirect diffuse light accumulate here\n    vec3 singleScattering = vec3(0.0);\n    vec3 multiScattering = vec3(0.0);\n    vec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;\n    computeMultiscattering(geometry.normal, geometry.viewDir, material.specularColor, material.specularF90, material.roughness, singleScattering, multiScattering);\n    vec3 diffuse = material.diffuseColor * (1.0 - ( singleScattering + multiScattering));\n    reflectedLight.indirectSpecular += radiance * singleScattering;\n    reflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;\n    reflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;\n}\n";

package/lib/mol-gl/shader/chunks/light-frag-params.glsl.js CHANGED Viewed

@@ -1,10 +1,10 @@
 /**
- * Copyright (c) 2017-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2017-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  *
  * adapted from three.js (https://github.com/mrdoob/three.js/)
- * which under the MIT License, Copyright © 2010-2019 three.js authors
+ * which under the MIT License, Copyright © 2010-2021 three.js authors
  */
-export var light_frag_params = "\nuniform float uLightIntensity;\nuniform float uAmbientIntensity;\nuniform float uReflectivity;\nuniform float uMetalness;\nuniform float uRoughness;\n\nstruct PhysicalMaterial {\n    vec3 diffuseColor;\n    float specularRoughness;\n    vec3 specularColor;\n};\n\nstruct IncidentLight {\n    vec3 color;\n    vec3 direction;\n};\n\nstruct ReflectedLight {\n    vec3 directDiffuse;\n    vec3 directSpecular;\n    vec3 indirectDiffuse;\n};\n\nstruct GeometricContext {\n    vec3 position;\n    vec3 normal;\n    vec3 viewDir;\n};\n\nvec3 F_Schlick(const in vec3 specularColor, const in float dotLH) {\n    // Original approximation by Christophe Schlick '94\n    // float fresnel = pow( 1.0 - dotLH, 5.0 );\n    // Optimized variant (presented by Epic at SIGGRAPH '13)\n    // https://cdn2.unrealengine.com/Resources/files/2013SiggraphPresentationsNotes-26915738.pdf\n    float fresnel = exp2((-5.55473 * dotLH - 6.98316) * dotLH);\n    return (1.0 - specularColor) * fresnel + specularColor;\n}\n\n// Moving Frostbite to Physically Based Rendering 3.0 - page 12, listing 2\n// https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf\nfloat G_GGX_SmithCorrelated(const in float alpha, const in float dotNL, const in float dotNV) {\n    float a2 = pow2(alpha);\n    // dotNL and dotNV are explicitly swapped. This is not a mistake.\n    float gv = dotNL * sqrt(a2 + (1.0 - a2) * pow2(dotNV));\n    float gl = dotNV * sqrt(a2 + (1.0 - a2) * pow2(dotNL));\n    return 0.5 / max(gv + gl, EPSILON);\n}\n\n// Microfacet Models for Refraction through Rough Surfaces - equation (33)\n// http://graphicrants.blogspot.com/2013/08/specular-brdf-reference.html\n// alpha is \"roughness squared\" in Disney\u2019s reparameterization\nfloat D_GGX(const in float alpha, const in float dotNH) {\n    float a2 = pow2(alpha);\n    float denom = pow2(dotNH) * (a2 - 1.0) + 1.0; // avoid alpha = 0 with dotNH = 1\n    return RECIPROCAL_PI * a2 / pow2(denom);\n}\n\nvec3 BRDF_Diffuse_Lambert(const in vec3 diffuseColor) {\n    return RECIPROCAL_PI * diffuseColor;\n}\n\n// GGX Distribution, Schlick Fresnel, GGX-Smith Visibility\nvec3 BRDF_Specular_GGX(const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float roughness) {\n    float alpha = pow2(roughness); // UE4's roughness\n    vec3 halfDir = normalize(incidentLight.direction + geometry.viewDir);\n\n    float dotNL = saturate(dot(geometry.normal, incidentLight.direction));\n    float dotNV = saturate(dot(geometry.normal, geometry.viewDir));\n    float dotNH = saturate(dot(geometry.normal, halfDir));\n    float dotLH = saturate(dot(incidentLight.direction, halfDir));\n\n    vec3 F = F_Schlick(specularColor, dotLH);\n    float G = G_GGX_SmithCorrelated(alpha, dotNL, dotNV);\n    float D = D_GGX(alpha, dotNH);\n    return F * (G * D);\n}\n\n// ref: https://www.unrealengine.com/blog/physically-based-shading-on-mobile - environmentBRDF for GGX on mobile\nvec3 BRDF_Specular_GGX_Environment(const in GeometricContext geometry, const in vec3 specularColor, const in float roughness) {\n    float dotNV = saturate(dot(geometry.normal, geometry.viewDir));\n    const vec4 c0 = vec4(-1, -0.0275, -0.572, 0.022);\n    const vec4 c1 = vec4(1, 0.0425, 1.04, -0.04);\n    vec4 r = roughness * c0 + c1;\n    float a004 = min(r.x * r.x, exp2(-9.28 * dotNV)) * r.x + r.y;\n    vec2 AB = vec2(-1.04, 1.04) * a004 + r.zw;\n    return specularColor * AB.x + AB.y;\n}\n\nvoid RE_Direct_Physical(const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\n    float dotNL = saturate(dot(geometry.normal, directLight.direction));\n    vec3 irradiance = dotNL * directLight.color;\n    irradiance *= PI; // punctual light\n\n    reflectedLight.directSpecular += irradiance * BRDF_Specular_GGX(directLight, geometry, material.specularColor, material.specularRoughness);\n    reflectedLight.directDiffuse += irradiance * BRDF_Diffuse_Lambert(material.diffuseColor);\n}\n\nvoid RE_IndirectDiffuse_Physical(const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\n    reflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert(material.diffuseColor);\n}\n";
+export var light_frag_params = "\n#if dLightCount != 0\n    uniform vec3 uLightDirection[dLightCount];\n    uniform vec3 uLightColor[dLightCount];\n#endif\nuniform vec3 uAmbientColor;\n\nstruct PhysicalMaterial {\n    vec3 diffuseColor;\n    float roughness;\n    vec3 specularColor;\n    float specularF90;\n};\n\nstruct IncidentLight {\n    vec3 color;\n    vec3 direction;\n};\n\nstruct ReflectedLight {\n    vec3 directDiffuse;\n    vec3 directSpecular;\n    vec3 indirectDiffuse;\n    vec3 indirectSpecular;\n};\n\nstruct GeometricContext {\n    vec3 position;\n    vec3 normal;\n    vec3 viewDir;\n};\n\nvec3 BRDF_Lambert(const in vec3 diffuseColor) {\n    return RECIPROCAL_PI * diffuseColor;\n}\n\nvec3 F_Schlick(const in vec3 f0, const in float f90, const in float dotVH) {\n    // Original approximation by Christophe Schlick '94\n    // float fresnel = pow( 1.0 - dotVH, 5.0 );\n    // Optimized variant (presented by Epic at SIGGRAPH '13)\n    // https://cdn2.unrealengine.com/Resources/files/2013SiggraphPresentationsNotes-26915738.pdf\n    float fresnel = exp2((-5.55473 * dotVH - 6.98316) * dotVH);\n    return f0 * (1.0 - fresnel) + (f90 * fresnel);\n}\n\n// Moving Frostbite to Physically Based Rendering 3.0 - page 12, listing 2\n// https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf\nfloat V_GGX_SmithCorrelated(const in float alpha, const in float dotNL, const in float dotNV) {\n    float a2 = pow2(alpha);\n    float gv = dotNL * sqrt(a2 + (1.0 - a2) * pow2(dotNV));\n    float gl = dotNV * sqrt(a2 + (1.0 - a2) * pow2(dotNL));\n    return 0.5 / max(gv + gl, EPSILON);\n}\n\n// Microfacet Models for Refraction through Rough Surfaces - equation (33)\n// http://graphicrants.blogspot.com/2013/08/specular-brdf-reference.html\n// alpha is \"roughness squared\" in Disney\u2019s reparameterization\nfloat D_GGX(const in float alpha, const in float dotNH) {\n    float a2 = pow2(alpha);\n    float denom = pow2(dotNH) * (a2 - 1.0) + 1.0; // avoid alpha = 0 with dotNH = 1\n    return RECIPROCAL_PI * a2 / pow2(denom);\n}\n\n// GGX Distribution, Schlick Fresnel, GGX_SmithCorrelated Visibility\nvec3 BRDF_GGX(const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 f0, const in float f90, const in float roughness) {\n    float alpha = pow2(roughness); // UE4's roughness\n    vec3 halfDir = normalize( lightDir + viewDir);\n    float dotNL = saturate(dot(normal, lightDir));\n    float dotNV = saturate(dot(normal, viewDir));\n    float dotNH = saturate(dot(normal, halfDir));\n    float dotVH = saturate(dot(viewDir, halfDir));\n    vec3 F = F_Schlick(f0, f90, dotVH);\n    float V = V_GGX_SmithCorrelated(alpha, dotNL, dotNV);\n    float D = D_GGX(alpha, dotNH);\n    return F * (V * D);\n}\n\n// Analytical approximation of the DFG LUT, one half of the\n// split-sum approximation used in indirect specular lighting.\n// via 'environmentBRDF' from \"Physically Based Shading on Mobile\"\n// https://www.unrealengine.com/blog/physically-based-shading-on-mobile\nvec2 DFGApprox(const in vec3 normal, const in vec3 viewDir, const in float roughness) {\n    float dotNV = saturate(dot(normal, viewDir));\n    const vec4 c0 = vec4(-1, -0.0275, -0.572, 0.022);\n    const vec4 c1 = vec4(1, 0.0425, 1.04, -0.04);\n    vec4 r = roughness * c0 + c1;\n    float a004 = min(r.x * r.x, exp2(-9.28 * dotNV)) * r.x + r.y;\n    vec2 fab = vec2(-1.04, 1.04) * a004 + r.zw;\n    return fab;\n}\n\n// Fdez-Ag\u00FCera's \"Multiple-Scattering Microfacet Model for Real-Time Image Based Lighting\"\n// Approximates multiscattering in order to preserve energy.\n// http://www.jcgt.org/published/0008/01/03/\nvoid computeMultiscattering(const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter) {\n    vec2 fab = DFGApprox(normal, viewDir, roughness);\n    vec3 FssEss = specularColor * fab.x + specularF90 * fab.y;\n    float Ess = fab.x + fab.y;\n    float Ems = 1.0 - Ess;\n    vec3 Favg = specularColor + (1.0 - specularColor) * 0.047619; // 1/21\n    vec3 Fms = FssEss * Favg / (1.0 - Ems * Favg);\n    singleScatter += FssEss;\n    multiScatter += Fms * Ems;\n}\n\nvoid RE_Direct_Physical(const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\n    float dotNL = saturate(dot(geometry.normal, directLight.direction));\n    vec3 irradiance = dotNL * directLight.color;\n    reflectedLight.directSpecular += irradiance * BRDF_GGX(directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularF90, material.roughness);\n    reflectedLight.directDiffuse += irradiance * BRDF_Lambert(material.diffuseColor);\n}\n\nvoid RE_IndirectDiffuse_Physical(const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\n    reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert(material.diffuseColor);\n}\n\nvoid RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\n    // Both indirect specular and indirect diffuse light accumulate here\n    vec3 singleScattering = vec3(0.0);\n    vec3 multiScattering = vec3(0.0);\n    vec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;\n    computeMultiscattering(geometry.normal, geometry.viewDir, material.specularColor, material.specularF90, material.roughness, singleScattering, multiScattering);\n    vec3 diffuse = material.diffuseColor * (1.0 - ( singleScattering + multiScattering));\n    reflectedLight.indirectSpecular += radiance * singleScattering;\n    reflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;\n    reflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;\n}\n";
 //# sourceMappingURL=light-frag-params.glsl.js.map

package/lib/mol-gl/shader/cylinders.frag.d.ts CHANGED Viewed

@@ -3,4 +3,4 @@
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
-export declare const cylinders_frag = "\nprecision highp float;\nprecision highp int;\n\nuniform mat4 uView;\n\nvarying mat4 vTransform;\nvarying vec3 vStart;\nvarying vec3 vEnd;\nvarying float vSize;\nvarying float vCap;\n\nuniform vec3 uCameraDir;\nuniform vec3 uCameraPosition;\n\n#include common\n#include common_frag_params\n#include color_frag_params\n#include light_frag_params\n#include common_clip\n\n// adapted from https://www.shadertoy.com/view/4lcSRn\n// The MIT License, Copyright 2016 Inigo Quilez\nbool CylinderImpostor(\n    in vec3 rayOrigin, in vec3 rayDir,\n    in vec3 start, in vec3 end, in float radius,\n    out vec4 intersection, out bool interior\n){\n    vec3 ba = end - start;\n    vec3 oc = rayOrigin - start;\n\n    float baba = dot(ba, ba);\n    float bard = dot(ba, rayDir);\n    float baoc = dot(ba, oc);\n\n    float k2 = baba - bard*bard;\n    float k1 = baba * dot(oc, rayDir) - baoc * bard;\n    float k0 = baba * dot(oc, oc) - baoc * baoc - radius * radius * baba;\n\n    float h = k1 * k1 - k2 * k0;\n    if (h < 0.0) return false;\n\n    bool topCap = (vCap > 0.9 && vCap < 1.1) || vCap >= 2.9;\n    bool bottomCap = (vCap > 1.9 && vCap < 2.1) || vCap >= 2.9;\n\n    // body outside\n    h = sqrt(h);\n    float t = (-k1 - h) / k2;\n    float y = baoc + t * bard;\n    if (y > 0.0 && y < baba) {\n        interior = false;\n        intersection = vec4(t, (oc + t * rayDir - ba * y / baba) / radius);\n        return true;\n    }\n\n    if (topCap && y < 0.0) {\n        // top cap\n        t = -baoc / bard;\n        if (abs(k1 + k2 * t) < h) {\n            interior = false;\n            intersection = vec4(t, ba * sign(y) / baba);\n            return true;\n        }\n    } else if(bottomCap && y >= 0.0) {\n        // bottom cap\n        t = (baba - baoc) / bard;\n        if (abs(k1 + k2 * t) < h) {\n            interior = false;\n            intersection = vec4(t, ba * sign(y) / baba);\n            return true;\n        }\n    }\n\n    #ifdef dDoubleSided\n        // body inside\n        h = -h;\n        t = (-k1 - h) / k2;\n        y = baoc + t * bard;\n        if (y > 0.0 && y < baba) {\n            interior = true;\n            intersection = vec4(t, (oc + t * rayDir - ba * y / baba) / radius);\n            return true;\n        }\n\n        // TODO: handle inside caps???\n    #endif\n\n    return false;\n}\n\nvoid main() {\n    #include clip_pixel\n\n    vec3 rayDir = mix(normalize(vModelPosition - uCameraPosition), uCameraDir, uIsOrtho);\n\n    vec4 intersection;\n    bool interior;\n    bool hit = CylinderImpostor(vModelPosition, rayDir, vStart, vEnd, vSize, intersection, interior);\n    if (!hit) discard;\n\n    vec3 vViewPosition = vModelPosition + intersection.x * rayDir;\n    vViewPosition = (uView * vec4(vViewPosition, 1.0)).xyz;\n    gl_FragDepthEXT = calcDepth(vViewPosition);\n\n    // bugfix (mac only?)\n    if (gl_FragDepthEXT < 0.0) discard;\n    if (gl_FragDepthEXT > 1.0) discard;\n\n    float fragmentDepth = gl_FragDepthEXT;\n    #include assign_material_color\n\n    #if defined(dRenderVariant_pick)\n        #include check_picking_alpha\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_depth)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_marking)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_color)\n        #ifdef dIgnoreLight\n            gl_FragColor = material;\n        #else\n            mat3 normalMatrix = transpose3(inverse3(mat3(uView)));\n            vec3 normal = normalize(normalMatrix * -normalize(intersection.yzw));\n            #include apply_light_color\n        #endif\n\n        #include apply_interior_color\n        #include apply_marker_color\n        #include apply_fog\n        #include wboit_write\n    #endif\n}\n";
+export declare const cylinders_frag = "\nprecision highp float;\nprecision highp int;\n\n#define bumpEnabled\n\nuniform mat4 uView;\n\nvarying mat4 vTransform;\nvarying vec3 vStart;\nvarying vec3 vEnd;\nvarying float vSize;\nvarying float vCap;\n\nuniform vec3 uCameraDir;\nuniform vec3 uCameraPosition;\nuniform mat4 uInvView;\n\n#include common\n#include common_frag_params\n#include color_frag_params\n#include light_frag_params\n#include common_clip\n\n// adapted from https://www.shadertoy.com/view/4lcSRn\n// The MIT License, Copyright 2016 Inigo Quilez\nbool CylinderImpostor(\n    in vec3 rayOrigin, in vec3 rayDir,\n    in vec3 start, in vec3 end, in float radius,\n    out vec4 intersection, out bool interior\n){\n    vec3 ba = end - start;\n    vec3 oc = rayOrigin - start;\n\n    float baba = dot(ba, ba);\n    float bard = dot(ba, rayDir);\n    float baoc = dot(ba, oc);\n\n    float k2 = baba - bard*bard;\n    float k1 = baba * dot(oc, rayDir) - baoc * bard;\n    float k0 = baba * dot(oc, oc) - baoc * baoc - radius * radius * baba;\n\n    float h = k1 * k1 - k2 * k0;\n    if (h < 0.0) return false;\n\n    bool topCap = (vCap > 0.9 && vCap < 1.1) || vCap >= 2.9;\n    bool bottomCap = (vCap > 1.9 && vCap < 2.1) || vCap >= 2.9;\n\n    // body outside\n    h = sqrt(h);\n    float t = (-k1 - h) / k2;\n    float y = baoc + t * bard;\n    if (y > 0.0 && y < baba) {\n        interior = false;\n        intersection = vec4(t, (oc + t * rayDir - ba * y / baba) / radius);\n        return true;\n    }\n\n    if (topCap && y < 0.0) {\n        // top cap\n        t = -baoc / bard;\n        if (abs(k1 + k2 * t) < h) {\n            interior = false;\n            intersection = vec4(t, ba * sign(y) / baba);\n            return true;\n        }\n    } else if(bottomCap && y >= 0.0) {\n        // bottom cap\n        t = (baba - baoc) / bard;\n        if (abs(k1 + k2 * t) < h) {\n            interior = false;\n            intersection = vec4(t, ba * sign(y) / baba);\n            return true;\n        }\n    }\n\n    #ifdef dDoubleSided\n        // body inside\n        h = -h;\n        t = (-k1 - h) / k2;\n        y = baoc + t * bard;\n        if (y > 0.0 && y < baba) {\n            interior = true;\n            intersection = vec4(t, (oc + t * rayDir - ba * y / baba) / radius);\n            return true;\n        }\n\n        // TODO: handle inside caps???\n    #endif\n\n    return false;\n}\n\nvoid main() {\n    #include clip_pixel\n\n    vec3 rayDir = mix(normalize(vModelPosition - uCameraPosition), uCameraDir, uIsOrtho);\n\n    vec4 intersection;\n    bool interior;\n    bool hit = CylinderImpostor(vModelPosition, rayDir, vStart, vEnd, vSize, intersection, interior);\n    if (!hit) discard;\n\n    vec3 vViewPosition = vModelPosition + intersection.x * rayDir;\n    vViewPosition = (uView * vec4(vViewPosition, 1.0)).xyz;\n    gl_FragDepthEXT = calcDepth(vViewPosition);\n\n    vec3 vModelPosition = (uInvView * vec4(vViewPosition, 1.0)).xyz;\n\n    if (gl_FragDepthEXT < 0.0) discard;\n    if (gl_FragDepthEXT > 1.0) discard;\n\n    float fragmentDepth = gl_FragDepthEXT;\n    #include assign_material_color\n\n    #if defined(dRenderVariant_pick)\n        #include check_picking_alpha\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_depth)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_marking)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_color)\n        #ifdef dIgnoreLight\n            gl_FragColor = material;\n        #else\n            mat3 normalMatrix = transpose3(inverse3(mat3(uView)));\n            vec3 normal = normalize(normalMatrix * -normalize(intersection.yzw));\n            #include apply_light_color\n        #endif\n\n        #include apply_interior_color\n        #include apply_marker_color\n        #include apply_fog\n        #include wboit_write\n    #endif\n}\n";

package/lib/mol-gl/shader/cylinders.frag.js CHANGED Viewed

@@ -3,5 +3,5 @@
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
-export var cylinders_frag = "\nprecision highp float;\nprecision highp int;\n\nuniform mat4 uView;\n\nvarying mat4 vTransform;\nvarying vec3 vStart;\nvarying vec3 vEnd;\nvarying float vSize;\nvarying float vCap;\n\nuniform vec3 uCameraDir;\nuniform vec3 uCameraPosition;\n\n#include common\n#include common_frag_params\n#include color_frag_params\n#include light_frag_params\n#include common_clip\n\n// adapted from https://www.shadertoy.com/view/4lcSRn\n// The MIT License, Copyright 2016 Inigo Quilez\nbool CylinderImpostor(\n    in vec3 rayOrigin, in vec3 rayDir,\n    in vec3 start, in vec3 end, in float radius,\n    out vec4 intersection, out bool interior\n){\n    vec3 ba = end - start;\n    vec3 oc = rayOrigin - start;\n\n    float baba = dot(ba, ba);\n    float bard = dot(ba, rayDir);\n    float baoc = dot(ba, oc);\n\n    float k2 = baba - bard*bard;\n    float k1 = baba * dot(oc, rayDir) - baoc * bard;\n    float k0 = baba * dot(oc, oc) - baoc * baoc - radius * radius * baba;\n\n    float h = k1 * k1 - k2 * k0;\n    if (h < 0.0) return false;\n\n    bool topCap = (vCap > 0.9 && vCap < 1.1) || vCap >= 2.9;\n    bool bottomCap = (vCap > 1.9 && vCap < 2.1) || vCap >= 2.9;\n\n    // body outside\n    h = sqrt(h);\n    float t = (-k1 - h) / k2;\n    float y = baoc + t * bard;\n    if (y > 0.0 && y < baba) {\n        interior = false;\n        intersection = vec4(t, (oc + t * rayDir - ba * y / baba) / radius);\n        return true;\n    }\n\n    if (topCap && y < 0.0) {\n        // top cap\n        t = -baoc / bard;\n        if (abs(k1 + k2 * t) < h) {\n            interior = false;\n            intersection = vec4(t, ba * sign(y) / baba);\n            return true;\n        }\n    } else if(bottomCap && y >= 0.0) {\n        // bottom cap\n        t = (baba - baoc) / bard;\n        if (abs(k1 + k2 * t) < h) {\n            interior = false;\n            intersection = vec4(t, ba * sign(y) / baba);\n            return true;\n        }\n    }\n\n    #ifdef dDoubleSided\n        // body inside\n        h = -h;\n        t = (-k1 - h) / k2;\n        y = baoc + t * bard;\n        if (y > 0.0 && y < baba) {\n            interior = true;\n            intersection = vec4(t, (oc + t * rayDir - ba * y / baba) / radius);\n            return true;\n        }\n\n        // TODO: handle inside caps???\n    #endif\n\n    return false;\n}\n\nvoid main() {\n    #include clip_pixel\n\n    vec3 rayDir = mix(normalize(vModelPosition - uCameraPosition), uCameraDir, uIsOrtho);\n\n    vec4 intersection;\n    bool interior;\n    bool hit = CylinderImpostor(vModelPosition, rayDir, vStart, vEnd, vSize, intersection, interior);\n    if (!hit) discard;\n\n    vec3 vViewPosition = vModelPosition + intersection.x * rayDir;\n    vViewPosition = (uView * vec4(vViewPosition, 1.0)).xyz;\n    gl_FragDepthEXT = calcDepth(vViewPosition);\n\n    // bugfix (mac only?)\n    if (gl_FragDepthEXT < 0.0) discard;\n    if (gl_FragDepthEXT > 1.0) discard;\n\n    float fragmentDepth = gl_FragDepthEXT;\n    #include assign_material_color\n\n    #if defined(dRenderVariant_pick)\n        #include check_picking_alpha\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_depth)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_marking)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_color)\n        #ifdef dIgnoreLight\n            gl_FragColor = material;\n        #else\n            mat3 normalMatrix = transpose3(inverse3(mat3(uView)));\n            vec3 normal = normalize(normalMatrix * -normalize(intersection.yzw));\n            #include apply_light_color\n        #endif\n\n        #include apply_interior_color\n        #include apply_marker_color\n        #include apply_fog\n        #include wboit_write\n    #endif\n}\n";
+export var cylinders_frag = "\nprecision highp float;\nprecision highp int;\n\n#define bumpEnabled\n\nuniform mat4 uView;\n\nvarying mat4 vTransform;\nvarying vec3 vStart;\nvarying vec3 vEnd;\nvarying float vSize;\nvarying float vCap;\n\nuniform vec3 uCameraDir;\nuniform vec3 uCameraPosition;\nuniform mat4 uInvView;\n\n#include common\n#include common_frag_params\n#include color_frag_params\n#include light_frag_params\n#include common_clip\n\n// adapted from https://www.shadertoy.com/view/4lcSRn\n// The MIT License, Copyright 2016 Inigo Quilez\nbool CylinderImpostor(\n    in vec3 rayOrigin, in vec3 rayDir,\n    in vec3 start, in vec3 end, in float radius,\n    out vec4 intersection, out bool interior\n){\n    vec3 ba = end - start;\n    vec3 oc = rayOrigin - start;\n\n    float baba = dot(ba, ba);\n    float bard = dot(ba, rayDir);\n    float baoc = dot(ba, oc);\n\n    float k2 = baba - bard*bard;\n    float k1 = baba * dot(oc, rayDir) - baoc * bard;\n    float k0 = baba * dot(oc, oc) - baoc * baoc - radius * radius * baba;\n\n    float h = k1 * k1 - k2 * k0;\n    if (h < 0.0) return false;\n\n    bool topCap = (vCap > 0.9 && vCap < 1.1) || vCap >= 2.9;\n    bool bottomCap = (vCap > 1.9 && vCap < 2.1) || vCap >= 2.9;\n\n    // body outside\n    h = sqrt(h);\n    float t = (-k1 - h) / k2;\n    float y = baoc + t * bard;\n    if (y > 0.0 && y < baba) {\n        interior = false;\n        intersection = vec4(t, (oc + t * rayDir - ba * y / baba) / radius);\n        return true;\n    }\n\n    if (topCap && y < 0.0) {\n        // top cap\n        t = -baoc / bard;\n        if (abs(k1 + k2 * t) < h) {\n            interior = false;\n            intersection = vec4(t, ba * sign(y) / baba);\n            return true;\n        }\n    } else if(bottomCap && y >= 0.0) {\n        // bottom cap\n        t = (baba - baoc) / bard;\n        if (abs(k1 + k2 * t) < h) {\n            interior = false;\n            intersection = vec4(t, ba * sign(y) / baba);\n            return true;\n        }\n    }\n\n    #ifdef dDoubleSided\n        // body inside\n        h = -h;\n        t = (-k1 - h) / k2;\n        y = baoc + t * bard;\n        if (y > 0.0 && y < baba) {\n            interior = true;\n            intersection = vec4(t, (oc + t * rayDir - ba * y / baba) / radius);\n            return true;\n        }\n\n        // TODO: handle inside caps???\n    #endif\n\n    return false;\n}\n\nvoid main() {\n    #include clip_pixel\n\n    vec3 rayDir = mix(normalize(vModelPosition - uCameraPosition), uCameraDir, uIsOrtho);\n\n    vec4 intersection;\n    bool interior;\n    bool hit = CylinderImpostor(vModelPosition, rayDir, vStart, vEnd, vSize, intersection, interior);\n    if (!hit) discard;\n\n    vec3 vViewPosition = vModelPosition + intersection.x * rayDir;\n    vViewPosition = (uView * vec4(vViewPosition, 1.0)).xyz;\n    gl_FragDepthEXT = calcDepth(vViewPosition);\n\n    vec3 vModelPosition = (uInvView * vec4(vViewPosition, 1.0)).xyz;\n\n    if (gl_FragDepthEXT < 0.0) discard;\n    if (gl_FragDepthEXT > 1.0) discard;\n\n    float fragmentDepth = gl_FragDepthEXT;\n    #include assign_material_color\n\n    #if defined(dRenderVariant_pick)\n        #include check_picking_alpha\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_depth)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_marking)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_color)\n        #ifdef dIgnoreLight\n            gl_FragColor = material;\n        #else\n            mat3 normalMatrix = transpose3(inverse3(mat3(uView)));\n            vec3 normal = normalize(normalMatrix * -normalize(intersection.yzw));\n            #include apply_light_color\n        #endif\n\n        #include apply_interior_color\n        #include apply_marker_color\n        #include apply_fog\n        #include wboit_write\n    #endif\n}\n";
 //# sourceMappingURL=cylinders.frag.js.map

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

@@ -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 vec2 uIsoValue;\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\n#if defined(dMarkerType_uniform)\n    uniform float uMarker;\n#elif defined(dMarkerType_groupInstance)\n    uniform vec2 uMarkerTexDim;\n    uniform sampler2D tMarker;\n#endif\n\nuniform float uFogNear;\nuniform float uFogFar;\nuniform vec3 uFogColor;\n\nuniform float uAlpha;\nuniform float uPickingAlphaThreshold;\nuniform bool uTransparentBackground;\n\nuniform float uInteriorDarkening;\nuniform bool uInteriorColorFlag;\nuniform vec3 uInteriorColor;\nbool interior;\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(dRenderVariant_color)\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#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\nvec4 transferFunction(float value) {\n    return texture2D(tTransferTex, vec2(value, 0.0));\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    #if defined(dRenderVariant_color) && !defined(dIgnoreLight)\n        mat3 normalMatrix = transpose3(inverse3(mat3(uModelView * vTransform)));\n    #endif\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    bool hit = false;\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    vec3 isoPos;\n\n    vec3 nextPos;\n    float nextValue;\n\n    vec3 color = vec3(0.45, 0.55, 0.8);\n    vec4 overpaint = vec4(0.0);\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            if (hit) break;\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        #if defined(dRenderMode_isosurface)\n            if (prevValue > 0.0 && ( // there was a prev Value\n                (prevValue < uIsoValue.x && value > uIsoValue.x) || // entering isosurface\n                (prevValue > uIsoValue.x && value < uIsoValue.x) // leaving isosurface\n            )) {\n                isoPos = v3m4(mix(pos - step, pos, ((prevValue - uIsoValue.x) / ((prevValue - uIsoValue.x) - (value - uIsoValue.x)))), cartnToUnit);\n\n                vec4 mvPosition = modelViewTransform * vec4(isoPos * uGridDim, 1.0);\n\n                #if defined(dClipVariant_pixel) && dClipObjectCount != 0\n                    vec3 vModelPosition = v3m4(isoPos * uGridDim, modelTransform);\n                    if (clipTest(vec4(vModelPosition, 0.0), 0)) {\n                        prevValue = value;\n                        pos += step;\n                        continue;\n                    }\n                #endif\n\n                float depth = calcDepth(mvPosition.xyz);\n                if (depth > getDepth(gl_FragCoord.xy / uDrawingBufferSize))\n                    break;\n\n                #ifdef enabledFragDepth\n                    if (!hit) {\n                        gl_FragDepthEXT = depth;\n                    }\n                #endif\n\n                #if defined(dRenderVariant_pickObject)\n                    return vec4(encodeFloatRGB(float(uObjectId)), 1.0);\n                #elif defined(dRenderVariant_pickInstance)\n                    return vec4(encodeFloatRGB(vInstance), 1.0);\n                #elif defined(dRenderVariant_pickGroup)\n                    #ifdef dPackedGroup\n                        return vec4(textureGroup(floor(isoPos * uGridDim + 0.5) / uGridDim).rgb, 1.0);\n                    #else\n                        vec3 g = floor(isoPos * uGridDim + 0.5);\n                        return vec4(encodeFloatRGB(g.z + g.y * uGridDim.z + g.x * uGridDim.z * uGridDim.y), 1.0);\n                    #endif\n                #elif defined(dRenderVariant_depth)\n                    #ifdef enabledFragDepth\n                        return packDepthToRGBA(gl_FragDepthEXT);\n                    #else\n                        return packDepthToRGBA(depth);\n                    #endif\n                #elif defined(dRenderVariant_color)\n                    #ifdef dPackedGroup\n                        float group = decodeFloatRGB(textureGroup(floor(isoPos * uGridDim + 0.5) / uGridDim).rgb);\n                    #else\n                        vec3 g = floor(isoPos * uGridDim + 0.5);\n                        float group = g.z + g.y * uGridDim.z + g.x * uGridDim.z * uGridDim.y;\n                    #endif\n\n                    #if defined(dColorType_uniform)\n                        color = uColor;\n                    #elif defined(dColorType_instance)\n                        color = readFromTexture(tColor, vInstance, uColorTexDim).rgb;\n                    #elif defined(dColorType_group)\n                        color = readFromTexture(tColor, group, uColorTexDim).rgb;\n                    #elif defined(dColorType_groupInstance)\n                        color = readFromTexture(tColor, vInstance * float(uGroupCount) + group, uColorTexDim).rgb;\n                    #elif defined(dColorType_vertex)\n                        color = texture3dFrom1dTrilinear(tColor, isoPos, uGridDim, uColorTexDim, 0.0).rgb;\n                    #elif defined(dColorType_vertexInstance)\n                        color = 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)).rgb;\n                        #endif\n\n                        color = mix(color, overpaint.rgb, overpaint.a);\n                    #endif\n\n                    // handle flipping and negative isosurfaces\n                    #ifdef dFlipSided\n                        bool flipped = value < uIsoValue.y; // flipped\n                    #else\n                        bool flipped = value > uIsoValue.y;\n                    #endif\n                    interior = value < uIsoValue.x && flipped;\n                    #ifndef dDoubleSided\n                        if (interior) {\n                            prevValue = value;\n                            pos += step;\n                            continue;\n                        }\n                    #endif\n                    vec3 vViewPosition = mvPosition.xyz;\n                    vec4 material = vec4(color, uAlpha);\n\n                    #ifdef dIgnoreLight\n                        gl_FragColor = material;\n                    #else\n                        #if defined(dFlatShaded)\n                            // nearest grid point\n                            isoPos = floor(isoPos * uGridDim + 0.5) / uGridDim;\n                        #endif\n                        #ifdef dPackedGroup\n                            // compute gradient by central differences\n                            gradient.x = textureVal(isoPos - dx).a - textureVal(isoPos + dx).a;\n                            gradient.y = textureVal(isoPos - dy).a - textureVal(isoPos + dy).a;\n                            gradient.z = textureVal(isoPos - dz).a - textureVal(isoPos + dz).a;\n                        #else\n                            gradient = textureVal(isoPos).xyz * 2.0 - 1.0;\n                        #endif\n                        vec3 normal = -normalize(normalMatrix * normalize(gradient));\n                        normal = normal * (float(flipped) * 2.0 - 1.0);\n                        normal = normal * -(float(interior) * 2.0 - 1.0);\n                        #include apply_light_color\n                    #endif\n\n                    #if defined(dMarkerType_uniform)\n                        float marker = uMarker;\n                    #elif defined(dMarkerType_groupInstance)\n                        float 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                    #endif\n                    #include apply_interior_color\n                    #include apply_marker_color\n\n                    preFogAlphaBlended = (1.0 - preFogAlphaBlended) * gl_FragColor.a + preFogAlphaBlended;\n                    fragmentDepth = depth;\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                #endif\n\n                #ifdef dSingleLayer\n                    break;\n                #endif\n\n                hit = true;\n            }\n            prevValue = value;\n        #elif defined(dRenderMode_volume)\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            #if defined(dRenderVariant_color)\n                vec3 vViewPosition = mvPosition.xyz;\n                vec4 material = transferFunction(value);\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                #if defined(dMarkerType_uniform)\n                    float marker = uMarker;\n                #elif defined(dMarkerType_groupInstance)\n                    #ifdef dPackedGroup\n                        float group = decodeFloatRGB(textureGroup(floor(unitPos * uGridDim + 0.5) / uGridDim).rgb);\n                    #else\n                        vec3 g = floor(unitPos * uGridDim + 0.5);\n                        float group = g.z + g.y * uGridDim.z + g.x * uGridDim.z * uGridDim.y;\n                    #endif\n                    float 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                #endif\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            #endif\n        #endif\n\n        // break if the color is opaque enough\n        if (dst.a > 0.95)\n            break;\n\n        pos += step;\n    }\n\n    #if defined(dRenderMode_isosurface) && defined(enabledFragDepth)\n        // ensure depth is written everywhere\n        if (!hit)\n            gl_FragDepthEXT = 1.0;\n    #endif\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    #ifdef dRenderVariant_marking\n        // not supported\n        discard;\n    #endif\n\n    #if defined(dRenderVariant_pick) || defined(dRenderVariant_depth)\n        #if defined(dRenderMode_volume)\n            // always ignore pick & depth for volume\n            discard;\n        #elif defined(dRenderMode_isosurface)\n            if (uAlpha < uPickingAlphaThreshold)\n                discard; // ignore so the element below can be picked\n        #endif\n    #endif\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    #if defined(dRenderVariant_pick) || defined(dRenderVariant_depth)\n        // discard when nothing was hit\n        if (gl_FragColor == vec4(0.0))\n            discard;\n    #endif\n\n    #if defined(dRenderVariant_color)\n        #if defined(dRenderMode_isosurface) && defined(enabledFragDepth)\n            float fragmentDepth = gl_FragDepthEXT;\n        #else\n            float fragmentDepth = calcDepth((uModelView * vec4(start, 1.0)).xyz);\n        #endif\n        float preFogAlpha = clamp(preFogAlphaBlended, 0.0, 1.0);\n        interior = false;\n        #include wboit_write\n    #endif\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 vec2 uIsoValue;\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\n#if defined(dMarkerType_uniform)\n    uniform float uMarker;\n#elif defined(dMarkerType_groupInstance)\n    uniform vec2 uMarkerTexDim;\n    uniform sampler2D tMarker;\n#endif\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;\n\nuniform float uInteriorDarkening;\nuniform bool uInteriorColorFlag;\nuniform vec3 uInteriorColor;\nbool interior;\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(dRenderVariant_color)\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 dSubstance\n        #if defined(dSubstanceType_groupInstance) || defined(dSubstanceType_vertexInstance)\n            uniform vec2 uSubstanceTexDim;\n            uniform sampler2D tSubstance;\n        #endif\n    #endif\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\nvec4 transferFunction(float value) {\n    return texture2D(tTransferTex, vec2(value, 0.0));\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    #if defined(dRenderVariant_color) && !defined(dIgnoreLight)\n        mat3 normalMatrix = transpose3(inverse3(mat3(uModelView * vTransform)));\n    #endif\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    bool hit = false;\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    vec3 isoPos;\n\n    vec3 nextPos;\n    float nextValue;\n\n    vec3 color = vec3(0.45, 0.55, 0.8);\n    vec4 overpaint = vec4(0.0);\n    vec3 substance = vec3(0.0);\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            if (hit) break;\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        #if defined(dRenderMode_isosurface)\n            if (prevValue > 0.0 && ( // there was a prev Value\n                (prevValue < uIsoValue.x && value > uIsoValue.x) || // entering isosurface\n                (prevValue > uIsoValue.x && value < uIsoValue.x) // leaving isosurface\n            )) {\n                isoPos = v3m4(mix(pos - step, pos, ((prevValue - uIsoValue.x) / ((prevValue - uIsoValue.x) - (value - uIsoValue.x)))), cartnToUnit);\n\n                vec4 mvPosition = modelViewTransform * vec4(isoPos * uGridDim, 1.0);\n\n                #if defined(dClipVariant_pixel) && dClipObjectCount != 0\n                    vec3 vModelPosition = v3m4(isoPos * uGridDim, modelTransform);\n                    if (clipTest(vec4(vModelPosition, 0.0), 0)) {\n                        prevValue = value;\n                        pos += step;\n                        continue;\n                    }\n                #endif\n\n                float depth = calcDepth(mvPosition.xyz);\n                if (depth > getDepth(gl_FragCoord.xy / uDrawingBufferSize))\n                    break;\n\n                #ifdef enabledFragDepth\n                    if (!hit) {\n                        gl_FragDepthEXT = depth;\n                    }\n                #endif\n\n                #if defined(dRenderVariant_pickObject)\n                    return vec4(encodeFloatRGB(float(uObjectId)), 1.0);\n                #elif defined(dRenderVariant_pickInstance)\n                    return vec4(encodeFloatRGB(vInstance), 1.0);\n                #elif defined(dRenderVariant_pickGroup)\n                    #ifdef dPackedGroup\n                        return vec4(textureGroup(floor(isoPos * uGridDim + 0.5) / uGridDim).rgb, 1.0);\n                    #else\n                        vec3 g = floor(isoPos * uGridDim + 0.5);\n                        return vec4(encodeFloatRGB(g.z + g.y * uGridDim.z + g.x * uGridDim.z * uGridDim.y), 1.0);\n                    #endif\n                #elif defined(dRenderVariant_depth)\n                    #ifdef enabledFragDepth\n                        return packDepthToRGBA(gl_FragDepthEXT);\n                    #else\n                        return packDepthToRGBA(depth);\n                    #endif\n                #elif defined(dRenderVariant_color)\n                    #ifdef dPackedGroup\n                        float group = decodeFloatRGB(textureGroup(floor(isoPos * uGridDim + 0.5) / uGridDim).rgb);\n                    #else\n                        vec3 g = floor(isoPos * uGridDim + 0.5);\n                        float group = g.z + g.y * uGridDim.z + g.x * uGridDim.z * uGridDim.y;\n                    #endif\n\n                    #if defined(dColorType_uniform)\n                        color = uColor;\n                    #elif defined(dColorType_instance)\n                        color = readFromTexture(tColor, vInstance, uColorTexDim).rgb;\n                    #elif defined(dColorType_group)\n                        color = readFromTexture(tColor, group, uColorTexDim).rgb;\n                    #elif defined(dColorType_groupInstance)\n                        color = readFromTexture(tColor, vInstance * float(uGroupCount) + group, uColorTexDim).rgb;\n                    #elif defined(dColorType_vertex)\n                        color = texture3dFrom1dTrilinear(tColor, isoPos, uGridDim, uColorTexDim, 0.0).rgb;\n                    #elif defined(dColorType_vertexInstance)\n                        color = 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                        color = mix(color, overpaint.rgb, overpaint.a);\n                    #endif\n\n                    // handle flipping and negative isosurfaces\n                    #ifdef dFlipSided\n                        bool flipped = value < uIsoValue.y; // flipped\n                    #else\n                        bool flipped = value > uIsoValue.y;\n                    #endif\n                    interior = value < uIsoValue.x && flipped;\n                    #ifndef dDoubleSided\n                        if (interior) {\n                            prevValue = value;\n                            pos += step;\n                            continue;\n                        }\n                    #endif\n                    vec3 vViewPosition = mvPosition.xyz;\n                    vec4 material = vec4(color, uAlpha);\n\n                    #ifdef dIgnoreLight\n                        gl_FragColor = material;\n                    #else\n                        #if defined(dFlatShaded)\n                            // nearest grid point\n                            isoPos = floor(isoPos * uGridDim + 0.5) / uGridDim;\n                        #endif\n                        #ifdef dPackedGroup\n                            // compute gradient by central differences\n                            gradient.x = textureVal(isoPos - dx).a - textureVal(isoPos + dx).a;\n                            gradient.y = textureVal(isoPos - dy).a - textureVal(isoPos + dy).a;\n                            gradient.z = textureVal(isoPos - dz).a - textureVal(isoPos + dz).a;\n                        #else\n                            gradient = textureVal(isoPos).xyz * 2.0 - 1.0;\n                        #endif\n                        vec3 normal = -normalize(normalMatrix * normalize(gradient));\n                        normal = normal * (float(flipped) * 2.0 - 1.0);\n                        normal = normal * -(float(interior) * 2.0 - 1.0);\n                        #ifdef dSubstance\n                            #if defined(dSubstanceType_groupInstance)\n                                substance = readFromTexture(tSubstance, vInstance * float(uGroupCount) + group, uSubstanceTexDim).rgb;\n                            #elif defined(dSubstanceType_vertexInstance)\n                                substance = texture3dFrom1dTrilinear(tSubstance, isoPos, uGridDim, uSubstanceTexDim, vInstance * float(uVertexCount)).rgb;\n                            #endif\n                            metalness = mix(metalness, substance.r, substance.b);\n                            roughness = mix(roughness, substance.g, substance.b);\n                        #endif\n                        #include apply_light_color\n                    #endif\n\n                    #if defined(dMarkerType_uniform)\n                        float marker = uMarker;\n                    #elif defined(dMarkerType_groupInstance)\n                        float 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                    #endif\n                    #include apply_interior_color\n                    #include apply_marker_color\n\n                    preFogAlphaBlended = (1.0 - preFogAlphaBlended) * gl_FragColor.a + preFogAlphaBlended;\n                    fragmentDepth = depth;\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                #endif\n\n                #ifdef dSingleLayer\n                    break;\n                #endif\n\n                hit = true;\n            }\n            prevValue = value;\n        #elif defined(dRenderMode_volume)\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            #if defined(dRenderVariant_color)\n                vec3 vViewPosition = mvPosition.xyz;\n                vec4 material = transferFunction(value);\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                #if defined(dMarkerType_uniform)\n                    float marker = uMarker;\n                #elif defined(dMarkerType_groupInstance)\n                    #ifdef dPackedGroup\n                        float group = decodeFloatRGB(textureGroup(floor(unitPos * uGridDim + 0.5) / uGridDim).rgb);\n                    #else\n                        vec3 g = floor(unitPos * uGridDim + 0.5);\n                        float group = g.z + g.y * uGridDim.z + g.x * uGridDim.z * uGridDim.y;\n                    #endif\n                    float 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                #endif\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            #endif\n        #endif\n\n        // break if the color is opaque enough\n        if (dst.a > 0.95)\n            break;\n\n        pos += step;\n    }\n\n    #if defined(dRenderMode_isosurface) && defined(enabledFragDepth)\n        // ensure depth is written everywhere\n        if (!hit)\n            gl_FragDepthEXT = 1.0;\n    #endif\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    #ifdef dRenderVariant_marking\n        // not supported\n        discard;\n    #endif\n\n    #if defined(dRenderVariant_pick) || defined(dRenderVariant_depth)\n        #if defined(dRenderMode_volume)\n            // always ignore pick & depth for volume\n            discard;\n        #elif defined(dRenderMode_isosurface)\n            if (uAlpha < uPickingAlphaThreshold)\n                discard; // ignore so the element below can be picked\n        #endif\n    #endif\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    #if defined(dRenderVariant_pick) || defined(dRenderVariant_depth)\n        // discard when nothing was hit\n        if (gl_FragColor == vec4(0.0))\n            discard;\n    #endif\n\n    #if defined(dRenderVariant_color)\n        #if defined(dRenderMode_isosurface) && defined(enabledFragDepth)\n            float fragmentDepth = gl_FragDepthEXT;\n        #else\n            float fragmentDepth = calcDepth((uModelView * vec4(start, 1.0)).xyz);\n        #endif\n        float preFogAlpha = clamp(preFogAlphaBlended, 0.0, 1.0);\n        interior = false;\n        #include wboit_write\n    #endif\n}\n";

package/lib/mol-gl/shader/direct-volume.frag.js CHANGED Viewed

@@ -4,5 +4,5 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  * @author Michael Krone <michael.krone@uni-tuebingen.de>
  */
-export var 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 vec2 uIsoValue;\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\n#if defined(dMarkerType_uniform)\n    uniform float uMarker;\n#elif defined(dMarkerType_groupInstance)\n    uniform vec2 uMarkerTexDim;\n    uniform sampler2D tMarker;\n#endif\n\nuniform float uFogNear;\nuniform float uFogFar;\nuniform vec3 uFogColor;\n\nuniform float uAlpha;\nuniform float uPickingAlphaThreshold;\nuniform bool uTransparentBackground;\n\nuniform float uInteriorDarkening;\nuniform bool uInteriorColorFlag;\nuniform vec3 uInteriorColor;\nbool interior;\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(dRenderVariant_color)\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#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\nvec4 transferFunction(float value) {\n    return texture2D(tTransferTex, vec2(value, 0.0));\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    #if defined(dRenderVariant_color) && !defined(dIgnoreLight)\n        mat3 normalMatrix = transpose3(inverse3(mat3(uModelView * vTransform)));\n    #endif\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    bool hit = false;\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    vec3 isoPos;\n\n    vec3 nextPos;\n    float nextValue;\n\n    vec3 color = vec3(0.45, 0.55, 0.8);\n    vec4 overpaint = vec4(0.0);\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            if (hit) break;\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        #if defined(dRenderMode_isosurface)\n            if (prevValue > 0.0 && ( // there was a prev Value\n                (prevValue < uIsoValue.x && value > uIsoValue.x) || // entering isosurface\n                (prevValue > uIsoValue.x && value < uIsoValue.x) // leaving isosurface\n            )) {\n                isoPos = v3m4(mix(pos - step, pos, ((prevValue - uIsoValue.x) / ((prevValue - uIsoValue.x) - (value - uIsoValue.x)))), cartnToUnit);\n\n                vec4 mvPosition = modelViewTransform * vec4(isoPos * uGridDim, 1.0);\n\n                #if defined(dClipVariant_pixel) && dClipObjectCount != 0\n                    vec3 vModelPosition = v3m4(isoPos * uGridDim, modelTransform);\n                    if (clipTest(vec4(vModelPosition, 0.0), 0)) {\n                        prevValue = value;\n                        pos += step;\n                        continue;\n                    }\n                #endif\n\n                float depth = calcDepth(mvPosition.xyz);\n                if (depth > getDepth(gl_FragCoord.xy / uDrawingBufferSize))\n                    break;\n\n                #ifdef enabledFragDepth\n                    if (!hit) {\n                        gl_FragDepthEXT = depth;\n                    }\n                #endif\n\n                #if defined(dRenderVariant_pickObject)\n                    return vec4(encodeFloatRGB(float(uObjectId)), 1.0);\n                #elif defined(dRenderVariant_pickInstance)\n                    return vec4(encodeFloatRGB(vInstance), 1.0);\n                #elif defined(dRenderVariant_pickGroup)\n                    #ifdef dPackedGroup\n                        return vec4(textureGroup(floor(isoPos * uGridDim + 0.5) / uGridDim).rgb, 1.0);\n                    #else\n                        vec3 g = floor(isoPos * uGridDim + 0.5);\n                        return vec4(encodeFloatRGB(g.z + g.y * uGridDim.z + g.x * uGridDim.z * uGridDim.y), 1.0);\n                    #endif\n                #elif defined(dRenderVariant_depth)\n                    #ifdef enabledFragDepth\n                        return packDepthToRGBA(gl_FragDepthEXT);\n                    #else\n                        return packDepthToRGBA(depth);\n                    #endif\n                #elif defined(dRenderVariant_color)\n                    #ifdef dPackedGroup\n                        float group = decodeFloatRGB(textureGroup(floor(isoPos * uGridDim + 0.5) / uGridDim).rgb);\n                    #else\n                        vec3 g = floor(isoPos * uGridDim + 0.5);\n                        float group = g.z + g.y * uGridDim.z + g.x * uGridDim.z * uGridDim.y;\n                    #endif\n\n                    #if defined(dColorType_uniform)\n                        color = uColor;\n                    #elif defined(dColorType_instance)\n                        color = readFromTexture(tColor, vInstance, uColorTexDim).rgb;\n                    #elif defined(dColorType_group)\n                        color = readFromTexture(tColor, group, uColorTexDim).rgb;\n                    #elif defined(dColorType_groupInstance)\n                        color = readFromTexture(tColor, vInstance * float(uGroupCount) + group, uColorTexDim).rgb;\n                    #elif defined(dColorType_vertex)\n                        color = texture3dFrom1dTrilinear(tColor, isoPos, uGridDim, uColorTexDim, 0.0).rgb;\n                    #elif defined(dColorType_vertexInstance)\n                        color = 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)).rgb;\n                        #endif\n\n                        color = mix(color, overpaint.rgb, overpaint.a);\n                    #endif\n\n                    // handle flipping and negative isosurfaces\n                    #ifdef dFlipSided\n                        bool flipped = value < uIsoValue.y; // flipped\n                    #else\n                        bool flipped = value > uIsoValue.y;\n                    #endif\n                    interior = value < uIsoValue.x && flipped;\n                    #ifndef dDoubleSided\n                        if (interior) {\n                            prevValue = value;\n                            pos += step;\n                            continue;\n                        }\n                    #endif\n                    vec3 vViewPosition = mvPosition.xyz;\n                    vec4 material = vec4(color, uAlpha);\n\n                    #ifdef dIgnoreLight\n                        gl_FragColor = material;\n                    #else\n                        #if defined(dFlatShaded)\n                            // nearest grid point\n                            isoPos = floor(isoPos * uGridDim + 0.5) / uGridDim;\n                        #endif\n                        #ifdef dPackedGroup\n                            // compute gradient by central differences\n                            gradient.x = textureVal(isoPos - dx).a - textureVal(isoPos + dx).a;\n                            gradient.y = textureVal(isoPos - dy).a - textureVal(isoPos + dy).a;\n                            gradient.z = textureVal(isoPos - dz).a - textureVal(isoPos + dz).a;\n                        #else\n                            gradient = textureVal(isoPos).xyz * 2.0 - 1.0;\n                        #endif\n                        vec3 normal = -normalize(normalMatrix * normalize(gradient));\n                        normal = normal * (float(flipped) * 2.0 - 1.0);\n                        normal = normal * -(float(interior) * 2.0 - 1.0);\n                        #include apply_light_color\n                    #endif\n\n                    #if defined(dMarkerType_uniform)\n                        float marker = uMarker;\n                    #elif defined(dMarkerType_groupInstance)\n                        float 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                    #endif\n                    #include apply_interior_color\n                    #include apply_marker_color\n\n                    preFogAlphaBlended = (1.0 - preFogAlphaBlended) * gl_FragColor.a + preFogAlphaBlended;\n                    fragmentDepth = depth;\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                #endif\n\n                #ifdef dSingleLayer\n                    break;\n                #endif\n\n                hit = true;\n            }\n            prevValue = value;\n        #elif defined(dRenderMode_volume)\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            #if defined(dRenderVariant_color)\n                vec3 vViewPosition = mvPosition.xyz;\n                vec4 material = transferFunction(value);\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                #if defined(dMarkerType_uniform)\n                    float marker = uMarker;\n                #elif defined(dMarkerType_groupInstance)\n                    #ifdef dPackedGroup\n                        float group = decodeFloatRGB(textureGroup(floor(unitPos * uGridDim + 0.5) / uGridDim).rgb);\n                    #else\n                        vec3 g = floor(unitPos * uGridDim + 0.5);\n                        float group = g.z + g.y * uGridDim.z + g.x * uGridDim.z * uGridDim.y;\n                    #endif\n                    float 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                #endif\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            #endif\n        #endif\n\n        // break if the color is opaque enough\n        if (dst.a > 0.95)\n            break;\n\n        pos += step;\n    }\n\n    #if defined(dRenderMode_isosurface) && defined(enabledFragDepth)\n        // ensure depth is written everywhere\n        if (!hit)\n            gl_FragDepthEXT = 1.0;\n    #endif\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    #ifdef dRenderVariant_marking\n        // not supported\n        discard;\n    #endif\n\n    #if defined(dRenderVariant_pick) || defined(dRenderVariant_depth)\n        #if defined(dRenderMode_volume)\n            // always ignore pick & depth for volume\n            discard;\n        #elif defined(dRenderMode_isosurface)\n            if (uAlpha < uPickingAlphaThreshold)\n                discard; // ignore so the element below can be picked\n        #endif\n    #endif\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    #if defined(dRenderVariant_pick) || defined(dRenderVariant_depth)\n        // discard when nothing was hit\n        if (gl_FragColor == vec4(0.0))\n            discard;\n    #endif\n\n    #if defined(dRenderVariant_color)\n        #if defined(dRenderMode_isosurface) && defined(enabledFragDepth)\n            float fragmentDepth = gl_FragDepthEXT;\n        #else\n            float fragmentDepth = calcDepth((uModelView * vec4(start, 1.0)).xyz);\n        #endif\n        float preFogAlpha = clamp(preFogAlphaBlended, 0.0, 1.0);\n        interior = false;\n        #include wboit_write\n    #endif\n}\n";
+export var 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 vec2 uIsoValue;\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\n#if defined(dMarkerType_uniform)\n    uniform float uMarker;\n#elif defined(dMarkerType_groupInstance)\n    uniform vec2 uMarkerTexDim;\n    uniform sampler2D tMarker;\n#endif\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;\n\nuniform float uInteriorDarkening;\nuniform bool uInteriorColorFlag;\nuniform vec3 uInteriorColor;\nbool interior;\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(dRenderVariant_color)\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 dSubstance\n        #if defined(dSubstanceType_groupInstance) || defined(dSubstanceType_vertexInstance)\n            uniform vec2 uSubstanceTexDim;\n            uniform sampler2D tSubstance;\n        #endif\n    #endif\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\nvec4 transferFunction(float value) {\n    return texture2D(tTransferTex, vec2(value, 0.0));\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    #if defined(dRenderVariant_color) && !defined(dIgnoreLight)\n        mat3 normalMatrix = transpose3(inverse3(mat3(uModelView * vTransform)));\n    #endif\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    bool hit = false;\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    vec3 isoPos;\n\n    vec3 nextPos;\n    float nextValue;\n\n    vec3 color = vec3(0.45, 0.55, 0.8);\n    vec4 overpaint = vec4(0.0);\n    vec3 substance = vec3(0.0);\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            if (hit) break;\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        #if defined(dRenderMode_isosurface)\n            if (prevValue > 0.0 && ( // there was a prev Value\n                (prevValue < uIsoValue.x && value > uIsoValue.x) || // entering isosurface\n                (prevValue > uIsoValue.x && value < uIsoValue.x) // leaving isosurface\n            )) {\n                isoPos = v3m4(mix(pos - step, pos, ((prevValue - uIsoValue.x) / ((prevValue - uIsoValue.x) - (value - uIsoValue.x)))), cartnToUnit);\n\n                vec4 mvPosition = modelViewTransform * vec4(isoPos * uGridDim, 1.0);\n\n                #if defined(dClipVariant_pixel) && dClipObjectCount != 0\n                    vec3 vModelPosition = v3m4(isoPos * uGridDim, modelTransform);\n                    if (clipTest(vec4(vModelPosition, 0.0), 0)) {\n                        prevValue = value;\n                        pos += step;\n                        continue;\n                    }\n                #endif\n\n                float depth = calcDepth(mvPosition.xyz);\n                if (depth > getDepth(gl_FragCoord.xy / uDrawingBufferSize))\n                    break;\n\n                #ifdef enabledFragDepth\n                    if (!hit) {\n                        gl_FragDepthEXT = depth;\n                    }\n                #endif\n\n                #if defined(dRenderVariant_pickObject)\n                    return vec4(encodeFloatRGB(float(uObjectId)), 1.0);\n                #elif defined(dRenderVariant_pickInstance)\n                    return vec4(encodeFloatRGB(vInstance), 1.0);\n                #elif defined(dRenderVariant_pickGroup)\n                    #ifdef dPackedGroup\n                        return vec4(textureGroup(floor(isoPos * uGridDim + 0.5) / uGridDim).rgb, 1.0);\n                    #else\n                        vec3 g = floor(isoPos * uGridDim + 0.5);\n                        return vec4(encodeFloatRGB(g.z + g.y * uGridDim.z + g.x * uGridDim.z * uGridDim.y), 1.0);\n                    #endif\n                #elif defined(dRenderVariant_depth)\n                    #ifdef enabledFragDepth\n                        return packDepthToRGBA(gl_FragDepthEXT);\n                    #else\n                        return packDepthToRGBA(depth);\n                    #endif\n                #elif defined(dRenderVariant_color)\n                    #ifdef dPackedGroup\n                        float group = decodeFloatRGB(textureGroup(floor(isoPos * uGridDim + 0.5) / uGridDim).rgb);\n                    #else\n                        vec3 g = floor(isoPos * uGridDim + 0.5);\n                        float group = g.z + g.y * uGridDim.z + g.x * uGridDim.z * uGridDim.y;\n                    #endif\n\n                    #if defined(dColorType_uniform)\n                        color = uColor;\n                    #elif defined(dColorType_instance)\n                        color = readFromTexture(tColor, vInstance, uColorTexDim).rgb;\n                    #elif defined(dColorType_group)\n                        color = readFromTexture(tColor, group, uColorTexDim).rgb;\n                    #elif defined(dColorType_groupInstance)\n                        color = readFromTexture(tColor, vInstance * float(uGroupCount) + group, uColorTexDim).rgb;\n                    #elif defined(dColorType_vertex)\n                        color = texture3dFrom1dTrilinear(tColor, isoPos, uGridDim, uColorTexDim, 0.0).rgb;\n                    #elif defined(dColorType_vertexInstance)\n                        color = 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                        color = mix(color, overpaint.rgb, overpaint.a);\n                    #endif\n\n                    // handle flipping and negative isosurfaces\n                    #ifdef dFlipSided\n                        bool flipped = value < uIsoValue.y; // flipped\n                    #else\n                        bool flipped = value > uIsoValue.y;\n                    #endif\n                    interior = value < uIsoValue.x && flipped;\n                    #ifndef dDoubleSided\n                        if (interior) {\n                            prevValue = value;\n                            pos += step;\n                            continue;\n                        }\n                    #endif\n                    vec3 vViewPosition = mvPosition.xyz;\n                    vec4 material = vec4(color, uAlpha);\n\n                    #ifdef dIgnoreLight\n                        gl_FragColor = material;\n                    #else\n                        #if defined(dFlatShaded)\n                            // nearest grid point\n                            isoPos = floor(isoPos * uGridDim + 0.5) / uGridDim;\n                        #endif\n                        #ifdef dPackedGroup\n                            // compute gradient by central differences\n                            gradient.x = textureVal(isoPos - dx).a - textureVal(isoPos + dx).a;\n                            gradient.y = textureVal(isoPos - dy).a - textureVal(isoPos + dy).a;\n                            gradient.z = textureVal(isoPos - dz).a - textureVal(isoPos + dz).a;\n                        #else\n                            gradient = textureVal(isoPos).xyz * 2.0 - 1.0;\n                        #endif\n                        vec3 normal = -normalize(normalMatrix * normalize(gradient));\n                        normal = normal * (float(flipped) * 2.0 - 1.0);\n                        normal = normal * -(float(interior) * 2.0 - 1.0);\n                        #ifdef dSubstance\n                            #if defined(dSubstanceType_groupInstance)\n                                substance = readFromTexture(tSubstance, vInstance * float(uGroupCount) + group, uSubstanceTexDim).rgb;\n                            #elif defined(dSubstanceType_vertexInstance)\n                                substance = texture3dFrom1dTrilinear(tSubstance, isoPos, uGridDim, uSubstanceTexDim, vInstance * float(uVertexCount)).rgb;\n                            #endif\n                            metalness = mix(metalness, substance.r, substance.b);\n                            roughness = mix(roughness, substance.g, substance.b);\n                        #endif\n                        #include apply_light_color\n                    #endif\n\n                    #if defined(dMarkerType_uniform)\n                        float marker = uMarker;\n                    #elif defined(dMarkerType_groupInstance)\n                        float 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                    #endif\n                    #include apply_interior_color\n                    #include apply_marker_color\n\n                    preFogAlphaBlended = (1.0 - preFogAlphaBlended) * gl_FragColor.a + preFogAlphaBlended;\n                    fragmentDepth = depth;\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                #endif\n\n                #ifdef dSingleLayer\n                    break;\n                #endif\n\n                hit = true;\n            }\n            prevValue = value;\n        #elif defined(dRenderMode_volume)\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            #if defined(dRenderVariant_color)\n                vec3 vViewPosition = mvPosition.xyz;\n                vec4 material = transferFunction(value);\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                #if defined(dMarkerType_uniform)\n                    float marker = uMarker;\n                #elif defined(dMarkerType_groupInstance)\n                    #ifdef dPackedGroup\n                        float group = decodeFloatRGB(textureGroup(floor(unitPos * uGridDim + 0.5) / uGridDim).rgb);\n                    #else\n                        vec3 g = floor(unitPos * uGridDim + 0.5);\n                        float group = g.z + g.y * uGridDim.z + g.x * uGridDim.z * uGridDim.y;\n                    #endif\n                    float 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                #endif\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            #endif\n        #endif\n\n        // break if the color is opaque enough\n        if (dst.a > 0.95)\n            break;\n\n        pos += step;\n    }\n\n    #if defined(dRenderMode_isosurface) && defined(enabledFragDepth)\n        // ensure depth is written everywhere\n        if (!hit)\n            gl_FragDepthEXT = 1.0;\n    #endif\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    #ifdef dRenderVariant_marking\n        // not supported\n        discard;\n    #endif\n\n    #if defined(dRenderVariant_pick) || defined(dRenderVariant_depth)\n        #if defined(dRenderMode_volume)\n            // always ignore pick & depth for volume\n            discard;\n        #elif defined(dRenderMode_isosurface)\n            if (uAlpha < uPickingAlphaThreshold)\n                discard; // ignore so the element below can be picked\n        #endif\n    #endif\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    #if defined(dRenderVariant_pick) || defined(dRenderVariant_depth)\n        // discard when nothing was hit\n        if (gl_FragColor == vec4(0.0))\n            discard;\n    #endif\n\n    #if defined(dRenderVariant_color)\n        #if defined(dRenderMode_isosurface) && defined(enabledFragDepth)\n            float fragmentDepth = gl_FragDepthEXT;\n        #else\n            float fragmentDepth = calcDepth((uModelView * vec4(start, 1.0)).xyz);\n        #endif\n        float preFogAlpha = clamp(preFogAlphaBlended, 0.0, 1.0);\n        interior = false;\n        #include wboit_write\n    #endif\n}\n";
 //# sourceMappingURL=direct-volume.frag.js.map

package/lib/mol-gl/shader/mesh.frag.d.ts CHANGED Viewed

@@ -3,4 +3,4 @@
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
-export declare const mesh_frag = "\nprecision highp float;\nprecision highp int;\n\n#include common\n#include common_frag_params\n#include color_frag_params\n#include light_frag_params\n#include normal_frag_params\n#include common_clip\n\nvoid main() {\n    #include clip_pixel\n\n    // Workaround for buggy gl_FrontFacing (e.g. on some integrated Intel GPUs)\n    #if defined(enabledStandardDerivatives)\n        vec3 fdx = dFdx(vViewPosition);\n        vec3 fdy = dFdy(vViewPosition);\n        vec3 faceNormal = normalize(cross(fdx,fdy));\n        bool frontFacing = dot(vNormal, faceNormal) > 0.0;\n    #else\n        bool frontFacing = dot(vNormal, vViewPosition) < 0.0;\n    #endif\n\n    #if defined(dFlipSided)\n        interior = frontFacing;\n    #else\n        interior = !frontFacing;\n    #endif\n\n    float fragmentDepth = gl_FragCoord.z;\n    #include assign_material_color\n\n    #if defined(dRenderVariant_pick)\n        #include check_picking_alpha\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_depth)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_marking)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_color)\n        #ifdef dIgnoreLight\n            gl_FragColor = material;\n        #else\n            #if defined(dFlatShaded) && defined(enabledStandardDerivatives)\n                vec3 normal = -faceNormal;\n            #else\n                vec3 normal = -normalize(vNormal);\n                #ifdef dDoubleSided\n                    normal = normal * (float(frontFacing) * 2.0 - 1.0);\n                #endif\n            #endif\n            #include apply_light_color\n        #endif\n\n        #include apply_interior_color\n        #include apply_marker_color\n        #include apply_fog\n        #include wboit_write\n    #endif\n}\n";
+export declare const mesh_frag = "\nprecision highp float;\nprecision highp int;\n\n#define bumpEnabled\n\n#include common\n#include common_frag_params\n#include color_frag_params\n#include light_frag_params\n#include normal_frag_params\n#include common_clip\n\nvoid main() {\n    #include clip_pixel\n\n    // Workaround for buggy gl_FrontFacing (e.g. on some integrated Intel GPUs)\n    vec3 fdx = dFdx(vViewPosition);\n    vec3 fdy = dFdy(vViewPosition);\n    vec3 faceNormal = normalize(cross(fdx,fdy));\n    bool frontFacing = dot(vNormal, faceNormal) > 0.0;\n\n    #if defined(dFlipSided)\n        interior = frontFacing;\n    #else\n        interior = !frontFacing;\n    #endif\n\n    float fragmentDepth = gl_FragCoord.z;\n    #include assign_material_color\n\n    #if defined(dRenderVariant_pick)\n        #include check_picking_alpha\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_depth)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_marking)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_color)\n        #ifdef dIgnoreLight\n            gl_FragColor = material;\n        #else\n            #if defined(dFlatShaded)\n                vec3 normal = -faceNormal;\n            #else\n                vec3 normal = -normalize(vNormal);\n                #ifdef dDoubleSided\n                    normal = normal * (float(frontFacing) * 2.0 - 1.0);\n                #endif\n            #endif\n            #include apply_light_color\n        #endif\n\n        #include apply_interior_color\n        #include apply_marker_color\n        #include apply_fog\n        #include wboit_write\n    #endif\n}\n";

package/lib/mol-gl/shader/mesh.frag.js CHANGED Viewed

@@ -3,5 +3,5 @@
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
-export var mesh_frag = "\nprecision highp float;\nprecision highp int;\n\n#include common\n#include common_frag_params\n#include color_frag_params\n#include light_frag_params\n#include normal_frag_params\n#include common_clip\n\nvoid main() {\n    #include clip_pixel\n\n    // Workaround for buggy gl_FrontFacing (e.g. on some integrated Intel GPUs)\n    #if defined(enabledStandardDerivatives)\n        vec3 fdx = dFdx(vViewPosition);\n        vec3 fdy = dFdy(vViewPosition);\n        vec3 faceNormal = normalize(cross(fdx,fdy));\n        bool frontFacing = dot(vNormal, faceNormal) > 0.0;\n    #else\n        bool frontFacing = dot(vNormal, vViewPosition) < 0.0;\n    #endif\n\n    #if defined(dFlipSided)\n        interior = frontFacing;\n    #else\n        interior = !frontFacing;\n    #endif\n\n    float fragmentDepth = gl_FragCoord.z;\n    #include assign_material_color\n\n    #if defined(dRenderVariant_pick)\n        #include check_picking_alpha\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_depth)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_marking)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_color)\n        #ifdef dIgnoreLight\n            gl_FragColor = material;\n        #else\n            #if defined(dFlatShaded) && defined(enabledStandardDerivatives)\n                vec3 normal = -faceNormal;\n            #else\n                vec3 normal = -normalize(vNormal);\n                #ifdef dDoubleSided\n                    normal = normal * (float(frontFacing) * 2.0 - 1.0);\n                #endif\n            #endif\n            #include apply_light_color\n        #endif\n\n        #include apply_interior_color\n        #include apply_marker_color\n        #include apply_fog\n        #include wboit_write\n    #endif\n}\n";
+export var mesh_frag = "\nprecision highp float;\nprecision highp int;\n\n#define bumpEnabled\n\n#include common\n#include common_frag_params\n#include color_frag_params\n#include light_frag_params\n#include normal_frag_params\n#include common_clip\n\nvoid main() {\n    #include clip_pixel\n\n    // Workaround for buggy gl_FrontFacing (e.g. on some integrated Intel GPUs)\n    vec3 fdx = dFdx(vViewPosition);\n    vec3 fdy = dFdy(vViewPosition);\n    vec3 faceNormal = normalize(cross(fdx,fdy));\n    bool frontFacing = dot(vNormal, faceNormal) > 0.0;\n\n    #if defined(dFlipSided)\n        interior = frontFacing;\n    #else\n        interior = !frontFacing;\n    #endif\n\n    float fragmentDepth = gl_FragCoord.z;\n    #include assign_material_color\n\n    #if defined(dRenderVariant_pick)\n        #include check_picking_alpha\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_depth)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_marking)\n        gl_FragColor = material;\n    #elif defined(dRenderVariant_color)\n        #ifdef dIgnoreLight\n            gl_FragColor = material;\n        #else\n            #if defined(dFlatShaded)\n                vec3 normal = -faceNormal;\n            #else\n                vec3 normal = -normalize(vNormal);\n                #ifdef dDoubleSided\n                    normal = normal * (float(frontFacing) * 2.0 - 1.0);\n                #endif\n            #endif\n            #include apply_light_color\n        #endif\n\n        #include apply_interior_color\n        #include apply_marker_color\n        #include apply_fog\n        #include wboit_write\n    #endif\n}\n";
 //# sourceMappingURL=mesh.frag.js.map

package/lib/mol-gl/shader/postprocessing.frag.d.ts CHANGED Viewed

@@ -4,4 +4,4 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  * @author Áron Samuel Kovács <aron.kovacs@mail.muni.cz>
  */
-export declare const postprocessing_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform sampler2D tSsaoDepth;\nuniform sampler2D tColor;\nuniform sampler2D tDepth;\nuniform sampler2D tOutlines;\nuniform vec2 uTexSize;\n\nuniform float uNear;\nuniform float uFar;\nuniform float uFogNear;\nuniform float uFogFar;\nuniform vec3 uFogColor;\nuniform bool uTransparentBackground;\n\nuniform float uOcclusionBias;\nuniform float uOcclusionRadius;\n\nuniform float uMaxPossibleViewZDiff;\n\nconst vec3 occlusionColor = vec3(0.0);\n\n#include common\n\nfloat getViewZ(const in float depth) {\n    #if dOrthographic == 1\n        return orthographicDepthToViewZ(depth, uNear, uFar);\n    #else\n        return perspectiveDepthToViewZ(depth, uNear, uFar);\n    #endif\n}\n\nfloat getDepth(const in vec2 coords) {\n    return unpackRGBAToDepth(texture2D(tDepth, coords));\n}\n\nbool isBackground(const in float depth) {\n    return depth == 1.0;\n}\n\nfloat getOutline(const in vec2 coords, out float closestTexel) {\n    float backgroundViewZ = uFar + 3.0 * uMaxPossibleViewZDiff;\n    vec2 invTexSize = 1.0 / uTexSize;\n\n    float selfDepth = getDepth(coords);\n    float selfViewZ = isBackground(selfDepth) ? backgroundViewZ : getViewZ(selfDepth);\n\n    float outline = 1.0;\n    closestTexel = 1.0;\n    for (int y = -dOutlineScale; y <= dOutlineScale; y++) {\n        for (int x = -dOutlineScale; x <= dOutlineScale; x++) {\n            if (x * x + y * y > dOutlineScale * dOutlineScale) {\n                continue;\n            }\n\n            vec2 sampleCoords = coords + vec2(float(x), float(y)) * invTexSize;\n\n            vec4 sampleOutlineCombined = texture2D(tOutlines, sampleCoords);\n            float sampleOutline = sampleOutlineCombined.r;\n            float sampleOutlineDepth = unpackRGToUnitInterval(sampleOutlineCombined.gb);\n\n            if (sampleOutline == 0.0 && sampleOutlineDepth < closestTexel && abs(selfViewZ - sampleOutlineDepth) > uMaxPossibleViewZDiff) {\n                outline = 0.0;\n                closestTexel = sampleOutlineDepth;\n            }\n        }\n    }\n    return outline;\n}\n\nfloat getSsao(vec2 coords) {\n    float rawSsao = unpackRGToUnitInterval(texture2D(tSsaoDepth, coords).xy);\n    if (rawSsao > 0.999) {\n        return 1.0;\n    } else if (rawSsao > 0.001) {\n        return rawSsao;\n    }\n    // treat values close to 0.0 as errors and return no occlusion\n    return 1.0;\n}\n\nvoid main(void) {\n    vec2 coords = gl_FragCoord.xy / uTexSize;\n    vec4 color = texture2D(tColor, coords);\n\n    float viewDist;\n    float fogFactor;\n\n    #ifdef dOcclusionEnable\n        float depth = getDepth(coords);\n        if (!isBackground(depth)) {\n            viewDist = abs(getViewZ(depth));\n            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);\n            float occlusionFactor = getSsao(coords);\n            if (!uTransparentBackground) {\n                color.rgb = mix(mix(occlusionColor, uFogColor, fogFactor), color.rgb, occlusionFactor);\n            } else {\n                color.rgb = mix(occlusionColor * (1.0 - fogFactor), color.rgb, occlusionFactor);\n            }\n        }\n    #endif\n\n    // outline needs to be handled after occlusion to keep them clean\n    #ifdef dOutlineEnable\n        float closestTexel;\n        float outline = getOutline(coords, closestTexel);\n\n        if (outline == 0.0) {\n            color.rgb *= outline;\n            viewDist = abs(getViewZ(closestTexel));\n            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);\n            if (!uTransparentBackground) {\n                color.rgb = mix(color.rgb, uFogColor, fogFactor);\n            } else {\n                color.a = 1.0 - fogFactor;\n            }\n        }\n    #endif\n\n    gl_FragColor = color;\n}\n";
+export declare const postprocessing_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform sampler2D tSsaoDepth;\nuniform sampler2D tColor;\nuniform sampler2D tDepth;\nuniform sampler2D tOutlines;\nuniform vec2 uTexSize;\n\nuniform float uNear;\nuniform float uFar;\nuniform float uFogNear;\nuniform float uFogFar;\nuniform vec3 uFogColor;\nuniform vec3 uOutlineColor;\nuniform bool uTransparentBackground;\n\nuniform float uOcclusionBias;\nuniform float uOcclusionRadius;\n\nuniform float uMaxPossibleViewZDiff;\n\nconst vec3 occlusionColor = vec3(0.0);\n\n#include common\n\nfloat getViewZ(const in float depth) {\n    #if dOrthographic == 1\n        return orthographicDepthToViewZ(depth, uNear, uFar);\n    #else\n        return perspectiveDepthToViewZ(depth, uNear, uFar);\n    #endif\n}\n\nfloat getDepth(const in vec2 coords) {\n    return unpackRGBAToDepth(texture2D(tDepth, coords));\n}\n\nbool isBackground(const in float depth) {\n    return depth == 1.0;\n}\n\nfloat getOutline(const in vec2 coords, out float closestTexel) {\n    float backgroundViewZ = uFar + 3.0 * uMaxPossibleViewZDiff;\n    vec2 invTexSize = 1.0 / uTexSize;\n\n    float selfDepth = getDepth(coords);\n    float selfViewZ = isBackground(selfDepth) ? backgroundViewZ : getViewZ(selfDepth);\n\n    float outline = 1.0;\n    closestTexel = 1.0;\n    for (int y = -dOutlineScale; y <= dOutlineScale; y++) {\n        for (int x = -dOutlineScale; x <= dOutlineScale; x++) {\n            if (x * x + y * y > dOutlineScale * dOutlineScale) {\n                continue;\n            }\n\n            vec2 sampleCoords = coords + vec2(float(x), float(y)) * invTexSize;\n\n            vec4 sampleOutlineCombined = texture2D(tOutlines, sampleCoords);\n            float sampleOutline = sampleOutlineCombined.r;\n            float sampleOutlineDepth = unpackRGToUnitInterval(sampleOutlineCombined.gb);\n\n            if (sampleOutline == 0.0 && sampleOutlineDepth < closestTexel && abs(selfViewZ - sampleOutlineDepth) > uMaxPossibleViewZDiff) {\n                outline = 0.0;\n                closestTexel = sampleOutlineDepth;\n            }\n        }\n    }\n    return outline;\n}\n\nfloat getSsao(vec2 coords) {\n    float rawSsao = unpackRGToUnitInterval(texture2D(tSsaoDepth, coords).xy);\n    if (rawSsao > 0.999) {\n        return 1.0;\n    } else if (rawSsao > 0.001) {\n        return rawSsao;\n    }\n    // treat values close to 0.0 as errors and return no occlusion\n    return 1.0;\n}\n\nvoid main(void) {\n    vec2 coords = gl_FragCoord.xy / uTexSize;\n    vec4 color = texture2D(tColor, coords);\n\n    float viewDist;\n    float fogFactor;\n\n    #ifdef dOcclusionEnable\n        float depth = getDepth(coords);\n        if (!isBackground(depth)) {\n            viewDist = abs(getViewZ(depth));\n            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);\n            float occlusionFactor = getSsao(coords);\n            if (!uTransparentBackground) {\n                color.rgb = mix(mix(occlusionColor, uFogColor, fogFactor), color.rgb, occlusionFactor);\n            } else {\n                color.rgb = mix(occlusionColor * (1.0 - fogFactor), color.rgb, occlusionFactor);\n            }\n        }\n    #endif\n\n    // outline needs to be handled after occlusion to keep them clean\n    #ifdef dOutlineEnable\n        float closestTexel;\n        float outline = getOutline(coords, closestTexel);\n\n        if (outline == 0.0) {\n            color.rgb = mix(uOutlineColor, color.rgb, outline);\n            viewDist = abs(getViewZ(closestTexel));\n            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);\n            if (!uTransparentBackground) {\n                color.rgb = mix(color.rgb, uFogColor, fogFactor);\n            } else {\n                color.a = 1.0 - fogFactor;\n            }\n        }\n    #endif\n\n    gl_FragColor = color;\n}\n";

package/lib/mol-gl/shader/postprocessing.frag.js CHANGED Viewed

@@ -4,5 +4,5 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  * @author Áron Samuel Kovács <aron.kovacs@mail.muni.cz>
  */
-export var postprocessing_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform sampler2D tSsaoDepth;\nuniform sampler2D tColor;\nuniform sampler2D tDepth;\nuniform sampler2D tOutlines;\nuniform vec2 uTexSize;\n\nuniform float uNear;\nuniform float uFar;\nuniform float uFogNear;\nuniform float uFogFar;\nuniform vec3 uFogColor;\nuniform bool uTransparentBackground;\n\nuniform float uOcclusionBias;\nuniform float uOcclusionRadius;\n\nuniform float uMaxPossibleViewZDiff;\n\nconst vec3 occlusionColor = vec3(0.0);\n\n#include common\n\nfloat getViewZ(const in float depth) {\n    #if dOrthographic == 1\n        return orthographicDepthToViewZ(depth, uNear, uFar);\n    #else\n        return perspectiveDepthToViewZ(depth, uNear, uFar);\n    #endif\n}\n\nfloat getDepth(const in vec2 coords) {\n    return unpackRGBAToDepth(texture2D(tDepth, coords));\n}\n\nbool isBackground(const in float depth) {\n    return depth == 1.0;\n}\n\nfloat getOutline(const in vec2 coords, out float closestTexel) {\n    float backgroundViewZ = uFar + 3.0 * uMaxPossibleViewZDiff;\n    vec2 invTexSize = 1.0 / uTexSize;\n\n    float selfDepth = getDepth(coords);\n    float selfViewZ = isBackground(selfDepth) ? backgroundViewZ : getViewZ(selfDepth);\n\n    float outline = 1.0;\n    closestTexel = 1.0;\n    for (int y = -dOutlineScale; y <= dOutlineScale; y++) {\n        for (int x = -dOutlineScale; x <= dOutlineScale; x++) {\n            if (x * x + y * y > dOutlineScale * dOutlineScale) {\n                continue;\n            }\n\n            vec2 sampleCoords = coords + vec2(float(x), float(y)) * invTexSize;\n\n            vec4 sampleOutlineCombined = texture2D(tOutlines, sampleCoords);\n            float sampleOutline = sampleOutlineCombined.r;\n            float sampleOutlineDepth = unpackRGToUnitInterval(sampleOutlineCombined.gb);\n\n            if (sampleOutline == 0.0 && sampleOutlineDepth < closestTexel && abs(selfViewZ - sampleOutlineDepth) > uMaxPossibleViewZDiff) {\n                outline = 0.0;\n                closestTexel = sampleOutlineDepth;\n            }\n        }\n    }\n    return outline;\n}\n\nfloat getSsao(vec2 coords) {\n    float rawSsao = unpackRGToUnitInterval(texture2D(tSsaoDepth, coords).xy);\n    if (rawSsao > 0.999) {\n        return 1.0;\n    } else if (rawSsao > 0.001) {\n        return rawSsao;\n    }\n    // treat values close to 0.0 as errors and return no occlusion\n    return 1.0;\n}\n\nvoid main(void) {\n    vec2 coords = gl_FragCoord.xy / uTexSize;\n    vec4 color = texture2D(tColor, coords);\n\n    float viewDist;\n    float fogFactor;\n\n    #ifdef dOcclusionEnable\n        float depth = getDepth(coords);\n        if (!isBackground(depth)) {\n            viewDist = abs(getViewZ(depth));\n            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);\n            float occlusionFactor = getSsao(coords);\n            if (!uTransparentBackground) {\n                color.rgb = mix(mix(occlusionColor, uFogColor, fogFactor), color.rgb, occlusionFactor);\n            } else {\n                color.rgb = mix(occlusionColor * (1.0 - fogFactor), color.rgb, occlusionFactor);\n            }\n        }\n    #endif\n\n    // outline needs to be handled after occlusion to keep them clean\n    #ifdef dOutlineEnable\n        float closestTexel;\n        float outline = getOutline(coords, closestTexel);\n\n        if (outline == 0.0) {\n            color.rgb *= outline;\n            viewDist = abs(getViewZ(closestTexel));\n            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);\n            if (!uTransparentBackground) {\n                color.rgb = mix(color.rgb, uFogColor, fogFactor);\n            } else {\n                color.a = 1.0 - fogFactor;\n            }\n        }\n    #endif\n\n    gl_FragColor = color;\n}\n";
+export var postprocessing_frag = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nuniform sampler2D tSsaoDepth;\nuniform sampler2D tColor;\nuniform sampler2D tDepth;\nuniform sampler2D tOutlines;\nuniform vec2 uTexSize;\n\nuniform float uNear;\nuniform float uFar;\nuniform float uFogNear;\nuniform float uFogFar;\nuniform vec3 uFogColor;\nuniform vec3 uOutlineColor;\nuniform bool uTransparentBackground;\n\nuniform float uOcclusionBias;\nuniform float uOcclusionRadius;\n\nuniform float uMaxPossibleViewZDiff;\n\nconst vec3 occlusionColor = vec3(0.0);\n\n#include common\n\nfloat getViewZ(const in float depth) {\n    #if dOrthographic == 1\n        return orthographicDepthToViewZ(depth, uNear, uFar);\n    #else\n        return perspectiveDepthToViewZ(depth, uNear, uFar);\n    #endif\n}\n\nfloat getDepth(const in vec2 coords) {\n    return unpackRGBAToDepth(texture2D(tDepth, coords));\n}\n\nbool isBackground(const in float depth) {\n    return depth == 1.0;\n}\n\nfloat getOutline(const in vec2 coords, out float closestTexel) {\n    float backgroundViewZ = uFar + 3.0 * uMaxPossibleViewZDiff;\n    vec2 invTexSize = 1.0 / uTexSize;\n\n    float selfDepth = getDepth(coords);\n    float selfViewZ = isBackground(selfDepth) ? backgroundViewZ : getViewZ(selfDepth);\n\n    float outline = 1.0;\n    closestTexel = 1.0;\n    for (int y = -dOutlineScale; y <= dOutlineScale; y++) {\n        for (int x = -dOutlineScale; x <= dOutlineScale; x++) {\n            if (x * x + y * y > dOutlineScale * dOutlineScale) {\n                continue;\n            }\n\n            vec2 sampleCoords = coords + vec2(float(x), float(y)) * invTexSize;\n\n            vec4 sampleOutlineCombined = texture2D(tOutlines, sampleCoords);\n            float sampleOutline = sampleOutlineCombined.r;\n            float sampleOutlineDepth = unpackRGToUnitInterval(sampleOutlineCombined.gb);\n\n            if (sampleOutline == 0.0 && sampleOutlineDepth < closestTexel && abs(selfViewZ - sampleOutlineDepth) > uMaxPossibleViewZDiff) {\n                outline = 0.0;\n                closestTexel = sampleOutlineDepth;\n            }\n        }\n    }\n    return outline;\n}\n\nfloat getSsao(vec2 coords) {\n    float rawSsao = unpackRGToUnitInterval(texture2D(tSsaoDepth, coords).xy);\n    if (rawSsao > 0.999) {\n        return 1.0;\n    } else if (rawSsao > 0.001) {\n        return rawSsao;\n    }\n    // treat values close to 0.0 as errors and return no occlusion\n    return 1.0;\n}\n\nvoid main(void) {\n    vec2 coords = gl_FragCoord.xy / uTexSize;\n    vec4 color = texture2D(tColor, coords);\n\n    float viewDist;\n    float fogFactor;\n\n    #ifdef dOcclusionEnable\n        float depth = getDepth(coords);\n        if (!isBackground(depth)) {\n            viewDist = abs(getViewZ(depth));\n            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);\n            float occlusionFactor = getSsao(coords);\n            if (!uTransparentBackground) {\n                color.rgb = mix(mix(occlusionColor, uFogColor, fogFactor), color.rgb, occlusionFactor);\n            } else {\n                color.rgb = mix(occlusionColor * (1.0 - fogFactor), color.rgb, occlusionFactor);\n            }\n        }\n    #endif\n\n    // outline needs to be handled after occlusion to keep them clean\n    #ifdef dOutlineEnable\n        float closestTexel;\n        float outline = getOutline(coords, closestTexel);\n\n        if (outline == 0.0) {\n            color.rgb = mix(uOutlineColor, color.rgb, outline);\n            viewDist = abs(getViewZ(closestTexel));\n            fogFactor = smoothstep(uFogNear, uFogFar, viewDist);\n            if (!uTransparentBackground) {\n                color.rgb = mix(color.rgb, uFogColor, fogFactor);\n            } else {\n                color.a = 1.0 - fogFactor;\n            }\n        }\n    #endif\n\n    gl_FragColor = color;\n}\n";
 //# sourceMappingURL=postprocessing.frag.js.map