directions.calculate { (response, error) in
                if error != nil {
                    return
                }
                if let route = response?.routes.first {

                    var coords = [CLLocationCoordinate2D]()
                    let pointCount = route.polyline.pointCount
                    let routeCoordinates = UnsafeMutablePointer<CLLocationCoordinate2D>.allocate(capacity: pointCount)
                    route.polyline.getCoordinates(routeCoordinates, range: NSMakeRange(0, pointCount))
                    for i in 0..<pointCount {
                        coords.append(routeCoordinates[i])
                    }
                    free(routeCoordinates)
                    for coord in coords {

                        let nextLocation = CLLocation(latitude: coord.latitude, longitude: coord.longitude)

                        self.annotationManager.addAnnotation(startLocation: currentLocation, endLocation: nextLocation, calloutString: NSUUID().uuidString)

                    }


                    let metersPerNode: CLLocationDistance = 5

                    let distance = Turf.distance(along: coords)

                    for i in stride(from: 0, to: distance, by: metersPerNode) {
                        if let nextCoord = Turf.coordinate(at: i, fromStartOf: coords) {
                            let interpNextLoc = CLLocation(latitude: nextCoord.latitude, longitude: nextCoord.longitude)
                            self.annotationManager.addAnnotation(startLocation: currentLocation, endLocation: interpNextLoc, calloutString: NSUUID().uuidString)
                        }
                    }
                }

            }

func addAnnotation(startLocation: CLLocation, endLocation: CLLocation, calloutString: String?) {
        let origin = matrix_identity_float4x4

        //distance and bearing between start and end
        let dist = Float(endLocation.distance(from: startLocation))
        let degrees = startLocation.bearingTo(endLocation: endLocation)
        let bearing = GLKMathDegreesToRadians(degrees)

        //rotate start location by bearing of end location and extend it the desired distance
        let position = vector_float4(0.0, 0.0, -dist, 0.0)
        let translationMatrix = createTranslationMatrix(position)
        let rotationMatrix = rotationY(bearing)
        let transformMatrix = simd_mul(rotationMatrix, translationMatrix)
        let transform = simd_mul(origin, transformMatrix)

        //create anchor
        let anchor = RoutesARAnchor(transform: transform)

        anchor.calloutString = calloutString
        session.add(anchor: anchor)
        anchors.append(anchor)
    }

private func createTranslationMatrix(_ translation: vector_float4) -> matrix_float4x4 {
        var m: matrix_float4x4 = matrix_identity_float4x4
        m.columns.3 = translation
        return m
    }

private func rotationY(_ radians: Float) -> matrix_float4x4 {
     var m: matrix_float4x4 = matrix_identity_float4x4

     m.columns.0.x = cos(radians)
     m.columns.0.z = -sin(radians)

     m.columns.2.x = sin(radians)
     m.columns.2.z = cos(radians)

     return simd_inverse(m)
 }

func bearingTo(endLocation: CLLocation) -> Float {
        var bearing: Float = 0.0

        let latStart = GLKMathDegreesToRadians(Float(coordinate.latitude))
        let latEnd = GLKMathDegreesToRadians(Float(coordinate.longitude))

        let lonStart = GLKMathDegreesToRadians(Float(endLocation.coordinate.latitude))
        let lonEnd = GLKMathDegreesToRadians(Float(endLocation.coordinate.longitude))

        let lonDistance = lonEnd - lonStart

        let y = sin(lonDistance) * cos(latEnd)
        let x = cos(latStart) * sin(latEnd) - sin(latStart) * cos(latEnd) * cos(lonDistance)
        let radianBearing = atan2(y, x)

        bearing = GLKMathRadiansToDegrees(radianBearing)

        return bearing
    }