// deck.gl // SPDX-License-Identifier: MIT // Copyright (c) vis.gl contributors export const shaderWGSL = /* wgsl */ `\ const ZERO_OFFSET: vec3 = vec3(0.0, 0.0, 0.0); struct Attributes { @location(0) instanceSourcePositions: vec3, @location(1) instanceSourcePositions64Low: vec3, @location(2) instanceTargetPositions: vec3, @location(3) instanceTargetPositions64Low: vec3, @location(4) instanceSourceColors: vec4, @location(5) instanceTargetColors: vec4, @location(6) instanceWidths: f32, @location(7) instanceHeights: f32, @location(8) instanceTilts: f32, }; struct Varyings { @builtin(position) position: vec4, @location(0) color: vec4, @location(1) uv: vec2, @location(2) pickingColor: vec3, @location(3) isValid: f32, }; fn paraboloid( distance: f32, sourceZ: f32, targetZ: f32, ratio: f32, height: f32 ) -> f32 { let deltaZ = targetZ - sourceZ; let dh = distance * height; if (dh == 0.0) { return sourceZ + deltaZ * ratio; } let unitZ = deltaZ / dh; let p2 = unitZ * unitZ + 1.0; let dir = select(0.0, 1.0, deltaZ <= 0.0); let z0 = mix(sourceZ, targetZ, dir); let r = mix(ratio, 1.0 - ratio, dir); return sqrt(max(r * (p2 - r), 0.0)) * dh + z0; } fn getExtrusionOffset(lineClipspace: vec2, side: f32, width: f32) -> vec2 { var direction = normalize(lineClipspace * project.viewportSize); // Rotate by 90° clockwise so the strip (-1 side first) winds counter-clockwise direction = vec2(direction.y, -direction.x); return direction * side * width / 2.0; } fn getSegmentRatio(index: f32) -> f32 { return smoothstep(0.0, 1.0, index / max(arc.numSegments - 1.0, 1.0)); } fn interpolateFlat( source: vec3, targetPosition: vec3, ratio: f32, height: f32, tiltDegrees: f32 ) -> vec3 { let distance = length(source.xy - targetPosition.xy); let z = paraboloid(distance, source.z, targetPosition.z, ratio, height); let tiltAngle = radians(tiltDegrees); let tiltDirection = normalize(targetPosition.xy - source.xy); let tilt = vec2(-tiltDirection.y, tiltDirection.x) * z * sin(tiltAngle); return vec3(mix(source.xy, targetPosition.xy, ratio) + tilt, z * cos(tiltAngle)); } // Great circle interpolation // http://www.movable-type.co.uk/scripts/latlong.html fn getAngularDistance(source: vec2, targetPosition: vec2) -> f32 { let sourceRadians = radians(source); let targetRadians = radians(targetPosition); let sinHalfDelta = sin((sourceRadians - targetRadians) / 2.0); let sinHalfDeltaSquared = sinHalfDelta * sinHalfDelta; let a = sinHalfDeltaSquared.y + cos(sourceRadians.y) * cos(targetRadians.y) * sinHalfDeltaSquared.x; return 2.0 * asin(sqrt(a)); } fn interpolateGreatCircle( source: vec3, targetPosition: vec3, source3D: vec3, target3D: vec3, angularDistance: f32, ratio: f32, height: f32 ) -> vec3 { var longitudeLatitude: vec2; // If the angular distance is PI, use linear interpolation. Otherwise use spherical interpolation. if (abs(angularDistance - PI) < 0.001) { longitudeLatitude = (1.0 - ratio) * source.xy + ratio * targetPosition.xy; } else { let a = sin((1.0 - ratio) * angularDistance); let b = sin(ratio * angularDistance); let p = source3D.yxz * a + target3D.yxz * b; longitudeLatitude = degrees(vec2( atan2(p.y, -p.x), atan2(p.z, length(p.xy)) )); } let z = paraboloid( angularDistance * EARTH_RADIUS, source.z, targetPosition.z, ratio, height ); return vec3(longitudeLatitude, z); } @vertex fn vertexMain( attributes: Attributes, @builtin(vertex_index) vertexIndex: u32, @builtin(instance_index) instanceIndex: u32 ) -> Varyings { geometry.worldPosition = attributes.instanceSourcePositions; geometry.worldPositionAlt = attributes.instanceTargetPositions; let segmentIndex = f32(vertexIndex / 2u); let segmentSide = select(-1.0, 1.0, vertexIndex % 2u == 1u); var segmentRatio = getSegmentRatio(segmentIndex); let previousRatio = getSegmentRatio(max(0.0, segmentIndex - 1.0)); var nextRatio = getSegmentRatio(min(arc.numSegments - 1.0, segmentIndex + 1.0)); // If this is the first point, use next - current as direction. var indexDirection = select(-1.0, 1.0, segmentIndex <= 0.0); var isValid = 1.0; var currentClip: vec4; var nextClip: vec4; if ( (arc.greatCircle != 0.0 || project.projectionMode == PROJECTION_MODE_GLOBE) && project.coordinateFrame == COORDINATE_SYSTEM_GEODETIC && project.projectionMode != PROJECTION_MODE_GEODETIC_OFFSETS ) { let source = project_globe_(vec3(attributes.instanceSourcePositions.xy, 0.0)); let targetPosition = project_globe_(vec3(attributes.instanceTargetPositions.xy, 0.0)); let angularDistance = getAngularDistance( attributes.instanceSourcePositions.xy, attributes.instanceTargetPositions.xy ); let previousPosition = interpolateGreatCircle( attributes.instanceSourcePositions, attributes.instanceTargetPositions, source, targetPosition, angularDistance, previousRatio, attributes.instanceHeights ); var currentPosition = interpolateGreatCircle( attributes.instanceSourcePositions, attributes.instanceTargetPositions, source, targetPosition, angularDistance, segmentRatio, attributes.instanceHeights ); var nextPosition = interpolateGreatCircle( attributes.instanceSourcePositions, attributes.instanceTargetPositions, source, targetPosition, angularDistance, nextRatio, attributes.instanceHeights ); if (abs(currentPosition.x - previousPosition.x) > 180.0) { indexDirection = -1.0; isValid = 0.0; } else if (abs(currentPosition.x - nextPosition.x) > 180.0) { indexDirection = 1.0; isValid = 0.0; } nextPosition = select(nextPosition, previousPosition, indexDirection < 0.0); nextRatio = select(nextRatio, previousRatio, indexDirection < 0.0); if (isValid == 0.0) { // Split at the antimeridian. nextPosition.x += select(360.0, -360.0, nextPosition.x > 0.0); let ratio = ( select(-180.0, 180.0, currentPosition.x > 0.0) - currentPosition.x ) / (nextPosition.x - currentPosition.x); currentPosition = mix(currentPosition, nextPosition, ratio); segmentRatio = mix(segmentRatio, nextRatio, ratio); } let currentPosition64Low = mix( attributes.instanceSourcePositions64Low, attributes.instanceTargetPositions64Low, segmentRatio ); let nextPosition64Low = mix( attributes.instanceSourcePositions64Low, attributes.instanceTargetPositions64Low, nextRatio ); let currentProjection = project_position_to_clipspace_and_commonspace( currentPosition, currentPosition64Low, ZERO_OFFSET ); currentClip = currentProjection.clipPosition; nextClip = project_position_to_clipspace(nextPosition, nextPosition64Low, ZERO_OFFSET); geometry.position = currentProjection.commonPosition; } else { var sourceWorld = attributes.instanceSourcePositions; var targetWorld = attributes.instanceTargetPositions; if (arc.useShortestPath != 0.0) { sourceWorld.x = ((sourceWorld.x + 180.0) % 360.0) - 180.0; targetWorld.x = ((targetWorld.x + 180.0) % 360.0) - 180.0; let deltaLongitude = targetWorld.x - sourceWorld.x; if (deltaLongitude > 180.0) { targetWorld.x -= 360.0; } if (deltaLongitude < -180.0) { sourceWorld.x -= 360.0; } } let source = project_position_vec3_f64( sourceWorld, attributes.instanceSourcePositions64Low ); let targetPosition = project_position_vec3_f64( targetWorld, attributes.instanceTargetPositions64Low ); // Common x at longitude=-180. var antimeridianX = 0.0; if (arc.useShortestPath != 0.0) { if ((project.projectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET || project.projectionMode == PROJECTION_MODE_GEODETIC_OFFSETS)) { antimeridianX = -(project.coordinateOrigin.x + 180.0) / 360.0 * TILE_SIZE; } let thresholdRatio = (antimeridianX - source.x) / (targetPosition.x - source.x); if (previousRatio <= thresholdRatio && nextRatio > thresholdRatio) { isValid = 0.0; indexDirection = sign(segmentRatio - thresholdRatio); segmentRatio = thresholdRatio; } } nextRatio = select(nextRatio, previousRatio, indexDirection < 0.0); var currentPosition = interpolateFlat( source, targetPosition, segmentRatio, attributes.instanceHeights, attributes.instanceTilts ); var nextPosition = interpolateFlat( source, targetPosition, nextRatio, attributes.instanceHeights, attributes.instanceTilts ); if (arc.useShortestPath != 0.0 && nextPosition.x < antimeridianX) { currentPosition.x += TILE_SIZE; nextPosition.x += TILE_SIZE; } currentClip = project_common_position_to_clipspace(vec4(currentPosition, 1.0)); nextClip = project_common_position_to_clipspace(vec4(nextPosition, 1.0)); geometry.position = vec4(currentPosition, 1.0); } geometry.uv = vec2(segmentRatio, segmentSide); geometry.pickingColor = picking_getPickingColorFromIndex(instanceIndex + arc.rowIndexOffset); let widthPixels = clamp( project_unit_size_to_pixel(attributes.instanceWidths * arc.widthScale, arc.widthUnits), arc.widthMinPixels, arc.widthMaxPixels ); var offset = getExtrusionOffset( (nextClip.xy - currentClip.xy) * indexDirection, segmentSide, widthPixels ); var size = vec3(offset, 0.0); DECKGL_FILTER_SIZE(&size, geometry); offset = size.xy; #ifdef ANTIALIASING let halfWidthPixels = length(offset); if (halfWidthPixels > 0.0) { // Keep the declared edge at abs(uv.y) == 1 while rasterizing the outer half of the centered // one-device-pixel coverage ramp. let coverageScale = 1.0 + 0.5 / project.devicePixelRatio / halfWidthPixels; offset *= coverageScale; geometry.uv.y *= coverageScale; } #endif var output: Varyings; output.position = currentClip + vec4(project_pixel_size_to_clipspace(offset), 0.0, 0.0); let color = mix(attributes.instanceSourceColors, attributes.instanceTargetColors, segmentRatio); output.color = vec4(color.rgb, color.a * layer.opacity); output.uv = geometry.uv; output.pickingColor = geometry.pickingColor; output.isValid = isValid; DECKGL_FILTER_GL_POSITION(&output.position, geometry); return output; } @fragment fn fragmentMain(varyings: Varyings) -> @location(0) vec4 { #ifdef ANTIALIASING let edgeCoord = abs(varyings.uv.y); let edgePixels = (1.0 - edgeCoord) / max(fwidth(edgeCoord), 1e-6); #endif if (varyings.isValid == 0.0) { discard; } #ifdef ANTIALIASING // Fragments outside the coverage ramp must not write depth or picking colors. if (edgePixels <= -SMOOTH_EDGE_RADIUS) { discard; } #endif fragmentGeometry.uv = varyings.uv; var color = varyings.color; #ifdef ANTIALIASING // Feather one device pixel across the width. Arc segments meet lengthwise, so only soften the // two outer edges of the strip. color.a *= smoothedge(0.0, edgePixels); #endif if (picking.isActive > 0.5) { if (!picking_isColorValid(varyings.pickingColor)) { discard; } var extensionColor = vec4(varyings.pickingColor, 1.0); DECKGL_FILTER_COLOR(&extensionColor, fragmentGeometry); // Color filters may discard, but must not alter the picking payload. return vec4(varyings.pickingColor, 1.0); } if (picking.isHighlightActive > 0.5) { let highlightedObjectColor = picking_normalizeColor(picking.highlightedObjectColor); if (picking_isColorZero(abs(varyings.pickingColor - highlightedObjectColor))) { let highlightAlpha = picking.highlightColor.a; let blendedAlpha = highlightAlpha + color.a * (1.0 - highlightAlpha); if (blendedAlpha > 0.0) { let highlightRatio = highlightAlpha / blendedAlpha; color = vec4( mix(color.rgb, picking.highlightColor.rgb, highlightRatio), blendedAlpha ); } } } DECKGL_FILTER_COLOR(&color, fragmentGeometry); return deckgl_premultiplied_alpha(color); } `;