;; this file:
;;   https://dataswamp.org/~incal/common-lisp/general-base/gb.lisp

(defun init-gb (gl-context win)
  (init-gl gl-context win)
  (init-coords)
  (init-poly) )

(defun gb ()
  (sdl2:with-init (:everything)
    (sdl2:with-window (win :title "A Camp Software" :flags '(:shown :opengl))
      (sdl2:with-gl-context (gl-context win)
        (init-gb gl-context win)
        (let*(
              ;; draw
              (draw t)
              (plen 0)

              ;; draw this
              (coords   nil)
              (stars    nil)
              (triangle t)

              ;; polygons, random
              (polygon   nil)
              (poly-vert 4)

              ;; polygon, same
              (poly nil)

              ;; translate
              (trans-x     0)
              (trans-y     0)
              (trans-z     0)
              (trans-delta 0.001)

              ;; rotate
              (rotate-x nil)
              (rotate-y nil)
              (rotate-z nil)

              (rotate-x-speed 1)
              (rotate-y-speed 1)
              (rotate-z-speed 1)
              )
          (sdl2:with-event-loop (:method :poll)
            (:keydown (:keysym ks)
               (let ((scv  (sdl2:scancode-value ks))
                     (symv (sdl2:sym-value ks))
                     (modv (sdl2:mod-value ks)) )
                 (cond
                   ;; [P] draw
                   ((sdl2:scancode= scv :scancode-p)
                    (case modv
                      (PLAIN (setf draw (not draw)))
                      (t     (when (setq poly (not poly))
                               (setq *poly* nil) ))))

                   ;; [9] [0] polygon vertices
                   ((sdl2:scancode= scv :scancode-9) (incf poly-vert))
                   ((sdl2:scancode= scv :scancode-0) (setf poly-vert (max 0 (decf poly-vert))))

                   ;; [B] [H] pause length
                   ((sdl2:scancode= scv :scancode-h) (setf plen (max 0 (decf plen))))
                   ((sdl2:scancode= scv :scancode-b) (incf plen))

                   ;; [I] [K] translate x
                   ((sdl2:scancode= scv :scancode-i) (incf trans-y trans-delta))
                   ((sdl2:scancode= scv :scancode-k) (decf trans-y trans-delta))
                   ;; [L] [J] y
                   ((sdl2:scancode= scv :scancode-l) (incf trans-x trans-delta))
                   ((sdl2:scancode= scv :scancode-j) (decf trans-x trans-delta))
                   ;; [O] [N] z
                   ((sdl2:scancode= scv :scancode-o) (incf trans-z trans-delta))
                   ((sdl2:scancode= scv :scancode-n) (decf trans-z trans-delta))

                   ;; [W] [S] rotate x
                   ((sdl2:scancode= scv :scancode-w) (incf rotate-x-speed))
                   ((sdl2:scancode= scv :scancode-s) (decf rotate-x-speed))
                   ;; [D] [A] y
                   ((sdl2:scancode= scv :scancode-d) (incf rotate-y-speed))
                   ((sdl2:scancode= scv :scancode-a) (decf rotate-y-speed))
                   ;; [F] [E] z
                   ((sdl2:scancode= scv :scancode-f) (incf rotate-z-speed))
                   ((sdl2:scancode= scv :scancode-e) (decf rotate-z-speed))

                   ;; [X] [Y] [Z] toggle rotate
                   ((sdl2:scancode= scv :scancode-x) (setf rotate-x (not rotate-x)))
                   ((sdl2:scancode= scv :scancode-y) (setf rotate-y (not rotate-y)))
                   ((sdl2:scancode= scv :scancode-z) (setf rotate-z (not rotate-z)))

                   ;; [R] enable all rotate (shift: inverse) (alt: disable)
                   ((sdl2:scancode= scv :scancode-r)
                    (case modv
                      (PLAIN (progn
                               (setf rotate-x t)
                               (setf rotate-y t)
                               (setf rotate-z t) ))
                      (SHIFT (progn
                               (setf rotate-x (not rotate-x))
                               (setf rotate-y (not rotate-y))
                               (setf rotate-z (not rotate-z)) ))
                      (ALT   (progn
                               (setf rotate-x nil)
                               (setf rotate-y nil)
                               (setf rotate-z nil) ))))

                   ;; [1] [2] [3] [4] toggle stuff
                   ((sdl2:scancode= scv :scancode-1) (setf triangle (not triangle)))
                   ((sdl2:scancode= scv :scancode-2) (setf polygon  (not polygon)))
                   ((sdl2:scancode= scv :scancode-3) (setf stars    (not stars)))
                   ((sdl2:scancode= scv :scancode-4) (setf coords   (not coords)))

                   ((sdl2:scancode= scv :scancode-q) (sdl2:push-event :quit)) )
                 (format t "key: ~a ~a ~a~%" scv symv modv) ))

            (:idle ()
               (when draw
                 (gl:clear :color-buffer :depth-buffer)

                 ;; rotate
                 (when rotate-x (gl:rotate 1 rotate-x-speed  0 0))
                 (when rotate-y (gl:rotate 1 0 rotate-y-speed  0))
                 (when rotate-z (gl:rotate 1 0 0 rotate-z-speed))

                 ;; translate
                 (unless (and (zerop trans-x)
                              (zerop trans-y)
                              (zerop trans-z) )
                   (gl:translate trans-x trans-y trans-z) )

                 ;; draw
                 (when coords   (draw-coords))
                 (when stars    (draw-point-test))
                 (when triangle (draw-triangle-test))
                 (when polygon  (draw-polygon-test poly-vert))
                 (when poly     (draw-poly))

                 (gl:flush)
                 (sdl2:gl-swap-window win)
                 (sdl2:delay plen) ))

            (:quit () t) ))))))