anchor.diff:  (defun from-look-at (from3 to3)
     (let* ((dir (v3:- from3 to3))
            (n-dir (v3:normalize dir))
  -         (right (v3:make (v:z n-dir) 0.0 (- (v:x n-dir))))
  +         (right (v3:make (v:z n-dir) 0.0 (cl:- (v:x n-dir))))
            (n-right (v3:normalize right))
            (up (v3:cross n-dir n-right)))
       (q:from-axies n-right up n-dir)))
  
positive.code:         ;; if angle between quaternions is less than 90 degrees
          (if (> cos-angle 0f0)
              ;; if angle is greater than zero
              (if (> (- 1.0 cos-angle) 0f0)
                  (let* ((angle (acos cos-angle))
                         (recip-sin-angle (/ 1.0 (sin angle))))
                    (list (* (sin (* (- 1.0 pos) angle))
                             recip-sin-angle)
                          (* (sin (* pos angle))
                             recip-sin-angle)))
                  ;; angle is close to zero
                  (list (- 1.0 pos) pos))
              ;; we take the shorter route
              ;; if angle is less that 180 degrees
              (if (> (+ 1.0 cos-angle) 0f0)
                  (let* ((angle (acos (- cos-angle)))
                         (recip-sin-angle (/ 1.0 (sin angle))))
                    (list (* (sin (* (- pos 1.0) angle))
                             recip-sin-angle)
                          (* (sin (* pos angle))
                             recip-sin-angle)))
                  ;; angle is close to 180 degrees
                  (list (- pos 1.0) pos))))
      (q+1 (q* start-quat start-mult)
           (q* end-quat end-mult))))
  
  (defun approx-slerp (start-quat end-quat pos)
    (let* ((cos-angle (v4:dot start-quat end-quat))
           (factor (expt (- 1.0 (* 0.7878088 cos-angle)) 2.0))
           (k (* 0.5069269 factor))
           (b (* 2.0 k))
           (c (* -3 k))
           (d (+ 1 k))
           (pos (+ (* pos (+ c (* b pos))) d)))
      ;; if angle is less than 90 degrees
      (if (> cos-angle 0f0)
          ;; use standard interp
          (q+1 (q* end-quat pos)
               (q* start-quat (- 1.0 pos)))
          ;; take shorter path
          (q+1 (q* end-quat pos)
               (q* start-quat (- pos 1.0))))))
  
negative.code:   ;; get cos of 'angle' between quaternions
    (let ((cos-angle (v4:dot start-quat end-quat)))
      (if (>= cos-angle 0f0)
          (+ (* end-quat pos)
  	   (* start-quat (cl:- 1.0 pos)))
          (+ (* end-quat pos)
  	   (* start-quat (cl:- pos 1.0))))))
  
  (defun slerp (start-quat end-quat pos)
    "Spherically interpolate between two quaternions. Note that this
  