@longline/aqua-ui 1.0.16 → 1.0.18

package/modules/ParticleGlobe/GL.js

@@ -0,0 +1,65 @@
+var GL = /** @class */ (function () {
+    function GL() {
+    }
+    GL.createProgram = function (gl, vertexSource, fragmentSource) {
+        var vertexShader = gl.createShader(gl.VERTEX_SHADER);
+        gl.shaderSource(vertexShader, vertexSource);
+        gl.compileShader(vertexShader);
+        var fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
+        gl.shaderSource(fragmentShader, fragmentSource);
+        gl.compileShader(fragmentShader);
+        var program = gl.createProgram();
+        gl.attachShader(program, vertexShader);
+        gl.attachShader(program, fragmentShader);
+        gl.linkProgram(program);
+        return program;
+    };
+    GL.createRGBATexture = function (gl, size, content, interpolated) {
+        var texture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        // Define size and format of level 0:
+        var level = 0;
+        var internalFormat = gl.RGBA;
+        var border = 0;
+        var format = gl.RGBA;
+        var type = gl.UNSIGNED_BYTE;
+        gl.texImage2D(gl.TEXTURE_2D, level, internalFormat, size, size, border, format, type, content);
+        if (!interpolated) {
+            // Set filtering to NEAREST so there's no interpolation:
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        }
+        return texture;
+    };
+    GL.createImageTexture = function (gl, image, interpolation) {
+        var texture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        // Define size and format of level 0:
+        var level = 0;
+        var internalFormat = gl.RGBA;
+        var format = gl.RGBA;
+        var type = gl.UNSIGNED_BYTE;
+        gl.texImage2D(gl.TEXTURE_2D, level, internalFormat, format, type, image);
+        if (interpolation) {
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+        }
+        else {
+            // Set filtering to NEAREST so there's no interpolation:
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        }
+        return texture;
+    };
+    GL.createFrameBuffer = function (gl, texture) {
+        // Create and bind the framebuffer:
+        var fbo = gl.createFramebuffer();
+        gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
+        // Attach the texture as the first color attachment:
+        var attachmentPoint = gl.COLOR_ATTACHMENT0;
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, attachmentPoint, gl.TEXTURE_2D, texture, 0);
+        return fbo;
+    };
+    return GL;
+}());
+export { GL };

package/modules/ParticleGlobe/OutlineFragmentShader.d.ts

@@ -0,0 +1,2 @@
+declare const OutlineFragmentShader = "\n  precision mediump float;\n  \n  uniform sampler2D u_texture;\n  varying vec2 v_texpos;\n  \n  void main() {\n    vec4 color = texture2D(u_texture, v_texpos);\n    if(color == vec4(0.0, 0.0, 0.0, 1.0)) {\n      gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);\n    } else {\n      gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);\n    }\n  }\n";
+export { OutlineFragmentShader };

package/modules/ParticleGlobe/OutlineFragmentShader.js

@@ -0,0 +1,2 @@
+var OutlineFragmentShader = /*glsl*/ "\n  precision mediump float;\n  \n  uniform sampler2D u_texture;\n  varying vec2 v_texpos;\n  \n  void main() {\n    vec4 color = texture2D(u_texture, v_texpos);\n    if(color == vec4(0.0, 0.0, 0.0, 1.0)) {\n      gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);\n    } else {\n      gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);\n    }\n  }\n";
+export { OutlineFragmentShader };

package/modules/ParticleGlobe/OutlineShader.d.ts

@@ -0,0 +1,3 @@
+declare const OutlineVertexShader = "\n  attribute vec2 a_pos;\n  attribute vec2 a_texpos;\n  uniform sampler2D u_texture;\n  varying vec2 v_texpos;\n\n  void main() {\n    gl_Position = vec4(a_pos, 0.0, 1.0);\n    v_texpos = vec2(a_texpos.x, a_texpos.y);\n  }\n";
+declare const OutlineFragmentShader = "\n  precision mediump float;\n  \n  uniform sampler2D u_texture;\n  varying vec2 v_texpos;\n  \n  void main() {\n    vec4 color = texture2D(u_texture, v_texpos);\n    if(color == vec4(0.0, 0.0, 0.0, 1.0)) {\n      gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);\n    } else {\n      gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);\n    }\n  }\n";
+export { OutlineVertexShader, OutlineFragmentShader };

package/modules/ParticleGlobe/OutlineShader.js

@@ -0,0 +1,3 @@
+var OutlineVertexShader = /*glsl*/ "\n  attribute vec2 a_pos;\n  attribute vec2 a_texpos;\n  uniform sampler2D u_texture;\n  varying vec2 v_texpos;\n\n  void main() {\n    gl_Position = vec4(a_pos, 0.0, 1.0);\n    v_texpos = vec2(a_texpos.x, a_texpos.y);\n  }\n";
+var OutlineFragmentShader = /*glsl*/ "\n  precision mediump float;\n  \n  uniform sampler2D u_texture;\n  varying vec2 v_texpos;\n  \n  void main() {\n    vec4 color = texture2D(u_texture, v_texpos);\n    if(color == vec4(0.0, 0.0, 0.0, 1.0)) {\n      gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);\n    } else {\n      gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);\n    }\n  }\n";
+export { OutlineVertexShader, OutlineFragmentShader };

package/modules/ParticleGlobe/OutputShader.d.ts

@@ -0,0 +1,3 @@
+declare const OutputVertexShader = "\n  // Current vertex index:\n  attribute float a_index;\n\n  // Encoded vertices texture:\n  uniform sampler2D u_texture;\n  uniform float u_resolution;\n  \n  // UV texture\n  uniform sampler2D u_uvtexture;\n  uniform float u_uvresolution;  \n\n  // Output: vertex color to draw.\n  varying vec4 v_color;\n\n  // Gradient:\n  uniform float u_gradientStops[12];\n  uniform vec4 u_gradientColors[12];  \n\n  // Point size:\n  uniform float u_pointsize;\n\n  //\n  // Given a value, find its corresponding color in the gradient stops.\n  //\n  vec4 getGradientColor(float position) {\n    // Find left and right stop:\n    float left = -1.0;\n    float right = 99.0;\n    vec4 leftColor;\n    vec4 rightColor;\n\n    for(int i = 0; i < 12; i++) {\n      if (u_gradientStops[i] <= position) {\n        left = u_gradientStops[i]; \n        leftColor = u_gradientColors[i];\n      } else break;\n    }\n\n    for(int i = 12 - 1; i >= 0; i--) {\n      if (u_gradientStops[i] >= position) {\n        right = u_gradientStops[i]; \n        rightColor = u_gradientColors[i];\n      } else break;\n    }\n\n    // Distance between stops:\n    float width = right - left;\n    // Distance from left stop:\n    float dist = position - left;\n    // Right stop weight:\n    float weight;\n    if(dist == 0.0) {\n      weight = dist;\n    } else {\n      weight = dist / width;\n    }\n\n    float r = leftColor.x + (rightColor.x - leftColor.x) * weight;\n    float g = leftColor.y + (rightColor.y - leftColor.y) * weight;\n    float b = leftColor.z + (rightColor.z - leftColor.z) * weight;\n    float a = leftColor.w + (rightColor.w - leftColor.w) * weight;\n    return vec4(r, g, b, a);    \n  }   \n\n  //\n  // Given a vertex index, calculate its texture coordinates in the source\n  // texture. Texture coordinates are 0..1, 0..1. \n  // For vertex #1 and a texture of 10x10, this will return vec2(0.1, 0.0).\n  // For vertex #1 and a texture of 16,16, this will return vec2(0.0625, 0.0).\n  //\n  vec2 indexToTexCoords(float index) {\n    float yIndex = floor(index / u_resolution); // 0..1\n    float xIndex = mod(index, u_resolution);    // 0..1\n    return vec2(xIndex, yIndex) / u_resolution;\n  }\n\n  const float BASE = 255.0;\n  const float SCALE = 32768.0;\n  const float OFFSET = 16384.0;\n\n  float decodeValue(vec2 channels) {\n    return (dot(channels, vec2(BASE * BASE, BASE)) - OFFSET) / SCALE;\n  }\n  // Decode a pixel value into x,y coordinates (0..1, 0..1)\n  vec2 decode(vec4 pixel) {\n    return vec2(\n      decodeValue(pixel.xy),\n      decodeValue(pixel.zw)\n    );\n  }\n\n  \n  //\n  // Given a vertex coordinate (0..1, 0..1), find UV from texture.\n  // Returns (-0.5..0.5,-0.5..0.5)\n  //\n  vec2 decodeSpeed(vec2 coord) {\n    vec2 invcoord = vec2(coord.x, 1.0 - coord.y);\n    vec4 pixel = texture2D(u_uvtexture, invcoord + 0.5/u_uvresolution);\n    if(pixel.x == 0.0 && pixel.y == 0.0 && pixel.z == 0.0 && pixel.w == 0.0) return vec2(99.0, 99.0);\n    // x-coordinate is RG, y-coordinate is BA:\n    float u = dot(pixel.xy, vec2(255.0 * 255.0, 255.0)) / 65536.0;\n    float v = dot(pixel.zw, vec2(255.0 * 255.0, 255.0)) / 65536.0;\n    return vec2(u - 0.5, v - 0.5);\n  }\n\n\n\n  void main() {\n    // From the vertex's index, get the coordinates in the texture where its\n    // position is stored.\n    vec2 texCoord = indexToTexCoords(a_index);\n\n    // Use the vertex's index to get its current position from the texture,\n    // in the 0..1, 0..1 range.\n    vec2 pos = decode(texture2D(u_texture, texCoord + 0.5/u_resolution));\n\n    // Vertex may be on land. If its speed is 99 according to the UV map,\n    // don't draw it.\n    vec2 speed = decodeSpeed(pos);\n    if(speed.x == 99.0) {\n      v_color = vec4(1.0,1.0,1.0,0.0);\n      return;\n    }\n\n    // Transform position into -1..1 range:\n    pos = pos * 2.0 - 1.0;\n    gl_Position = vec4(pos, 0.0, 1.0);\n\n    // Point size and color:\n    gl_PointSize = u_pointsize;\n    float absspeed = length(speed); // Max U and V are 0.5. Max vector length is then 0.7072\n    v_color = getGradientColor(absspeed / 0.7072);\n\n    // Show some particles in red for easy tracing:\n    // if(a_index < 100.0) {\n    //   v_color = vec4(1.0, 0.0, 0.0, 1.0);\n    //   gl_PointSize = 5.0;\n    // }\n  }\n";
+declare const OutputFragmentShader = "\n  precision mediump float;\n  varying vec4 v_color;\n  \n  void main() {\n    gl_FragColor = vec4(v_color);\n  }\n";
+export { OutputVertexShader, OutputFragmentShader };

package/modules/ParticleGlobe/OutputShader.js

@@ -0,0 +1,4 @@
+import { DecodeSpeed } from "./include/decodeSpeed.include";
+var OutputVertexShader = /*glsl*/ "\n  // Current vertex index:\n  attribute float a_index;\n\n  // Encoded vertices texture:\n  uniform sampler2D u_texture;\n  uniform float u_resolution;\n  \n  // UV texture\n  uniform sampler2D u_uvtexture;\n  uniform float u_uvresolution;  \n\n  // Output: vertex color to draw.\n  varying vec4 v_color;\n\n  // Gradient:\n  uniform float u_gradientStops[12];\n  uniform vec4 u_gradientColors[12];  \n\n  // Point size:\n  uniform float u_pointsize;\n\n  //\n  // Given a value, find its corresponding color in the gradient stops.\n  //\n  vec4 getGradientColor(float position) {\n    // Find left and right stop:\n    float left = -1.0;\n    float right = 99.0;\n    vec4 leftColor;\n    vec4 rightColor;\n\n    for(int i = 0; i < 12; i++) {\n      if (u_gradientStops[i] <= position) {\n        left = u_gradientStops[i]; \n        leftColor = u_gradientColors[i];\n      } else break;\n    }\n\n    for(int i = 12 - 1; i >= 0; i--) {\n      if (u_gradientStops[i] >= position) {\n        right = u_gradientStops[i]; \n        rightColor = u_gradientColors[i];\n      } else break;\n    }\n\n    // Distance between stops:\n    float width = right - left;\n    // Distance from left stop:\n    float dist = position - left;\n    // Right stop weight:\n    float weight;\n    if(dist == 0.0) {\n      weight = dist;\n    } else {\n      weight = dist / width;\n    }\n\n    float r = leftColor.x + (rightColor.x - leftColor.x) * weight;\n    float g = leftColor.y + (rightColor.y - leftColor.y) * weight;\n    float b = leftColor.z + (rightColor.z - leftColor.z) * weight;\n    float a = leftColor.w + (rightColor.w - leftColor.w) * weight;\n    return vec4(r, g, b, a);    \n  }   \n\n  //\n  // Given a vertex index, calculate its texture coordinates in the source\n  // texture. Texture coordinates are 0..1, 0..1. \n  // For vertex #1 and a texture of 10x10, this will return vec2(0.1, 0.0).\n  // For vertex #1 and a texture of 16,16, this will return vec2(0.0625, 0.0).\n  //\n  vec2 indexToTexCoords(float index) {\n    float yIndex = floor(index / u_resolution); // 0..1\n    float xIndex = mod(index, u_resolution);    // 0..1\n    return vec2(xIndex, yIndex) / u_resolution;\n  }\n\n  const float BASE = 255.0;\n  const float SCALE = 32768.0;\n  const float OFFSET = 16384.0;\n\n  float decodeValue(vec2 channels) {\n    return (dot(channels, vec2(BASE * BASE, BASE)) - OFFSET) / SCALE;\n  }\n  // Decode a pixel value into x,y coordinates (0..1, 0..1)\n  vec2 decode(vec4 pixel) {\n    return vec2(\n      decodeValue(pixel.xy),\n      decodeValue(pixel.zw)\n    );\n  }\n\n  ".concat(DecodeSpeed, "\n\n  void main() {\n    // From the vertex's index, get the coordinates in the texture where its\n    // position is stored.\n    vec2 texCoord = indexToTexCoords(a_index);\n\n    // Use the vertex's index to get its current position from the texture,\n    // in the 0..1, 0..1 range.\n    vec2 pos = decode(texture2D(u_texture, texCoord + 0.5/u_resolution));\n\n    // Vertex may be on land. If its speed is 99 according to the UV map,\n    // don't draw it.\n    vec2 speed = decodeSpeed(pos);\n    if(speed.x == 99.0) {\n      v_color = vec4(1.0,1.0,1.0,0.0);\n      return;\n    }\n\n    // Transform position into -1..1 range:\n    pos = pos * 2.0 - 1.0;\n    gl_Position = vec4(pos, 0.0, 1.0);\n\n    // Point size and color:\n    gl_PointSize = u_pointsize;\n    float absspeed = length(speed); // Max U and V are 0.5. Max vector length is then 0.7072\n    v_color = getGradientColor(absspeed / 0.7072);\n\n    // Show some particles in red for easy tracing:\n    // if(a_index < 100.0) {\n    //   v_color = vec4(1.0, 0.0, 0.0, 1.0);\n    //   gl_PointSize = 5.0;\n    // }\n  }\n");
+var OutputFragmentShader = /*glsl*/ "\n  precision mediump float;\n  varying vec4 v_color;\n  \n  void main() {\n    gl_FragColor = vec4(v_color);\n  }\n";
+export { OutputVertexShader, OutputFragmentShader };

package/modules/ParticleGlobe/OutputVertexShaderOld.d.ts

@@ -0,0 +1,2 @@
+declare const OutputVertexShader = "\n  // Current vertex index:\n  attribute float a_index;\n\n  // Encoded vertices texture:\n  uniform sampler2D u_texture;\n  uniform float u_resolution;\n  \n  // UV texture\n  uniform sampler2D u_uvtexture;\n  uniform float u_uvresolution;  \n\n  // Output: vertex color to draw.\n  varying vec4 v_color;\n\n  uniform float u_gradientStops[12];\n  uniform vec4 u_gradientColors[12];  \n\n  //\n  // Given a value, find its corresponding color in the gradient stops.\n  //\n  vec4 getGradientColor(float position) {\n    // Find left and right stop:\n    float left = -1.0;\n    float right = 99.0;\n    vec4 leftColor;\n    vec4 rightColor;\n\n    for(int i = 0; i < 12; i++) {\n      if (u_gradientStops[i] <= position) {\n        left = u_gradientStops[i]; \n        leftColor = u_gradientColors[i];\n      } else break;\n    }\n\n    for(int i = 12 - 1; i >= 0; i--) {\n      if (u_gradientStops[i] >= position) {\n        right = u_gradientStops[i]; \n        rightColor = u_gradientColors[i];\n      } else break;\n    }\n\n    // Distance between stops:\n    float width = right - left;\n    // Distance from left stop:\n    float dist = position - left;\n    // Right stop weight:\n    float weight;\n    if(dist == 0.0) {\n      weight = dist;\n    } else {\n      weight = dist / width;\n    }\n\n    float r = leftColor.x + (rightColor.x - leftColor.x) * weight;\n    float g = leftColor.y + (rightColor.y - leftColor.y) * weight;\n    float b = leftColor.z + (rightColor.z - leftColor.z) * weight;\n    float a = leftColor.w + (rightColor.w - leftColor.w) * weight;\n    return vec4(r, g, b, a);    \n  }   \n\n  //\n  // Given a vertex index, calculate its texture coordinates in the source\n  // texture. Texture coordinates are 0..1, 0..1. \n  // For vertex #1 and a texture of 10x10, this will return vec2(0.1, 0.0).\n  // For vertex #1 and a texture of 16,16, this will return vec2(0.0625, 0.0).\n  //\n  vec2 indexToTexCoords(float index) {\n    float yIndex = floor(index / u_resolution); // 0..1\n    float xIndex = mod(index, u_resolution);    // 0..1\n    return vec2(xIndex, yIndex) / u_resolution;\n  }\n\n  const float BASE = 255.0;\n  const float SCALE = 32768.0;\n  const float OFFSET = 16384.0;\n\n  float decodeValue(vec2 channels) {\n    return (dot(channels, vec2(BASE * BASE, BASE)) - OFFSET) / SCALE;\n  }\n  // Decode a pixel value into x,y coordinates (0..1, 0..1)\n  vec2 decode(vec4 pixel) {\n    return vec2(\n      decodeValue(pixel.xy),\n      decodeValue(pixel.zw)\n    );\n  }\n\n  //\n  // Given a vertex coordinate (0..1, 0..1), find UV from texture.\n  vec2 decodeSpeed(vec2 coord) {\n    vec2 invcoord = vec2(coord.x, 1.0 - coord.y);\n    vec4 pixel = texture2D(u_uvtexture, invcoord + 0.5/u_uvresolution);\n    // pixel = texture2D(u_uvtexture, vec2(0.9, 0.1));\n    if(pixel.w == 0.0) return vec2(99.0, 99.0);\n    return vec2(pixel.x - 0.5, pixel.y - 0.5);\n  }  \n\n  void main() {\n    // From the vertex's index, get the coordinates in the texture where its\n    // position is stored.\n    vec2 texCoord = indexToTexCoords(a_index);\n\n    // Use the vertex's index to get its current position from the texture,\n    // in the 0..1, 0..1 range.\n    vec2 pos = decode(texture2D(u_texture, texCoord + 0.5/u_resolution));\n\n    // Vertex may be on land. If its speed is 99 according to the UV map,\n    // don't draw it.\n    vec2 speed = decodeSpeed(pos);\n    if(speed.x == 99.0) {\n      v_color = vec4(0.0,0.0,0.0,0.0);\n      return;\n    }\n\n    // Transform position into -1..1 range:\n    pos = pos * 2.0 - 1.0;\n\n    gl_Position = vec4(pos, 0.0, 1.0);\n\n    gl_PointSize = 1.0;\n    \n    float absspeed = length(speed); // up to 0.6\n    v_color = getGradientColor(absspeed * 3.5);\n  }\n";
+export { OutputVertexShader };

package/modules/ParticleGlobe/OutputVertexShaderOld.js

@@ -0,0 +1,2 @@
+var OutputVertexShader = /*glsl*/ "\n  // Current vertex index:\n  attribute float a_index;\n\n  // Encoded vertices texture:\n  uniform sampler2D u_texture;\n  uniform float u_resolution;\n  \n  // UV texture\n  uniform sampler2D u_uvtexture;\n  uniform float u_uvresolution;  \n\n  // Output: vertex color to draw.\n  varying vec4 v_color;\n\n  uniform float u_gradientStops[12];\n  uniform vec4 u_gradientColors[12];  \n\n  //\n  // Given a value, find its corresponding color in the gradient stops.\n  //\n  vec4 getGradientColor(float position) {\n    // Find left and right stop:\n    float left = -1.0;\n    float right = 99.0;\n    vec4 leftColor;\n    vec4 rightColor;\n\n    for(int i = 0; i < 12; i++) {\n      if (u_gradientStops[i] <= position) {\n        left = u_gradientStops[i]; \n        leftColor = u_gradientColors[i];\n      } else break;\n    }\n\n    for(int i = 12 - 1; i >= 0; i--) {\n      if (u_gradientStops[i] >= position) {\n        right = u_gradientStops[i]; \n        rightColor = u_gradientColors[i];\n      } else break;\n    }\n\n    // Distance between stops:\n    float width = right - left;\n    // Distance from left stop:\n    float dist = position - left;\n    // Right stop weight:\n    float weight;\n    if(dist == 0.0) {\n      weight = dist;\n    } else {\n      weight = dist / width;\n    }\n\n    float r = leftColor.x + (rightColor.x - leftColor.x) * weight;\n    float g = leftColor.y + (rightColor.y - leftColor.y) * weight;\n    float b = leftColor.z + (rightColor.z - leftColor.z) * weight;\n    float a = leftColor.w + (rightColor.w - leftColor.w) * weight;\n    return vec4(r, g, b, a);    \n  }   \n\n  //\n  // Given a vertex index, calculate its texture coordinates in the source\n  // texture. Texture coordinates are 0..1, 0..1. \n  // For vertex #1 and a texture of 10x10, this will return vec2(0.1, 0.0).\n  // For vertex #1 and a texture of 16,16, this will return vec2(0.0625, 0.0).\n  //\n  vec2 indexToTexCoords(float index) {\n    float yIndex = floor(index / u_resolution); // 0..1\n    float xIndex = mod(index, u_resolution);    // 0..1\n    return vec2(xIndex, yIndex) / u_resolution;\n  }\n\n  const float BASE = 255.0;\n  const float SCALE = 32768.0;\n  const float OFFSET = 16384.0;\n\n  float decodeValue(vec2 channels) {\n    return (dot(channels, vec2(BASE * BASE, BASE)) - OFFSET) / SCALE;\n  }\n  // Decode a pixel value into x,y coordinates (0..1, 0..1)\n  vec2 decode(vec4 pixel) {\n    return vec2(\n      decodeValue(pixel.xy),\n      decodeValue(pixel.zw)\n    );\n  }\n\n  //\n  // Given a vertex coordinate (0..1, 0..1), find UV from texture.\n  vec2 decodeSpeed(vec2 coord) {\n    vec2 invcoord = vec2(coord.x, 1.0 - coord.y);\n    vec4 pixel = texture2D(u_uvtexture, invcoord + 0.5/u_uvresolution);\n    // pixel = texture2D(u_uvtexture, vec2(0.9, 0.1));\n    if(pixel.w == 0.0) return vec2(99.0, 99.0);\n    return vec2(pixel.x - 0.5, pixel.y - 0.5);\n  }  \n\n  void main() {\n    // From the vertex's index, get the coordinates in the texture where its\n    // position is stored.\n    vec2 texCoord = indexToTexCoords(a_index);\n\n    // Use the vertex's index to get its current position from the texture,\n    // in the 0..1, 0..1 range.\n    vec2 pos = decode(texture2D(u_texture, texCoord + 0.5/u_resolution));\n\n    // Vertex may be on land. If its speed is 99 according to the UV map,\n    // don't draw it.\n    vec2 speed = decodeSpeed(pos);\n    if(speed.x == 99.0) {\n      v_color = vec4(0.0,0.0,0.0,0.0);\n      return;\n    }\n\n    // Transform position into -1..1 range:\n    pos = pos * 2.0 - 1.0;\n\n    gl_Position = vec4(pos, 0.0, 1.0);\n\n    gl_PointSize = 1.0;\n    \n    float absspeed = length(speed); // up to 0.6\n    v_color = getGradientColor(absspeed * 3.5);\n  }\n";
+export { OutputVertexShader };

package/modules/ParticleGlobe/ParticleGlobe.d.ts

@@ -0,0 +1,91 @@
+import * as React from 'react';
+import { IGradientStop } from '../../map/layers/InterpolationLayer/IGradientStop';
+interface IProps {
+    /** @ignore */
+    className?: string;
+    /**
+     * Gradient stops. A default gradient is preset.
+     */
+    gradientStops?: IGradientStop[];
+    /**
+     * Number of particles.
+     * @default 100000;
+     */
+    numParticles?: number;
+    /**
+     * If true, renders a globe. Otherwise a flat map.
+     * @default false
+     */
+    globe?: boolean;
+    /**
+     * The original particle speed (in m/s) is divided by this factor to calculate
+     * the final particle speed in pixels/frame.
+     * @edefault 1000.0
+     */
+    speedFactor?: number;
+    /**
+     * If not 0, draw particle trails. The value is the fade strength.
+     * @default 0
+     */
+    trails?: number;
+    /**
+     * Point size (in pixels). Minimum is 1.
+     * @default 1
+     */
+    pointSize?: number;
+    /**
+     * X-axis angle, in degrees (0-360)
+     * @default 15
+     */
+    angleX?: number;
+    /**
+     * Y-axis angle, in degrees (0-360)
+     * @default 0
+     */
+    angleY?: number;
+    /**
+     * X-axis (horizontal axis) rotation per frame, in degrees (0-360)
+     * @default 0
+     */
+    deltaX?: number;
+    /**
+     * Y-axis (vertical axis) rotation per frame, in degrees (0-360)
+     * @default 0.02
+     */
+    deltaY?: number;
+    /**
+     * If true, draw landmass outlines.
+     * @default false
+     */
+    outlines?: boolean;
+    /**
+     * @default 60
+     */
+    minLifetime?: number;
+    /**
+     * @default 1000
+     */
+    maxLifetime?: number;
+    /**
+     * Adds an aura to the globe. This is the thickness of the aura, in pixels.
+     * @default 0
+     */
+    glow?: number;
+    /**
+     * Landmass display.
+     * @default none
+     */
+    landmass?: 'day' | 'night' | 'none';
+    /**
+     * Landmass brightness.
+     * @default 1.0
+     */
+    brightness?: number;
+    /**
+     * If set, globe rotates slightly when the mouse approximates the corners of the viewport.
+     * @default false
+     */
+    responsive?: boolean;
+}
+declare const ParticleGlobe: ({ numParticles, globe, trails, pointSize, angleX, angleY, deltaX, deltaY, outlines, minLifetime, maxLifetime, glow, landmass, brightness, speedFactor, responsive, gradientStops, ...props }: IProps) => React.JSX.Element;
+export { ParticleGlobe };