@cosmos.gl/graph 2.6.0 → 2.6.2-rc.0

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

@@ -1,243 +0,0 @@
-// Fragment shader for rendering points with various shapes and smooth edges
-
-#ifdef GL_ES
-precision highp float;
-#endif
-
-uniform float greyoutOpacity;
-uniform float pointOpacity;
-uniform sampler2D imageAtlasTexture;
-uniform bool isDarkenGreyout;
-uniform vec4 backgroundColor;
-
-
-varying float pointShape;
-varying float isGreyedOut;
-varying vec4 shapeColor;
-varying vec4 imageAtlasUV;
-varying float shapeSize;
-varying float imageSizeVarying;
-varying float overallSize;
-
-// Smoothing controls the smoothness of the point's edge
-const float smoothing = 0.9;
-
-// Shape constants
-const float CIRCLE = 0.0;
-const float SQUARE = 1.0;
-const float TRIANGLE = 2.0;
-const float DIAMOND = 3.0;
-const float PENTAGON = 4.0;
-const float HEXAGON = 5.0;
-const float STAR = 6.0;
-const float CROSS = 7.0;
-const float NONE = 8.0;
-
-// Distance functions for different shapes
-float circleDistance(vec2 p) {
-    return dot(p, p);
-}
-
-// Function to apply greyout logic to image colors
-vec4 applyGreyoutToImage(vec4 imageColor) {
-    vec3 finalColor = imageColor.rgb;
-    float finalAlpha = imageColor.a;
-    
-    if (isGreyedOut > 0.0) {
-        float blendFactor = 0.65; // Controls how much to modify (0.0 = original, 1.0 = target color)
-        
-        if (isDarkenGreyout) {
-            finalColor = mix(finalColor, vec3(0.2), blendFactor);
-        } else {
-            finalColor = mix(finalColor, max(backgroundColor.rgb, vec3(0.8)), blendFactor);
-        }
-    }
-    
-    return vec4(finalColor, finalAlpha);
-}
-
-float squareDistance(vec2 p) {
-    vec2 d = abs(p) - vec2(0.8);
-    return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);
-}
-
-float triangleDistance(vec2 p) {
-    const float k = sqrt(3.0);   // ≈1.732; slope of 60° lines for an equilateral triangle
-    p.x = abs(p.x) - 0.9;        // fold the X axis and shift: brings left and right halves together
-    p.y = p.y + 0.55;             // move the whole shape up slightly so it is centred vertically
-
-    // reflect points that fall outside the main triangle back inside, to reuse the same maths
-    if (p.x + k * p.y > 0.0)
-        p = vec2(p.x - k * p.y,  -k * p.x - p.y) / 2.0;
-
-    p.x -= clamp(p.x, -1.0, 0.0); // clip any remainder on the left side
-
-    // Return signed distance: negative = inside; positive = outside
-    return -length(p) * sign(p.y);
-}
-
-float diamondDistance(vec2 p) {
-    // aspect > 1  →  taller diamond
-    const float aspect = 1.2;
-    return abs(p.x) + abs(p.y) / aspect - 0.8;
-}
-
-float pentagonDistance(vec2 p) {
-    // Regular pentagon signed-distance (Inigo Quilez)
-    const vec3 k = vec3(0.809016994, 0.587785252, 0.726542528);
-    p.x = abs(p.x);
-
-    // Reflect across the two tilted edges ─ only if point is outside
-    p -= 2.0 * min(dot(vec2(-k.x, k.y), p), 0.0) * vec2(-k.x, k.y);
-    p -= 2.0 * min(dot(vec2( k.x, k.y), p), 0.0) * vec2( k.x, k.y);
-
-    // Clip against the top horizontal edge (keeps top point sharp)
-    p -= vec2(clamp(p.x, -k.z * k.x, k.z * k.x), k.z);
-
-    // Return signed distance (negative → inside, positive → outside)
-    return length(p) * sign(p.y);
-}
-
-float hexagonDistance(vec2 p) {
-    const vec3 k = vec3(-0.866025404, 0.5, 0.577350269);
-    p = abs(p);
-    p -= 2.0 * min(dot(k.xy, p), 0.0) * k.xy;
-    p -= vec2(clamp(p.x, -k.z * 0.8, k.z * 0.8), 0.8);
-    return length(p) * sign(p.y);
-}
-
-float starDistance(vec2 p) {
-    // 5-point star signed-distance function (adapted from Inigo Quilez)
-    // r  – outer radius, rf – inner/outer radius ratio
-    const float r  = 0.9;
-    const float rf = 0.45;
-
-    // Pre-computed rotation vectors for the star arms (36° increments)
-    const vec2 k1 = vec2(0.809016994, -0.587785252);
-    const vec2 k2 = vec2(-k1.x, k1.y);
-
-    // Fold the plane into a single arm sector
-    p.x = abs(p.x);
-    p -= 2.0 * max(dot(k1, p), 0.0) * k1;
-    p -= 2.0 * max(dot(k2, p), 0.0) * k2;
-    p.x = abs(p.x);
-
-    // Translate so the top tip of the star lies on the X-axis
-    p.y -= r;
-
-    // Vector describing the edge between an outer tip and its adjacent inner point
-    vec2 ba = rf * vec2(-k1.y, k1.x) - vec2(0.0, 1.0);
-    // Project the point onto that edge and clamp the projection to the segment
-    float h = clamp(dot(p, ba) / dot(ba, ba), 0.0, r);
-
-    // Return signed distance (negative => inside, positive => outside)
-    return length(p - ba * h) * sign(p.y * ba.x - p.x * ba.y);
-}
-
-float crossDistance(vec2 p) {
-    // Signed distance function for a cross (union of two rectangles)
-    // Adapted from Inigo Quilez (https://iquilezles.org/)
-    // Each arm has half-sizes 0.3 (thickness) and 0.8 (length)
-    p = abs(p);
-    if (p.y > p.x) p = p.yx;       // exploit symmetry
-
-    vec2 q = p - vec2(0.8, 0.3);   // subtract half-sizes (length, thickness)
-
-    // Standard rectangle SDF, then take union of the two arms
-    return length(max(q, 0.0)) + min(max(q.x, q.y), 0.0);
-}
-
-float getShapeDistance(vec2 p, float shape) {
-    if (shape == SQUARE) return squareDistance(p);
-    else if (shape == TRIANGLE) return triangleDistance(p);
-    else if (shape == DIAMOND) return diamondDistance(p);
-    else if (shape == PENTAGON) return pentagonDistance(p);
-    else if (shape == HEXAGON) return hexagonDistance(p);
-    else if (shape == STAR) return starDistance(p);
-    else if (shape == CROSS) return crossDistance(p);
-    else return circleDistance(p); // Default to circle
-}
-
-void main() {
-    // Discard the fragment if the point is fully transparent and has no image
-    if (shapeColor.a == 0.0 && imageAtlasUV.x == -1.0) {
-        discard;
-    }
-
-    // Discard the fragment if the point has no shape and no image
-    if (pointShape == NONE && imageAtlasUV.x == -1.0) {
-        discard;
-    }
-
-    // Calculate coordinates within the point
-    vec2 pointCoord = 2.0 * gl_PointCoord - 1.0;
-
-    vec4 finalShapeColor = vec4(0.0);
-    vec4 finalImageColor = vec4(0.0);
-    
-    // Handle shape rendering with centering logic
-    if (pointShape != NONE) {
-        // Calculate shape coordinates with centering
-        vec2 shapeCoord = pointCoord;
-        if (overallSize > shapeSize && shapeSize > 0.0) {
-            // Shape is smaller than overall size, center it
-            float scale = shapeSize / overallSize;
-            shapeCoord = pointCoord / scale;
-        }
-        
-        float opacity;
-        if (pointShape == CIRCLE) {
-            // For circles, use the original distance calculation
-            float pointCenterDistance = dot(shapeCoord, shapeCoord);
-            opacity = 1.0 - smoothstep(smoothing, 1.0, pointCenterDistance);
-        } else {
-            // For other shapes, use the shape distance function
-            float shapeDistance = getShapeDistance(shapeCoord, pointShape);
-            opacity = 1.0 - smoothstep(-0.01, 0.01, shapeDistance);
-        }
-        opacity *= shapeColor.a;
-
-        finalShapeColor = vec4(shapeColor.rgb, opacity);
-    }
-
-    // Handle image rendering with centering logic
-    if (imageAtlasUV.x != -1.0) {
-        // Calculate image coordinates with centering
-        vec2 imageCoord = pointCoord;
-        if (overallSize > imageSizeVarying && imageSizeVarying > 0.0) {
-            // Image is smaller than overall size, center it
-            float scale = imageSizeVarying / overallSize;
-            imageCoord = pointCoord / scale;
-            
-            // Check if we're outside the valid image area
-            if (abs(imageCoord.x) > 1.0 || abs(imageCoord.y) > 1.0) {
-                // We're outside the image bounds, don't render the image
-                finalImageColor = vec4(0.0);
-            } else {
-                // Sample from texture atlas
-                vec2 atlasUV = mix(imageAtlasUV.xy, imageAtlasUV.zw, (imageCoord + 1.0) * 0.5);
-                vec4 imageColor = texture2D(imageAtlasTexture, atlasUV);
-                finalImageColor = applyGreyoutToImage(imageColor);
-            }
-        } else {
-            // Image is same size or larger than overall size, no scaling needed
-            // Sample from texture atlas
-            vec2 atlasUV = mix(imageAtlasUV.xy, imageAtlasUV.zw, (imageCoord + 1.0) * 0.5);
-            vec4 imageColor = texture2D(imageAtlasTexture, atlasUV);
-            finalImageColor = applyGreyoutToImage(imageColor);
-        }
-    }
-
-    float finalPointAlpha = max(finalShapeColor.a, finalImageColor.a);
-    if (isGreyedOut > 0.0 && greyoutOpacity != -1.0) {
-        finalPointAlpha *= greyoutOpacity;
-    } else {
-        finalPointAlpha *= pointOpacity;
-    }
-
-    // Blend image color above point color
-    gl_FragColor = vec4(
-        mix(finalShapeColor.rgb, finalImageColor.rgb, finalImageColor.a),
-        finalPointAlpha
-    );
-}

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

@@ -1,127 +0,0 @@
-#ifdef GL_ES
-precision highp float;
-#endif
-
-attribute vec2 pointIndices;
-attribute float size;
-attribute vec4 color;
-attribute float shape;
-attribute float imageIndex;
-attribute float imageSize;
-
-uniform sampler2D positionsTexture;
-uniform sampler2D pointGreyoutStatus;
-uniform sampler2D imageAtlasCoords;
-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 bool scalePointsOnZoom;
-uniform float maxPointSize;
-uniform bool isDarkenGreyout;
-uniform bool skipSelected;
-uniform bool skipUnselected;
-uniform bool hasImages;
-uniform float imageCount;
-uniform float imageAtlasCoordsTextureSize;
-
-varying float pointShape;
-varying float isGreyedOut;
-varying vec4 shapeColor;
-varying vec4 imageAtlasUV;
-varying float shapeSize;
-varying float imageSizeVarying;
-varying float overallSize;
-
-float calculatePointSize(float size) {
-  float pSize;
-  if (scalePointsOnZoom) { 
-    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 = texture2D(pointGreyoutStatus, (pointIndices + 0.5) / pointsTextureSize);
-  isGreyedOut = greyoutStatus.r;
-  bool isSelected = greyoutStatus.r == 0.0;
-  
-  // Discard point based on rendering mode
-  if (skipSelected && isSelected) {
-    gl_Position = vec4(2.0, 2.0, 2.0, 1.0); // Move off-screen
-    gl_PointSize = 0.0;
-    return;
-  }
-  if (skipUnselected && !isSelected) {
-    gl_Position = vec4(2.0, 2.0, 2.0, 1.0); // Move off-screen
-    gl_PointSize = 0.0;
-    return;
-  }
-  
-  // Position
-  vec4 pointPosition = texture2D(positionsTexture, (pointIndices + 0.5) / pointsTextureSize);
-  vec2 point = pointPosition.rg;
-
-  // Transform point position to normalized device coordinates
-  vec2 normalizedPosition = 2.0 * point / spaceSize - 1.0;
-  normalizedPosition *= spaceSize / screenSize;
-  vec3 finalPosition = transformationMatrix * vec3(normalizedPosition, 1);
-  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)
-      
-      if (isDarkenGreyout) {
-        // 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);
-      }
-    }
-  }
-
-  if (!hasImages || imageIndex < 0.0 || imageIndex >= imageCount) {
-    imageAtlasUV = vec4(-1.0);
-    return;
-  }
-  // 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 = texture2D(imageAtlasCoords, atlasCoordTexCoord);
-  imageAtlasUV = atlasCoords;
-} 

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

@@ -1,9 +0,0 @@
-#ifdef GL_ES
-precision highp float;
-#endif
-
-varying vec4 rgba;
-
-void main() {
-  gl_FragColor = rgba;
-}

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

@@ -1,29 +0,0 @@
-#ifdef GL_ES
-precision highp float;
-#endif
-
-uniform sampler2D positionsTexture;
-uniform float pointsTextureSize;
-uniform float spaceSize;
-uniform vec2 screenSize;
-uniform mat3 transformationMatrix;
-
-attribute vec2 pointIndices;
-
-varying vec4 rgba;
-
-void main() {
-  vec4 pointPosition = texture2D(positionsTexture, (pointIndices + 0.5) / pointsTextureSize);
-  vec2 p = 2.0 * pointPosition.rg / spaceSize - 1.0;
-  p *= spaceSize / screenSize;
-  vec3 final = transformationMatrix * vec3(p, 1);
-
-  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

@@ -1,9 +0,0 @@
-#ifdef GL_ES
-precision highp float;
-#endif
-
-varying vec4 rgba;
-
-void main() {
-  gl_FragColor = rgba;
-}

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

@@ -1,57 +0,0 @@
-#ifdef GL_ES
-precision highp float;
-#endif
-
-attribute float size;
-
-uniform sampler2D positionsTexture;
-uniform float pointsTextureSize;
-uniform float sizeScale;
-uniform float spaceSize;
-uniform vec2 screenSize;
-uniform float ratio;
-uniform mat3 transformationMatrix;
-uniform vec2 mousePosition;
-uniform bool scalePointsOnZoom;
-uniform float maxPointSize;
-
-attribute vec2 pointIndices;
-
-varying vec4 rgba;
-
-float calculatePointSize(float size) {
-  float pSize;
-  if (scalePointsOnZoom) { 
-    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 = texture2D(positionsTexture, (pointIndices + 0.5) / pointsTextureSize);
-
-  // Transform point position to normalized device coordinates
-  vec2 normalizedPoint = 2.0 * pointPosition.rg / spaceSize - 1.0;
-  normalizedPoint *= spaceSize / screenSize;
-  vec3 finalPosition = transformationMatrix * vec3(normalizedPoint, 1);
-
-  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);
-  // Check if the mouse is within the point radius
-  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

@@ -1,48 +0,0 @@
-#ifdef GL_ES
-precision highp float;
-#endif
-
-uniform sampler2D positionsTexture;
-uniform sampler2D pointSize;
-uniform float sizeScale;
-uniform float spaceSize;
-uniform vec2 screenSize;
-uniform float ratio;
-uniform mat3 transformationMatrix;
-uniform vec2 selection0;
-uniform vec2 selection1;
-uniform bool scalePointsOnZoom;
-uniform float maxPointSize;
-
-varying vec2 textureCoords;
-
-float pointSizeF(float size) {
-  float pSize;
-  if (scalePointsOnZoom) { 
-    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() {
-  vec4 pointPosition = texture2D(positionsTexture, textureCoords);
-  vec2 p = 2.0 * pointPosition.rg / spaceSize - 1.0;
-  p *= spaceSize / screenSize;
-  vec3 final = transformationMatrix * vec3(p, 1);
-
-  vec4 pSize = texture2D(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;
-
-  gl_FragColor = vec4(0.0, 0.0, pointPosition.rg);
-  if (final.x >= left && final.x <= right && final.y >= top && final.y <= bottom) {
-    gl_FragColor.r = 1.0;
-  }
-}
-

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

@@ -1,65 +0,0 @@
-#ifdef GL_ES
-precision highp float;
-#endif
-
-uniform sampler2D positionsTexture;
-uniform sampler2D polygonPathTexture; // Texture containing polygon path points
-uniform int polygonPathLength;
-uniform float spaceSize;
-uniform vec2 screenSize;
-uniform mat3 transformationMatrix;
-
-varying vec2 textureCoords;
-
-// 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 = texture2D(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 = texture2D(positionsTexture, textureCoords);
-  vec2 p = 2.0 * pointPosition.rg / spaceSize - 1.0;
-  p *= spaceSize / screenSize;
-  vec3 final = transformationMatrix * vec3(p, 1);
-
-  // Convert to screen coordinates for polygon check
-  vec2 screenPos = (final.xy + 1.0) * screenSize / 2.0;
-  
-  gl_FragColor = vec4(0.0, 0.0, pointPosition.rg);
-  
-  // Check if point center is inside the polygon
-  if (pointInPolygon(screenPos, polygonPathTexture, polygonPathLength)) {
-    gl_FragColor.r = 1.0;
-  }
-}