(in-package #:cl-user)

(defun lc-v- (a b) (map 'vector #'- a b)) ; 3-vector subtract a-b

(defun lc-cross (a b)                   ; 3-vector cross product
  (macrolet ((woo (p q)
              `(- (* (elt a ,p) (elt b ,q ))
                  (* (elt a ,q) (elt b ,p)))))
    (vector (woo 1 2)
            (woo 2 0)
            (woo 0 1))))

(defun apply-to-hemicube-faces (n fn)
  (let ((size (/ n)))
    (dotimes (d 3)
      (dotimes (i n)
        (dotimes (j n)
          (let ((base-x (* i size))
                (base-y (* j size)))
            (funcall fn d i j
                     (vector base-x base-y 0)
                     (vector base-x base-y 0)
                     (vector base-x base-y 0)
                     (vector base-x base-y 0))))))))

(defun lc-point-transformer ()
  (lambda (point)
    (let ((z (+ 2.0 (elt point 2)))
          (zoom 2.0))
      (vector (* zoom (/ (elt point 0) z))
              (* zoom (/ (elt point 1) z))
              z))))

(defun apply-to-transformed-faces (pane continuation)
  (let ((transformer (lc-point-transformer)))
    (apply-to-hemicube-faces 5
      (lambda (side i j &rest points)
        (format *Debug-io* "xxx ~s~%" points)
        (format *Debug-io* "yyy ~s~%" (mapcar transformer points))
        (apply continuation side i j (mapcar transformer points))))))

(defun lc-face-normal (points)
  (lc-cross (lc-v- (elt points 2)
                   (elt points 1))
            (lc-v- (elt points 0)
                   (elt points 1))))

(defun backface-p (points)
  (<= (elt (lc-face-normal points) 2) 0))

(defun draw-logic-cube (pane)
  (apply-to-transformed-faces pane
    (lambda (side i j &rest camera-points)
      (format *Debug-io* "camera points ~s~%" camera-points)
      (unless (backface-p camera-points)
        (setf camera-points (qlc-scale-polygon camera-points (squeeze pane)))))))