           (.empty rx-observable)
           (let [{:keys [vx vy]} a]
             (.generateWithRelativeTime rx-observable
-              (math-vec (* update-interval-ms (or vx 0))
-                        (* update-interval-ms (or vy 0)))
-              (fn [v] (> (vec-length-sq v) min-slide-speed-sq))
-              dampen
-              identity
-              (constantly update-interval-ms))))))))
+                                       (math-vec (* update-interval-ms (or vx 0))
+                                                 (* update-interval-ms (or vy 0)))
+                                       (fn [v] (> (vec-length-sq v) min-slide-speed-sq))
+                                       dampen
+                                       identity
+                                       (constantly update-interval-ms))))))))
 
 (defn move-camera-on-swipe! [manager current-state]
   (.subscribe

        displacement (subtract-vec pos camera-pos)
        r (scaled-distance-from-camera state pos)
        projected-r (project-displacement r)]
    (add-vec view-center (scalar-multiply displacement
                                        (/ projected-r r)))))

(defn project-radius [t]
    (+ min-radius (* (- max-radius min-radius)
                     (min 1 (/ 1 (.pow js/Math 2 (* 2 (- t 0.25))))))))

(defn view-radius [state pos]
  (let [r (scaled-distance-from-camera state pos)]

    (/ (vec-distance (:camera-pos state) pos) corner-distance)))

(defn elliptic-distance-from-camera [state pos]
  "An alternate method of computing distance, currently unused."
  (let [{:keys [view-size camera-pos]} state
        rx (/ (:x view-size) 2)
        ry (/ (:y view-size) 2)
