anchor.diff:                (gl:draw-arrays :triangles 0 3)
                 (gl:draw-arrays :triangles 2 3)
                 (gl:disable-vertex-attrib-array 0)
  +              (gl:flush)
  +              (sdl2:gl-swap-window window)
                 (gl:free-gl-array coords))
  -            (gl:flush)
  -            (sdl2:gl-swap-window window)
   
               (sdl2:with-event-loop (:method :poll)
                 (:keydown
  
positive.code:             (sdl2:hide-cursor)
              (gl:enable :depth-test)
              (gl:clear-color 0.0 0 0 1.0)
              (gl:clear :color-buffer :depth-buffer)
              (let ((coords (make-gl-array :float #(-0.5  0.5 -1.0
                                                     0.5  0.5 -1.0
                                                     0.5 -0.5 -1.0
                                                    -0.5 -0.5 -1.0
                                                    -0.5  0.5 -1.0))))
                (gl:use-program program)
                (gl:uniform-matrix (gl:get-uniform-location program "projection_matrix") 4
                                   (vector (perspective 45.0 (/ width height) 0.1 100.0)))
                (gl:uniform-matrix (gl:get-uniform-location program "view_matrix") 4
                                   (vector (look-at '(2.0 2.0 -1.0) '(0.0 0.0 -3.0) '(0.0 1.0 0.0))))
                (gl:bind-buffer :array-buffer (nth 0 buffers))
                (gl:buffer-data :array-buffer :static-draw coords)
                (gl:vertex-attrib-pointer 0 3 :float nil 0 0)
  
negative.code:             0.0 0.0 (/ (+ zfar znear) (- znear zfar)) (/ (* 2.0 zfar znear) (- znear zfar))
              0.0 0.0 -1.0 0.0)))
  
  ;; Returns scalar from vector.
  (defun magnitude (v)
    (sqrt (reduce '+ (map 'vector #'(lambda (x) (expt x 2)) v))))
  
  ;; Returns unit vector from vector.
  (defun normalize (v)
    (let ((c (magnitude v)))
      (map 'vector #'(lambda (x) (/ x c)) v)))
  
  ;; Using one of the definitions from Wikipedia. I hope this works.
  (defun cross-product (u v)
    (vector (- (* (elt u 1) (elt v 2)) (elt u 2) (elt v 1))
            (- (* (elt u 2) (elt v 0)) (elt u 0) (elt v 2))
            (- (* (elt u 0) (elt v 1)) (elt u 1) (elt v 0))))
  
  ;; Very naive reimplementation of the gluLookAt matrix.
  ;; https://www.opengl.org/sdk/docs/man2/xhtml/gluLookAt.xml
  (defun look-at (eye center up)
    (let* ((f (normalize (map 'vector #'- center eye)))
           (s (cross-product f (normalize up)))
           (u (cross-product (normalize s) f)))
      (concatenate 'vector
                   s #(0)
                   u #(0)
                   (map 'vector #'- f) #(0)
                   #(0 0 0 1))))
  
  (defun main-loop (&key (width 1280) (height 720) (title "cl-foo"))
    (sdl2:with-init (:everything)
  