@cosmos.gl/graph 2.6.2 → 2.7.0-beta.0

package/src/modules/Points/draw-points.vert

@@ -0,0 +1,203 @@
+#version 300 es
+#ifdef GL_ES
+precision highp float;
+#endif
+
+in vec2 pointIndices;
+in float size;
+in vec4 color;
+in float shape;
+in float imageIndex;
+in float imageSize;
+
+uniform sampler2D positionsTexture;
+uniform sampler2D pointGreyoutStatus;
+uniform sampler2D imageAtlasCoords;
+
+#ifdef USE_UNIFORM_BUFFERS
+layout(std140) uniform drawVertexUniforms {
+  float ratio;
+  mat4 transformationMatrix;
+  float pointsTextureSize;
+  float sizeScale;
+  float spaceSize;
+  vec2 screenSize;
+  vec4 greyoutColor;
+  vec4 backgroundColor;
+  float scalePointsOnZoom;
+  float maxPointSize;
+  float isDarkenGreyout;
+  float skipSelected;
+  float skipUnselected;
+  float hasImages;
+  float imageCount;
+  float imageAtlasCoordsTextureSize;
+} drawVertex;
+
+#define ratio drawVertex.ratio
+#define transformationMatrix drawVertex.transformationMatrix
+#define pointsTextureSize drawVertex.pointsTextureSize
+#define sizeScale drawVertex.sizeScale
+#define spaceSize drawVertex.spaceSize
+#define screenSize drawVertex.screenSize
+#define greyoutColor drawVertex.greyoutColor
+#define backgroundColor drawVertex.backgroundColor
+#define scalePointsOnZoom drawVertex.scalePointsOnZoom
+#define maxPointSize drawVertex.maxPointSize
+#define isDarkenGreyout drawVertex.isDarkenGreyout
+#define skipSelected drawVertex.skipSelected
+#define skipUnselected drawVertex.skipUnselected
+#define hasImages drawVertex.hasImages
+#define imageCount drawVertex.imageCount
+#define imageAtlasCoordsTextureSize drawVertex.imageAtlasCoordsTextureSize
+#else
+uniform float ratio;
+uniform mat3 transformationMatrix;
+uniform float pointsTextureSize;
+uniform float sizeScale;
+uniform float spaceSize;
+uniform vec2 screenSize;
+uniform vec4 greyoutColor;
+uniform vec4 backgroundColor;
+uniform float scalePointsOnZoom;
+uniform float maxPointSize;
+uniform float isDarkenGreyout;
+uniform float skipSelected;
+uniform float skipUnselected;
+uniform float hasImages;
+uniform float imageCount;
+uniform float imageAtlasCoordsTextureSize;
+#endif
+
+out float pointShape;
+out float isGreyedOut;
+out vec4 shapeColor;
+out vec4 imageAtlasUV;
+out float shapeSize;
+out float imageSizeVarying;
+out float overallSize;
+
+float calculatePointSize(float size) {
+  float pSize;
+
+  if (scalePointsOnZoom > 0.0) { 
+    pSize = size * ratio * transformationMatrix[0][0];
+  } else {
+    pSize = size * ratio * min(5.0, max(1.0, transformationMatrix[0][0] * 0.01));
+  }
+
+  return min(pSize, maxPointSize * ratio);
+}
+
+void main() {    
+  // Check greyout status for selective rendering
+  vec4 greyoutStatus = texture(pointGreyoutStatus, (pointIndices + 0.5) / pointsTextureSize);
+  isGreyedOut = greyoutStatus.r;
+  float isSelected = (greyoutStatus.r == 0.0) ? 1.0 : 0.0;
+  
+  // Discard point based on rendering mode
+  if (skipSelected > 0.0 && isSelected > 0.0) {
+    gl_Position = vec4(2.0, 2.0, 2.0, 1.0); // Move off-screen
+    gl_PointSize = 0.0;
+    return;
+  }
+  if (skipUnselected > 0.0 && isSelected <= 0.0) {
+    gl_Position = vec4(2.0, 2.0, 2.0, 1.0); // Move off-screen
+    gl_PointSize = 0.0;
+    return;
+  }
+  
+  // Position
+  vec4 pointPosition = texture(positionsTexture, (pointIndices + 0.5) / pointsTextureSize);
+  vec2 point = pointPosition.rg;
+
+  // Transform point position to normalized device coordinates
+  // Convert from space coordinates [0, spaceSize] to normalized [-1, 1]
+  vec2 normalizedPosition = 2.0 * point / spaceSize - 1.0;
+  
+  // Apply aspect ratio correction - this is needed to map the square space to the rectangular screen
+  // The transformation matrix handles zoom/pan, but we need this to handle aspect ratio
+  normalizedPosition *= spaceSize / screenSize;
+  
+  #ifdef USE_UNIFORM_BUFFERS
+  mat3 transformMat3 = mat3(transformationMatrix);
+  vec3 finalPosition = transformMat3 * vec3(normalizedPosition, 1);
+  #else
+  vec3 finalPosition = transformationMatrix * vec3(normalizedPosition, 1);
+  #endif
+  gl_Position = vec4(finalPosition.rg, 0, 1);
+
+  // Calculate sizes for shape and image
+  float shapeSizeValue = calculatePointSize(size * sizeScale);
+  float imageSizeValue = calculatePointSize(imageSize * sizeScale);
+  
+  // Use the larger of the two sizes for the overall point size
+  float overallSizeValue = max(shapeSizeValue, imageSizeValue);
+  gl_PointSize = overallSizeValue;
+
+  // Pass size information to fragment shader
+  shapeSize = shapeSizeValue;
+  imageSizeVarying = imageSizeValue;
+  overallSize = overallSizeValue;
+
+  shapeColor = color;
+  pointShape = shape;
+
+  // Adjust alpha of selected points
+  if (isGreyedOut > 0.0) {
+    if (greyoutColor[0] != -1.0) {
+      shapeColor = greyoutColor;
+    } else {
+      // If greyoutColor is not set, make color lighter or darker based on isDarkenGreyout
+      float blendFactor = 0.65; // Controls how much to modify (0.0 = original, 1.0 = target color)
+      
+      #ifdef USE_UNIFORM_BUFFERS
+      if (isDarkenGreyout > 0.0) {
+        // Darken the color
+        shapeColor.rgb = mix(shapeColor.rgb, vec3(0.2), blendFactor);
+      } else {
+        // Lighten the color
+        shapeColor.rgb = mix(shapeColor.rgb, max(backgroundColor.rgb, vec3(0.8)), blendFactor);
+      }
+      #else
+      if (isDarkenGreyout > 0.0) {
+        // Darken the color
+        shapeColor.rgb = mix(shapeColor.rgb, vec3(0.2), blendFactor);
+      } else {
+        // Lighten the color
+        shapeColor.rgb = mix(shapeColor.rgb, max(backgroundColor.rgb, vec3(0.8)), blendFactor);
+      }
+      #endif
+    }
+  }
+
+  #ifdef USE_UNIFORM_BUFFERS
+  if (hasImages <= 0.0 || imageIndex < 0.0 || imageIndex >= imageCount) {
+    imageAtlasUV = vec4(-1.0);
+  } else {
+    // Calculate image atlas UV coordinates based on imageIndex
+    float atlasCoordIndex = imageIndex;
+    // Calculate the position in the texture grid
+    float texX = mod(atlasCoordIndex, imageAtlasCoordsTextureSize);
+    float texY = floor(atlasCoordIndex / imageAtlasCoordsTextureSize);
+    // Convert to texture coordinates (0.0 to 1.0)
+    vec2 atlasCoordTexCoord = (vec2(texX, texY) + 0.5) / imageAtlasCoordsTextureSize;
+    vec4 atlasCoords = texture(imageAtlasCoords, atlasCoordTexCoord);
+    imageAtlasUV = atlasCoords;
+  }
+  #else
+  if (hasImages <= 0.0 || imageIndex < 0.0 || imageIndex >= imageCount) {
+    imageAtlasUV = vec4(-1.0);
+  } else {
+    // Calculate image atlas UV coordinates based on imageIndex
+    float atlasCoordIndex = imageIndex;
+    // Calculate the position in the texture grid
+    float texX = mod(atlasCoordIndex, imageAtlasCoordsTextureSize);
+    float texY = floor(atlasCoordIndex / imageAtlasCoordsTextureSize);
+    // Convert to texture coordinates (0.0 to 1.0)
+    vec2 atlasCoordTexCoord = (vec2(texX, texY) + 0.5) / imageAtlasCoordsTextureSize;
+    vec4 atlasCoords = texture(imageAtlasCoords, atlasCoordTexCoord);
+    imageAtlasUV = atlasCoords;
+  }
+  #endif
+} 

package/src/modules/Points/fill-sampled-points.frag

@@ -0,0 +1,12 @@
+#version 300 es
+#ifdef GL_ES
+precision highp float;
+#endif
+
+in vec4 rgba;
+
+out vec4 fragColor;
+
+void main() {
+  fragColor = rgba;
+}

package/src/modules/Points/fill-sampled-points.vert

@@ -0,0 +1,51 @@
+#version 300 es
+#ifdef GL_ES
+precision highp float;
+#endif
+
+in vec2 pointIndices;
+
+uniform sampler2D positionsTexture;
+
+#ifdef USE_UNIFORM_BUFFERS
+layout(std140) uniform fillSampledPointsUniforms {
+  float pointsTextureSize;
+  mat4 transformationMatrix;
+  float spaceSize;
+  vec2 screenSize;
+} fillSampledPoints;
+
+#define pointsTextureSize fillSampledPoints.pointsTextureSize
+#define transformationMatrix fillSampledPoints.transformationMatrix
+#define spaceSize fillSampledPoints.spaceSize
+#define screenSize fillSampledPoints.screenSize
+#else
+uniform float pointsTextureSize;
+uniform float spaceSize;
+uniform vec2 screenSize;
+uniform mat3 transformationMatrix;
+#endif
+
+out vec4 rgba;
+
+void main() {
+  vec4 pointPosition = texture(positionsTexture, (pointIndices + 0.5) / pointsTextureSize);
+  vec2 p = 2.0 * pointPosition.rg / spaceSize - 1.0;
+  p *= spaceSize / screenSize;
+  #ifdef USE_UNIFORM_BUFFERS
+  // Convert mat4 to mat3 for vec3 multiplication
+  mat3 transformMat3 = mat3(transformationMatrix);
+  vec3 final = transformMat3 * vec3(p, 1);
+  #else
+  vec3 final = transformationMatrix * vec3(p, 1);
+  #endif
+
+  vec2 pointScreenPosition = (final.xy + 1.0) * screenSize / 2.0;
+  float index = pointIndices.g * pointsTextureSize + pointIndices.r;
+  rgba = vec4(index, 1.0, pointPosition.xy);
+  float i = (pointScreenPosition.x + 0.5) / screenSize.x;
+  float j = (pointScreenPosition.y + 0.5) / screenSize.y;
+  gl_Position = vec4(2.0 * vec2(i, j) - 1.0, 0.0, 1.0);
+
+  gl_PointSize = 1.0;
+}

package/src/modules/Points/find-hovered-point.frag

@@ -0,0 +1,15 @@
+#version 300 es
+#ifdef GL_ES
+precision highp float;
+#endif
+
+in vec4 rgba;
+
+out vec4 fragColor;
+
+void main() {
+  if (rgba.g <= 0.0) {
+    discard;
+  }
+  fragColor = rgba;
+}

package/src/modules/Points/find-hovered-point.vert

@@ -0,0 +1,90 @@
+#version 300 es
+#ifdef GL_ES
+precision highp float;
+#endif
+
+in vec2 pointIndices;
+in float size;
+
+uniform sampler2D positionsTexture;
+
+#ifdef USE_UNIFORM_BUFFERS
+layout(std140) uniform findHoveredPointUniforms {
+  float pointsTextureSize;
+  float sizeScale;
+  float spaceSize;
+  vec2 screenSize;
+  float ratio;
+  mat4 transformationMatrix;
+  vec2 mousePosition;
+  float scalePointsOnZoom;
+  float maxPointSize;
+} findHoveredPoint;
+
+#define pointsTextureSize findHoveredPoint.pointsTextureSize
+#define sizeScale findHoveredPoint.sizeScale
+#define spaceSize findHoveredPoint.spaceSize
+#define screenSize findHoveredPoint.screenSize
+#define ratio findHoveredPoint.ratio
+#define transformationMatrix findHoveredPoint.transformationMatrix
+#define mousePosition findHoveredPoint.mousePosition
+#define scalePointsOnZoom findHoveredPoint.scalePointsOnZoom
+#define maxPointSize findHoveredPoint.maxPointSize
+#else
+uniform float pointsTextureSize;
+uniform float sizeScale;
+uniform float spaceSize;
+uniform vec2 screenSize;
+uniform float ratio;
+uniform mat3 transformationMatrix;
+uniform vec2 mousePosition;
+uniform float scalePointsOnZoom;
+uniform float maxPointSize;
+#endif
+
+out vec4 rgba;
+
+float calculatePointSize(float size) {
+  float pSize;
+
+  if (scalePointsOnZoom > 0.0) { 
+    pSize = size * ratio * transformationMatrix[0][0];
+  } else {
+    pSize = size * ratio * min(5.0, max(1.0, transformationMatrix[0][0] * 0.01));
+  }
+
+  return min(pSize, maxPointSize * ratio);
+}
+
+float euclideanDistance (float x1, float x2, float y1, float y2) {
+  return sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
+}
+
+void main() {
+  vec4 pointPosition = texture(positionsTexture, (pointIndices + 0.5) / pointsTextureSize);
+  vec2 point = pointPosition.rg;
+
+  vec2 normalizedPosition = 2.0 * point / spaceSize - 1.0;
+  normalizedPosition *= spaceSize / screenSize;
+  
+  #ifdef USE_UNIFORM_BUFFERS
+  mat3 transformMat3 = mat3(transformationMatrix);
+  vec3 finalPosition = transformMat3 * vec3(normalizedPosition, 1);
+  #else
+  vec3 finalPosition = transformationMatrix * vec3(normalizedPosition, 1);
+  #endif
+
+  float pointRadius = 0.5 * calculatePointSize(size * sizeScale);
+  vec2 pointScreenPosition = (finalPosition.xy + 1.0) * screenSize / 2.0;
+  
+  rgba = vec4(0.0);
+  gl_Position = vec4(0.5, 0.5, 0.0, 1.0);
+  
+  if (euclideanDistance(pointScreenPosition.x, mousePosition.x, pointScreenPosition.y, mousePosition.y) < pointRadius / ratio) {
+    float index = pointIndices.g * pointsTextureSize + pointIndices.r;
+    rgba = vec4(index, size, pointPosition.xy);
+    gl_Position = vec4(-0.5, -0.5, 0.0, 1.0);
+  }
+
+  gl_PointSize = 1.0;
+}

package/src/modules/Points/find-points-on-area-selection.frag

@@ -0,0 +1,88 @@
+#version 300 es
+#ifdef GL_ES
+precision highp float;
+#endif
+
+uniform sampler2D positionsTexture;
+uniform sampler2D pointSize;
+
+#ifdef USE_UNIFORM_BUFFERS
+layout(std140) uniform findPointsOnAreaSelectionUniforms {
+  float sizeScale;
+  float spaceSize;
+  vec2 screenSize;
+  float ratio;
+  mat4 transformationMatrix;
+  vec2 selection0;
+  vec2 selection1;
+  float scalePointsOnZoom;
+  float maxPointSize;
+} findPointsOnAreaSelection;
+
+#define sizeScale findPointsOnAreaSelection.sizeScale
+#define spaceSize findPointsOnAreaSelection.spaceSize
+#define screenSize findPointsOnAreaSelection.screenSize
+#define ratio findPointsOnAreaSelection.ratio
+#define transformationMatrix findPointsOnAreaSelection.transformationMatrix
+#define selection0 findPointsOnAreaSelection.selection0
+#define selection1 findPointsOnAreaSelection.selection1
+#define scalePointsOnZoom findPointsOnAreaSelection.scalePointsOnZoom
+#define maxPointSize findPointsOnAreaSelection.maxPointSize
+#else
+uniform float sizeScale;
+uniform float spaceSize;
+uniform vec2 screenSize;
+uniform float ratio;
+uniform mat3 transformationMatrix;
+uniform vec2 selection0;
+uniform vec2 selection1;
+uniform float scalePointsOnZoom;
+uniform float maxPointSize;
+#endif
+
+in vec2 textureCoords;
+
+out vec4 fragColor;
+
+float pointSizeF(float size) {
+  float pSize;
+  // Extract top-left element from mat4 (or use mat3 conversion)
+  #ifdef USE_UNIFORM_BUFFERS
+  float scale = transformationMatrix[0][0]; // mat4 first element
+  #else
+  float scale = transformationMatrix[0][0]; // mat3 first element
+  #endif
+  if (scalePointsOnZoom > 0.0) { 
+    pSize = size * ratio * scale;
+  } else {
+    pSize = size * ratio * min(5.0, max(1.0, scale * 0.01));
+  }
+  return min(pSize, maxPointSize * ratio);
+}
+
+void main() {
+  vec4 pointPosition = texture(positionsTexture, textureCoords);
+  vec2 p = 2.0 * pointPosition.rg / spaceSize - 1.0;
+  p *= spaceSize / screenSize;
+  #ifdef USE_UNIFORM_BUFFERS
+  // Convert mat4 to mat3 for vec3 multiplication
+  mat3 transformMat3 = mat3(transformationMatrix);
+  vec3 final = transformMat3 * vec3(p, 1);
+  #else
+  vec3 final = transformationMatrix * vec3(p, 1);
+  #endif
+
+  vec4 pSize = texture(pointSize, textureCoords);
+  float size = pSize.r * sizeScale;
+
+  float left = 2.0 * (selection0.x - 0.5 * pointSizeF(size)) / screenSize.x - 1.0;
+  float right = 2.0 * (selection1.x + 0.5 * pointSizeF(size)) / screenSize.x - 1.0;
+  float top =  2.0 * (selection0.y - 0.5 * pointSizeF(size)) / screenSize.y - 1.0;
+  float bottom =  2.0 * (selection1.y + 0.5 * pointSizeF(size)) / screenSize.y - 1.0;
+
+  fragColor = vec4(0.0, 0.0, pointPosition.r, pointPosition.g);
+  if (final.x >= left && final.x <= right && final.y >= top && final.y <= bottom) {
+    fragColor.r = 1.0;
+  }
+}
+

package/src/modules/Points/find-points-on-polygon-selection.frag

@@ -0,0 +1,89 @@
+#version 300 es
+#ifdef GL_ES
+precision highp float;
+#endif
+
+uniform sampler2D positionsTexture;
+uniform sampler2D polygonPathTexture; // Texture containing polygon path points
+
+#ifdef USE_UNIFORM_BUFFERS
+layout(std140) uniform findPointsOnPolygonSelectionUniforms {
+  float spaceSize;
+  vec2 screenSize;
+  mat4 transformationMatrix;
+  float polygonPathLength;
+} findPointsOnPolygonSelection;
+
+#define spaceSize findPointsOnPolygonSelection.spaceSize
+#define screenSize findPointsOnPolygonSelection.screenSize
+#define transformationMatrix findPointsOnPolygonSelection.transformationMatrix
+#define polygonPathLength int(findPointsOnPolygonSelection.polygonPathLength)
+#else
+uniform int polygonPathLength;
+uniform float spaceSize;
+uniform vec2 screenSize;
+uniform mat3 transformationMatrix;
+#endif
+
+in vec2 textureCoords;
+
+out vec4 fragColor;
+
+// Get a point from the polygon path texture at a specific index
+vec2 getPolygonPoint(sampler2D pathTexture, int index, int pathLength) {
+  if (index >= pathLength) return vec2(0.0);
+  
+  // Calculate texture coordinates for the index
+  int textureSize = int(ceil(sqrt(float(pathLength))));
+  int x = index - (index / textureSize) * textureSize;
+  int y = index / textureSize;
+  
+  vec2 texCoord = (vec2(float(x), float(y)) + 0.5) / float(textureSize);
+  vec4 pathData = texture(pathTexture, texCoord);
+  
+  return pathData.xy;
+}
+
+// Point-in-polygon algorithm using ray casting
+bool pointInPolygon(vec2 point, sampler2D pathTexture, int pathLength) {
+  bool inside = false;
+  
+  for (int i = 0; i < 2048; i++) {
+    if (i >= pathLength) break;
+    
+    int j = int(mod(float(i + 1), float(pathLength)));
+    
+    vec2 pi = getPolygonPoint(pathTexture, i, pathLength);
+    vec2 pj = getPolygonPoint(pathTexture, j, pathLength);
+    
+    if (((pi.y > point.y) != (pj.y > point.y)) &&
+        (point.x < (pj.x - pi.x) * (point.y - pi.y) / (pj.y - pi.y) + pi.x)) {
+      inside = !inside;
+    }
+  }
+  
+  return inside;
+}
+
+void main() {
+  vec4 pointPosition = texture(positionsTexture, textureCoords);
+  vec2 p = 2.0 * pointPosition.rg / spaceSize - 1.0;
+  p *= spaceSize / screenSize;
+  #ifdef USE_UNIFORM_BUFFERS
+  // Convert mat4 to mat3 for vec3 multiplication
+  mat3 transformMat3 = mat3(transformationMatrix);
+  vec3 final = transformMat3 * vec3(p, 1);
+  #else
+  vec3 final = transformationMatrix * vec3(p, 1);
+  #endif
+
+  // Convert to screen coordinates for polygon check
+  vec2 screenPos = (final.xy + 1.0) * screenSize / 2.0;
+  
+  fragColor = vec4(0.0, 0.0, pointPosition.r, pointPosition.g);
+  
+  // Check if point center is inside the polygon
+  if (pointInPolygon(screenPos, polygonPathTexture, polygonPathLength)) {
+    fragColor.r = 1.0;
+  }
+}