anchor.diff:  
     ;;(format t "win: ~A mouse: ~A x: ~A y: ~A button: ~A state: ~A clicks: ~A ts: ~A~%" win mouse x y button state clicks ts)
   
  -  (let ((event (list win mouse x y button state clicks ts)))
  +  (let ((event `((:window . ,win)
  +		 (:mouse . ,mouse)
  +		 (:mouse-screen-position ,x . ,y)
  +		 (:button . ,button)
  +		 (:state . ,state)
  +		 (:clicks . ,clicks)
  +		 (:timestamp . ,ts))))
   
       (map-event (lambda (k v)
  -		 (let ((collisions (check-intersect (car (children k)) k x y *viewport* *projection*)))
  +		 (multiple-value-bind (collisions start ray) (check-intersect (car (children k)) k x y *viewport* *projection*)
   		   (when collisions
   		     (setf *last-mouse-down-target* k)
  -		     (funcall v k collisions (cons :mouse-down event)))))
  -	       *on-mouse-down-objects*)))
  +		     (funcall v k collisions (acons :event :mouse-down
  +						    (acons :ray-start start
  +							   (acons :ray ray event)))))))
  +	       :mouse-down)))
   
   (clinch:defevent clinch:*on-mouse-up* (win mouse x y button state clicks ts)
   
  -  ;;(format t "win: ~A mouse: ~A x: ~A y: ~A button: ~A state: ~A clicks: ~A ts: ~A~%" win mouse x y button state clicks ts)
  -  (let ((event (list win mouse x y button state clicks ts)))
  -    (map-event (lambda (k v)
  -		 (let ((collisions (check-intersect (car (children k)) k x y *viewport* *projection*)))
  -		   (when collisions
  -		     (when (and
  -			    (eq button *click-button*)
  -			    (eq *last-mouse-down-target* k))
  -		       (let ((f (gethash k *on-mouse-click-objects*)))
  -			 (when f (funcall f k collisions (cons :mouse-click event)))))
  -		     (funcall v k collisions (cons :mouse-up event))
  -		     (setf *last-mouse-down-target* nil))))
  -	       
  -	       *on-mouse-up-objects*)))
  +  (format t "win: ~A mouse: ~A x: ~A y: ~A button: ~A state: ~A clicks: ~A ts: ~A~%" win mouse x y button state clicks ts)
  +    (let ((event `((:window . ,win)
  +		   (:mouse . ,mouse)
  +		   (:mouse-screen-position ,x . ,y)
  +		   (:button . ,button)
  +		   (:state . ,state)
  +		   (:clicks . ,clicks)
  +		   (:timestamp . ,ts))))
  +      (map-event (lambda (k v)
  +		   (multiple-value-bind (collisions start ray) (check-intersect (car (children k)) k x y *viewport* *projection*)
  +		     (when collisions
  +		       (let ((e (acons :ray-start start
  +				       (acons :ray ray event))))
  +			 (when (eq *last-mouse-down-target* k)
  +			   (let ((f (gethash k (gethash :mouse-click *event-hash*))))
  +			     (when f (funcall f k collisions  (acons :event :mouse-click e)))))
  +			 (funcall v k collisions (acons :event :mouse-up e)))
  +		       (setf *last-mouse-down-target* nil))))
  +		 
  +		 :mouse-up)))
   
   
     ;; (loop for n in *buttons*
  
positive.code: (ql:quickload :clinch-pango)
  (ql:quickload :clinch-freeimage)
  (use-package :clinch)
  
  (defparameter *click-button* 1)
  
  (defparameter *node* nil)
  (defparameter *projection* nil)
  
negative.code: 
  
  
  ;; a = (sb-cga:vec* button-end-position entity-distance)
  ;; b-pos & b = buttons start and end 
  ;; d-pos and d-hat = screen position and direction
  
  (defun calculate-movement (d-pos d-hat a-pos a b-pos b)
    (let ((a-rel (v3:- a-pos d-pos))
  	(b-rel (v3:- b-pos d-pos)))
      (v3:-
       (v3:+ b-rel
  	   (v3:*s b
  		  ;; find 'x'
  		  (/ (v3:dot (v3:- (v3:+ a-rel a)
  				   b-rel)
  			     d-hat)
  		     (v3:dot b d-hat))))
       (v3:+ a-rel a))))
  
  
  ;; Idea...
  ;; Start = original vector
  ;; Current = current vector
  (defun calculate-movement (start end)
    (v3:- end
  	(v3:*s start (v3:dot start end))))
  
  
  	;; (if (eql mouse-state :dragging)
  	    
  