@agrotools1/at-components 0.6.0 → 0.6.4

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/2d/engine/webgl/shaders/sources/shaderRepository.js

@@ -1,3885 +0,0 @@
-const e = { background: { "background.frag": `uniform lowp vec4 u_color;
-void main() {
-gl_FragColor = u_color;
-}`, "background.vert": `attribute vec2 a_pos;
-uniform highp mat3 u_dvsMat3;
-uniform mediump vec2 u_coord_range;
-uniform mediump float u_depth;
-void main() {
-vec3 v_pos = u_dvsMat3 * vec3(u_coord_range * a_pos, 1.0);
-gl_Position = vec4(v_pos.xy, 0.0, 1.0);
-}` }, bitBlit: { "bitBlit.frag": `uniform lowp sampler2D u_tex;
-uniform lowp float u_opacity;
-varying mediump vec2 v_uv;
-void main() {
-lowp vec4 color = texture2D(u_tex, v_uv);
-gl_FragColor = color * u_opacity;
-}`, "bitBlit.vert": `attribute vec2 a_pos;
-attribute vec2 a_tex;
-varying mediump vec2 v_uv;
-void main(void) {
-gl_Position = vec4(a_pos , 0.0, 1.0);
-v_uv = a_tex;
-}` }, blend: { "blend.frag": `precision mediump float;
-uniform sampler2D u_layerTexture;
-uniform lowp float u_opacity;
-uniform lowp float u_inFadeOpacity;
-#ifndef NORMAL
-uniform sampler2D u_backbufferTexture;
-#endif
-varying mediump vec2 v_uv;
-float rgb2v(in vec3 c) {
-return max(c.x, max(c.y, c.z));
-}
-vec3 rgb2hsv(in vec3 c) {
-vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-float d = q.x - min(q.w, q.y);
-float e = 1.0e-10;
-return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), min(d / (q.x + e), 1.0), q.x);
-}
-vec3 hsv2rgb(in vec3 c) {
-vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
-vec3 tint(in vec3 Cb, in vec3 Cs) {
-float vIn = rgb2v(Cb);
-vec3 hsvTint = rgb2hsv(Cs);
-vec3 hsvOut = vec3(hsvTint.x, hsvTint.y, vIn * hsvTint.z);
-return hsv2rgb(hsvOut);
-}
-float overlay(in float Cb, in float Cs) {
-return (1.0 - step(0.5, Cs)) * (1.0 - 2.0 * (1.0 - Cs ) * (1.0 - Cb)) + step(0.5, Cs) * (2.0 * Cs * Cb);
-}
-float colorDodge(in float Cb, in float Cs) {
-return (Cb == 0.0) ? 0.0 : (Cs == 1.0) ? 1.0 : min(1.0, Cb / (1.0 - Cs));
-}
-float colorBurn(in float Cb, in float Cs) {
-return (Cb == 1.0) ? 1.0 : (Cs == 0.0) ? 0.0 : 1.0 - min(1.0, (1.0 - Cb) / Cs);
-}
-float hardLight(in float Cb, in float Cs) {
-return (1.0 - step(0.5, Cs)) * (2.0 * Cs * Cb) + step(0.5, Cs) * (1.0 - 2.0 * (1.0 - Cs) * (1.0 - Cb));
-}
-float reflectBlend(in float Cb, in float Cs) {
-return (Cs == 1.0) ? Cs : min(Cb * Cb / (1.0 - Cs), 1.0);
-}
-float softLight(in float Cb, in float Cs) {
-if (Cs <= 0.5) {
-return Cb - (1.0 - 2.0 * Cs) * Cb * (1.0 - Cb);
-}
-if (Cb <= 0.25) {
-return Cb + (2.0 * Cs - 1.0) * Cb * ((16.0 * Cb - 12.0) * Cb + 3.0);
-}
-return Cb + (2.0 * Cs - 1.0) * (sqrt(Cb) - Cb);
-}
-float vividLight(in float Cb, in float Cs) {
-return (1.0 - step(0.5, Cs)) * colorBurn(Cb, 2.0 * Cs) + step(0.5, Cs) * colorDodge(Cb, (2.0 * (Cs - 0.5)));
-}
-float minv3(in vec3 c) {
-return min(min(c.r, c.g), c.b);
-}
-float maxv3(in vec3 c) {
-return max(max(c.r, c.g), c.b);
-}
-float lumv3(in vec3 c) {
-return dot(c, vec3(0.3, 0.59, 0.11));
-}
-float satv3(vec3 c) {
-return maxv3(c) - minv3(c);
-}
-vec3 clipColor(vec3 color) {
-float lum = lumv3(color);
-float mincol = minv3(color);
-float maxcol = maxv3(color);
-if (mincol < 0.0) {
-color = lum + ((color - lum) * lum) / (lum - mincol);
-}
-if (maxcol > 1.0) {
-color = lum + ((color - lum) * (1.0 - lum)) / (maxcol - lum);
-}
-return color;
-}
-vec3 setLum(vec3 cbase, vec3 clum) {
-float lbase = lumv3(cbase);
-float llum = lumv3(clum);
-float ldiff = llum - lbase;
-vec3 color = cbase + vec3(ldiff);
-return clipColor(color);
-}
-vec3 setLumSat(vec3 cbase, vec3 csat, vec3 clum)
-{
-float minbase = minv3(cbase);
-float sbase = satv3(cbase);
-float ssat = satv3(csat);
-vec3 color;
-if (sbase > 0.0) {
-color = (cbase - minbase) * ssat / sbase;
-} else {
-color = vec3(0.0);
-}
-return setLum(color, clum);
-}
-void main() {
-vec4 src = texture2D(u_layerTexture, v_uv);
-#ifdef NORMAL
-gl_FragColor = src *  u_opacity;
-#else
-vec4 dst = texture2D(u_backbufferTexture, v_uv);
-vec3 Cs = src.a == 0.0 ? src.rgb : vec3(src.rgb / src.a);
-vec3 Cb = dst.a == 0.0 ? dst.rgb : vec3(dst.rgb / dst.a);
-float as = u_opacity * src.a;
-float ab = dst.a;
-#ifdef DESTINATION_OVER
-gl_FragColor = vec4(as * Cs * (1.0 - ab) + ab * Cb, as + ab - as * ab);
-#endif
-#ifdef SOURCE_IN
-vec4 color = vec4(as * Cs * ab, as * ab);
-vec4 fadeColor = (1.0 - u_opacity) * u_inFadeOpacity * vec4(ab * Cb, ab);
-gl_FragColor = color + fadeColor;
-#endif
-#ifdef DESTINATION_IN
-vec4 color = vec4(ab * Cb * as, ab * as);
-vec4 fadeColor = (1.0 - u_opacity) * u_inFadeOpacity * vec4(ab * Cb, ab);
-gl_FragColor = color + fadeColor;
-#endif
-#ifdef SOURCE_OUT
-gl_FragColor = vec4(as * Cs * (1.0 - ab), as * (1.0 - ab));
-#endif
-#ifdef DESTINATION_OUT
-gl_FragColor = vec4(ab * Cb * (1.0 - as), ab * (1.0 - as));
-#endif
-#ifdef SOURCE_ATOP
-gl_FragColor = vec4(as * Cs * ab + ab * Cb * (1.0 - as), ab);
-#endif
-#ifdef DESTINATION_ATOP
-gl_FragColor = vec4(as * Cs * (1.0 - ab) + ab * Cb * as, as);
-#endif
-#ifdef XOR
-gl_FragColor = vec4(as * Cs * (1.0 - ab) + ab * Cb * (1.0 - as),
-as * (1.0 - ab) + ab * (1.0 - as));
-#endif
-#ifdef MULTIPLY
-gl_FragColor = vec4(as * Cs * ab * Cb + (1.0 - ab) * as * Cs + (1.0 - as) * ab * Cb,
-as + ab * (1.0 - as));
-#endif
-#ifdef SCREEN
-gl_FragColor = vec4((Cs + Cb - Cs * Cb) * as * ab + Cs * as * (1.0 - ab) + Cb * ab *(1.0 - as),
-as + ab * (1.0 - as));
-#endif
-#ifdef OVERLAY
-vec3 f = vec3(overlay(Cb.r, Cs.r), overlay(Cb.g, Cs.g), overlay(Cb.b, Cs.b));
-gl_FragColor = vec4(f * as * ab + Cs * as * (1.0 - ab) + Cb * ab *(1.0 - as),
-as + ab * (1.0 - as));
-#endif
-#ifdef DARKEN
-gl_FragColor = vec4(min(Cs, Cb) * as * ab + Cs * as * (1.0 - ab) + Cb * ab *(1.0 - as),
-as + ab * (1.0 - as));
-#endif
-#ifdef LIGHTER
-gl_FragColor = vec4(as * Cs + ab * Cb, as + ab);
-#endif
-#ifdef LIGHTEN
-gl_FragColor = vec4(max(Cs, Cb) * as * ab + Cs * as * (1.0 - ab) + Cb * ab *(1.0 - as),
-as + ab * (1.0 - as));
-#endif
-#ifdef COLOR_DODGE
-vec3 f = clamp(vec3(colorDodge(Cb.r, Cs.r), colorDodge(Cb.g, Cs.g), colorDodge(Cb.b, Cs.b)), vec3(0.0), vec3(1.0));
-gl_FragColor = vec4(f * as * ab + Cs * as * (1.0 - ab) + Cb * ab *(1.0 - as),
-as + ab * (1.0 - as));
-#endif
-#ifdef COLOR_BURN
-vec3 f = vec3(colorBurn(Cb.r, Cs.r), colorBurn(Cb.g, Cs.g), colorBurn(Cb.b, Cs.b));
-gl_FragColor = vec4(f * as * ab + Cs * as * (1.0 - ab) + Cb * ab *(1.0 - as),
-as + ab * (1.0 - as));
-#endif
-#ifdef HARD_LIGHT
-vec3 f = vec3(hardLight(Cb.r, Cs.r), hardLight(Cb.g, Cs.g), hardLight(Cb.b, Cs.b));
-gl_FragColor = vec4(f * as * ab + Cs * as * (1.0 - ab) + Cb * ab *(1.0 - as),
-as + ab * (1.0 - as));
-#endif
-#ifdef SOFT_LIGHT
-vec3 f = vec3(softLight(Cb.r, Cs.r), softLight(Cb.g, Cs.g), softLight(Cb.b, Cs.b));
-gl_FragColor = vec4(f * as * ab + Cs * as * (1.0 - ab) + Cb * ab *(1.0 - as),
-as + ab * (1.0 - as));
-#endif
-#ifdef DIFFERENCE
-gl_FragColor = vec4(abs(Cb - Cs) * as * ab + Cs * as * (1.0 - ab) + Cb * ab *(1.0 - as),
-as + ab * (1.0 - as));
-#endif
-#ifdef EXCLUSION
-vec3 f = Cs + Cb - 2.0 * Cs * Cb;
-gl_FragColor = vec4(f * as * ab + Cs * as * (1.0 - ab) + Cb * ab *(1.0 - as),
-as + ab * (1.0 - as));
-#endif
-#ifdef INVERT
-gl_FragColor = vec4((1.0 - Cb) * as * ab + Cb * ab * (1.0 - as), ab);
-#endif
-#ifdef VIVID_LIGHT
-vec3 f = vec3(clamp(vividLight(Cb.r, Cs.r), 0.0, 1.0),
-clamp(vividLight(Cb.g, Cs.g), 0.0, 1.0),
-clamp(vividLight(Cb.b, Cs.b), 0.0, 1.0));
-gl_FragColor = vec4(f * as * ab + Cs * as * (1.0 - ab) + Cb * ab *(1.0 - as),
-as + ab * (1.0 - as));
-#endif
-#ifdef HUE
-vec3 f = setLumSat(Cs,Cb,Cb);
-gl_FragColor = vec4(f * as * ab + Cs * as * (1.0 - ab) + Cb * ab *(1.0 - as),
-as + ab * (1.0 - as));
-#endif
-#ifdef SATURATION
-vec3 f = setLumSat(Cb,Cs,Cb);
-gl_FragColor = vec4(f * as * ab + Cs * as * (1.0 - ab) + Cb * ab *(1.0 - as),
-as + ab * (1.0 - as));
-#endif
-#ifdef COLOR
-vec3 f = setLum(Cs,Cb);
-gl_FragColor = vec4(f * as * ab + Cs * as * (1.0 - ab) + Cb * ab *(1.0 - as),
-as + ab * (1.0 - as));
-#endif
-#ifdef LUMINOSITY
-vec3 f = setLum(Cb,Cs);
-gl_FragColor = vec4(f * as * ab + Cs * as * (1.0 - ab) + Cb * ab *(1.0 - as),
-as + ab * (1.0 - as));
-#endif
-#ifdef PLUS
-gl_FragColor = clamp(vec4(src.r + Cb.r, src.g + Cb.g, src.b + Cb.b, as + ab), 0.0, 1.0);
-#endif
-#ifdef MINUS
-gl_FragColor = vec4(clamp(vec3(Cb.r - src.r, Cb.g - src.g, Cb.b - src.b), 0.0, 1.0), ab * as);
-#endif
-#ifdef AVERAGE
-vec3 f = (Cb + Cs) / 2.0;
-gl_FragColor = vec4(f * as * ab + Cs * as * (1.0 - ab) + Cb * ab *(1.0 - as),
-as + ab * (1.0 - as));
-#endif
-#ifdef REFLECT
-vec3 f = clamp(vec3(reflectBlend(Cb.r, Cs.r),
-reflectBlend(Cb.g, Cs.g),
-reflectBlend(Cb.b, Cs.b)), vec3(0.0), vec3(1.0));
-gl_FragColor = vec4(f * as * ab + Cs * as * (1.0 - ab) + Cb * ab *(1.0 - as),
-as + ab * (1.0 - as));
-#endif
-#endif
-}`, "blend.vert": `attribute vec2 a_position;
-varying mediump vec2 v_uv;
-void main(void) {
-gl_Position = vec4(a_position , 0.0, 1.0);
-v_uv = (a_position + 1.0) / 2.0;
-}` }, debug: { overlay: { "overlay.frag": `precision mediump float;
-varying vec4 v_color;
-void main(void) {
-gl_FragColor = v_color;
-}`, "overlay.vert": `attribute vec3 a_PositionAndFlags;
-uniform mat3 u_dvsMat3;
-uniform vec4 u_colors[4];
-uniform float u_opacities[4];
-varying vec4 v_color;
-void main(void) {
-vec2 position = a_PositionAndFlags.xy;
-float flags = a_PositionAndFlags.z;
-int colorIndex = int(mod(flags, 4.0));
-vec4 color;
-for (int i = 0; i < 4; i++) {
-color = u_colors[i];
-if (i == colorIndex) {
-break;
-}
-}
-int opacityIndex = int(mod(floor(flags / 4.0), 4.0));
-float opacity;
-for (int i = 0; i < 4; i++) {
-opacity = u_opacities[i];
-if (i == opacityIndex) {
-break;
-}
-}
-v_color = color * opacity;
-gl_Position = vec4((u_dvsMat3 * vec3(position, 1.0)).xy, 0.0, 1.0);
-}` } }, dot: { dot: { "dot.frag": `precision mediump float;
-varying vec4 v_color;
-varying float v_dotRatio;
-varying float v_invEdgeRatio;
-uniform highp float u_tileZoomFactor;
-void main()
-{
-float dist = length(gl_PointCoord - vec2(.5, .5)) * 2.;
-float alpha = smoothstep(0., 1., v_invEdgeRatio * (dist - v_dotRatio) + 1.);
-gl_FragColor = v_color * alpha;
-}`, "dot.vert": `precision highp float;
-attribute vec2 a_pos;
-uniform sampler2D u_texture;
-uniform highp mat3 u_dvsMat3;
-uniform highp float u_tileZoomFactor;
-uniform highp float u_dotSize;
-uniform highp float u_pixelRatio;
-varying vec2 v_pos;
-varying vec4 v_color;
-varying float v_dotRatio;
-varying float v_invEdgeRatio;
-const float EPSILON = 0.000001;
-void main()
-{
-mat3 tileToTileTexture = mat3(  1., 0., 0.,
-0., -1., 0.,
-0., 1., 1.  );
-vec3 texCoords = tileToTileTexture * vec3(a_pos.xy / 512., 1.);
-v_color = texture2D(u_texture, texCoords.xy);
-float smoothEdgeWidth = max(u_dotSize / 2., 1.) ;
-float z = 0.;
-z += 2.0 * step(v_color.a, EPSILON);
-gl_PointSize = (smoothEdgeWidth + u_dotSize);
-gl_Position = vec4((u_dvsMat3 * vec3(a_pos + .5, 1.)).xy, z, 1.);
-v_dotRatio = u_dotSize / gl_PointSize;
-v_invEdgeRatio = -1. / ( smoothEdgeWidth / gl_PointSize );
-gl_PointSize  *= (u_pixelRatio * u_tileZoomFactor);
-}` } }, filtering: { "bicubic.glsl": `vec4 computeWeights(float v) {
-float b = 1.0 / 6.0;
-float v2 = v * v;
-float v3 = v2 * v;
-float w0 = b * (-v3 + 3.0 * v2 - 3.0 * v + 1.0);
-float w1 = b * (3.0 * v3  - 6.0 * v2 + 4.0);
-float w2 = b * (-3.0 * v3 + 3.0 * v2 + 3.0 * v + 1.0);
-float w3 = b * v3;
-return vec4(w0, w1, w2, w3);
-}
-vec4 bicubicOffsetsAndWeights(float v) {
-vec4 w = computeWeights(v);
-float g0 = w.x + w.y;
-float g1 = w.z + w.w;
-float h0 = 1.0 - (w.y / g0) + v;
-float h1 = 1.0 + (w.w / g1) - v;
-return vec4(h0, h1, g0, g1);
-}
-vec4 sampleBicubicBSpline(sampler2D sampler, vec2 coords, vec2 texSize) {
-vec2 eX = vec2(1.0 / texSize.x, 0.0);
-vec2 eY = vec2(0.0, 1.0 / texSize.y);
-vec2 texel = coords * texSize - 0.5;
-vec3 hgX = bicubicOffsetsAndWeights(fract(texel).x).xyz;
-vec3 hgY = bicubicOffsetsAndWeights(fract(texel).y).xyz;
-vec2 coords10 = coords + hgX.x * eX;
-vec2 coords00 = coords - hgX.y * eX;
-vec2 coords11 = coords10 + hgY.x * eY;
-vec2 coords01 = coords00 + hgY.x * eY;
-coords10 = coords10 - hgY.y * eY;
-coords00 = coords00 - hgY.y * eY;
-vec4 color00 = texture2D(sampler, coords00);
-vec4 color10 = texture2D(sampler, coords10);
-vec4 color01 = texture2D(sampler, coords01);
-vec4 color11 = texture2D(sampler, coords11);
-color00 = mix(color00, color01, hgY.z);
-color10 = mix(color10, color11, hgY.z);
-color00 = mix(color00, color10, hgX.z);
-return color00;
-}`, "bilinear.glsl": `vec4 sampleBilinear(sampler2D sampler, vec2 coords, vec2 texSize) {
-vec2 texelStart = floor(coords * texSize);
-vec2 coord0 = texelStart / texSize;
-vec2 coord1 = (texelStart +  vec2(1.0, 0.0)) / texSize;
-vec2 coord2 = (texelStart +  vec2(0.0, 1.0)) / texSize;
-vec2 coord3 = (texelStart +  vec2(1.0, 1.0)) / texSize;
-vec4 color0 = texture2D(sampler, coord0);
-vec4 color1 = texture2D(sampler, coord1);
-vec4 color2 = texture2D(sampler, coord2);
-vec4 color3 = texture2D(sampler, coord3);
-vec2 blend = fract(coords * texSize);
-vec4 color01 = mix(color0, color1, blend.x);
-vec4 color23 = mix(color2, color3, blend.x);
-vec4 color = mix(color01, color23, blend.y);
-#ifdef NNEDGE
-float alpha = floor(color0.a * color1.a * color2.a * color3.a + 0.5);
-color = color * alpha + (1.0 - alpha) * texture2D(sampler, coords);
-#endif
-return color;
-}`, "epx.glsl": `vec4 sampleEPX(sampler2D sampler, float size, vec2 coords, vec2 texSize) {
-vec2 invSize = 1.0 / texSize;
-vec2 texel = coords * texSize;
-vec2 texel_i = floor(texel);
-vec2 texel_frac = fract(texel);
-vec4 colorP = texture2D(sampler, texel_i * invSize);
-vec4 colorP1 = vec4(colorP);
-vec4 colorP2 = vec4(colorP);
-vec4 colorP3 = vec4(colorP);
-vec4 colorP4 = vec4(colorP);
-vec4 colorA = texture2D(sampler, (texel_i - vec2(0.0, 1.0)) * invSize);
-vec4 colorB = texture2D(sampler, (texel_i + vec2(1.0, 0.0)) * invSize);
-vec4 colorC = texture2D(sampler, (texel_i - vec2(1.0, 0.0)) * invSize);
-vec4 colorD = texture2D(sampler, (texel_i + vec2(0.0, 1.0)) * invSize);
-if (colorC == colorA && colorC != colorD && colorA != colorB) {
-colorP1 = colorA;
-}
-if (colorA == colorB && colorA != colorC && colorB != colorD) {
-colorP2 = colorB;
-}
-if (colorD == colorC && colorD != colorB && colorC != colorA) {
-colorP3 = colorC;
-}
-if (colorB == colorD && colorB != colorA && colorD != colorC) {
-colorP4 = colorD;
-}
-vec4 colorP12 = mix(colorP1, colorP2, texel_frac.x);
-vec4 colorP34 = mix(colorP1, colorP2, texel_frac.x);
-return mix(colorP12, colorP34, texel_frac.y);
-}` }, fx: { integrate: { "integrate.frag": `precision mediump float;
-uniform lowp sampler2D u_sourceTexture;
-uniform lowp sampler2D u_maskTexture;
-uniform mediump float u_zoomLevel;
-uniform highp float u_timeDelta;
-uniform highp float u_animationTime;
-varying highp vec2 v_texcoord;
-#include <materials/utils.glsl>
-void main()
-{
-#ifdef DELTA
-vec4 texel = texture2D(u_sourceTexture, v_texcoord);
-vec4 data0 = texture2D(u_maskTexture, v_texcoord);
-float flags = data0.r * 255.0;
-float groupMinZoom = data0.g * 255.0;
-float wouldClip = float(groupMinZoom == 0.);
-float direction = wouldClip * 1.0 + (1.0 - wouldClip) * -1.0;
-float dt = u_timeDelta / max(u_animationTime, 0.0001);
-vec4 nextState = vec4(texel + direction * dt);
-gl_FragColor =  vec4(nextState);
-#elif defined(UPDATE)
-vec4 texel = texture2D(u_sourceTexture, v_texcoord);
-gl_FragColor = texel;
-#endif
-}`, "integrate.vert": `precision mediump float;
-attribute vec2 a_pos;
-varying highp vec2 v_texcoord;
-void main()
-{
-v_texcoord = a_pos;
-gl_Position = vec4(a_pos * 2.0 - 1.0, 0.0, 1.0);
-}` } }, heatmap: { heatmapResolve: { "heatmapResolve.frag": `precision highp float;
-#ifdef HEATMAP_PRECISION_HALF_FLOAT
-#define COMPRESSION_FACTOR 4.0
-#else
-#define COMPRESSION_FACTOR 1.0
-#endif
-uniform sampler2D u_texture;
-uniform sampler2D u_gradient;
-uniform vec2 u_densityMinAndInvRange;
-uniform float u_densityNormalization;
-varying vec2 v_uv;
-void main() {
-vec4 data = texture2D(u_texture, v_uv);
-float density = data.r * COMPRESSION_FACTOR;
-density *= u_densityNormalization;
-density = (density - u_densityMinAndInvRange.x) * u_densityMinAndInvRange.y;
-vec4 color = texture2D(u_gradient, vec2(density, 0.5));
-gl_FragColor = vec4(color.rgb * color.a, color.a);
-}`, "heatmapResolve.vert": `precision highp float;
-attribute vec2 a_pos;
-varying vec2 v_uv;
-void main() {
-v_uv = a_pos;
-gl_Position = vec4(a_pos * 2.0 - 1.0, 1., 1.);
-}` } }, highlight: { "blur.frag": `varying mediump vec2 v_texcoord;
-uniform mediump vec4 u_direction;
-uniform mediump mat4 u_channelSelector;
-uniform mediump float u_sigma;
-uniform sampler2D u_texture;
-mediump float gauss1(mediump vec2 dir) {
-return exp(-dot(dir, dir) / (2.0 * u_sigma * u_sigma));
-}
-mediump vec4 selectChannel(mediump vec4 sample) {
-return u_channelSelector * sample;
-}
-void accumGauss1(mediump float i, inout mediump float tot, inout mediump float weight) {
-mediump float w = gauss1(i * u_direction.xy);
-tot += selectChannel(texture2D(u_texture, v_texcoord + i * u_direction.zw))[3] * w;
-weight += w;
-}
-void main(void) {
-mediump float tot = 0.0;
-mediump float weight = 0.0;
-accumGauss1(-5.0, tot, weight);
-accumGauss1(-4.0, tot, weight);
-accumGauss1(-3.0, tot, weight);
-accumGauss1(-2.0, tot, weight);
-accumGauss1(-1.0, tot, weight);
-accumGauss1(0.0, tot, weight);
-accumGauss1(1.0, tot, weight);
-accumGauss1(2.0, tot, weight);
-accumGauss1(3.0, tot, weight);
-accumGauss1(4.0, tot, weight);
-accumGauss1(5.0, tot, weight);
-gl_FragColor = vec4(0.0, 0.0, 0.0, tot / weight);
-}`, "highlight.frag": `varying mediump vec2 v_texcoord;
-uniform sampler2D u_texture;
-uniform mediump float u_sigma;
-uniform sampler2D u_shade;
-uniform mediump vec2 u_minMaxDistance;
-mediump float estimateDistance() {
-mediump float y = texture2D(u_texture, v_texcoord)[3];
-const mediump float y0 = 0.5;
-mediump float m0 = 1.0 / (sqrt(2.0 * 3.1415) * u_sigma);
-mediump float d = (y - y0) / m0;
-return d;
-}
-mediump vec4 shade(mediump float d) {
-mediump float mappedDistance = (d - u_minMaxDistance.x) / (u_minMaxDistance.y - u_minMaxDistance.x);
-mappedDistance = clamp(mappedDistance, 0.0, 1.0);
-return texture2D(u_shade, vec2(mappedDistance, 0.5));
-}
-void main(void) {
-mediump float d = estimateDistance();
-gl_FragColor = shade(d);
-}`, "textured.vert": `attribute mediump vec2 a_position;
-attribute mediump vec2 a_texcoord;
-varying mediump vec2 v_texcoord;
-void main(void) {
-gl_Position = vec4(a_position, 0.0, 1.0);
-v_texcoord = a_texcoord;
-}` }, magnifier: { "magnifier.frag": `uniform lowp vec4 u_background;
-uniform mediump sampler2D u_readbackTexture;
-uniform mediump sampler2D u_maskTexture;
-uniform mediump sampler2D u_overlayTexture;
-uniform bool u_maskEnabled;
-uniform bool u_overlayEnabled;
-varying mediump vec2 v_texCoord;
-const lowp float barrelFactor = 1.1;
-lowp vec2 barrel(lowp vec2 uv) {
-lowp vec2 uvn = uv * 2.0 - 1.0;
-if (uvn.x == 0.0 && uvn.y == 0.0) {
-return vec2(0.5, 0.5);
-}
-lowp float theta = atan(uvn.y, uvn.x);
-lowp float r = pow(length(uvn), barrelFactor);
-return r * vec2(cos(theta), sin(theta)) * 0.5 + 0.5;
-}
-void main(void)
-{
-lowp vec4 color = texture2D(u_readbackTexture, barrel(v_texCoord));
-color = (color + (1.0 - color.a) * u_background);
-lowp float mask = u_maskEnabled ? texture2D(u_maskTexture, v_texCoord).a : 1.0;
-color *= mask;
-lowp vec4 overlayColor = u_overlayEnabled ? texture2D(u_overlayTexture, v_texCoord) : vec4(0);
-gl_FragColor = overlayColor + (1.0 - overlayColor.a) * color;
-}`, "magnifier.vert": `precision mediump float;
-attribute mediump vec2 a_pos;
-uniform mediump vec4 u_drawPos;
-varying mediump vec2 v_texCoord;
-void main(void)
-{
-v_texCoord = a_pos;
-gl_Position = vec4(u_drawPos.xy + vec2(a_pos - 0.5) * u_drawPos.zw, 0.0, 1.0);
-}` }, materials: { "attributeData.glsl": `uniform highp sampler2D filterFlags;
-uniform highp sampler2D animation;
-uniform highp sampler2D gpgpu;
-uniform highp sampler2D visualVariableData;
-uniform highp sampler2D dataDriven0;
-uniform highp sampler2D dataDriven1;
-uniform highp sampler2D dataDriven2;
-uniform float size;
-highp vec2 getAttributeDataCoords(in highp vec3 id) {
-highp vec3  texel = unpackDisplayIdTexel(id);
-highp float u32 = float(int(texel.r) + int(texel.g) * 256 + int(texel.b) * 256 * 256);
-highp float col = mod(u32, size);
-highp float row = (u32 - col) / size;
-highp float u = col / size;
-highp float v = row / size;
-return vec2(u, v);
-}
-highp vec2 getAttributeDataTextureCoords(in highp vec3 id) {
-return (getAttributeDataCoords(id) * 2.0) - 1.0 + (.5 / vec2(size));
-}
-highp vec4 getFilterData(in highp vec3 id) {
-vec2 coords = getAttributeDataCoords(id);
-return texture2D(filterFlags, coords);
-}
-highp vec4 getAnimation(in highp vec3 id) {
-highp vec2 coords = getAttributeDataCoords(id);
-return texture2D(animation, coords);
-}
-highp vec4 getVisualVariableData(in highp vec3 id) {
-highp vec2 coords = getAttributeDataCoords(id);
-return texture2D(visualVariableData, coords);
-}
-highp vec4 getDataDriven0(in highp vec3 id) {
-highp vec2 coords = getAttributeDataCoords(id);
-return texture2D(dataDriven0, coords);
-}
-highp vec4 getDataDriven1(in highp vec3 id) {
-highp vec2 coords = getAttributeDataCoords(id);
-return texture2D(dataDriven1, coords);
-}
-highp vec4 getGPGPU(in highp vec3 id) {
-highp vec2 coords = getAttributeDataCoords(id);
-return texture2D(gpgpu, coords);
-}
-highp vec4 getDataDriven2(in highp vec3 id) {
-highp vec2 coords = getAttributeDataCoords(id);
-return texture2D(dataDriven2, coords);
-}
-float u88VVToFloat(in vec2 v) {
-bool isMagic = v.x == 255.0 && v.y == 255.0;
-if (isMagic) {
-return NAN_MAGIC_NUMBER;
-}
-return (v.x + v.y * float(0x100)) - 32768.0;
-}`, "barycentric.glsl": `float inTriangle(vec3 bary) {
-vec3 absBary = abs(bary);
-return step((absBary.x + absBary.y + absBary.z), 1.05);
-}
-vec3 xyToBarycentric(in vec2 pos, in vec2 v0,  in vec2 v1, in vec2 v2) {
-mat3 xyToBarycentricMat3 = mat3(
-v1.x * v2.y - v2.x * v1.y, v2.x * v0.y - v0.x * v2.y, v0.x * v1.y - v1.x * v0.y,
-v1.y - v2.y, v2.y - v0.y, v0.y - v1.y,
-v2.x - v1.x, v0.x - v2.x, v1.x - v0.x
-);
-float A2 = v0.x * (v1.y - v2.y) + v1.x * (v2.y - v0.y) + v2.x * (v0.y - v1.y);
-return (1. / A2) * xyToBarycentricMat3 * vec3(1., pos);
-}`, "constants.glsl": `const float C_DEG_TO_RAD = 3.14159265359 / 180.0;
-const float C_256_TO_RAD = 3.14159265359 / 128.0;
-const float C_RAD_TO_DEG = 180.0 / 3.141592654;
-const float POSITION_PRECISION = 1.0 / 8.0;
-const float FILL_POSITION_PRECISION = 1.0 / 1.0;
-const float SOFT_EDGE_RATIO = 1.0;
-const float THIN_LINE_WIDTH_FACTOR = 1.1;
-const float THIN_LINE_HALF_WIDTH = 1.0;
-const float EXTRUDE_SCALE_PLACEMENT_PADDING = 1.0 / 4.0;
-const float OFFSET_PRECISION = 1.0 / 8.0;
-const float OUTLINE_SCALE = 1.0 / 5.0;
-const float SDF_FONT_SIZE = 24.0;
-const float MAX_SDF_DISTANCE = 8.0;
-const float PLACEMENT_PADDING = 8.0;
-const float EPSILON = 0.00001;
-const float EPSILON_HITTEST = 0.05;
-const int MAX_FILTER_COUNT = 2;
-const int ATTR_VV_SIZE = 0;
-const int ATTR_VV_COLOR = 1;
-const int ATTR_VV_OPACITY = 2;
-const int ATTR_VV_ROTATION = 3;
-const highp float NAN_MAGIC_NUMBER = 1e-30;
-const int BITSET_GENERIC_LOCK_COLOR = 1;
-const int BITSET_GENERIC_CONSIDER_ALPHA_ONLY = 4;
-const int BITSET_MARKER_ALIGNMENT_MAP = 0;
-const int BITSET_MARKER_OUTLINE_ALLOW_COLOR_OVERRIDE = 2;
-const int BITSET_MARKER_SCALE_SYMBOLS_PROPORTIONALLY = 3;
-const int BITSET_TYPE_FILL_OUTLINE = 0;
-const int BITSET_FILL_RANDOM_PATTERN_OFFSET = 2;
-const int BITSET_FILL_HAS_UNRESOLVED_REPLACEMENT_COLOR = 3;
-const int BITSET_FILL_HAS_PATTERN_HEIGHT_PRECISION_FACTOR = 5;
-const int BITSET_FILL_HAS_PATTERN_WIDTH_PRECISION_FACTOR = 6;
-const int BITSET_LINE_SCALE_DASH = 2;`, fill: { "common.glsl": `#include <materials/symbologyTypeUtils.glsl>
-#ifdef PATTERN
-uniform mediump vec2 u_mosaicSize;
-varying mediump float v_sampleAlphaOnly;
-#endif
-#if SYMBOLOGY_TYPE == SYMBOLOGY_TYPE_DOT_DENSITY
-uniform lowp vec4 u_isActive[ 2 ];
-uniform highp float u_dotValue;
-uniform highp float u_tileDotsOverArea;
-uniform highp float u_dotTextureDotCount;
-uniform mediump float u_tileZoomFactor;
-#endif
-varying highp vec3 v_id;
-varying lowp vec4 v_color;
-varying lowp float v_opacity;
-varying mediump vec4 v_aux1;
-#ifdef PATTERN
-varying mediump vec2 v_tileTextureCoord;
-#endif
-#ifdef SYMBOLOGY_TYPE_IS_OUTLINE_FILL_LIKE
-varying lowp float v_isOutline;
-#endif
-#if SYMBOLOGY_TYPE == SYMBOLOGY_TYPE_DOT_DENSITY
-varying highp vec2 v_dotTextureCoords;
-varying highp vec4 v_dotThresholds[ 2 ];
-#endif`, "fill.frag": `precision highp float;
-#include <materials/constants.glsl>
-#include <materials/utils.glsl>
-#include <materials/fill/common.glsl>
-#ifdef PATTERN
-uniform lowp sampler2D u_texture;
-#endif
-#if SYMBOLOGY_TYPE == SYMBOLOGY_TYPE_DOT_DENSITY
-uniform mediump mat4 u_dotColors[ 2 ];
-uniform sampler2D u_dotTextures[ 2 ];
-uniform vec4 u_dotBackgroundColor;
-#endif
-#ifdef SYMBOLOGY_TYPE_IS_OUTLINE_FILL_LIKE
-#include <materials/shared/line/common.glsl>
-#include <materials/shared/line/line.frag>
-lowp vec4 drawLine() {
-float v_lineWidth = v_aux1.x;
-vec2  v_normal    = v_aux1.yz;
-LineData inputs = LineData(
-v_color,
-v_normal,
-v_lineWidth,
-v_opacity,
-v_id
-);
-return shadeLine(inputs);
-}
-#endif
-lowp vec4 drawFill() {
-lowp vec4 out_color = vec4(0.);
-#ifdef HITTEST
-out_color = v_color;
-#elif defined(PATTERN)
-mediump vec4 v_tlbr = v_aux1;
-mediump vec2 normalizedTextureCoord = mod(v_tileTextureCoord, 1.0);
-mediump vec2 samplePos = mix(v_tlbr.xy, v_tlbr.zw, normalizedTextureCoord);
-lowp vec4 color = texture2D(u_texture, samplePos);
-if (v_sampleAlphaOnly > 0.5) {
-color.rgb = vec3(color.a);
-}
-out_color = v_opacity * v_color * color;
-#elif SYMBOLOGY_TYPE == SYMBOLOGY_TYPE_DOT_DENSITY && !defined(HIGHLIGHT)
-vec4 textureThresholds0 = texture2D(u_dotTextures[0], v_dotTextureCoords);
-vec4 textureThresholds1 = texture2D(u_dotTextures[1], v_dotTextureCoords);
-vec4 difference0 = v_dotThresholds[0] - textureThresholds0;
-vec4 difference1 = v_dotThresholds[1] - textureThresholds1;
-#ifdef DD_DOT_BLENDING
-vec4 isPositive0 = step(0.0, difference0);
-vec4 isPositive1 = step(0.0, difference1);
-float weightSum = dot(isPositive0, difference0) + dot(isPositive1, difference1);
-float lessThanEqZero = step(weightSum, 0.0);
-float greaterThanZero = 1.0 - lessThanEqZero ;
-float divisor = (weightSum + lessThanEqZero);
-vec4 weights0 = difference0 * isPositive0 / divisor;
-vec4 weights1 = difference1 * isPositive1 / divisor;
-vec4 dotColor = u_dotColors[0] * weights0 + u_dotColors[1] * weights1;
-vec4 preEffectColor = greaterThanZero * dotColor + lessThanEqZero * u_dotBackgroundColor;
-#else
-float diffMax = max(max4(difference0), max4(difference1));
-float lessThanZero = step(diffMax, 0.0);
-float greaterOrEqZero = 1.0 - lessThanZero;
-vec4 isMax0 = step(diffMax, difference0);
-vec4 isMax1 = step(diffMax, difference1);
-vec4 dotColor = u_dotColors[0] * isMax0 + u_dotColors[1] * isMax1;
-vec4 preEffectColor = greaterOrEqZero * dotColor + lessThanZero * u_dotBackgroundColor;
-#endif
-out_color = preEffectColor;
-#else
-out_color = v_opacity * v_color;
-#endif
-#ifdef HIGHLIGHT
-out_color.a = 1.0;
-#endif
-return out_color;
-}
-void main() {
-#ifdef SYMBOLOGY_TYPE_IS_OUTLINE_FILL_LIKE
-if (v_isOutline > 0.5) {
-gl_FragColor = drawLine();
-} else {
-gl_FragColor = drawFill();
-}
-#else
-gl_FragColor = drawFill();
-#endif
-}`, "fill.vert": `#include <materials/symbologyTypeUtils.glsl>
-#define PACKED_LINE
-precision highp float;
-attribute float a_bitset;
-#if SYMBOLOGY_TYPE == SYMBOLOGY_TYPE_DOT_DENSITY
-attribute float a_inverseArea;
-vec4 a_color = vec4(0.0, 0.0, 0.0, 1.0);
-vec2 a_zoomRange = vec2(0.0, 10000.0);
-#else
-attribute vec4 a_color;
-attribute vec4 a_aux2;
-attribute vec4 a_aux3;
-#ifndef SYMBOLOGY_TYPE_IS_SIMPLE_LIKE
-attribute vec4 a_aux1;
-attribute vec2 a_zoomRange;
-#else
-vec2 a_zoomRange = vec2(0.0, 10000.0);
-#endif
-#endif
-uniform vec2 u_tileOffset;
-uniform vec2 u_maxIntNumOfCrossing;
-#include <util/encoding.glsl>
-#include <materials/vcommon.glsl>
-#include <materials/fill/common.glsl>
-#include <materials/fill/hittest.glsl>
-const float INV_SCALE_COMPRESSION_FACTOR = 1.0 / 128.0;
-const float MAX_REPRESENTABLE_INT = 16777216.0;
-#if SYMBOLOGY_TYPE == SYMBOLOGY_TYPE_DOT_DENSITY
-vec4 dotThreshold(vec4 featureAttrOverFeatureArea, float dotValue, float tileDotsOverArea) {
-return featureAttrOverFeatureArea * (1.0 / dotValue)  * (1.0 / tileDotsOverArea);
-}
-#endif
-#ifdef SYMBOLOGY_TYPE_IS_OUTLINE_FILL_LIKE
-#include <materials/shared/line/common.glsl>
-#include <materials/shared/line/line.vert>
-void drawLine(out lowp vec4 out_color, out highp vec3 out_pos) {
-LineData outputs = buildLine(
-out_pos,
-a_id,
-a_pos,
-a_color,
-(a_aux3.xy - 128.) / 16.,
-(a_aux3.zw - 128.) / 16.,
-0.,
-a_aux2.z / 16.,
-a_bitset,
-vec4(0.),
-vec2(0.),
-a_aux2.w / 16.
-);
-v_id      = outputs.id;
-v_opacity = outputs.opacity;
-v_aux1    = vec4(outputs.lineHalfWidth, outputs.normal, 0.);
-out_color = outputs.color;
-}
-#endif
-void drawFill(out lowp vec4 out_color, out highp vec3 out_pos) {
-float a_bitSet = a_bitset;
-out_color = getColor(a_color, a_bitSet, BITSET_GENERIC_LOCK_COLOR);
-v_opacity = getOpacity();
-v_id      = norm(a_id);
-#if SYMBOLOGY_TYPE == SYMBOLOGY_TYPE_DOT_DENSITY
-mat3 tileToTileNormalized = mat3(  2. / 512.,  0.,  0.,
-0., -2. / 512.,  0.,
--1.,  1.,  1.  );
-out_pos   = tileToTileNormalized * vec3((a_pos * FILL_POSITION_PRECISION), 1.);
-#else
-out_pos   = u_dvsMat3 * vec3(a_pos * FILL_POSITION_PRECISION, 1.);
-#endif
-#ifdef PATTERN
-vec4  a_tlbr   = a_aux1;
-float a_width  = a_aux2.x;
-float a_height = a_aux2.y;
-vec2  a_offset = a_aux2.zw;
-vec2  a_scale  = a_aux3.xy;
-float a_angle  = a_aux3.z;
-if (getBit(a_bitset, BITSET_FILL_HAS_PATTERN_WIDTH_PRECISION_FACTOR) > 0.5) {
-a_width *= INV_SCALE_COMPRESSION_FACTOR;
-}
-if (getBit(a_bitset, BITSET_FILL_HAS_PATTERN_HEIGHT_PRECISION_FACTOR) > 0.5) {
-a_height *= INV_SCALE_COMPRESSION_FACTOR;
-}
-vec2 scale = INV_SCALE_COMPRESSION_FACTOR * a_scale;
-float width = u_zoomFactor * a_width * scale.x;
-float height = u_zoomFactor * a_height * scale.y;
-float angle = C_256_TO_RAD * a_angle;
-float sinA = sin(angle);
-float cosA = cos(angle);
-float dx = 0.0;
-float dy = 0.0;
-if (getBit(a_bitset, BITSET_FILL_RANDOM_PATTERN_OFFSET) > 0.5) {
-float id = rgba2float(vec4(a_id, 0.0));
-dx = rand(vec2(id, 0.0));
-dy = rand(vec2(0.0, id));
-}
-mat3 patternMatrix = mat3(cosA / width, sinA / height, 0,
--sinA / width, cosA / height, 0,
-dx,            dy,           1);
-vec2 patternSize = vec2(a_width, a_height);
-vec2 numPatternsPerMaxInt = vec2(MAX_REPRESENTABLE_INT) / patternSize;
-vec2 maxIntCrossingOffsetCorrection = patternSize * fract(u_maxIntNumOfCrossing * numPatternsPerMaxInt);
-vec2 tileOffset = u_tileOffset + maxIntCrossingOffsetCorrection - 0.5 * patternSize;
-tileOffset = vec2(tileOffset.x * cosA - tileOffset.y * sinA, tileOffset.x * sinA + tileOffset.y * cosA);
-tileOffset = mod(tileOffset, patternSize);
-vec2 symbolOffset = u_zoomFactor * scale * vec2(a_offset - tileOffset) / vec2(width, height);
-v_tileTextureCoord = (patternMatrix * vec3(a_pos * FILL_POSITION_PRECISION, 1.0)).xy - symbolOffset;
-v_aux1 = a_tlbr / u_mosaicSize.xyxy;
-v_sampleAlphaOnly = getBit(a_bitset, BITSET_GENERIC_CONSIDER_ALPHA_ONLY);
-if (getBit(a_bitSet, BITSET_FILL_HAS_UNRESOLVED_REPLACEMENT_COLOR) > 0.5) {
-#ifdef VV_COLOR
-v_sampleAlphaOnly *= (1.0 - float(isNan(VV_ADATA[ATTR_VV_COLOR]))) * (1.0 - getBit(a_bitSet, BITSET_GENERIC_LOCK_COLOR));
-#else
-v_sampleAlphaOnly = 0.0;
-#endif
-}
-#elif SYMBOLOGY_TYPE == SYMBOLOGY_TYPE_DOT_DENSITY
-vec4 ddAttributeData0 = getAttributeData2(a_id) * u_isActive[0] * a_inverseArea;
-vec4 ddAttributeData1 = getAttributeData3(a_id) * u_isActive[1] * a_inverseArea;
-float size = u_tileZoomFactor * 512.0 * 1.0 / u_pixelRatio;
-v_dotThresholds[0] = dotThreshold(ddAttributeData0, u_dotValue, u_tileDotsOverArea);
-v_dotThresholds[1] = dotThreshold(ddAttributeData1, u_dotValue, u_tileDotsOverArea);
-v_dotTextureCoords = (a_pos * FILL_POSITION_PRECISION + 0.5) / size;
-#endif
-}
-#ifdef HITTEST
-void draw(out lowp vec4 out_color, out highp vec3 out_pos) {
-#ifdef SYMBOLOGY_TYPE_IS_OUTLINE_FILL_LIKE
-if (getBit(a_bitset, BITSET_TYPE_FILL_OUTLINE) > 0.5) {
-out_pos = vec3(0., 0., 2.);
-return;
-}
-#endif
-hittestFill(out_color, out_pos);
-gl_PointSize = 1.0;
-}
-#elif defined(SYMBOLOGY_TYPE_IS_OUTLINE_FILL_LIKE)
-void draw(out lowp vec4 out_color, out highp vec3 out_pos) {
-v_isOutline = getBit(a_bitset, BITSET_TYPE_FILL_OUTLINE);
-if (v_isOutline > 0.5) {
-drawLine(out_color, out_pos);
-} else {
-drawFill(out_color, out_pos);
-}
-}
-#else
-#define draw drawFill
-#endif
-void main()
-{
-INIT;
-highp vec3 pos  = vec3(0.);
-highp vec4 color  = vec4(0.);
-draw(color, pos);
-v_color = color;
-gl_Position = vec4(clip(v_color, pos, getFilterFlags(), a_zoomRange), 1.0);
-}`, "hittest.glsl": `#ifdef HITTEST
-#include <materials/hittest/common.glsl>
-attribute vec2 a_pos1;
-attribute vec2 a_pos2;
-void hittestFill(
-out lowp vec4 out_color,
-out highp vec3 out_pos
-) {
-vec3 pos        = u_viewMat3 * u_tileMat3 * vec3(a_pos  * FILL_POSITION_PRECISION, 1.);
-vec3 pos1       = u_viewMat3 * u_tileMat3 * vec3(a_pos1 * FILL_POSITION_PRECISION, 1.);
-vec3 pos2       = u_viewMat3 * u_tileMat3 * vec3(a_pos2 * FILL_POSITION_PRECISION, 1.);
-float hittestDist = u_hittestDist;
-float dist = distPointTriangle(u_hittestPos, pos.xy, pos1.xy, pos2.xy);
-out_pos = vec3(getAttributeDataTextureCoords(a_id), 0.0);
-if (dist < 0. || dist >= hittestDist) {
-out_pos.z += 2.0;
-}
-out_color = vec4(1. / 255., 0, 0, dist == 0. ? (1. / 255.) : 0.);
-}
-#endif` }, hittest: { "common.glsl": `#ifdef HITTEST
-uniform float hittestDist;
-uniform highp vec2 hittestPos;
-float projectScalar(vec2 a, vec2 b) {
-return dot(a, normalize(b));
-}
-float distPointSegment(vec2 p0, vec2 p1, vec2 p2) {
-vec2 L = p2 - p1;
-vec2 A = p0 - p1;
-float projAL = projectScalar(A, L);
-float t = clamp(projAL / length(L), 0., 1.);
-return distance(p0, p1 + t * (p2 - p1));
-}
-void hittestMarker(out lowp vec4 out_color, out highp vec3 out_pos, in highp vec3 pos, float size) {
-float dist = distance(pos, vec3(hittestPos, 1.));
-out_pos = vec3(getAttributeDataTextureCoords(a_id), 0.0);
-if ((dist - size) > hittestDist) {
-out_pos.z += 2.0;
-}
-out_color = vec4(1. / 255., 0, 0, (dist - size) < 0. ? (1. / 255.) : 0.);
-}
-float intersectPointTriangleBary(vec2 p, vec2 a, vec2 b, vec2 c) {
-return inTriangle(xyToBarycentric(p, a, b, c));
-}
-float distPointTriangle(vec2 p, vec2 a, vec2 b, vec2 c) {
-vec2 ba = b - a;
-vec2 ca = c - a;
-float crossProduct = ba.x * ca.y - ca.x * ba.y;
-bool isParallel = crossProduct < EPSILON_HITTEST && crossProduct > -EPSILON_HITTEST;
-if (isParallel) {
-return -1.;
-}
-if (intersectPointTriangleBary(p.xy, a, b, c) == 1.) {
-return 0.;
-}
-float distAB = distPointSegment(p, a, b);
-float distBC = distPointSegment(p, b, c);
-float distCA = distPointSegment(p, c, a);
-return min(min(distAB, distBC), distCA);
-}
-#endif` }, icon: { "common.glsl": `#include <util/encoding.glsl>
-uniform lowp vec2 u_mosaicSize;
-varying lowp vec4 v_color;
-varying highp vec3 v_id;
-varying highp vec4 v_sizeTex;
-varying mediump vec3 v_pos;
-varying lowp float v_opacity;
-uniform lowp sampler2D u_texture;
-#ifdef SDF
-varying lowp vec4 v_outlineColor;
-varying mediump float v_outlineWidth;
-varying mediump float v_distRatio;
-varying mediump float v_overridingOutlineColor;
-varying mediump float v_isThin;
-#endif
-#ifdef SDF
-vec4 getColor(vec2 v_size, vec2 v_tex) {
-#ifdef HITTEST
-lowp vec4 fillPixelColor = vec4(1.0);
-#else
-lowp vec4 fillPixelColor = v_color;
-#endif
-float d = 0.5 - rgba2float(texture2D(u_texture, v_tex));
-float size = max(v_size.x, v_size.y);
-float dist = d * size * SOFT_EDGE_RATIO * v_distRatio;
-fillPixelColor *= clamp(0.5 - dist, 0.0, 1.0);
-float outlineWidth = v_outlineWidth;
-#ifdef HIGHLIGHT
-outlineWidth = max(outlineWidth, 4.0 * v_isThin);
-#endif
-if (outlineWidth > 0.25) {
-lowp vec4 outlinePixelColor = v_overridingOutlineColor * v_color + (1.0 - v_overridingOutlineColor) * v_outlineColor;
-float clampedOutlineSize = min(outlineWidth, size);
-outlinePixelColor *= clamp(0.5 - abs(dist) + clampedOutlineSize * 0.5, 0.0, 1.0);
-return v_opacity * ((1.0 - outlinePixelColor.a) * fillPixelColor + outlinePixelColor);
-}
-return v_opacity * fillPixelColor;
-}
-#else
-vec4 getColor(vec2 _v_size, vec2 v_tex) {
-lowp vec4 texColor = texture2D(u_texture, v_tex);
-return v_opacity * texColor * v_color;
-}
-#endif`, heatmapAccumulate: { "common.glsl": `varying lowp vec4 v_hittestResult;
-varying mediump vec2 v_offsetFromCenter;
-varying highp float v_fieldValue;`, "heatmapAccumulate.frag": `precision mediump float;
-#include <materials/icon/heatmapAccumulate/common.glsl>
-#ifdef HEATMAP_PRECISION_HALF_FLOAT
-#define COMPRESSION_FACTOR 0.25
-#else
-#define COMPRESSION_FACTOR 1.0
-#endif
-uniform lowp sampler2D u_texture;
-void main() {
-#ifdef HITTEST
-gl_FragColor = v_hittestResult;
-#else
-float radius = length(v_offsetFromCenter);
-float shapeWeight = step(radius, 1.0);
-float oneMinusRadiusSquared = 1.0 - radius * radius;
-float kernelWeight = oneMinusRadiusSquared * oneMinusRadiusSquared;
-gl_FragColor = vec4(shapeWeight * kernelWeight * v_fieldValue * COMPRESSION_FACTOR);
-#endif
-}`, "heatmapAccumulate.vert": `precision highp float;
-attribute vec2 a_vertexOffset;
-vec4 a_color = vec4(0.0);
-vec2 a_zoomRange = vec2(0.0, 10000.0);
-uniform float u_radius;
-uniform float u_isFieldActive;
-#include <materials/vcommon.glsl>
-#include <materials/hittest/common.glsl>
-#include <materials/icon/heatmapAccumulate/common.glsl>
-void main() {
-float filterFlags = getFilterFlags();
-#ifdef HITTEST
-highp vec4 out_hittestResult = vec4(0.);
-highp vec3 out_pos = vec3(0.);
-vec3 pos = u_viewMat3 * u_tileMat3 * vec3(a_pos * POSITION_PRECISION, 1.0);
-hittestMarker(out_hittestResult, out_pos, pos, u_radius);
-v_hittestResult = out_hittestResult;
-gl_PointSize = 1.;
-gl_Position = vec4(clip(a_color, out_pos, filterFlags, a_zoomRange), 1.0);
-#else
-v_offsetFromCenter = sign(a_vertexOffset);
-v_fieldValue = getAttributeData2(a_id).x * u_isFieldActive + 1.0 - u_isFieldActive;
-vec3 centerPos = u_dvsMat3 * vec3(a_pos * POSITION_PRECISION, 1.0);
-vec3 vertexPos = centerPos + u_displayViewMat3 * vec3(v_offsetFromCenter, 0.0) * u_radius;
-gl_Position = vec4(clip(a_color, vertexPos, filterFlags, a_zoomRange), 1.0);
-#endif
-}` }, "hittest.glsl": `#ifdef HITTEST
-#include <materials/hittest/common.glsl>
-attribute vec2 a_vertexOffset1;
-attribute vec2 a_vertexOffset2;
-attribute vec2 a_texCoords1;
-attribute vec2 a_texCoords2;
-vec2 getTextureCoords(in vec3 bary, in vec2 texCoords0, in vec2 texCoords1, in vec2 texCoords2) {
-return texCoords0 * bary.x + texCoords1 * bary.y + texCoords2 * bary.z;
-}
-void hittestIcon(
-inout lowp vec4 out_color,
-out highp vec3 out_pos,
-in vec3 pos,
-in vec3 offset,
-in vec2 size,
-in float scaleFactor,
-in float isMapAligned
-) {
-out_pos = vec3(getAttributeDataTextureCoords(a_id), 0.0);
-vec3 posBase = u_viewMat3 * u_tileMat3  * pos;
-vec3 offset1 = scaleFactor * vec3(a_vertexOffset1 / 16.0, 0.);
-vec3 offset2 = scaleFactor * vec3(a_vertexOffset2 / 16.0, 0.);
-vec2 pos0    = (posBase + getMatrixNoDisplay(isMapAligned) * offset).xy;
-vec2 pos1    = (posBase + getMatrixNoDisplay(isMapAligned) * offset1).xy;
-vec2 pos2    = (posBase + getMatrixNoDisplay(isMapAligned) * offset2).xy;
-vec3 bary0 = xyToBarycentric(u_hittestPos + vec2(-u_hittestDist, -u_hittestDist), pos0, pos1, pos2);
-vec3 bary1 = xyToBarycentric(u_hittestPos + vec2(0., -u_hittestDist), pos0, pos1, pos2);
-vec3 bary2 = xyToBarycentric(u_hittestPos + vec2(u_hittestDist, -u_hittestDist), pos0, pos1, pos2);
-vec3 bary3 = xyToBarycentric(u_hittestPos + vec2(-u_hittestDist, 0.), pos0, pos1, pos2);
-vec3 bary4 = xyToBarycentric(u_hittestPos, pos0, pos1, pos2);
-vec3 bary5 = xyToBarycentric(u_hittestPos + vec2(u_hittestDist, 0.), pos0, pos1, pos2);
-vec3 bary6 = xyToBarycentric(u_hittestPos + vec2(-u_hittestDist, u_hittestDist), pos0, pos1, pos2);
-vec3 bary7 = xyToBarycentric(u_hittestPos + vec2(0., u_hittestDist), pos0, pos1, pos2);
-vec3 bary8 = xyToBarycentric(u_hittestPos + vec2(u_hittestDist, u_hittestDist), pos0, pos1, pos2);
-vec2 tex0 = a_texCoords  / u_mosaicSize;
-vec2 tex1 = a_texCoords1 / u_mosaicSize;
-vec2 tex2 = a_texCoords2 / u_mosaicSize;
-float alphaSum = 0.;
-alphaSum += inTriangle(bary0) * getColor(size, getTextureCoords(bary0, tex0, tex1, tex2)).a;
-alphaSum += inTriangle(bary1) * getColor(size, getTextureCoords(bary1, tex0, tex1, tex2)).a;
-alphaSum += inTriangle(bary2) * getColor(size, getTextureCoords(bary2, tex0, tex1, tex2)).a;
-alphaSum += inTriangle(bary3) * getColor(size, getTextureCoords(bary3, tex0, tex1, tex2)).a;
-alphaSum += inTriangle(bary4) * getColor(size, getTextureCoords(bary4, tex0, tex1, tex2)).a;
-alphaSum += inTriangle(bary5) * getColor(size, getTextureCoords(bary5, tex0, tex1, tex2)).a;
-alphaSum += inTriangle(bary6) * getColor(size, getTextureCoords(bary6, tex0, tex1, tex2)).a;
-alphaSum += inTriangle(bary7) * getColor(size, getTextureCoords(bary7, tex0, tex1, tex2)).a;
-out_pos.z += step(alphaSum, .05) * 2.0;
-out_color = vec4(1. / 255., 0., 0., alphaSum / 255.);
-}
-#endif`, "icon.frag": `precision mediump float;
-#include <materials/constants.glsl>
-#include <materials/utils.glsl>
-#include <materials/icon/common.glsl>
-void main()
-{
-#ifdef HITTEST
-vec4 color = v_color;
-#else
-vec4 color = getColor(v_sizeTex.xy, v_sizeTex.zw);
-#endif
-#ifdef HIGHLIGHT
-color.a = step(1.0 / 255.0, color.a);
-#endif
-gl_FragColor = color;
-}`, "icon.vert": `precision highp float;
-attribute vec4 a_color;
-attribute vec4 a_outlineColor;
-attribute vec4 a_sizeAndOutlineWidth;
-attribute vec2 a_vertexOffset;
-attribute vec2 a_texCoords;
-attribute vec2 a_bitSetAndDistRatio;
-attribute vec2 a_zoomRange;
-#include <materials/vcommon.glsl>
-#include <materials/icon/common.glsl>
-#include <materials/icon/hittest.glsl>
-float getMarkerScaleFactor(inout vec2 size, in float referenceSize) {
-#ifdef VV_SIZE
-float f = getSize(size.y) / size.y;
-float sizeFactor = size.y / referenceSize;
-return getSize(referenceSize) / referenceSize;
-#else
-return 1.;
-#endif
-}
-void main()
-{
-INIT;
-float a_bitSet = a_bitSetAndDistRatio.x;
-vec3  pos           = vec3(a_pos * POSITION_PRECISION, 1.0);
-vec2  size          = a_sizeAndOutlineWidth.xy * a_sizeAndOutlineWidth.xy / 128.0;
-vec3  offset        = vec3(a_vertexOffset / 16.0, 0.);
-float outlineSize   = a_sizeAndOutlineWidth.z * a_sizeAndOutlineWidth.z / 128.0;
-float isMapAligned  = getBit(a_bitSet, BITSET_MARKER_ALIGNMENT_MAP);
-float referenceSize = a_sizeAndOutlineWidth.w * a_sizeAndOutlineWidth.w / 128.0;
-float scaleSymbolProportionally = getBit(a_bitSet, BITSET_MARKER_SCALE_SYMBOLS_PROPORTIONALLY);
-float scaleFactor               = getMarkerScaleFactor(size, referenceSize);
-size.xy     *= scaleFactor;
-offset.xy   *= scaleFactor;
-outlineSize *= scaleSymbolProportionally * (scaleFactor - 1.0) + 1.0;
-vec2 v_tex   = a_texCoords / u_mosaicSize;
-float filterFlags = getFilterFlags();
-v_color    = getColor(a_color, a_bitSet, BITSET_GENERIC_LOCK_COLOR);
-v_opacity  = getOpacity();
-v_id       = norm(a_id);
-v_pos      = u_dvsMat3 * pos + getMatrix(isMapAligned) * getRotation()  * offset;
-v_sizeTex  = vec4(size.xy, v_tex.xy);
-#ifdef SDF
-v_isThin   = getBit(a_bitSet, BITSET_MARKER_OUTLINE_ALLOW_COLOR_OVERRIDE);
-#ifdef VV_COLOR
-v_overridingOutlineColor = v_isThin;
-#else
-v_overridingOutlineColor = 0.0;
-#endif
-v_outlineWidth = min(outlineSize, max(max(size.x, size.y) - 0.99, 0.0));
-v_outlineColor = a_outlineColor;
-v_distRatio = a_bitSetAndDistRatio.y / 128.0;
-#endif
-#ifdef HITTEST
-highp vec4 out_color = vec4(0.);
-highp vec3 out_pos   = vec3(0.);
-hittestIcon(out_color, out_pos, pos, offset, size, scaleFactor, isMapAligned);
-v_color = out_color;
-gl_PointSize = 1.;
-gl_Position = vec4(clip(v_color, out_pos, filterFlags, a_zoomRange), 1.0);
-#else
-gl_Position = vec4(clip(v_color, v_pos, filterFlags, a_zoomRange), 1.0);
-#endif
-}` }, label: { "common.glsl": `uniform mediump float u_zoomLevel;
-uniform mediump float u_mapRotation;
-uniform mediump float u_mapAligned;
-uniform mediump vec2 u_mosaicSize;
-varying mediump float v_antialiasingWidth;
-varying mediump float v_edgeDistanceOffset;
-varying mediump vec2 v_tex;
-varying mediump vec4 v_color;
-varying lowp vec4 v_animation;`, "label.frag": "#include <materials/text/text.frag>", "label.vert": `precision highp float;
-#include <materials/vcommon.glsl>
-#include <materials/text/common.glsl>
-attribute vec4 a_color;
-attribute vec4 a_haloColor;
-attribute vec4 a_texAndSize;
-attribute vec4 a_refSymbolAndPlacementOffset;
-attribute vec4 a_glyphData;
-attribute vec2 a_vertexOffset;
-attribute vec2 a_texCoords;
-uniform float u_isHaloPass;
-uniform float u_isBackgroundPass;
-uniform float u_mapRotation;
-uniform float u_mapAligned;
-float getZ(in float minZoom, in float maxZoom, in float angle) {
-float glyphAngle = angle * 360.0 / 254.0;
-float mapAngle = u_mapRotation * 360.0 / 254.0;
-float diffAngle = min(360.0 - abs(mapAngle - glyphAngle), abs(mapAngle - glyphAngle));
-float z = 0.0;
-z += u_mapAligned * (2.0 * (1.0 - step(minZoom, u_currentZoom)));
-z += u_mapAligned * 2.0 * step(90.0, diffAngle);
-z += 2.0 * (1.0 - step(u_currentZoom, maxZoom));
-return z;
-}
-void main()
-{
-INIT;
-float groupMinZoom    = getMinZoom();
-float glyphMinZoom    = a_glyphData.x;
-float glyphMaxZoom    = a_glyphData.y;
-float glyphAngle      = a_glyphData.z;
-float a_isBackground  = a_glyphData.w;
-float a_minZoom          = max(groupMinZoom, glyphMinZoom);
-float a_placementPadding = a_refSymbolAndPlacementOffset.x * EXTRUDE_SCALE_PLACEMENT_PADDING;
-vec2  a_placementDir     = unpack_u8_nf32(a_refSymbolAndPlacementOffset.zw);
-float a_refSymbolSize    = a_refSymbolAndPlacementOffset.y;
-float fontSize           = a_texAndSize.z;
-float haloSize           = a_texAndSize.w * OUTLINE_SCALE;
-vec2  vertexOffset = a_vertexOffset * OFFSET_PRECISION;
-vec3  pos          = vec3(a_pos * POSITION_PRECISION, 1.0);
-float z            = getZ(a_minZoom, glyphMaxZoom, glyphAngle);
-float fontScale    = fontSize / SDF_FONT_SIZE;
-float halfSize     = getSize(a_refSymbolSize) / 2.0;
-float animation    = pow(getAnimationState(), vec4(2.0)).r;
-float isText = 1.0 - a_isBackground;
-float isBackground = u_isBackgroundPass * a_isBackground;
-vec4  nonHaloColor = (isBackground + isText) * a_color;
-v_color     = animation * ((1.0 - u_isHaloPass) * nonHaloColor + (u_isHaloPass * a_haloColor));
-v_opacity   = 1.0;
-v_tex       = a_texCoords / u_mosaicSize;
-v_edgeDistanceOffset = u_isHaloPass * haloSize / fontScale / MAX_SDF_DISTANCE;
-v_antialiasingWidth  = 0.105 * SDF_FONT_SIZE / fontSize / u_pixelRatio;
-vec2 placementOffset = a_placementDir * (halfSize + a_placementPadding);
-vec3 glyphOffset     = u_displayMat3 * vec3(vertexOffset + placementOffset, 0.0);
-vec3 v_pos           = vec3((u_dvsMat3 * pos + glyphOffset).xy, z);
-float isHidden = u_isBackgroundPass * isText + (1.0 - u_isBackgroundPass) * a_isBackground;
-v_pos.z += 2.0 * isHidden;
-gl_Position = vec4(v_pos, 1.0);
-#ifdef DEBUG
-v_color = vec4(a_color.rgb, z == 0.0 ? 1.0 : 0.645);
-#endif
-}` }, line: { "common.glsl": `varying lowp vec4 v_color;
-varying highp vec3 v_id;
-varying mediump vec2 v_normal;
-varying mediump float v_lineHalfWidth;
-varying lowp float v_opacity;
-#ifdef PATTERN
-varying mediump vec4 v_tlbr;
-varying mediump vec2 v_patternSize;
-#endif
-#if defined(PATTERN) || defined(SDF)
-varying highp float v_accumulatedDistance;
-#endif
-#ifdef SDF
-varying mediump float v_lineWidthRatio;
-#endif`, "hittest.glsl": `#include <materials/hittest/common.glsl>
-#ifdef HITTEST
-attribute vec2 a_pos1;
-attribute vec2 a_pos2;
-void hittestLine(out lowp vec4 out_color, out highp vec3 out_pos, float halfWidth) {
-vec3 pos        = u_viewMat3 * u_tileMat3 * vec3(a_pos  * POSITION_PRECISION, 1.);
-vec3 pos1       = u_viewMat3 * u_tileMat3 * vec3(a_pos1 * POSITION_PRECISION, 1.);
-vec3 pos2       = u_viewMat3 * u_tileMat3 * vec3(a_pos2 * POSITION_PRECISION, 1.);
-vec3 outTextureCoords = vec3(getAttributeDataTextureCoords(a_id), 0.0);
-float dist = min(distPointSegment(u_hittestPos, pos.xy, pos1.xy),
-distPointSegment(u_hittestPos, pos.xy, pos2.xy)) - halfWidth;
-out_pos = vec3(getAttributeDataTextureCoords(a_id), 0.0);
-if (dist >= u_hittestDist) {
-out_pos.z += 2.0;
-}
-out_color = vec4(1. / 255., 0, 0, dist <= 0. ? (1. / 255.) : 0.);
-}
-#endif`, "line.frag": `precision lowp float;
-#include <util/encoding.glsl>
-#include <materials/constants.glsl>
-#include <materials/symbologyTypeUtils.glsl>
-#include <materials/line/common.glsl>
-#include <materials/shared/line/common.glsl>
-#include <materials/shared/line/line.frag>
-#ifdef HITTEST
-void main() {
-gl_FragColor = v_color;
-}
-#else
-void main() {
-LineData inputs = LineData(
-v_color,
-v_normal,
-v_lineHalfWidth,
-v_opacity,
-#ifndef SYMBOLOGY_TYPE_IS_OUTLINE_FILL_LIKE
-#ifdef PATTERN
-v_tlbr,
-v_patternSize,
-#endif
-#ifdef SDF
-v_lineWidthRatio,
-#endif
-#if defined(PATTERN) || defined(SDF)
-v_accumulatedDistance,
-#endif
-#endif
-v_id
-);
-gl_FragColor = shadeLine(inputs);
-}
-#endif`, "line.vert": `precision highp float;
-attribute vec4 a_color;
-attribute vec4 a_offsetAndNormal;
-attribute vec2 a_accumulatedDistanceAndHalfWidth;
-attribute vec4 a_tlbr;
-attribute vec4 a_segmentDirection;
-attribute vec2 a_aux;
-attribute vec2 a_zoomRange;
-#include <materials/vcommon.glsl>
-#include <materials/symbologyTypeUtils.glsl>
-#include <materials/line/common.glsl>
-#include <materials/line/hittest.glsl>
-#include <materials/shared/line/common.glsl>
-#include <materials/shared/line/line.vert>
-#ifdef HITTEST
-void draw() {
-float aa        = 0.5 * u_antialiasing;
-float a_halfWidth = a_accumulatedDistanceAndHalfWidth.y / 16.;
-float a_cimHalfWidth = a_aux.x / 16. ;
-vec2  a_offset = a_offsetAndNormal.xy / 16.;
-float baseWidth = getBaseLineHalfWidth(a_halfWidth, a_cimHalfWidth);
-float halfWidth = getLineHalfWidth(baseWidth, aa);
-highp vec3 pos  = vec3(0.);
-v_color = vec4(0.);
-hittestLine(v_color, pos, halfWidth);
-gl_PointSize = 1.;
-gl_Position = vec4(clip(v_color, pos, getFilterFlags(), a_zoomRange), 1.0);
-}
-#else
-void draw()
-{
-highp vec3 pos = vec3(0.);
-LineData outputs = buildLine(
-pos,
-a_id,
-a_pos,
-a_color,
-a_offsetAndNormal.xy / 16.,
-a_offsetAndNormal.zw / 16.,
-a_accumulatedDistanceAndHalfWidth.x,
-a_accumulatedDistanceAndHalfWidth.y / 16.,
-a_segmentDirection.w,
-a_tlbr,
-a_segmentDirection.xy / 16.,
-a_aux.x / 16.
-);
-v_id              = outputs.id;
-v_color           = outputs.color;
-v_normal          = outputs.normal;
-v_lineHalfWidth   = outputs.lineHalfWidth;
-v_opacity         = outputs.opacity;
-#ifndef SYMBOLOGY_TYPE_IS_OUTLINE_FILL_LIKE
-#ifdef PATTERN
-v_tlbr          = outputs.tlbr;
-v_patternSize   = outputs.patternSize;
-#endif
-#ifdef SDF
-v_lineWidthRatio = outputs.lineWidthRatio;
-#endif
-#if defined(PATTERN) || defined(SDF)
-v_accumulatedDistance = outputs.accumulatedDistance;
-#endif
-#endif
-gl_Position = vec4(clip(outputs.color, pos, getFilterFlags(), a_zoomRange), 1.0);
-}
-#endif
-void main() {
-INIT;
-draw();
-}` }, pie: { "pie.common.glsl": `uniform float outlineWidth;
-uniform mediump float sectorThreshold;
-varying vec3  v_id;
-varying vec3  v_pos;
-varying vec2  v_offset;
-varying vec4  v_color;
-varying float v_size;
-varying float v_numOfEntries;
-varying float v_maxSectorAngle;
-varying vec2  v_filteredSectorToColorId[numberOfFields];
-varying vec2  v_texCoords;
-varying float v_outlineWidth;
-varying float v_opacity;
-struct FilteredChartInfo {
-float endSectorAngle;
-int colorId;
-};`, "pie.frag": `precision highp float;
-#include <util/atan2.glsl>
-#include <materials/constants.glsl>
-#include <materials/utils.glsl>
-#include <materials/pie/pie.common.glsl>
-uniform lowp vec4 colors[numberOfFields];
-uniform lowp vec4 defaultColor;
-uniform lowp vec4 othersColor;
-uniform lowp vec4 outlineColor;
-uniform float donutRatio;
-lowp vec4 getSectorColor(in int index, in vec2 filteredSectorToColorId[numberOfFields]) {
-mediump int colorIndex = int(filteredSectorToColorId[index].y);
-return colors[colorIndex];
-}
-const int OTHER_SECTOR_ID = 255;
-#ifdef HITTEST
-vec4 getColor() {
-float distanceSize = length(v_offset) * v_size;
-float donutSize = donutRatio * v_size;
-float alpha = step(donutSize, distanceSize) * (1.0 - step(v_size, distanceSize));
-return v_color;
-}
-#else
-vec4 getColor() {
-float angle = 90.0 - C_RAD_TO_DEG * atan2(v_offset.y, v_offset.x);
-if (angle < 0.0) {
-angle += 360.0;
-} else if (angle > 360.0) {
-angle = mod(angle, 360.0);
-}
-int numOfEntries = int(v_numOfEntries);
-float maxSectorAngle = v_maxSectorAngle;
-lowp vec4 fillColor = (maxSectorAngle > 0.0 || sectorThreshold > 0.0) ? othersColor : defaultColor;
-lowp vec4 prevColor = vec4(0.0);
-lowp vec4 nextColor = vec4(0.0);
-float startSectorAngle = 0.0;
-float endSectorAngle = 0.0;
-if (angle < maxSectorAngle) {
-for (int index = 0; index < numberOfFields; ++index) {
-startSectorAngle = endSectorAngle;
-endSectorAngle = v_filteredSectorToColorId[index].x;
-if (endSectorAngle > angle) {
-fillColor = getSectorColor(index, v_filteredSectorToColorId);
-prevColor = sectorThreshold != 0.0 && index == 0 && abs(360.0 - maxSectorAngle) < EPSILON ? othersColor :
-getSectorColor(index > 0 ? index - 1 : numOfEntries - 1, v_filteredSectorToColorId);
-nextColor = sectorThreshold != 0.0 && abs(endSectorAngle - maxSectorAngle) < EPSILON ? othersColor :
-getSectorColor(index < numOfEntries - 1 ? index + 1 : 0, v_filteredSectorToColorId);
-break;
-}
-if (index == numOfEntries - 1) {
-break;
-}
-}
-} else {
-prevColor = getSectorColor(numOfEntries - 1, v_filteredSectorToColorId);
-nextColor = getSectorColor(0, v_filteredSectorToColorId);
-startSectorAngle = maxSectorAngle;
-endSectorAngle = 360.0;
-}
-lowp vec4 outlineColor = outlineColor;
-float offset = length(v_offset);
-float distanceSize = offset * v_size;
-if (startSectorAngle != 0.0 || endSectorAngle != 360.0) {
-float distanceToStartSector = (angle - startSectorAngle);
-float distanceToEndSector = (endSectorAngle - angle);
-float sectorThreshold = 0.6;
-float beginSectorAlpha = smoothstep(0.0, sectorThreshold, distanceToStartSector * offset);
-float endSectorAlpha = smoothstep(0.0, sectorThreshold, distanceToEndSector * offset);
-if (endSectorAlpha > 0.0) {
-fillColor = mix(nextColor, fillColor, endSectorAlpha);
-} else if (beginSectorAlpha > 0.0) {
-fillColor = mix(prevColor, fillColor, beginSectorAlpha);
-}
-}
-float donutSize = donutRatio * (v_size - v_outlineWidth);
-float endOfDonut = donutSize - v_outlineWidth;
-float aaThreshold = 0.75;
-float innerCircleAlpha = endOfDonut - aaThreshold > 0.0 ? smoothstep(endOfDonut - aaThreshold, endOfDonut + aaThreshold, distanceSize) : 1.0;
-float outerCircleAlpha = 1.0 - smoothstep(v_size - aaThreshold, v_size + aaThreshold , distanceSize);
-float circleAlpha = innerCircleAlpha * outerCircleAlpha;
-float startOfOutline = v_size - v_outlineWidth;
-if (startOfOutline > 0.0 && v_outlineWidth > 0.25) {
-float outlineFactor = smoothstep(startOfOutline - aaThreshold, startOfOutline + aaThreshold, distanceSize);
-float innerLineFactor = donutSize - aaThreshold > 0.0 ? 1.0 - smoothstep(donutSize - aaThreshold, donutSize + aaThreshold , distanceSize) : 0.0;
-fillColor = mix(fillColor, outlineColor, innerLineFactor + outlineFactor);
-}
-return v_opacity * circleAlpha * fillColor;
-}
-#endif
-void main()
-{
-vec4 color = getColor();
-#ifdef highlight
-color.a = step(1.0 / 255.0, color.a);
-#endif
-gl_FragColor = color;
-}`, "pie.vert": `#include <materials/constants.glsl>
-#include <materials/utils.glsl>
-#include <materials/barycentric.glsl>
-#include <materials/vcommon.glsl>
-#include <materials/vv.glsl>
-#include <materials/attributeData.glsl>
-#include <materials/pie/pie.common.glsl>
-#include <materials/hittest/common.glsl>
-attribute float a_bitSet;
-attribute vec2  a_offset;
-attribute vec2  a_texCoords;
-attribute vec2  a_size;
-attribute float a_referenceSize;
-attribute vec2  a_zoomRange;
-int filterValue(in float sectorAngle,
-in int currentIndex,
-inout FilteredChartInfo filteredInfo,
-inout vec2 filteredSectorToColorId[numberOfFields]) {
-if (sectorAngle > sectorThreshold * 360.0) {
-filteredInfo.endSectorAngle += sectorAngle;
-filteredSectorToColorId[filteredInfo.colorId] = vec2(filteredInfo.endSectorAngle, currentIndex);
-++filteredInfo.colorId;
-}
-return 0;
-}
-int filterValues(inout vec2 filteredSectorToColorId[numberOfFields],
-inout FilteredChartInfo filteredInfo,
-in float sectorAngles[numberOfFields]) {
-for (int index = 0; index < numberOfFields; ++index) {
-float sectorValue = sectorAngles[index];
-filterValue(sectorValue, index, filteredInfo, filteredSectorToColorId);
-}
-return filteredInfo.colorId;
-}
-vec2 getMarkerSize(inout vec2 offset, inout vec2 baseSize, inout float outlineSize, in float a_referenceSize, in float bitSet) {
-vec2 outSize = baseSize;
-#ifdef VV_SIZE
-float r = getSize(a_referenceSize, currentScale) / a_referenceSize;
-outSize.xy *= r;
-offset.xy *= r;
-float scaleSymbolProportionally = getBit(bitSet, BITSET_MARKER_SCALE_SYMBOLS_PROPORTIONALLY);
-outlineSize *= scaleSymbolProportionally * (r - 1.0) + 1.0;
-#endif
-return outSize;
-}
-vec3 getOffset(in vec2 in_offset, float a_bitSet) {
-float isMapAligned = getBit(a_bitSet, BITSET_MARKER_ALIGNMENT_MAP);
-vec3  offset       = vec3(in_offset, 0.0);
-return getMatrix(isMapAligned) * offset;
-}
-float filterNaNValues(in float value) {
-return value != NAN_MAGIC_NUMBER && value > 0.0 ? value : 0.0;
-}
-void main()
-{
-INIT;
-vec2  a_size   = a_size;
-vec2  a_offset = a_offset / 16.0;
-float outlineSize = outlineWidth;
-float a_bitSet = a_bitSet;
-float a_referenceSize = a_referenceSize;
-vec2 a_texCoords = a_texCoords / 4.0;
-vec2 markerSize = getMarkerSize(a_offset, a_size, outlineSize, a_referenceSize, a_bitSet);
-float filterFlags = getFilterFlags();
-vec3  pos         = vec3(a_pos / 10.0, 1.0);
-v_opacity      = getOpacity();
-v_id           = norm(a_id);
-v_pos          = displayViewScreenMat3 * pos + getOffset(a_offset, a_bitSet);
-v_offset       = sign(a_texCoords - 0.5);
-v_size         = max(markerSize.x, markerSize.y);
-v_outlineWidth = outlineSize;
-float attributeData[10];
-vec4 attributeData3 = getDataDriven0(a_id);
-attributeData[0] = filterNaNValues(attributeData3.x);
-attributeData[1] = filterNaNValues(attributeData3.y);
-attributeData[2] = filterNaNValues(attributeData3.z);
-attributeData[3] = filterNaNValues(attributeData3.w);
-#if (numberOfFields > 4)
-vec4 attributeData4 = getDataDriven1(a_id);
-attributeData[4] = filterNaNValues(attributeData4.x);
-attributeData[5] = filterNaNValues(attributeData4.y);
-attributeData[6] = filterNaNValues(attributeData4.z);
-attributeData[7] = filterNaNValues(attributeData4.w);
-#endif
-#if (numberOfFields > 8)
-vec4 attributeData5 = getDataDriven2(a_id);
-attributeData[8] = filterNaNValues(attributeData5.x);
-attributeData[9] = filterNaNValues(attributeData5.y);
-#endif
-float sum = 0.0;
-for (int i = 0; i < numberOfFields; ++i) {
-sum += attributeData[i];
-}
-float sectorAngles[numberOfFields];
-for (int i = 0; i < numberOfFields; ++i) {
-sectorAngles[i] = 360.0 * attributeData[i] / sum;
-}
-vec2 filteredSectorToColorId[numberOfFields];
-FilteredChartInfo filteredInfo = FilteredChartInfo(0.0, 0);
-int numOfEntries = filterValues(filteredSectorToColorId, filteredInfo, sectorAngles);
-v_numOfEntries = float(numOfEntries);
-v_maxSectorAngle = filteredInfo.endSectorAngle;
-v_filteredSectorToColorId = filteredSectorToColorId;
-#ifdef HITTEST
-highp vec3 out_pos = vec3(0.0);
-v_color            = vec4(0.0);
-hittestMarker(v_color, out_pos, viewMat3 * tileMat3 *  pos, v_size);
-gl_PointSize = 1.0;
-gl_Position = vec4(clip(v_color, out_pos, filterFlags, a_zoomRange), 1.0);
-#else
-gl_Position = vec4(clip(v_color, v_pos, filterFlags, a_zoomRange), 1.0);
-#endif
-}` }, shared: { line: { "common.glsl": `#if !defined(SYMBOLOGY_TYPE_IS_OUTLINE_FILL_LIKE) && defined(PATTERN)
-uniform mediump vec2 u_mosaicSize;
-varying mediump float v_sampleAlphaOnly;
-#endif
-struct LineData {
-lowp vec4 color;
-mediump vec2 normal;
-mediump float lineHalfWidth;
-lowp float opacity;
-#ifndef SYMBOLOGY_TYPE_IS_OUTLINE_FILL_LIKE
-#ifdef PATTERN
-mediump vec4 tlbr;
-mediump vec2 patternSize;
-#endif
-#ifdef SDF
-mediump float lineWidthRatio;
-#endif
-#if defined(PATTERN) || defined(SDF)
-highp float accumulatedDistance;
-#endif
-#endif
-highp vec3 id;
-};`, "line.frag": `uniform lowp float u_blur;
-#if !defined(SYMBOLOGY_TYPE_IS_OUTLINE_FILL_LIKE) && !defined(HIGHLIGHT)
-#if defined(PATTERN) || defined(SDF)
-uniform sampler2D u_texture;
-uniform highp float u_pixelRatio;
-#endif
-#endif
-#if defined(SDF) && !defined(HIGHLIGHT) && !defined(SYMBOLOGY_TYPE_IS_OUTLINE_FILL_LIKE)
-lowp vec4 getLineColor(LineData line) {
-mediump float adjustedPatternWidth = line.patternSize.x * 2.0 * line.lineWidthRatio;
-mediump float relativeTexX = fract(line.accumulatedDistance / adjustedPatternWidth);
-mediump float relativeTexY = 0.5 + 0.25 * line.normal.y;
-mediump vec2 texCoord = mix(line.tlbr.xy, line.tlbr.zw, vec2(relativeTexX, relativeTexY));
-mediump float d = rgba2float(texture2D(u_texture, texCoord)) - 0.5;
-float dist = d * line.lineHalfWidth;
-return line.opacity * clamp(0.5 - dist, 0.0, 1.0) * line.color;
-}
-#elif defined(PATTERN) && !defined(HIGHLIGHT) && !defined(SYMBOLOGY_TYPE_IS_OUTLINE_FILL_LIKE)
-lowp vec4 getLineColor(LineData line) {
-mediump float lineHalfWidth = line.lineHalfWidth;
-mediump float adjustedPatternHeight = line.patternSize.y * 2.0 * lineHalfWidth / line.patternSize.x;
-mediump float relativeTexY = fract(line.accumulatedDistance / adjustedPatternHeight);
-mediump float relativeTexX = 0.5 + 0.5 * line.normal.y;
-mediump vec2 texCoord = mix(line.tlbr.xy, line.tlbr.zw, vec2(relativeTexX, relativeTexY));
-lowp vec4 color = texture2D(u_texture, texCoord);
-#ifdef VV_COLOR
-if (v_sampleAlphaOnly > 0.5) {
-color.rgb = vec3(color.a);
-}
-#endif
-return line.opacity * line.color * color;
-}
-#else
-lowp vec4 getLineColor(LineData line) {
-return line.opacity * line.color;
-}
-#endif
-vec4 shadeLine(LineData line)
-{
-mediump float thinLineFactor = max(THIN_LINE_WIDTH_FACTOR * step(line.lineHalfWidth, THIN_LINE_HALF_WIDTH), 1.0);
-mediump float fragDist = length(line.normal) * line.lineHalfWidth;
-lowp float alpha = clamp(thinLineFactor * (line.lineHalfWidth - fragDist) / (u_blur + thinLineFactor - 1.0), 0.0, 1.0);
-lowp vec4 out_color = getLineColor(line) * alpha;
-#ifdef HIGHLIGHT
-out_color.a = step(1.0 / 255.0, out_color.a);
-#endif
-#ifdef ID
-if (out_color.a < 1.0 / 255.0) {
-discard;
-}
-out_color = vec4(line.id, 0.0);
-#endif
-return out_color;
-}`, "line.vert": `float getBaseLineHalfWidth(in float lineHalfWidth, in float referenceHalfWidth) {
-#ifdef VV_SIZE
-float refLineWidth = 2.0 * referenceHalfWidth;
-return 0.5 * (lineHalfWidth / max(referenceHalfWidth, EPSILON)) * getSize(refLineWidth);
-#else
-return lineHalfWidth;
-#endif
-}
-float getLineHalfWidth(in float baseWidth, in float aa) {
-float halfWidth = max(baseWidth + aa, 0.45) + 0.1 * aa;
-#ifdef HIGHLIGHT
-halfWidth = max(halfWidth, 2.0);
-#endif
-return halfWidth;
-}
-vec2 getDist(in vec2 offset, in float halfWidth) {
-float thinLineFactor = max(THIN_LINE_WIDTH_FACTOR * step(halfWidth, THIN_LINE_HALF_WIDTH), 1.0);
-return thinLineFactor * halfWidth * offset;
-}
-LineData buildLine(
-out vec3 out_pos,
-in vec3 in_id,
-in vec2 in_pos,
-in vec4 in_color,
-in vec2 in_offset,
-in vec2 in_normal,
-in float in_accumulatedDist,
-in float in_lineHalfWidth,
-in float in_bitSet,
-in vec4 in_tlbr,
-in vec2 in_segmentDirection,
-in float in_referenceHalfWidth
-)
-{
-float aa        = 0.5 * u_antialiasing;
-float baseWidth = getBaseLineHalfWidth(in_lineHalfWidth, in_referenceHalfWidth);
-float halfWidth = getLineHalfWidth(baseWidth, aa);
-float z         = 2.0 * step(baseWidth, 0.0);
-vec2  dist      = getDist(in_offset, halfWidth);
-vec3  offset    = u_displayViewMat3 * vec3(dist, 0.0);
-vec3  pos       = u_dvsMat3 * vec3(in_pos * POSITION_PRECISION, 1.0) + offset;
-#ifdef SYMBOLOGY_TYPE_IS_OUTLINE_FILL_LIKE
-vec4  color     = in_color;
-float opacity   = 1.0;
-#else
-vec4  color     = getColor(in_color, in_bitSet, BITSET_GENERIC_LOCK_COLOR);
-float opacity   = getOpacity();
-#ifdef SDF
-const float SDF_PATTERN_HALF_WIDTH = 15.5;
-float scaleDash = getBit(in_bitSet, BITSET_LINE_SCALE_DASH);
-float lineWidthRatio = (scaleDash * max(halfWidth - 0.55 * u_antialiasing, 0.25) + (1.0 - scaleDash)) / SDF_PATTERN_HALF_WIDTH;
-#endif
-#endif
-#if !defined(SYMBOLOGY_TYPE_IS_OUTLINE_FILL_LIKE) && defined(PATTERN)
-v_sampleAlphaOnly = getBit(in_bitSet, BITSET_GENERIC_CONSIDER_ALPHA_ONLY);
-#endif
-out_pos = vec3(pos.xy, z);
-return LineData(
-color,
-in_normal,
-halfWidth,
-opacity,
-#ifndef SYMBOLOGY_TYPE_IS_OUTLINE_FILL_LIKE
-#ifdef PATTERN
-in_tlbr / u_mosaicSize.xyxy,
-vec2(in_tlbr.z - in_tlbr.x, in_tlbr.w - in_tlbr.y),
-#endif
-#ifdef SDF
-lineWidthRatio,
-#endif
-#if defined(PATTERN) || defined(SDF)
-in_accumulatedDist * u_zoomFactor + dot(in_segmentDirection, dist),
-#endif
-#endif
-norm(in_id)
-);
-}` } }, "symbologyTypeUtils.glsl": `#if SYMBOLOGY_TYPE == SYMBOLOGY_TYPE_OUTLINE_FILL || SYMBOLOGY_TYPE == SYMBOLOGY_TYPE_OUTLINE_FILL_SIMPLE
-#define SYMBOLOGY_TYPE_IS_OUTLINE_FILL_LIKE
-#endif
-#if SYMBOLOGY_TYPE == SYMBOLOGY_TYPE_SIMPLE || SYMBOLOGY_TYPE == SYMBOLOGY_TYPE_OUTLINE_FILL_SIMPLE
-#define SYMBOLOGY_TYPE_IS_SIMPLE_LIKE
-#endif`, text: { "common.glsl": `uniform highp vec2 u_mosaicSize;
-varying highp vec3 v_id;
-varying mediump vec3 v_pos;
-varying lowp float v_opacity;
-varying lowp vec4 v_color;
-varying highp vec2 v_tex;
-varying mediump float v_antialiasingWidth;
-varying mediump float v_edgeDistanceOffset;
-varying lowp float v_transparency;`, "hittest.glsl": "#include <materials/hittest/common.glsl>", "text.frag": `precision mediump float;
-#include <materials/text/common.glsl>
-uniform lowp sampler2D u_texture;
-#ifdef HITTEST
-vec4 getColor() {
-return v_color;
-}
-#else
-vec4 getColor()
-{
-float SDF_CUTOFF = (2.0 / 8.0);
-float SDF_BASE_EDGE_DIST = 1.0 - SDF_CUTOFF;
-lowp float dist = texture2D(u_texture, v_tex).a;
-mediump float edge = SDF_BASE_EDGE_DIST - v_edgeDistanceOffset;
-#ifdef HIGHLIGHT
-edge /= 2.0;
-#endif
-lowp float aa = v_antialiasingWidth;
-lowp float alpha = smoothstep(edge - aa, edge + aa, dist);
-return alpha * v_color * v_opacity;
-}
-#endif
-void main()
-{
-gl_FragColor = getColor();
-}`, "text.vert": `precision highp float;
-#include <materials/utils.glsl>
-#include <materials/vcommon.glsl>
-#include <materials/text/common.glsl>
-#include <materials/text/hittest.glsl>
-attribute vec4 a_color;
-attribute vec4 a_haloColor;
-attribute vec4 a_texFontSize;
-attribute vec4 a_aux;
-attribute vec2 a_zoomRange;
-attribute vec2 a_vertexOffset;
-attribute vec2 a_texCoords;
-uniform float u_isHaloPass;
-uniform float u_isBackgroundPass;
-float getTextSize(inout vec2 offset, inout float baseSize, in float referenceSize) {
-#ifdef VV_SIZE
-float r = getSize(referenceSize) / referenceSize;
-baseSize *= r;
-offset.xy *= r;
-return baseSize;
-#endif
-return baseSize;
-}
-void main()
-{
-INIT;
-float a_isBackground  = a_aux.y;
-float a_referenceSize = a_aux.z * a_aux.z / 256.0;
-float a_bitSet        = a_aux.w;
-float a_fontSize      = a_texFontSize.z;
-vec2  a_offset        = a_vertexOffset * OFFSET_PRECISION;
-vec3  in_pos        = vec3(a_pos * POSITION_PRECISION, 1.0);
-float fontSize      = getTextSize(a_offset, a_fontSize, a_referenceSize);
-float fontScale     = fontSize / SDF_FONT_SIZE;
-vec3  offset        = getRotation() * vec3(a_offset, 0.0);
-mat3  extrudeMatrix = getBit(a_bitSet, 0) == 1.0 ? u_displayViewMat3 : u_displayMat3;
-float isText = 1.0 - a_isBackground;
-float isBackground = u_isBackgroundPass * a_isBackground;
-vec4  nonHaloColor  = (isBackground * a_color) + (isText * getColor(a_color, a_bitSet, 1));
-v_color   = u_isHaloPass * a_haloColor + (1.0 - u_isHaloPass) * nonHaloColor;
-v_opacity = getOpacity();
-v_id      = norm(a_id);
-v_tex     = a_texCoords / u_mosaicSize;
-v_pos     = u_dvsMat3 * in_pos + extrudeMatrix * offset;
-float isHidden = u_isBackgroundPass * isText + (1.0 - u_isBackgroundPass) * a_isBackground;
-v_pos.z += 2.0 * isHidden;
-v_edgeDistanceOffset = u_isHaloPass * OUTLINE_SCALE * a_texFontSize.w / fontScale / MAX_SDF_DISTANCE;
-v_antialiasingWidth  = 0.105 * SDF_FONT_SIZE / fontSize / u_pixelRatio;
-#ifdef HITTEST
-highp vec3 out_pos  = vec3(0.);
-v_color = vec4(0.);
-hittestMarker(v_color, out_pos, u_viewMat3 * u_tileMat3 *  vec3(a_pos * POSITION_PRECISION, 1.0)
-+ u_tileMat3 * offset, fontSize / 2.);
-gl_PointSize = 1.;
-gl_Position = vec4(clip(v_color, out_pos, getFilterFlags(), a_zoomRange), 1.0);
-#else
-gl_Position =  vec4(clip(v_color, v_pos, getFilterFlags(), a_zoomRange), 1.0);
-#endif
-}` }, "utils.glsl": `float rshift(in float u32, in int amount) {
-return floor(u32 / pow(2.0, float(amount)));
-}
-float getBit(in float bitset, in int bitIndex) {
-float offset = pow(2.0, float(bitIndex));
-return mod(floor(bitset / offset), 2.0);
-}
-const int highlightReasonsLength = 3;
-float getFilterBit(in float bitset, in int bitIndex) {
-return getBit(bitset, bitIndex + highlightReasonsLength);
-}
-float getHighlightBit(in float bitset, in int bitIndex) {
-return getBit(bitset, bitIndex);
-}
-highp vec3 unpackDisplayIdTexel(in highp vec3 bitset) {
-float isAggregate = getBit(bitset.b, 7);
-return (1.0 - isAggregate) * bitset + isAggregate * (vec3(bitset.rgb) - vec3(0.0, 0.0, float(0x80)));
-}
-vec4 unpack(in float u32) {
-float r = mod(rshift(u32, 0), 255.0);
-float g = mod(rshift(u32, 8), 255.0);
-float b = mod(rshift(u32, 16), 255.0);
-float a = mod(rshift(u32, 24), 255.0);
-return vec4(r, g, b, a);
-}
-vec3 norm(in vec3 v) {
-return v /= 255.0;
-}
-vec4 norm(in vec4 v) {
-return v /= 255.0;
-}
-float max4(vec4 target) {
-return max(max(max(target.x, target.y), target.z), target.w);
-}
-vec2 unpack_u8_nf32(vec2 bytes) {
-return (bytes - 127.0) / 127.0;
-}
-highp float rand(in vec2 co) {
-highp float a = 12.9898;
-highp float b = 78.233;
-highp float c = 43758.5453;
-highp float dt = dot(co, vec2(a,b));
-highp float sn = mod(dt, 3.14);
-return fract(sin(sn) * c);
-}`, "vcommon.glsl": `#include <materials/constants.glsl>
-#include <materials/utils.glsl>
-#include <materials/attributeData.glsl>
-#include <materials/vv.glsl>
-#include <materials/barycentric.glsl>
-attribute vec2 a_pos;
-attribute highp vec3 a_id;
-uniform highp mat3 displayViewScreenMat3;
-uniform highp mat3 displayViewMat3;
-uniform highp mat3 displayMat3;
-uniform highp mat3 tileMat3;
-uniform highp mat3 viewMat3;
-uniform highp float pixelRatio;
-uniform mediump float zoomFactor;
-uniform mediump float antialiasing;
-uniform mediump float currentScale;
-uniform mediump float currentZoom;
-uniform mediump float metersPerSRUnit;
-vec4 VV_ADATA = vec4(0.0);
-void loadVisualVariableData(inout vec4 target) {
-target.rgba = getVisualVariableData(a_id);
-}
-#ifdef VV
-#define INIT loadVisualVariableData(VV_ADATA)
-#else
-#define INIT
-#endif
-vec4 getColor(in vec4 a_color, in float a_bitSet, int index) {
-#ifdef VV_COLOR
-float isColorLocked   = getBit(a_bitSet, index);
-return getVVColor(VV_ADATA[ATTR_VV_COLOR], a_color, isColorLocked);
-#else
-return a_color;
-#endif
-}
-float getOpacity() {
-#ifdef VV_OPACITY
-return getVVOpacity(VV_ADATA[ATTR_VV_OPACITY]);
-#else
-return 1.0;
-#endif
-}
-float getSize(in float in_size, in float currentScale) {
-#ifdef VV_SIZE
-return getVVSize(in_size, VV_ADATA[ATTR_VV_SIZE], currentScale);
-#else
-return in_size;
-#endif
-}
-mat3 getRotation() {
-#ifdef VV_ROTATION
-return getVVRotationMat3(mod(VV_ADATA[ATTR_VV_ROTATION], 360.0));
-#else
-return mat3(1.0);
-#endif
-}
-float getFilterFlags() {
-#ifdef IGNORES_SAMPLER_PRECISION
-return ceil(getFilterData(a_id).x * 255.0);
-#else
-return getFilterData(a_id).x * 255.0;
-#endif
-}
-vec4 getAnimationState() {
-return getAnimation(a_id);
-}
-float getMinZoom() {
-vec4 data0 = getFilterData(a_id) * 255.0;
-return data0.g;
-}
-mat3 getMatrixNoDisplay(float isMapAligned) {
-return isMapAligned * viewMat3 * tileMat3 + (1.0 - isMapAligned) * tileMat3;
-}
-mat3 getMatrix(float isMapAligned) {
-return isMapAligned * displayViewMat3 + (1.0 - isMapAligned) * displayMat3;
-}
-float checkHighlightBit(float filterFlags, int index) {
-return getHighlightBit(filterFlags, index);
-}
-float checkHighlight(float filterFlags) {
-float result = checkHighlightBit(filterFlags, 0);
-for (int i = 1; i < highlightReasonsLength; i++) {
-result = result + checkHighlightBit(filterFlags, i);
-}
-return step(0.1, result);
-}
-vec3 clip(inout vec4 color, inout vec3 pos, in float filterFlags, in vec2 minMaxZoom) {
-pos.z += 2.0 * (1.0 - getFilterBit(filterFlags, 0));
-#ifdef inside
-pos.z += 2.0 * (1.0 - getFilterBit(filterFlags, 1));
-#elif defined(outside)
-pos.z += 2.0 * getFilterBit(filterFlags, 1);
-#elif defined(highlight)
-#if !defined(highlight_all)
-pos.z += 2.0 * (1.0 - checkHighlight(filterFlags));
-#endif
-#endif
-pos.z += 2.0 * (step(minMaxZoom.y, currentZoom) + (1.0 - step(minMaxZoom.x, currentZoom)));
-return pos;
-}`, "vv.glsl": `#if defined(VV_SIZE_MIN_MAX_VALUE) || defined(VV_SIZE_SCALE_STOPS) || defined(VV_SIZE_FIELD_STOPS) || defined(VV_SIZE_UNIT_VALUE)
-#define VV_SIZE
-#endif
-#if defined(VV_COLOR) || defined(VV_SIZE) || defined(VV_OPACITY) || defined(VV_ROTATION)
-#define VV
-#endif
-#ifdef VV_COLOR
-uniform highp float colorValues[8];
-uniform vec4 colors[8];
-#endif
-#ifdef VV_SIZE_MIN_MAX_VALUE
-uniform highp vec4 minMaxValueAndSize;
-#endif
-#ifdef VV_SIZE_SCALE_STOPS
-uniform highp float values[8];
-uniform float sizes[8];
-#endif
-#ifdef VV_SIZE_FIELD_STOPS
-uniform highp float values[8];
-uniform float sizes[8];
-#endif
-#ifdef VV_SIZE_UNIT_VALUE
-uniform highp float unitMeterRatio;
-#endif
-#ifdef VV_OPACITY
-uniform highp float opacityValues[8];
-uniform float opacities[8];
-#endif
-#ifdef VV_ROTATION
-uniform lowp float rotationType;
-#endif
-bool isNan(float val) {
-return (val == NAN_MAGIC_NUMBER);
-}
-#ifdef VV_SIZE_MIN_MAX_VALUE
-float getVVMinMaxSize(float sizeValue, float fallback) {
-if (isNan(sizeValue)) {
-return fallback;
-}
-float interpolationRatio = (sizeValue  - minMaxValueAndSize.x) / (minMaxValueAndSize.y - minMaxValueAndSize.x);
-interpolationRatio = clamp(interpolationRatio, 0.0, 1.0);
-return minMaxValueAndSize.z + interpolationRatio * (minMaxValueAndSize.w - minMaxValueAndSize.z);
-}
-#endif
-#ifdef VV_SIZE_SCALE_STOPS
-float getVVScaleStopsSize(float currentScale) {
-float outSize;
-if (currentScale <= values[0]) {
-outSize = sizes[0];
-} else {
-if (currentScale >= values[7]) {
-outSize = sizes[7];
-} else {
-int index;
-index = -1;
-for (int i = 0; i < 8; i++) {
-if (values[i] > currentScale) {
-index = i;
-break;
-}
-}
-int prevIndex = index - 1;
-float a = currentScale - values[prevIndex];
-float b = values[index] - values[prevIndex];
-outSize = mix(sizes[prevIndex], sizes[index], a / b);
-}
-}
-return outSize;
-}
-#endif
-#ifdef VV_SIZE_FIELD_STOPS
-const int VV_SIZE_N = 8;
-float getVVStopsSize(float sizeValue, float fallback) {
-if (isNan(sizeValue)) {
-return fallback;
-}
-if (sizeValue <= values[0]) {
-return sizes[0];
-}
-for (int i = 1; i < VV_SIZE_N; ++i) {
-if (values[i] >= sizeValue) {
-float f = (sizeValue - values[i-1]) / (values[i] - values[i-1]);
-return mix(sizes[i-1], sizes[i], f);
-}
-}
-return sizes[VV_SIZE_N - 1];
-}
-#endif
-#ifdef VV_SIZE_UNIT_VALUE
-float getVVUnitValue(float sizeValue, float fallback) {
-if (isNan(sizeValue)) {
-return fallback;
-}
-return sizeValue * (metersPerSRUnit / unitMeterRatio);
-}
-#endif
-#ifdef VV_OPACITY
-const int VV_OPACITY_N = 8;
-float getVVOpacity(float opacityValue) {
-if (isNan(opacityValue)) {
-return 1.0;
-}
-if (opacityValue <= opacityValues[0]) {
-return opacities[0];
-}
-for (int i = 1; i < VV_OPACITY_N; ++i) {
-if (opacityValues[i] >= opacityValue) {
-float f = (opacityValue - opacityValues[i-1]) / (opacityValues[i] - opacityValues[i-1]);
-return mix(opacities[i-1], opacities[i], f);
-}
-}
-return opacities[VV_OPACITY_N - 1];
-}
-#endif
-#ifdef VV_ROTATION
-mat4 getVVRotation(float rotationValue) {
-if (isNan(rotationValue)) {
-return mat4(1, 0, 0, 0,
-0, 1, 0, 0,
-0, 0, 1, 0,
-0, 0, 0, 1);
-}
-float rotation = rotationValue;
-if (rotationType == 1.0) {
-rotation = 90.0 - rotation;
-}
-float angle = C_DEG_TO_RAD * rotation;
-float sinA = sin(angle);
-float cosA = cos(angle);
-return mat4(cosA, sinA, 0, 0,
--sinA,  cosA, 0, 0,
-0,     0, 1, 0,
-0,     0, 0, 1);
-}
-mat3 getVVRotationMat3(float rotationValue) {
-if (isNan(rotationValue)) {
-return mat3(1, 0, 0,
-0, 1, 0,
-0, 0, 1);
-}
-float rotation = rotationValue;
-if (rotationType == 1.0) {
-rotation = 90.0 - rotation;
-}
-float angle = C_DEG_TO_RAD * -rotation;
-float sinA = sin(angle);
-float cosA = cos(angle);
-return mat3(cosA, -sinA, 0,
-sinA, cosA, 0,
-0,    0,    1);
-}
-#endif
-#ifdef VV_COLOR
-const int VV_COLOR_N = 8;
-vec4 getVVColor(float colorValue, vec4 fallback, float isColorLocked) {
-if (isNan(colorValue) || isColorLocked == 1.0) {
-return fallback;
-}
-if (colorValue <= colorValues[0]) {
-return colors[0];
-}
-for (int i = 1; i < VV_COLOR_N; ++i) {
-if (colorValues[i] >= colorValue) {
-float f = (colorValue - colorValues[i-1]) / (colorValues[i] - colorValues[i-1]);
-return mix(colors[i-1], colors[i], f);
-}
-}
-return colors[VV_COLOR_N - 1];
-}
-#endif
-float getVVSize(in float size, in float vvSize, in float currentScale)  {
-#ifdef VV_SIZE_MIN_MAX_VALUE
-return getVVMinMaxSize(vvSize, size);
-#elif defined(VV_SIZE_SCALE_STOPS)
-float outSize = getVVScaleStopsSize(currentScale);
-return isNan(outSize) ? size : outSize;
-#elif defined(VV_SIZE_FIELD_STOPS)
-float outSize = getVVStopsSize(vvSize, size);
-return isNan(outSize) ? size : outSize;
-#elif defined(VV_SIZE_UNIT_VALUE)
-return getVVUnitValue(vvSize, size);
-#else
-return size;
-#endif
-}` }, overlay: { overlay: { "overlay.frag": `precision lowp float;
-uniform lowp sampler2D u_texture;
-uniform lowp float u_opacity;
-varying mediump vec2 v_uv;
-void main() {
-vec4 color = texture2D(u_texture, v_uv);
-gl_FragColor = color *  u_opacity;
-}`, "overlay.vert": `precision mediump float;
-attribute vec2 a_pos;
-attribute vec2 a_uv;
-uniform highp mat3 u_dvsMat3;
-uniform mediump vec2 u_perspective;
-varying mediump vec2 v_uv;
-void main(void) {
-v_uv = a_uv;
-float w = 1.0 + dot(a_uv, u_perspective);
-vec3 pos = u_dvsMat3 * vec3(a_pos, 1.0);
-gl_Position = vec4(w * pos.xy, 0.0, w);
-}` } }, "post-processing": { blit: { "blit.frag": `precision mediump float;
-uniform sampler2D u_texture;
-varying vec2 v_uv;
-void main() {
-gl_FragColor = texture2D(u_texture, v_uv);
-}` }, bloom: { composite: { "composite.frag": `precision mediump float;
-varying vec2 v_uv;
-uniform sampler2D u_blurTexture1;
-uniform sampler2D u_blurTexture2;
-uniform sampler2D u_blurTexture3;
-uniform sampler2D u_blurTexture4;
-uniform sampler2D u_blurTexture5;
-uniform float u_bloomStrength;
-uniform float u_bloomRadius;
-uniform float u_bloomFactors[NUMMIPS];
-uniform vec3 u_bloomTintColors[NUMMIPS];
-float lerpBloomFactor(const in float factor) {
-float mirrorFactor = 1.2 - factor;
-return mix(factor, mirrorFactor, u_bloomRadius);
-}
-void main() {
-vec4 color = u_bloomStrength * (
-lerpBloomFactor(u_bloomFactors[0]) * vec4(u_bloomTintColors[0], 1.0) * texture2D(u_blurTexture1, v_uv) +
-lerpBloomFactor(u_bloomFactors[1]) * vec4(u_bloomTintColors[1], 1.0) * texture2D(u_blurTexture2, v_uv) +
-lerpBloomFactor(u_bloomFactors[2]) * vec4(u_bloomTintColors[2], 1.0) * texture2D(u_blurTexture3, v_uv) +
-lerpBloomFactor(u_bloomFactors[3]) * vec4(u_bloomTintColors[3], 1.0) * texture2D(u_blurTexture4, v_uv) +
-lerpBloomFactor(u_bloomFactors[4]) * vec4(u_bloomTintColors[4], 1.0) * texture2D(u_blurTexture5, v_uv)
-);
-gl_FragColor = clamp(color, 0.0, 1.0);
-}` }, gaussianBlur: { "gaussianBlur.frag": `precision mediump float;
-uniform sampler2D u_colorTexture;
-uniform vec2 u_texSize;
-uniform vec2 u_direction;
-varying vec2 v_uv;
-#define KERNEL_RADIUS RADIUS
-#define SIGMA RADIUS
-float gaussianPdf(in float x, in float sigma) {
-return 0.39894 * exp(-0.5 * x * x / ( sigma * sigma)) / sigma;
-}
-void main() {
-vec2 invSize = 1.0 / u_texSize;
-float fSigma = float(SIGMA);
-float weightSum = gaussianPdf(0.0, fSigma);
-vec4 pixelColorSum = texture2D(u_colorTexture, v_uv) * weightSum;
-for (int i = 1; i < KERNEL_RADIUS; i ++) {
-float x = float(i);
-float w = gaussianPdf(x, fSigma);
-vec2 uvOffset = u_direction * invSize * x;
-vec4 sample1 = texture2D(u_colorTexture, v_uv + uvOffset);
-vec4 sample2 = texture2D(u_colorTexture, v_uv - uvOffset);
-pixelColorSum += (sample1 + sample2) * w;
-weightSum += 2.0 * w;
-}
-gl_FragColor = pixelColorSum /weightSum;
-}` }, luminosityHighPass: { "luminosityHighPass.frag": `precision mediump float;
-uniform sampler2D u_texture;
-uniform vec3 u_defaultColor;
-uniform float u_defaultOpacity;
-uniform float u_luminosityThreshold;
-uniform float u_smoothWidth;
-varying vec2 v_uv;
-void main() {
-vec4 texel = texture2D(u_texture, v_uv);
-vec3 luma = vec3(0.299, 0.587, 0.114);
-float v = dot(texel.xyz, luma);
-vec4 outputColor = vec4(u_defaultColor.rgb, u_defaultOpacity);
-float alpha = smoothstep(u_luminosityThreshold, u_luminosityThreshold + u_smoothWidth, v);
-gl_FragColor = mix(outputColor, texel, alpha);
-}` } }, blur: { gaussianBlur: { "gaussianBlur.frag": `precision mediump float;
-uniform sampler2D u_colorTexture;
-uniform vec2 u_texSize;
-uniform vec2 u_direction;
-uniform float u_sigma;
-varying vec2 v_uv;
-#define KERNEL_RADIUS RADIUS
-float gaussianPdf(in float x, in float sigma) {
-return 0.39894 * exp(-0.5 * x * x / ( sigma * sigma)) / sigma;
-}
-void main() {
-vec2 invSize = 1.0 / u_texSize;
-float fSigma = u_sigma;
-float weightSum = gaussianPdf(0.0, fSigma);
-vec4 pixelColorSum = texture2D(u_colorTexture, v_uv) * weightSum;
-for (int i = 1; i < KERNEL_RADIUS; i ++) {
-float x = float(i);
-float w = gaussianPdf(x, fSigma);
-vec2 uvOffset = u_direction * invSize * x;
-vec4 sample1 = texture2D(u_colorTexture, v_uv + uvOffset);
-vec4 sample2 = texture2D(u_colorTexture, v_uv - uvOffset);
-pixelColorSum += (sample1 + sample2) * w;
-weightSum += 2.0 * w;
-}
-gl_FragColor = pixelColorSum /weightSum;
-}` }, "radial-blur": { "radial-blur.frag": `precision mediump float;
-uniform sampler2D u_colorTexture;
-varying vec2 v_uv;
-const float sampleDist = 1.0;
-const float sampleStrength = 2.2;
-void main(void) {
-float samples[10];
-samples[0] = -0.08;
-samples[1] = -0.05;
-samples[2] = -0.03;
-samples[3] = -0.02;
-samples[4] = -0.01;
-samples[5] =  0.01;
-samples[6] =  0.02;
-samples[7] =  0.03;
-samples[8] =  0.05;
-samples[9] =  0.08;
-vec2 dir = 0.5 - v_uv;
-float dist = sqrt(dir.x * dir.x + dir.y * dir.y);
-dir = dir / dist;
-vec4 color = texture2D(u_colorTexture,v_uv);
-vec4 sum = color;
-for (int i = 0; i < 10; i++) {
-sum += texture2D(u_colorTexture, v_uv + dir * samples[i] * sampleDist);
-}
-sum *= 1.0 / 11.0;
-float t = dist * sampleStrength;
-t = clamp(t, 0.0, 1.0);
-gl_FragColor = mix(color, sum, t);
-}` } }, dra: { "dra.frag": `precision mediump float;
-uniform sampler2D u_minColor;
-uniform sampler2D u_maxColor;
-uniform sampler2D u_texture;
-varying vec2 v_uv;
-void main() {
-vec4 minColor = texture2D(u_minColor, vec2(0.5));
-vec4 maxColor = texture2D(u_maxColor, vec2(0.5));
-vec4 color = texture2D(u_texture, v_uv);
-vec3 minColorUnpremultiply = minColor.rgb / minColor.a;
-vec3 maxColorUnpremultiply = maxColor.rgb / maxColor.a;
-vec3 colorUnpremultiply = color.rgb / color.a;
-vec3 range = maxColorUnpremultiply - minColorUnpremultiply;
-gl_FragColor = vec4(color.a * (colorUnpremultiply - minColorUnpremultiply) / range, color.a);
-}`, "min-max": { "min-max.frag": `#extension GL_EXT_draw_buffers : require
-precision mediump float;
-#define CELL_SIZE 2
-uniform sampler2D u_minTexture;
-uniform sampler2D u_maxTexture;
-uniform vec2 u_srcResolution;
-uniform vec2 u_dstResolution;
-varying vec2 v_uv;
-void main() {
-vec2 srcPixel = floor(gl_FragCoord.xy) * float(CELL_SIZE);
-vec2 onePixel = vec2(1.0) / u_srcResolution;
-vec2 uv = (srcPixel + 0.5) / u_srcResolution;
-vec4 minColor = vec4(1.0);
-vec4 maxColor = vec4(0.0);
-for (int y = 0; y < CELL_SIZE; ++y) {
-for (int x = 0; x < CELL_SIZE; ++x) {
-vec2 offset = uv + vec2(x, y) * onePixel;
-minColor = min(minColor, texture2D(u_minTexture, offset));
-maxColor = max(maxColor, texture2D(u_maxTexture, offset));
-}
-}
-gl_FragData[0] = minColor;
-gl_FragData[1] = maxColor;
-}` } }, "drop-shadow": { composite: { "composite.frag": `precision mediump float;
-uniform sampler2D u_layerFBOTexture;
-uniform sampler2D u_blurTexture;
-uniform vec4 u_shadowColor;
-uniform vec2 u_shadowOffset;
-uniform highp mat3 u_displayViewMat3;
-varying vec2 v_uv;
-void main() {
-vec3 offset = u_displayViewMat3 * vec3(u_shadowOffset, 0.0);
-vec4 layerColor = texture2D(u_layerFBOTexture, v_uv);
-vec4 blurColor = texture2D(u_blurTexture, v_uv - offset.xy / 2.0);
-gl_FragColor = ((1.0 - layerColor.a) * blurColor.a * u_shadowColor + layerColor);
-}` } }, "edge-detect": { "frei-chen": { "frei-chen.frag": `precision mediump float;
-uniform sampler2D u_colorTexture;
-uniform vec2 u_texSize;
-varying vec2 v_uv;
-vec2 texel = vec2(1.0 / u_texSize.x, 1.0 / u_texSize.y);
-mat3 G[9];
-const mat3 g0 = mat3( 0.3535533845424652, 0, -0.3535533845424652, 0.5, 0, -0.5, 0.3535533845424652, 0, -0.3535533845424652 );
-const mat3 g1 = mat3( 0.3535533845424652, 0.5, 0.3535533845424652, 0, 0, 0, -0.3535533845424652, -0.5, -0.3535533845424652 );
-const mat3 g2 = mat3( 0, 0.3535533845424652, -0.5, -0.3535533845424652, 0, 0.3535533845424652, 0.5, -0.3535533845424652, 0 );
-const mat3 g3 = mat3( 0.5, -0.3535533845424652, 0, -0.3535533845424652, 0, 0.3535533845424652, 0, 0.3535533845424652, -0.5 );
-const mat3 g4 = mat3( 0, -0.5, 0, 0.5, 0, 0.5, 0, -0.5, 0 );
-const mat3 g5 = mat3( -0.5, 0, 0.5, 0, 0, 0, 0.5, 0, -0.5 );
-const mat3 g6 = mat3( 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.6666666865348816, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204 );
-const mat3 g7 = mat3( -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, 0.6666666865348816, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408 );
-const mat3 g8 = mat3( 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408 );
-void main() {
-G[0] = g0,
-G[1] = g1,
-G[2] = g2,
-G[3] = g3,
-G[4] = g4,
-G[5] = g5,
-G[6] = g6,
-G[7] = g7,
-G[8] = g8;
-mat3 I;
-float cnv[9];
-vec3 sample;
-for (float i = 0.0; i < 3.0; i++) {
-for (float j = 0.0; j < 3.0; j++) {
-sample = texture2D(u_colorTexture, v_uv + texel * vec2(i - 1.0,j - 1.0)).rgb;
-I[int(i)][int(j)] = length(sample);
-}
-}
-for (int i = 0; i < 9; i++) {
-float dp3 = dot(G[i][0], I[0]) + dot(G[i][1], I[1]) + dot(G[i][2], I[2]);
-cnv[i] = dp3 * dp3;
-}
-float M = (cnv[0] + cnv[1]) + (cnv[2] + cnv[3]);
-float S = (cnv[4] + cnv[5]) + (cnv[6] + cnv[7]) + (cnv[8] + M);
-gl_FragColor = vec4(vec3(sqrt(M / S)), texture2D(u_colorTexture, v_uv).a);
-}` }, sobel: { "sobel.frag": `precision mediump float;
-uniform sampler2D u_colorTexture;
-varying vec2 v_uv;
-uniform vec2 u_texSize;
-vec2 texel = vec2(1.0 / u_texSize.x, 1.0 / u_texSize.y);
-mat3 G[2];
-const mat3 g0 = mat3( 1.0, 2.0, 1.0, 0.0, 0.0, 0.0, -1.0, -2.0, -1.0 );
-const mat3 g1 = mat3( 1.0, 0.0, -1.0, 2.0, 0.0, -2.0, 1.0, 0.0, -1.0 );
-void main() {
-mat3 I;
-float cnv[2];
-vec3 sample;
-G[0] = g0;
-G[1] = g1;
-for (float i = 0.0; i < 3.0; i++) {
-for (float j = 0.0; j < 3.0; j++) {
-sample = texture2D( u_colorTexture, v_uv + texel * vec2(i-1.0,j-1.0) ).rgb;
-I[int(i)][int(j)] = length(sample);
-}
-}
-for (int i = 0; i < 2; i++) {
-float dp3 = dot(G[i][0], I[0]) + dot(G[i][1], I[1]) + dot(G[i][2], I[2]);
-cnv[i] = dp3 * dp3;
-}
-gl_FragColor = vec4(vec3(0.5 * sqrt(cnv[0] * cnv[0] + cnv[1] * cnv[1])), texture2D(u_colorTexture, v_uv).a);
-}` } }, "edge-enhance": { "edge-enhance.frag": `precision mediump float;
-uniform sampler2D u_colorTexture;
-varying vec2 v_uv;
-uniform vec2 u_texSize;
-vec2 texel = vec2(1.0 / u_texSize.x, 1.0 / u_texSize.y);
-mat3 G[2];
-const mat3 g0 = mat3( 1.0, 0.0, -1.0, 1.0, 0.0, -1.0, 1.0, 0.0, -1.0 );
-const mat3 g1 = mat3( 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, -1.0, -1.0, -1.0 );
-void main() {
-mat3 I;
-float cnv[2];
-vec3 sample;
-G[0] = g0;
-G[1] = g1;
-for (float i = 0.0; i < 3.0; i++) {
-for (float j = 0.0; j < 3.0; j++) {
-sample = texture2D( u_colorTexture, v_uv + texel * vec2(i-1.0,j-1.0) ).rgb;
-I[int(i)][int(j)] = length(sample);
-}
-}
-for (int i = 0; i < 2; i++) {
-float dp3 = dot(G[i][0], I[0]) + dot(G[i][1], I[1]) + dot(G[i][2], I[2]);
-cnv[i] = dp3 * dp3;
-}
-vec4 color = texture2D(u_colorTexture, v_uv);
-gl_FragColor = vec4(0.5 * sqrt(cnv[0] * cnv[0] + cnv[1] * cnv[1]) * color);
-}` }, filterEffect: { "filterEffect.frag": `precision mediump float;
-uniform sampler2D u_colorTexture;
-uniform mat4 u_coefficients;
-varying vec2 v_uv;
-void main() {
-vec4 color = texture2D(u_colorTexture, v_uv);
-vec4 rgbw = u_coefficients * vec4(color.a > 0.0 ? color.rgb / color.a : vec3(0.0), 1.0);
-float a = color.a;
-gl_FragColor = vec4(a * rgbw.rgb, a);
-}` }, pp: { "pp.vert": `precision mediump float;
-attribute vec2 a_position;
-varying vec2 v_uv;
-void main() {
-gl_Position = vec4(a_position, 0.0, 1.0);
-v_uv = (a_position + 1.0) / 2.0;
-}` } }, raster: { bitmap: { "bitmap.frag": `precision mediump float;
-varying highp vec2 v_texcoord;
-uniform sampler2D u_texture;
-uniform highp vec2 u_coordScale;
-uniform lowp float u_opacity;
-#include <filtering/bicubic.glsl>
-void main() {
-#ifdef BICUBIC
-vec4 color = sampleBicubicBSpline(u_texture, v_texcoord, u_coordScale);
-#else
-vec4 color = texture2D(u_texture, v_texcoord);
-#endif
-gl_FragColor = vec4(color.rgb * u_opacity, color.a * u_opacity);
-}`, "bitmap.vert": `precision mediump float;
-attribute vec2 a_pos;
-uniform highp mat3 u_dvsMat3;
-uniform highp vec2 u_coordScale;
-varying highp vec2 v_texcoord;
-void main()
-{
-v_texcoord = a_pos;
-gl_Position = vec4(u_dvsMat3 * vec3(a_pos * u_coordScale, 1.0), 1.0);
-}` }, common: { "common.glsl": `uniform sampler2D u_image;
-uniform int u_bandCount;
-uniform bool u_flipY;
-uniform float u_opacity;
-uniform int u_resampling;
-uniform vec2 u_srcImageSize;
-#ifdef APPLY_PROJECTION
-#include <raster/common/projection.glsl>
-#endif
-#ifdef BICUBIC
-#include <filtering/bicubic.glsl>
-#endif
-#ifdef BILINEAR
-#include <filtering/bilinear.glsl>
-#endif
-vec2 getPixelLocation(vec2 coords) {
-vec2 targetLocation = u_flipY ? vec2(coords.s, 1.0 - coords.t) : coords;
-#ifdef APPLY_PROJECTION
-targetLocation = projectPixelLocation(targetLocation);
-#endif
-return targetLocation;
-}
-bool isOutside(vec2 coords){
-if (coords.t>1.00001 ||coords.t<-0.00001 || coords.s>1.00001 ||coords.s<-0.00001) {
-return true;
-} else {
-return false;
-}
-}
-vec4 getPixel(vec2 pixelLocation) {
-#ifdef BICUBIC
-vec4 color = sampleBicubicBSpline(u_image, pixelLocation, u_srcImageSize);
-#elif defined(BILINEAR)
-vec4 color = sampleBilinear(u_image, pixelLocation, u_srcImageSize);
-#else
-vec4 color = texture2D(u_image, pixelLocation);
-#endif
-return color;
-}`, "common.vert": `precision mediump float;
-attribute vec2 a_pos;
-uniform highp mat3 u_dvsMat3;
-uniform highp vec2 u_coordScale;
-uniform highp float u_scale;
-uniform highp vec2 u_offset;
-varying highp vec2 v_texcoord;
-void main()
-{
-v_texcoord = a_pos * u_scale + u_offset;
-gl_Position = vec4(u_dvsMat3 * vec3(a_pos * u_coordScale, 1.0), 1.0);
-}`, "contrastBrightness.glsl": `uniform float u_contrastOffset;
-uniform float u_brightnessOffset;
-vec4 adjustContrastBrightness(vec4 currentPixel, bool isFloat) {
-vec4 pixelValue = isFloat ? currentPixel * 255.0 : currentPixel;
-float maxI = 255.0;
-float mid = 128.0;
-float c = u_contrastOffset;
-float b = u_brightnessOffset;
-vec4 v;
-if (c > 0.0 && c < 100.0) {
-v = (200.0 * pixelValue - 100.0 * maxI + 2.0 * maxI * b) / (2.0 * (100.0 - c)) + mid;
-} else if (c <= 0.0 && c > -100.0) {
-v = (200.0 * pixelValue - 100.0 * maxI + 2.0 * maxI * b) * (100.0 + c) / 20000.0 + mid;
-} else if (c == 100.0) {
-v = (200.0 * pixelValue - 100.0 * maxI + (maxI + 1.0) * (100.0 - c) + 2.0 * maxI * b);
-v = (sign(v) + 1.0) / 2.0;
-} else if (c == -100.0) {
-v = vec4(mid, mid, mid, currentPixel.a);
-}
-vec3 rgb = clamp(v.rgb / 255.0, 0.0, 1.0);
-return vec4(rgb, currentPixel.a);
-}`, "getSurfaceValues.glsl": `#include <raster/common/mirror.glsl>
-void getSurfaceValues(sampler2D imageTexture, vec2 texCoord, vec2 srcImageSize, inout float values[10]) {
-vec2 onePixel = 1.0 / srcImageSize;
-vec4 va = texture2D(imageTexture, mirror(texCoord + onePixel * vec2(-1.0, -1.0)));
-vec4 vb = texture2D(imageTexture, mirror(texCoord + onePixel * vec2(0.0, -1.0)));
-vec4 vc = texture2D(imageTexture, mirror(texCoord + onePixel * vec2(1.0, -1.0)));
-vec4 vd = texture2D(imageTexture, mirror(texCoord + onePixel * vec2(-1.0, 0.0)));
-vec4 ve = texture2D(imageTexture, mirror(texCoord));
-vec4 vf = texture2D(imageTexture, mirror(texCoord + onePixel * vec2(1.0, 0.0)));
-vec4 vg = texture2D(imageTexture, mirror(texCoord + onePixel * vec2(-1.0, 1.0)));
-vec4 vh = texture2D(imageTexture, mirror(texCoord + onePixel * vec2(0.0, 1.0)));
-vec4 vi = texture2D(imageTexture, mirror(texCoord + onePixel * vec2(1.0, 1.0)));
-float alpha = va.a * vb.a * vc.a * vd.a * ve.a * vf.a * vg.a * vh.a * vi.a;
-values[0] = va.r;
-values[1] = vb.r;
-values[2] = vc.r;
-values[3] = vd.r;
-values[4] = ve.r;
-values[5] = vf.r;
-values[6] = vg.r;
-values[7] = vh.r;
-values[8] = vi.r;
-values[9] = alpha;
-}`, "inverse.glsl": `float invertValue(float value) {
-float s = sign(value);
-return (s * s) / (value + abs(s) - 1.0);
-}`, "mirror.glsl": `vec2 mirror(vec2 pos) {
-vec2 pos1 = abs(pos);
-return step(pos1, vec2(1.0, 1.0)) * pos1 + step(1.0, pos1) * (2.0 - pos1);
-}`, "projection.glsl": `uniform sampler2D u_transformGrid;
-uniform vec2 u_transformSpacing;
-uniform vec2 u_transformGridSize;
-uniform vec2 u_targetImageSize;
-vec2 projectPixelLocation(vec2 coords) {
-#ifdef LOOKUP_PROJECTION
-vec4 pv = texture2D(u_transformGrid, coords);
-return vec2(pv.r, pv.g);
-#endif
-vec2 index_image = floor(coords * u_targetImageSize);
-vec2 oneTransformPixel = vec2(0.25 / u_transformGridSize.s, 1.0 / u_transformGridSize.t);
-vec2 index_transform = floor(index_image / u_transformSpacing) / u_transformGridSize;
-vec2 pos = fract((index_image + vec2(0.5, 0.5)) / u_transformSpacing);
-vec2 srcLocation;
-vec2 transform_location = index_transform + oneTransformPixel * 0.5;
-if (pos.s <= pos.t) {
-vec4 ll_abc = texture2D(u_transformGrid, vec2(transform_location.s, transform_location.t));
-vec4 ll_def = texture2D(u_transformGrid, vec2(transform_location.s + oneTransformPixel.s, transform_location.t));
-srcLocation.s = dot(ll_abc.rgb, vec3(pos, 1.0));
-srcLocation.t = dot(ll_def.rgb, vec3(pos, 1.0));
-} else {
-vec4 ur_abc = texture2D(u_transformGrid, vec2(transform_location.s + 2.0 * oneTransformPixel.s, transform_location.t));
-vec4 ur_def = texture2D(u_transformGrid, vec2(transform_location.s + 3.0 * oneTransformPixel.s, transform_location.t));
-srcLocation.s = dot(ur_abc.rgb, vec3(pos, 1.0));
-srcLocation.t = dot(ur_def.rgb, vec3(pos, 1.0));
-}
-return srcLocation;
-}` }, flow: { "getFadeOpacity.glsl": `uniform float u_decayRate;
-uniform float u_fadeToZero;
-float getFadeOpacity(float x) {
-float cutOff = mix(0.0, exp(-u_decayRate), u_fadeToZero);
-return (exp(-u_decayRate * x) - cutOff) / (1.0 - cutOff);
-}`, "getFragmentColor.glsl": `vec4 getFragmentColor(vec4 color, float dist, float size, float featheringSize) {
-float featheringStart = clamp(0.5 - featheringSize / size, 0.0, 0.5);
-if (dist > featheringStart) {
-color *= 1.0 - (dist - featheringStart) / (0.5 - featheringStart);
-}
-return color;
-}`, imagery: { "imagery.frag": `precision highp float;
-varying vec2 v_texcoord;
-uniform sampler2D u_texture;
-uniform float u_Min;
-uniform float u_Max;
-uniform float u_featheringSize;
-#include <raster/flow/vv.glsl>
-float getIntensity(float v) {
-return u_Min + v * (u_Max - u_Min);
-}
-void main(void) {
-vec4 sampled = texture2D(u_texture, v_texcoord);
-float intensity = getIntensity(sampled.r);
-gl_FragColor = getColor(intensity);
-gl_FragColor.a *= getOpacity(sampled.r);
-gl_FragColor.a *= sampled.a;
-gl_FragColor.rgb *= gl_FragColor.a;
-}`, "imagery.vert": `attribute vec2 a_position;
-attribute vec2 a_texcoord;
-uniform mat3 u_dvsMat3;
-varying vec2 v_texcoord;
-void main(void) {
-vec2 xy = (u_dvsMat3 * vec3(a_position, 1.0)).xy;
-gl_Position = vec4(xy, 0.0, 1.0);
-v_texcoord = a_texcoord;
-}` }, particles: { "particles.frag": `precision highp float;
-varying vec4 v_color;
-varying vec2 v_texcoord;
-varying float v_size;
-uniform float u_featheringSize;
-#include <raster/flow/getFragmentColor.glsl>
-void main(void) {
-gl_FragColor = getFragmentColor(v_color, length(v_texcoord - 0.5), v_size, u_featheringSize);
-}`, "particles.vert": `attribute vec4 a_xyts0;
-attribute vec4 a_xyts1;
-attribute vec4 a_typeIdDurationSeed;
-attribute vec4 a_extrudeInfo;
-uniform mat3 u_dvsMat3;
-uniform mat3 u_displayViewMat3;
-uniform float u_time;
-uniform float u_trailLength;
-uniform float u_flowSpeed;
-varying vec4 v_color;
-varying vec2 v_texcoord;
-varying float v_size;
-uniform float u_featheringSize;
-uniform float u_introFade;
-#include <raster/flow/vv.glsl>
-#include <raster/flow/getFadeOpacity.glsl>
-void main(void) {
-vec2 position0 = a_xyts0.xy;
-float t0 = a_xyts0.z;
-float speed0 = a_xyts0.w;
-vec2 position1 = a_xyts1.xy;
-float t1 = a_xyts1.z;
-float speed1 = a_xyts1.w;
-float type = a_typeIdDurationSeed.x;
-float id = a_typeIdDurationSeed.y;
-float duration = a_typeIdDurationSeed.z;
-float seed = a_typeIdDurationSeed.w;
-vec2 e0 = a_extrudeInfo.xy;
-vec2 e1 = a_extrudeInfo.zw;
-float animationPeriod = duration + u_trailLength;
-float scaledTime = u_time * u_flowSpeed;
-float randomizedTime = scaledTime + seed * animationPeriod;
-float t = mod(randomizedTime, animationPeriod);
-float fUnclamped = (t - t0) / (t1 - t0);
-float f = clamp(fUnclamped, 0.0, 1.0);
-float clampedTime = mix(t0, t1, f);
-float speed = mix(speed0, speed1, f);
-vec2 extrude;
-vec2 position;
-float fadeOpacity;
-float introOpacity;
-if (type == 2.0) {
-if (fUnclamped < 0.0 || (fUnclamped > 1.0 && t1 != duration)) {
-gl_Position = vec4(0.0, 0.0, -2.0, 1.0);
-return;
-}
-vec2 ortho = mix(e0, e1, f);
-vec2 parallel;
-parallel = normalize(position1 - position0) * 0.5;
-if (id == 1.0) {
-extrude = ortho;
-v_texcoord = vec2(0.5, 0.0);
-} else if (id == 2.0) {
-extrude = -ortho;
-v_texcoord = vec2(0.5, 1.0);
-} else if (id == 3.0) {
-extrude = ortho + parallel;
-v_texcoord = vec2(1.0, 0.0);
-} else if (id == 4.0) {
-extrude = -ortho + parallel;
-v_texcoord = vec2(1.0, 1.0);
-}
-fadeOpacity = getFadeOpacity((t - clampedTime) / u_trailLength);
-introOpacity = 1.0 - exp(-clampedTime);
-v_size = getSize(speed);
-v_color = getColor(speed);
-v_color.a *= getOpacity(speed);
-position = mix(position0, position1, f);
-} else {
-if (fUnclamped < 0.0) {
-gl_Position = vec4(0.0, 0.0, -2.0, 1.0);
-return;
-}
-if (id == 1.0) {
-extrude = e0;
-v_texcoord = vec2(0.5, 0.0);
-fadeOpacity = getFadeOpacity((t - t0) / u_trailLength);
-introOpacity = 1.0 - exp(-t0);
-v_size = getSize(speed0);
-v_color = getColor(speed0);
-v_color.a *= getOpacity(speed0);
-position = position0;
-} else if (id == 2.0) {
-extrude = -e0;
-v_texcoord = vec2(0.5, 1.0);
-fadeOpacity = getFadeOpacity((t - t0) / u_trailLength);
-introOpacity = 1.0 - exp(-t0);
-v_size = getSize(speed0);
-v_color = getColor(speed0);
-v_color.a *= getOpacity(speed0);
-position = position0;
-} else if (id == 3.0) {
-extrude = mix(e0, e1, f);
-v_texcoord = vec2(0.5, 0.0);
-fadeOpacity = getFadeOpacity((t - clampedTime) / u_trailLength);
-introOpacity = 1.0 - exp(-clampedTime);
-v_size = getSize(speed);
-v_color = getColor(speed);
-v_color.a *= getOpacity(speed);
-position = mix(position0, position1, f);
-} else if (id == 4.0) {
-extrude = -mix(e0, e1, f);
-v_texcoord = vec2(0.5, 1.0);
-fadeOpacity = getFadeOpacity((t - clampedTime) / u_trailLength);
-introOpacity = 1.0 - exp(-clampedTime);
-v_size = getSize(speed);
-v_color = getColor(speed);
-v_color.a *= getOpacity(speed);
-position = mix(position0, position1, f);
-}
-}
-vec2 xy = (u_dvsMat3 * vec3(position, 1.0) + u_displayViewMat3 * vec3(extrude * v_size, 0.0)).xy;
-gl_Position = vec4(xy, 0.0, 1.0);
-v_color.a *= fadeOpacity;
-v_color.a *= mix(1.0, introOpacity, u_introFade);
-v_color.rgb *= v_color.a;
-}` }, streamlines: { "streamlines.frag": `precision highp float;
-varying float v_side;
-varying float v_time;
-varying float v_totalTime;
-varying float v_timeSeed;
-varying vec4 v_color;
-varying float v_size;
-uniform float u_time;
-uniform float u_trailLength;
-uniform float u_flowSpeed;
-uniform float u_featheringSize;
-uniform float u_introFade;
-#include <raster/flow/getFragmentColor.glsl>
-#include <raster/flow/getFadeOpacity.glsl>
-void main(void) {
-float t = mod(v_timeSeed * (v_totalTime + u_trailLength) + u_time * u_flowSpeed, v_totalTime + u_trailLength) - v_time;
-vec4 color = v_color * step(0.0, t) * getFadeOpacity(t / u_trailLength);
-color *= mix(1.0, 1.0 - exp(-v_time), u_introFade);
-gl_FragColor = getFragmentColor(color, length((v_side + 1.0) / 2.0 - 0.5), v_size, u_featheringSize);
-}`, "streamlines.vert": `attribute vec3 a_positionAndSide;
-attribute vec3 a_timeInfo;
-attribute vec2 a_extrude;
-attribute float a_speed;
-uniform mat3 u_dvsMat3;
-uniform mat3 u_displayViewMat3;
-varying float v_time;
-varying float v_totalTime;
-varying float v_timeSeed;
-varying vec4 v_color;
-varying float v_side;
-varying float v_size;
-uniform float u_featheringSize;
-#include <raster/flow/vv.glsl>
-void main(void) {
-vec4 lineColor = getColor(a_speed);
-float lineOpacity = getOpacity(a_speed);
-float lineSize = getSize(a_speed);
-vec2 position = a_positionAndSide.xy;
-v_side = a_positionAndSide.z;
-vec2 xy = (u_dvsMat3 * vec3(position, 1.0) + u_displayViewMat3 * vec3(a_extrude * lineSize, 0.0)).xy;
-gl_Position = vec4(xy, 0.0, 1.0);
-v_time = a_timeInfo.x;
-v_totalTime = a_timeInfo.y;
-v_timeSeed = a_timeInfo.z;
-v_color = lineColor;
-v_color.a *= lineOpacity;
-v_color.rgb *= v_color.a;
-v_size = lineSize;
-}` }, "vv.glsl": `#define MAX_STOPS 8
-#ifdef VV_COLOR
-uniform float u_color_stops[MAX_STOPS];
-uniform vec4 u_color_values[MAX_STOPS];
-uniform int u_color_count;
-#else
-uniform vec4 u_color;
-#endif
-#ifdef VV_OPACITY
-uniform float u_opacity_stops[MAX_STOPS];
-uniform float u_opacity_values[MAX_STOPS];
-uniform int u_opacity_count;
-#else
-uniform float u_opacity;
-#endif
-#ifdef VV_SIZE
-uniform float u_size_stops[MAX_STOPS];
-uniform float u_size_values[MAX_STOPS];
-uniform int u_size_count;
-#else
-uniform float u_size;
-#endif
-uniform float u_featheringOffset;
-vec4 getColor(float x) {
-#ifdef VV_COLOR
-vec4 color = u_color_values[0];
-{
-for (int i = 1; i < MAX_STOPS; i++) {
-if (i >= u_color_count) {
-break;
-}
-float x1 = u_color_stops[i - 1];
-if (x < x1) {
-break;
-}
-float x2 = u_color_stops[i];
-vec4 y2 = u_color_values[i];
-if (x < x2) {
-vec4 y1 = u_color_values[i - 1];
-color = y1 + (y2 - y1) * (x - x1) / (x2 - x1);
-} else {
-color = y2;
-}
-}
-}
-#else
-vec4 color = u_color;
-#endif
-return color;
-}
-float getOpacity(float x) {
-#ifdef VV_OPACITY
-float opacity = u_opacity_values[0];
-{
-for (int i = 1; i < MAX_STOPS; i++) {
-if (i >= u_opacity_count) {
-break;
-}
-float x1 = u_opacity_stops[i - 1];
-if (x < x1) {
-break;
-}
-float x2 = u_opacity_stops[i];
-float y2 = u_opacity_values[i];
-if (x < x2) {
-float y1 = u_opacity_values[i - 1];
-opacity = y1 + (y2 - y1) * (x - x1) / (x2 - x1);
-} else {
-opacity = y2;
-}
-}
-}
-#else
-float opacity = u_opacity;
-#endif
-return opacity;
-}
-float getSize(float x) {
-#ifdef VV_SIZE
-float size = u_size_values[0];
-{
-for (int i = 1; i < MAX_STOPS; i++) {
-if (i >= u_size_count) {
-break;
-}
-float x1 = u_size_stops[i - 1];
-if (x < x1) {
-break;
-}
-float x2 = u_size_stops[i];
-float y2 = u_size_values[i];
-if (x < x2) {
-float y1 = u_size_values[i - 1];
-size = y1 + (y2 - y1) * (x - x1) / (x2 - x1);
-} else {
-size = y2;
-}
-}
-}
-#else
-float size = u_size;
-#endif
-return size + 2.0 * u_featheringSize * u_featheringOffset;
-}` }, hillshade: { "hillshade.frag": `precision mediump float;
-varying highp vec2 v_texcoord;
-#include <raster/common/common.glsl>
-uniform int u_hillshadeType;
-uniform float u_sinZcosAs[6];
-uniform float u_sinZsinAs[6];
-uniform float u_cosZs[6];
-uniform float u_weights[6];
-uniform vec2 u_factor;
-uniform float u_minValue;
-uniform float u_maxValue;
-#include <raster/lut/colorize.glsl>
-#include <raster/common/getSurfaceValues.glsl>
-vec3 rgb2hsv(vec3 c) {
-vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-float d = q.x - min(q.w, q.y);
-float e = 1.0e-10;
-return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), min(d / (q.x + e), 1.0), q.x);
-}
-vec3 hsv2rgb(vec3 c) {
-vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
-vec4 overlay(float val, float minValue, float maxValue, float hillshade) {
-val = clamp((val - minValue) / (maxValue - minValue), 0.0, 1.0);
-vec4 rgb = colorize(vec4(val, val, val, 1.0), 255.0);
-vec3 hsv = rgb2hsv(rgb.xyz);
-hsv.z = hillshade;
-return vec4(hsv2rgb(hsv), 1.0) * rgb.a;
-}
-void main() {
-vec2 pixelLocation = getPixelLocation(v_texcoord);
-if (isOutside(pixelLocation)) {
-gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
-return;
-}
-vec4 currentPixel = getPixel(pixelLocation);
-if (currentPixel.a == 0.0) {
-gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
-return;
-}
-float pv[10];
-getSurfaceValues(u_image, pixelLocation, u_srcImageSize, pv);
-float alpha = pv[9];
-float dzx = (pv[2] + 2.0 * pv[5] + pv[8] - pv[0] - 2.0 * pv[3] - pv[6]) * u_factor.s;
-float dzy = (pv[6] + 2.0 * pv[7] + pv[8] - pv[0] - 2.0 * pv[1] - pv[2]) * u_factor.t;
-float dzd = sqrt(1.0 + dzx * dzx + dzy * dzy);
-float hillshade = 0.0;
-if (u_hillshadeType == 0){
-float cosDelta = u_sinZsinAs[0] * dzy - u_sinZcosAs[0] * dzx;
-float z = (u_cosZs[0] + cosDelta) / dzd;
-if (z < 0.0)  z = 0.0;
-hillshade = z;
-} else {
-for (int k = 0; k < 6; k++) {
-float cosDelta = u_sinZsinAs[k] * dzy - u_sinZcosAs[k] * dzx;
-float z = (u_cosZs[k] + cosDelta) / dzd;
-if (z < 0.0) z = 0.0;
-hillshade = hillshade + z * u_weights[k];
-if (k == 5) break;
-}
-}
-#ifdef APPLY_COLORMAP
-gl_FragColor = overlay(pv[4], u_minValue, u_maxValue, hillshade) * alpha * u_opacity;
-#else
-gl_FragColor = vec4(hillshade, hillshade, hillshade, 1.0) * alpha * u_opacity;
-#endif
-}` }, lut: { "colorize.glsl": `uniform sampler2D u_colormap;
-uniform float u_colormapOffset;
-uniform float u_colormapMaxIndex;
-vec4 colorize(vec4 currentPixel, float scaleFactor) {
-float clrIndex = clamp(currentPixel.r * scaleFactor - u_colormapOffset, 0.0, u_colormapMaxIndex);
-vec2 clrPosition = vec2((clrIndex + 0.5) / (u_colormapMaxIndex + 1.0), 0.0);
-vec4 color = texture2D(u_colormap, clrPosition);
-vec4 result = vec4(color.rgb, color.a * currentPixel.a);
-return result;
-}`, "lut.frag": `precision mediump float;
-varying highp vec2 v_texcoord;
-#include <raster/common/common.glsl>
-#include <raster/lut/colorize.glsl>
-void main() {
-vec2 pixelLocation = getPixelLocation(v_texcoord);
-if (isOutside(pixelLocation)) {
-gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
-return;
-}
-vec4 currentPixel = getPixel(pixelLocation);
-vec4 result = colorize(currentPixel, 1.0);
-gl_FragColor = vec4(result.xyz, 1.0) * result.a * u_opacity;
-}` }, magdir: { "magdir.frag": `precision mediump float;
-varying vec4 v_color;
-uniform lowp float u_opacity;
-void main() {
-gl_FragColor = v_color * u_opacity;
-}`, "magdir.vert": `precision mediump float;
-attribute vec2 a_pos;
-attribute vec2 a_offset;
-attribute vec2 a_vv;
-uniform highp mat3 u_dvsMat3;
-uniform highp vec2 u_coordScale;
-uniform vec2 u_symbolSize;
-uniform vec2 u_symbolPercentRange;
-uniform vec2 u_dataRange;
-uniform float u_rotation;
-uniform vec4 u_colors[12];
-varying vec4 v_color;
-void main()
-{
-float angle = a_offset.y + u_rotation;
-#ifndef ROTATION_GEOGRAPHIC
-angle = 3.14159265359 * 2.0 - angle - 3.14159265359 / 2.0;
-#endif
-vec2 offset = vec2(cos(angle), sin(angle)) * a_offset.x;
-#ifdef DATA_RANGE
-float valuePercentage = clamp((a_vv.y - u_dataRange.x) / (u_dataRange.y - u_dataRange.x), 0.0, 1.0);
-float sizeRatio = u_symbolPercentRange.x + valuePercentage * (u_symbolPercentRange.y - u_symbolPercentRange.x);
-float sizePercentage = clamp(sizeRatio, u_symbolPercentRange.x, u_symbolPercentRange.y);
-#else
-float sizePercentage = (u_symbolPercentRange.x + u_symbolPercentRange.y) / 2.0;
-#endif
-vec2 pos = a_pos + offset * sizePercentage * u_symbolSize;
-v_color = u_colors[int(a_vv.x)];
-gl_Position = vec4(u_dvsMat3 * vec3(pos * u_coordScale, 1.0), 1.0);
-}` }, reproject: { "reproject.frag": `precision mediump float;
-varying vec2 v_texcoord;
-#include <raster/common/common.glsl>
-void main() {
-vec2 pixelLocation = getPixelLocation(v_texcoord);
-if (isOutside(pixelLocation)) {
-gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
-return;
-}
-vec4 currentPixel = getPixel(pixelLocation);
-gl_FragColor = vec4(currentPixel.rgb, 1.0) * currentPixel.a * u_opacity;
-}`, "reproject.vert": `precision mediump float;
-attribute vec2 a_position;
-varying highp vec2 v_texcoord;
-void main()
-{
-v_texcoord = a_position;
-gl_Position = vec4(2.0 * (a_position - 0.5), 0.0, 1.0);
-}` }, rfx: { aspect: { "aspect.frag": `precision mediump float;
-uniform sampler2D u_image;
-varying vec2 v_texcoord;
-uniform vec2 u_cellSize;
-uniform vec2 u_srcImageSize;
-#include <raster/common/getSurfaceValues.glsl>
-const float pi = 3.14159265359;
-void main() {
-float pv[10];
-getSurfaceValues(u_image, v_texcoord, u_srcImageSize, pv);
-float alpha = pv[9];
-float dzx = (pv[2] + 2.0 * pv[5] + pv[8] - pv[0] - 2.0 * pv[3] - pv[6]) / (8.0 * u_cellSize[0]);
-float dzy = -(pv[6] + 2.0 * pv[7] + pv[8] - pv[0] - 2.0 * pv[1] - pv[2]) / (8.0 * u_cellSize[1]);
-alpha *= sign(abs(dzx) + abs(dzy));
-float aspect_rad = (dzx == 0.0) ? (step(0.0, dzy) * 0.5 * pi + step(dzy, 0.0) * 1.5 * pi) : mod((2.5 * pi + atan(dzy, -dzx)), 2.0 * pi);
-float aspect = aspect_rad * 180.0 / pi;
-gl_FragColor = vec4(aspect, aspect, aspect, 1.0) * alpha;
-}` }, bandarithmetic: { "bandarithmetic.frag": `precision mediump float;
-uniform sampler2D u_image;
-varying vec2 v_texcoord;
-uniform mediump mat3 u_bandIndexMat3;
-uniform float u_adjustments[3];
-#include <raster/common/inverse.glsl>
-void main() {
-vec4 pv = texture2D(u_image, v_texcoord);
-vec3 pv2 = u_bandIndexMat3 * pv.rgb;
-float nir = pv2.r;
-float red = pv2.g;
-float index;
-#ifdef NDXI
-index = (nir - red) * invertValue(nir + red);
-#elif defined(SR)
-index = nir * invertValue(red);
-#elif defined(CI)
-index = nir * invertValue(red) - 1.0;
-#elif defined(SAVI)
-index = (nir - red) * invertValue(nir + red + u_adjustments[0]) * (1.0 + u_adjustments[0]);
-#elif defined(TSAVI)
-float s = u_adjustments[0];
-float a = u_adjustments[1];
-float x = u_adjustments[2];
-float y = -a * s + x * (1.0 + s * s);
-index = (s * (nir - s * red - a)) * invertValue(a * nir + red + y);
-#elif defined(MSAVI)
-float nir2 = 2.0 * nir + 1.0;
-index = 0.5 * (nir2 - sqrt(nir2 * nir2 - 8.0 * (nir - red)));
-#elif defined(GEMI)
-float eta = (2.0 * (nir * nir - red * red) + 1.5 * nir + 0.5 * red) * invertValue(nir + red + 0.5);
-index = eta * (1.0 - 0.25 * eta) - (red - 0.125) * invertValue(1.0 - red);
-#elif defined(PVI)
-float a = u_adjustments[0];
-float b = u_adjustments[1];
-float y = sqrt(1.0 + a * a);
-index = (nir - a * red - b) * invertValue(y);
-#elif defined(VARI)
-index = (pv2.g - pv2.r) * invertValue(pv2.g + pv2.r - pv2.b);
-#elif defined(MTVI)
-float green = pv2.b;
-float v = sqrt(pow((2.0 * nir + 1.0), 2.0) - (6.0 * nir - 5.0 * sqrt(red)) - 0.5);
-index = 1.5 * (1.2 * (nir - green) - 2.5 * (red - green)) * invertValue(v);
-#elif defined(RTVICORE)
-float green = pv2.b;
-index = 100.0 * (nir - red) - 10.0 * (nir - green);
-#elif defined(EVI)
-float blue = pv2.b;
-float denom = nir + 6.0 * red - 7.5 * blue + 1.0;
-index =  (2.5 * (nir - red)) * invertValue(denom);
-#elif defined(WNDWI)
-float g = pv2.r;
-float n = pv2.g;
-float s = pv2.s;
-float a = u_adjustments[0];
-float denom = g + a * n + (1.0 - a) * s;
-index = (g - a * n - (1 - a) * s) * invertValue(denom);
-#elif defined(BAI)
-index = invertValue(pow((0.1 - red), 2.0) + pow((0.06 - nir), 2.0));
-#else
-gl_FragColor = pv;
-return;
-#endif
-gl_FragColor = vec4(index, index, index, pv.a);
-}` }, compositeband: { "compositeband.frag": `precision mediump float;
-uniform sampler2D u_image;
-uniform sampler2D u_image1;
-uniform sampler2D u_image2;
-#ifdef ONE_CONSTANT
-uniform float u_image1Const;
-#ifdef TWO_CONSTANT
-uniform float u_image2Const;
-#endif
-uniform mat3 u_imageSwap;
-#endif
-varying vec2 v_texcoord;
-void main() {
-vec4 pv0 = texture2D(u_image, v_texcoord);
-float a = pv0.r;
-float alpha = pv0.a;
-#ifdef TWO_CONSTANT
-float b = u_image1Const;
-float c = u_image2Const;
-vec3 abc = u_imageSwap * vec3(a, b, c);
-a = abc.s;
-b = abc.t;
-c = abc.p;
-#elif defined(ONE_CONSTANT)
-vec4 pv1 = texture2D(u_image1, v_texcoord);
-float b = pv1.r;
-float c = u_image1Const;
-vec3 abc = u_imageSwap * vec3(a, b, c);
-a = abc.s;
-b = abc.t;
-c = abc.p;
-alpha *= pv1.a;
-#else
-vec4 pv1 = texture2D(u_image1, v_texcoord);
-vec4 pv2 = texture2D(u_image2, v_texcoord);
-float b = pv1.r;
-float c = pv2.r;
-alpha = alpha * pv1.a * pv2.a;
-#endif
-gl_FragColor = vec4(a, b, c, alpha);
-}` }, contrast: { "contrast.frag": `precision mediump float;
-uniform sampler2D u_image;
-varying vec2 v_texcoord;
-#include <raster/common/contrastBrightness.glsl>
-void main() {
-vec4 pv = texture2D(u_image, v_texcoord);
-vec4 result = adjustContrastBrightness(pv, false) ;
-gl_FragColor = vec4(result.rgb * 255.0, result.a);
-}` }, convolution: { "convolution.frag": `precision mediump float;
-uniform sampler2D u_image;
-varying vec2 v_texcoord;
-uniform vec2 u_srcImageSize;
-#define KERNEL_SIZE_ROWS ROWS
-#define KERNEL_SIZE_COLS COLS
-uniform vec2 u_clampRange;
-uniform float u_kernel[25];
-#include <raster/common/mirror.glsl>
-void main() {
-vec3 rgb = vec3(0.0, 0.0, 0.0);
-vec2 resolution = 1.0 / u_srcImageSize;
-float rowOffset = -float(floor(float(KERNEL_SIZE_ROWS) / 2.0));
-float colOffset = -float(floor(float(KERNEL_SIZE_COLS) / 2.0));
-float alpha = 1.0;
-for (int row = 0; row < KERNEL_SIZE_ROWS; row++) {
-float pos_row = rowOffset + float(row);
-for (int col = 0; col < KERNEL_SIZE_COLS; col++) {
-vec2 pos = v_texcoord + vec2(colOffset + float(col), pos_row) * resolution;
-vec4 pv = texture2D(u_image, mirror(pos));
-rgb += pv.rgb * u_kernel[row * KERNEL_SIZE_COLS + col];
-alpha *= pv.a;
-}
-}
-rgb = clamp(rgb, u_clampRange.s, u_clampRange.t);
-gl_FragColor = vec4(rgb * alpha, alpha);
-}` }, curvature: { "curvature.frag": `precision mediump float;
-uniform sampler2D u_image;
-varying vec2 v_texcoord;
-uniform float u_zlFactor;
-uniform vec2 u_srcImageSize;
-#include <raster/common/getSurfaceValues.glsl>
-void main() {
-float pv[10];
-getSurfaceValues(u_image, v_texcoord, u_srcImageSize, pv);
-float alpha = pv[9];
-float d = ((pv[3] + pv[5]) * 0.5 - pv[4]);
-float e = ((pv[1] + pv[7]) * 0.5 - pv[4]);
-float curvature = 0.0;
-#ifdef STANDARD
-curvature = -u_zlFactor * (d + e);
-gl_FragColor = vec4(curvature, curvature, curvature, alpha);
-#else
-float f = (-pv[0] + pv[2] + pv[6] - pv[8]) / 4.0;
-float g = (-pv[3] + pv[5]) / 2.0;
-float h = (pv[1] - pv[7]) / 2.0;
-float g2 = g * g;
-float h2 = h * h;
-#ifdef PROFILE
-curvature = (u_zlFactor * (d * g2 + e * h2 + f * g * h)) / (g2 + h2);
-#else
-curvature = (-u_zlFactor * (d * h2 + e * g2 - f * g * h)) / (g2 + h2);
-#endif
-#endif
-gl_FragColor = vec4(curvature, curvature, curvature, alpha);
-}` }, extractband: { "extractband.frag": `precision mediump float;
-uniform sampler2D u_image;
-varying vec2 v_texcoord;
-uniform mediump mat3 u_bandIndexMat3;
-void main() {
-vec4 pv = texture2D(u_image, v_texcoord);
-vec3 pv2 = u_bandIndexMat3 * pv.rgb;
-gl_FragColor = vec4(pv2, pv.a);
-}` }, focalstatistics: { "focalstatistics.frag": `precision mediump float;
-uniform sampler2D u_image;
-varying vec2 v_texcoord;
-uniform vec2 u_srcImageSize;
-#define KERNEL_SIZE_ROWS ROWS
-#define KERNEL_SIZE_COLS COLS
-uniform vec2 u_clampRange;
-#include <raster/common/mirror.glsl>
-#include <raster/common/inverse.glsl>
-void main() {
-vec2 resolution = 1.0 / u_srcImageSize;
-float rowOffset = -float(floor(float(KERNEL_SIZE_ROWS) / 2.0));
-float colOffset = -float(floor(float(KERNEL_SIZE_COLS) / 2.0));
-float count = 0.0;
-#ifdef STDDEV
-vec3 sum = vec3(0.0, 0.0, 0.0);
-vec3 sum2 = vec3(0.0, 0.0, 0.0);
-#endif
-vec4 currentPixel = texture2D(u_image, v_texcoord);
-vec3 rgb = currentPixel.rgb;
-for (int row = 0; row < KERNEL_SIZE_ROWS; row++) {
-float pos_row = rowOffset + float(row);
-for (int col = 0; col < KERNEL_SIZE_COLS; col++) {
-vec2 pos = v_texcoord + vec2(colOffset + float(col), pos_row) * resolution;
-vec4 pv = texture2D(u_image, mirror(pos));
-count += pv.a;
-#ifdef MIN
-rgb = min(rgb, pv.rgb);
-#elif defined(MAX)
-rgb = max(rgb, pv.rgb);
-#elif defined(MEAN)
-rgb += pv.rgb;
-#elif defined(STDDEV)
-sum += pv.rgb;
-sum2 += (pv.rgb * pv.rgb);
-#endif
-}
-}
-#ifdef MEAN
-rgb *= invertValue(count);
-#elif defined(STDDEV)
-rgb = sqrt((sum2 - sum * sum * invertValue(count)) * invertValue(count));
-#endif
-float alpha = step(0.9999, count);
-rgb = clamp(rgb, u_clampRange.s, u_clampRange.t);
-#ifdef FILL
-rgb = (1.0 - currentPixel.a) * rgb + currentPixel.a * currentPixel.rgb;
-#endif
-gl_FragColor = vec4(rgb * alpha, alpha);
-}` }, grayscale: { "grayscale.frag": `precision mediump float;
-uniform sampler2D u_image;
-varying vec2 v_texcoord;
-uniform vec3 u_weights;
-void main() {
-vec4 pv = texture2D(u_image, v_texcoord);
-float value = dot(u_weights, pv.rgb);
-gl_FragColor = vec4(value, value, value, pv.a);
-}` }, local: { "local.frag": `precision mediump float;
-uniform sampler2D u_image;
-uniform sampler2D u_image1;
-#ifdef ONE_CONSTANT
-uniform float u_image1Const;
-#ifdef TWO_CONSTANT
-uniform float u_image2Const;
-#endif
-uniform mat3 u_imageSwap;
-#endif
-varying vec2 v_texcoord;
-uniform vec2 u_domainRange;
-#include <raster/common/inverse.glsl>
-void main() {
-vec4 pv0 = texture2D(u_image, v_texcoord);
-float a = pv0.r;
-#ifdef TWO_IMAGES
-#ifdef ONE_CONSTANT
-float b = u_image1Const;
-vec3 abc = u_imageSwap * vec3(a, b, 0);
-a = abc.s;
-b = abc.t;
-#else
-vec4 pv1 = texture2D(u_image1, v_texcoord);
-float b = pv1.r;
-#endif
-#elif defined(CONDITIONAL)
-#ifdef TWO_CONSTANT
-float b = u_image1Const;
-float c = u_image2Const;
-vec3 abc = u_imageSwap * vec3(a, b, c);
-a = abc.s;
-b = abc.t;
-c = abc.p;
-#elif defined(ONE_CONSTANT)
-vec4 pv1 = texture2D(u_image1, v_texcoord);
-float b = pv1.r;
-float c = u_image1Const;
-vec3 abc = u_imageSwap * vec3(a, b, c);
-a = abc.s;
-b = abc.t;
-c = abc.p;
-#else
-vec4 pv1 = texture2D(u_image1, v_texcoord);
-vec4 pv2 = texture2D(u_image2, v_texcoord);
-float b = pv1.r;
-float c = pv2.r;
-#endif
-#endif
-float result = a;
-float alpha = pv0.a;
-#ifdef PLUS
-result = a + b;
-#elif defined(MINUS)
-result = a - b;
-#elif defined(TIMES)
-result = a * b;
-#elif defined(DIVIDE)
-result = a * invertValue(b);
-alpha *= float(abs(sign(b)));
-#elif defined(FLOATDIVIDE)
-result = a * invertValue(b);
-alpha *= float(abs(sign(b)));
-#elif defined(FLOORDIVIDE)
-result = floor(a * invertValue(b));
-alpha *= float(abs(sign(b)));
-#elif defined(SQUARE)
-result = a * a;
-#elif defined(SQRT)
-result = sqrt(a);
-#elif defined(POWER)
-result = pow(a, b);
-#elif defined(LN)
-result = a <= 0.0 ? 0.0: log(a);
-alpha *= float(a > 0.0);
-#elif defined(LOG_1_0)
-result = a <= 0.0 ? 0.0: log2(a) * invertValue(log2(10.0));
-alpha *= float(a > 0.0);
-#elif defined(LOG_2)
-result = a <= 0.0 ? 0.0: log2(a);
-alpha *= float(a > 0.0);
-#elif defined(EXP)
-result = exp(a);
-#elif defined(EXP_1_0)
-result = pow(10.0, a);
-#elif defined(EXP_2)
-result = pow(2.0, a);
-#elif defined(ROUNDDOWN)
-result = floor(a);
-#elif defined(ROUNDUP)
-result = ceil(a);
-#elif defined(INT)
-result = float(sign(a)) * floor(abs(a));
-#elif defined(MOD)
-result = mod(a, b);
-#elif defined(NEGATE)
-result = -a;
-#elif defined(ABS)
-result = abs(a);
-#elif defined(ACOS)
-result = abs(a) > 1.0 ? 0.0: acos(a);
-alpha *= step(abs(a), 1.00001);
-#elif defined(ACOSH)
-result = acosh(a);
-#elif defined(ASIN)
-result = abs(a) > 1.0 ? 0.0: asin(a);
-alpha *= step(abs(a), 1.00001);
-#elif defined(ASINH)
-result = asinh(a);
-#elif defined(ATAN)
-result = atan(a);
-#elif defined(ATANH)
-result = abs(a) > 1.0 ? 0.0: atanh(a);
-alpha *= step(abs(a), 1.0);
-#elif defined(ATAN_2)
-result = atan(a, b);
-#elif defined(COS)
-result = cos(a);
-#elif defined(COSH)
-result = cosh(a);
-#elif defined(SIN)
-result = sin(a);
-#elif defined(SINH)
-result = sinh(a);
-#elif defined(TAN)
-result = tan(a);
-#elif defined(TANH)
-result = tanh(a);
-#elif defined(BITWISEAND)
-result = a & b;
-#elif defined(BITWISEOR)
-result = a | b;
-#elif defined(BITWISELEFTSHIFT)
-result = a << b;
-#elif defined(BITWISERIGHTSHIFT)
-result = a >> b;
-#elif defined(BITWISENOT)
-result = ~a;
-#elif defined(BITWISEXOR)
-result = a ^ b;
-#elif defined(BOOLEANAND)
-result = float((a != 0.0) && (b != 0.0));
-#elif defined(BOOLEANNOT)
-result = float(a == 0.0);
-#elif defined(BOOLEANOR)
-result = float((a != 0.0) || (b != 0.0));
-#elif defined(BOOLEANXOR)
-result = float((a != 0.0) ^^ (b != 0.0));
-#elif defined(GREATERTHAN)
-result = float(a > b);
-#elif defined(GREATERTHANEQUAL)
-result = float(a >= b);
-#elif defined(LESSTHAN)
-result = float(a < b);
-#elif defined(LESSTHANEQUAL)
-result = float(a <= b);
-#elif defined(EQUALTO)
-result = float(a == b);
-#elif defined(NOTEQUAL)
-result = float(a != b);
-#elif defined(ISNULL)
-result = float(alpha == 0.0);
-alpha = 1.0;
-#elif defined(SETNULL)
-float maskValue = float(a == 0.0);
-result = maskValue * b;
-alpha *= maskValue;
-#elif defined(CONDITIONAL)
-float weight = float(abs(sign(a)));
-result = weight * b + (1.0 - weight) * c;
-#endif
-bool isInvalid = result < u_domainRange.s || result > u_domainRange.t;
-result = isInvalid ? 0.0 : result;
-alpha *= float(!isInvalid);
-#ifdef ROUND_OUTPUT
-result = floor(result + 0.5);
-#endif
-gl_FragColor = vec4(result, result, result, alpha);
-}` }, mask: { "mask.frag": `precision mediump float;
-uniform sampler2D u_image;
-varying vec2 v_texcoord;
-#define LEN_INCLUDED_RANGES 6
-#define LEN_NODATA_VALUES 6
-uniform highp float u_includedRanges[6];
-uniform highp float u_noDataValues[6];
-float maskFactor(float bandValue, float fromValue, float to) {
-float factor = 1.0;
-for (int i = 0; i < LEN_NODATA_VALUES; i++) {
-factor *= float(u_noDataValues[i] != bandValue);
-}
-factor *= step(fromValue, bandValue) * step(bandValue, to);
-return factor;
-}
-void main() {
-vec4 pv = texture2D(u_image, v_texcoord);
-float redFactor = maskFactor(pv.r, u_includedRanges[0], u_includedRanges[1]);
-#ifdef MULTI_BAND
-float greenFactor = maskFactor(pv.g, u_includedRanges[2], u_includedRanges[3]);
-float blueFactor = maskFactor(pv.b, u_includedRanges[4], u_includedRanges[5]);
-float maskFactor = redFactor * greenFactor * blueFactor;
-gl_FragColor = pv * maskFactor;
-#else
-gl_FragColor = pv * redFactor;
-#endif
-}` }, ndvi: { "ndvi.frag": `precision mediump float;
-uniform sampler2D u_image;
-varying vec2 v_texcoord;
-uniform mediump mat3 u_bandIndexMat3;
-#include <raster/common/inverse.glsl>
-void main() {
-vec4 pv = texture2D(u_image, v_texcoord);
-vec3 pv2 = u_bandIndexMat3 * pv.rgb;
-float nir = pv2.r;
-float red = pv2.g;
-float index = (nir - red) * invertValue(nir + red);
-#ifdef SCALED
-index = floor((index + 1.0) * 100.0 + 0.5);
-#endif
-gl_FragColor = vec4(index, index, index, pv.a);
-}` }, remap: { "remap.frag": `precision mediump float;
-uniform sampler2D u_image;
-varying vec2 v_texcoord;
-#define LEN_REMAP_RANGES 18
-#define LEN_NODATA_RANGES 12
-uniform highp float u_rangeMaps[18];
-uniform highp float u_noDataRanges[12];
-uniform highp float u_unmatchMask;
-uniform vec2 u_clampRange;
-void main() {
-vec4 pv = texture2D(u_image, v_texcoord);
-float factor = 1.0;
-float bandValue = pv.r;
-for (int i = 0; i < LEN_NODATA_RANGES; i+=2) {
-float inside = 1.0 - step(u_noDataRanges[i], bandValue) * step(bandValue, u_noDataRanges[i+1]);
-factor *= inside;
-}
-float mapValue = 0.0;
-float includeMask = 0.0;
-for (int i = 0; i < LEN_REMAP_RANGES; i+=3) {
-float stepMask = step(u_rangeMaps[i], bandValue) * step(bandValue, u_rangeMaps[i+1]);
-includeMask = (1.0 - stepMask) * includeMask + stepMask;
-mapValue = (1.0 - stepMask) * mapValue + stepMask * u_rangeMaps[i+2];
-}
-bandValue = factor * (mapValue + (1.0 - includeMask) * u_unmatchMask * pv.r);
-float bandMask = factor * max(u_unmatchMask, includeMask);
-bandValue = clamp(bandValue, u_clampRange.s, u_clampRange.t);
-gl_FragColor = vec4(bandValue, bandValue, bandValue, bandMask * pv.a);
-}` }, slope: { "slope.frag": `precision mediump float;
-uniform sampler2D u_image;
-varying vec2 v_texcoord;
-uniform vec2 u_cellSize;
-uniform float u_zFactor;
-uniform vec2 u_srcImageSize;
-uniform float u_pixelSizePower;
-uniform float u_pixelSizeFactor;
-#include <raster/common/getSurfaceValues.glsl>
-void main() {
-float pv[10];
-getSurfaceValues(u_image, v_texcoord, u_srcImageSize, pv);
-float alpha = pv[9];
-float xf = (u_zFactor + pow(u_cellSize[0], u_pixelSizePower) * u_pixelSizeFactor) / (8.0 * u_cellSize[0]);
-float yf = (u_zFactor + pow(u_cellSize[1], u_pixelSizePower) * u_pixelSizeFactor) / (8.0 * u_cellSize[1]);
-float dzx = (pv[2] + 2.0 * pv[5] + pv[8] - pv[0] - 2.0 * pv[3] - pv[6]) * xf;
-float dzy = -(pv[6] + 2.0 * pv[7] + pv[8] - pv[0] - 2.0 * pv[1] - pv[2]) * yf;
-float rise2run = sqrt(dzx * dzx + dzy * dzy);
-#ifdef PERCENT_RISE
-float percentRise = rise2run * 100.0;
-gl_FragColor = vec4(percentRise, percentRise, percentRise, alpha);
-#else
-float degree = atan(rise2run) * 57.2957795;
-gl_FragColor = vec4(degree, degree, degree, alpha);
-#endif
-}` }, stretch: { "stretch.frag": `precision mediump float;
-uniform sampler2D u_image;
-varying highp vec2 v_texcoord;
-uniform float u_minCutOff[3];
-uniform float u_maxCutOff[3];
-uniform float u_minOutput;
-uniform float u_maxOutput;
-uniform float u_factor[3];
-uniform float u_gamma[3];
-uniform float u_gammaCorrection[3];
-float stretchOneValue(float val, float minCutOff, float maxCutOff, float minOutput, float maxOutput, float factor, float gamma, float gammaCorrection) {
-val = clamp(val, minCutOff, maxCutOff);
-float stretchedVal;
-#ifdef USE_GAMMA
-float tempf = 1.0;
-float outRange = maxOutput - minOutput;
-float relativeVal = (val - minCutOff) / (maxCutOff - minCutOff);
-tempf -= step(1.0, gamma) * sign(gamma - 1.0) * pow(1.0 / outRange, relativeVal * gammaCorrection);
-stretchedVal = tempf * outRange * pow(relativeVal, 1.0 / gamma) + minOutput;
-stretchedVal = clamp(stretchedVal, minOutput, maxOutput);
-#else
-stretchedVal = minOutput + (val - minCutOff) * factor;
-#endif
-#ifdef ROUND_OUTPUT
-stretchedVal = floor(stretchedVal + 0.5);
-#endif
-return stretchedVal;
-}
-void main() {
-vec4 currentPixel = texture2D(u_image, v_texcoord);
-float redVal = stretchOneValue(currentPixel.r, u_minCutOff[0], u_maxCutOff[0], u_minOutput, u_maxOutput, u_factor[0], u_gamma[0], u_gammaCorrection[0]);
-#ifdef MULTI_BAND
-float greenVal = stretchOneValue(currentPixel.g, u_minCutOff[1], u_maxCutOff[1], u_minOutput, u_maxOutput, u_factor[1], u_gamma[1], u_gammaCorrection[1]);
-float blueVal = stretchOneValue(currentPixel.b, u_minCutOff[2], u_maxCutOff[2], u_minOutput, u_maxOutput, u_factor[2], u_gamma[2], u_gammaCorrection[2]);
-gl_FragColor = vec4(redVal, greenVal, blueVal, currentPixel.a);
-#else
-gl_FragColor = vec4(redVal, redVal, redVal, currentPixel.a);
-#endif
-}` }, vs: { "vs.vert": `precision mediump float;
-attribute vec2 a_pos;
-uniform highp mat3 u_dvsMat3;
-uniform highp vec2 u_coordScale;
-varying highp vec2 v_texcoord;
-void main()
-{
-v_texcoord = a_pos;
-gl_Position = vec4(u_dvsMat3 * vec3(a_pos * u_coordScale, 1.0), 1.0);
-}` } }, scalar: { "scalar.frag": `precision mediump float;
-uniform lowp float u_opacity;
-varying vec2 v_pos;
-const vec4 outlineColor = vec4(0.2, 0.2, 0.2, 1.0);
-const float outlineSize = 0.02;
-const float innerRadius = 0.25;
-const float outerRadius = 0.42;
-const float innerSquareLength = 0.15;
-void main() {
-mediump float dist = length(v_pos);
-mediump float fillalpha1 = smoothstep(outerRadius, outerRadius + outlineSize, dist);
-fillalpha1 *= (1.0-smoothstep(outerRadius + outlineSize, outerRadius + 0.1 + outlineSize, dist));
-#ifdef INNER_CIRCLE
-mediump float fillalpha2 = smoothstep(innerRadius, innerRadius + outlineSize, dist);
-fillalpha2 *= (1.0-smoothstep(innerRadius + outlineSize, innerRadius + 0.1 + outlineSize, dist));
-#else
-mediump float fillalpha2 = (abs(v_pos.x) < innerSquareLength ? 1.0 : 0.0) * (abs(v_pos.y) < innerSquareLength ? 1.0 : 0.0);
-#endif
-gl_FragColor = (fillalpha2 + fillalpha1) * outlineColor * u_opacity;
-}`, "scalar.vert": `precision mediump float;
-attribute vec2 a_pos;
-attribute vec2 a_offset;
-attribute vec2 a_vv;
-uniform highp mat3 u_dvsMat3;
-uniform highp vec2 u_coordScale;
-uniform vec2 u_symbolSize;
-uniform vec2 u_symbolPercentRange;
-uniform vec2 u_dataRange;
-varying vec2 v_pos;
-void main()
-{
-#ifdef DATA_RANGE
-float valuePercentage = clamp((a_vv.y - u_dataRange.x) / (u_dataRange.y - u_dataRange.x), 0.0, 1.0);
-float sizeRatio = u_symbolPercentRange.x + valuePercentage * (u_symbolPercentRange.y - u_symbolPercentRange.x);
-float sizePercentage = clamp(sizeRatio, u_symbolPercentRange.x, u_symbolPercentRange.y);
-#else
-float sizePercentage = (u_symbolPercentRange.x + u_symbolPercentRange.y) / 2.0;
-#endif
-vec2 size = u_symbolSize * sizePercentage;
-vec2 pos = a_pos + a_offset * size;
-v_pos = a_offset;
-gl_Position = vec4(u_dvsMat3 * vec3(pos * u_coordScale, 1.0), 1.0);
-}` }, stretch: { "stretch.frag": `precision mediump float;
-varying highp vec2 v_texcoord;
-#include <raster/common/common.glsl>
-uniform float u_minCutOff[3];
-uniform float u_maxCutOff[3];
-uniform float u_minOutput;
-uniform float u_maxOutput;
-uniform float u_factor[3];
-uniform bool u_useGamma;
-uniform float u_gamma[3];
-uniform float u_gammaCorrection[3];
-#include <raster/lut/colorize.glsl>
-float stretchOneValue(float val, float minCutOff, float maxCutOff, float minOutput, float maxOutput, float factor, bool useGamma, float gamma, float gammaCorrection) {
-if (val >= maxCutOff) {
-return maxOutput;
-} else if (val <= minCutOff) {
-return minOutput;
-}
-float stretchedVal;
-if (useGamma) {
-float tempf = 1.0;
-float outRange = maxOutput - minOutput;
-float relativeVal = (val - minCutOff) / (maxCutOff - minCutOff);
-if (gamma > 1.0) {
-tempf -= pow(1.0 / outRange, relativeVal * gammaCorrection);
-}
-stretchedVal = (tempf * outRange * pow(relativeVal, 1.0 / gamma) + minOutput) / 255.0;
-} else {
-stretchedVal = minOutput + (val - minCutOff) * factor;
-}
-return stretchedVal;
-}
-void main() {
-vec2 pixelLocation = getPixelLocation(v_texcoord);
-if (isOutside(pixelLocation)) {
-gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
-return;
-}
-vec4 currentPixel = getPixel(pixelLocation);
-#ifdef NOOP
-gl_FragColor = vec4(currentPixel.rgb, 1.0) * currentPixel.a * u_opacity;
-return;
-#endif
-if (u_bandCount == 1) {
-float grayVal = stretchOneValue(currentPixel.r, u_minCutOff[0], u_maxCutOff[0], u_minOutput, u_maxOutput, u_factor[0], u_useGamma, u_gamma[0], u_gammaCorrection[0]);
-#ifdef APPLY_COLORMAP
-vec4 result = colorize(vec4(grayVal, grayVal, grayVal, 1.0), u_useGamma ? 255.0 : 1.0);
-gl_FragColor = vec4(result.xyz, 1.0) * result.a * currentPixel.a * u_opacity;
-#else
-gl_FragColor = vec4(grayVal, grayVal, grayVal, 1.0) * currentPixel.a * u_opacity;
-#endif
-} else {
-float redVal = stretchOneValue(currentPixel.r, u_minCutOff[0], u_maxCutOff[0], u_minOutput, u_maxOutput, u_factor[0], u_useGamma, u_gamma[0], u_gammaCorrection[0]);
-float greenVal = stretchOneValue(currentPixel.g, u_minCutOff[1], u_maxCutOff[1], u_minOutput, u_maxOutput, u_factor[1], u_useGamma, u_gamma[1], u_gammaCorrection[1]);
-float blueVal = stretchOneValue(currentPixel.b, u_minCutOff[2], u_maxCutOff[2], u_minOutput, u_maxOutput, u_factor[2], u_useGamma, u_gamma[2], u_gammaCorrection[2]);
-gl_FragColor = vec4(redVal, greenVal, blueVal, 1.0) * currentPixel.a * u_opacity;
-}
-}` } }, stencil: { "stencil.frag": `void main() {
-gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);
-}`, "stencil.vert": `attribute vec2 a_pos;
-uniform mat3 u_worldExtent;
-void main() {
-gl_Position = vec4(u_worldExtent * vec3(a_pos, 1.0), 1.0);
-}` }, test: { "TestShader.common.glsl": `#ifndef RETURN_RED
-varying    vec4      v_color;
-#endif
-varying    vec2      v_offset;`, "TestShader.frag": `precision highp float;
-#include <test/TestShader.common.glsl>
-void main() {
-if (v_offset.x > -.5 && v_offset.y > -.5 && v_offset.x < .5 && v_offset.y < .5) {
-discard;
-}
-#ifdef RETURN_RED
-gl_FragColor = vec4(1., 0., 0., 1.);
-#else
-gl_FragColor = v_color;
-#endif
-}`, "TestShader.vert": `const float POS_PRECISION_FACTOR = 10.;
-const float OFFSET_PRECISION_FACTOR = 10.;
-const float SIZE_PRECISION_FACTOR = 10.;
-attribute  vec2      a_pos_packed;
-attribute  vec2      a_offset_packed;
-attribute  float     a_size_packed;
-#ifdef DATA_DRIVEN_COLOR
-const float u_dataDrivenColor_validValues[4] = float[4](0., 0., 1., 0.);
-uniform    vec4      u_dataDrivenColor_colorFallback;
-uniform    vec4      u_dataDrivenColor_color;
-#endif
-uniform    float     u_view_zoomLevel;
-#include <test/TestShader.common.glsl>
-#ifdef DATA_DRIVEN_COLOR
-vec4 getColor(float value) {
-int index = -1;
-for (int i = 0; i < 4; i++) {
-if (u_dataDrivenColor_validValues[i] == value) {
-index = i;
-break;
-}
-}
-if (index == -1) {
-return u_dataDrivenColor_colorFallback;
-}
-return u_dataDrivenColor_color;
-}
-#endif
-void main() {
-vec2  a_pos = a_pos_packed / POS_PRECISION_FACTOR;
-vec2  a_offset = a_offset_packed / OFFSET_PRECISION_FACTOR;
-float a_size = a_size_packed / SIZE_PRECISION_FACTOR;
-vec4 color = vec4(1., 0., 0., 1.);
-#ifdef DATA_DRIVEN_COLOR
-color = getColor(1.);
-#endif
-vec2 offsetScaled = a_offset * a_size;
-vec4 pos = vec4(a_pos.xy + offsetScaled, 0., 1.);
-gl_Position = pos;
-#ifndef RETURN_RED
-v_color = color;
-#endif
-v_offset = a_offset;
-}` }, tileInfo: { "tileInfo.frag": `uniform mediump sampler2D u_texture;
-varying mediump vec2 v_tex;
-void main(void) {
-lowp vec4 color = texture2D(u_texture, v_tex);
-color.rgb *= color.a;
-gl_FragColor = color;
-}`, "tileInfo.vert": `attribute vec2 a_pos;
-uniform highp mat3 u_dvsMat3;
-uniform mediump float u_depth;
-uniform mediump vec2 u_coord_ratio;
-uniform mediump vec2 u_delta;
-uniform mediump vec2 u_dimensions;
-varying mediump vec2 v_tex;
-void main() {
-mediump vec2 offset = u_coord_ratio * vec2(u_delta + a_pos * u_dimensions);
-vec3 v_pos = u_dvsMat3 * vec3(offset, 1.0);
-gl_Position = vec4(v_pos.xy, 0.0, 1.0);
-v_tex = a_pos;
-}` }, util: { "atan2.glsl": `float atan2(in float y, in float x) {
-float t0, t1, t2, t3, t4;
-t3 = abs(x);
-t1 = abs(y);
-t0 = max(t3, t1);
-t1 = min(t3, t1);
-t3 = 1.0 / t0;
-t3 = t1 * t3;
-t4 = t3 * t3;
-t0 =         - 0.013480470;
-t0 = t0 * t4 + 0.057477314;
-t0 = t0 * t4 - 0.121239071;
-t0 = t0 * t4 + 0.195635925;
-t0 = t0 * t4 - 0.332994597;
-t0 = t0 * t4 + 0.999995630;
-t3 = t0 * t3;
-t3 = (abs(y) > abs(x)) ? 1.570796327 - t3 : t3;
-t3 = x < 0.0 ?  3.141592654 - t3 : t3;
-t3 = y < 0.0 ? -t3 : t3;
-return t3;
-}`, "encoding.glsl": `const vec4 rgba2float_factors = vec4(
-255.0 / (256.0),
-255.0 / (256.0 * 256.0),
-255.0 / (256.0 * 256.0 * 256.0),
-255.0 / (256.0 * 256.0 * 256.0 * 256.0)
-);
-float rgba2float(vec4 rgba) {
-return dot(rgba, rgba2float_factors);
-}` } };
-export {
-  e as default
-};