;;;; my-proj.lisp

(in-package #:my-proj)

;;
(defparameter *lisp-data* (list (list (v!  0.5 -0.36 0) (v! 0 1 0 1))
				(list (v!    0   0.5 0) (v! 1 0 0 1))
				(list (v! -0.5 -0.36 0) (v! 0 0 1 1))))
(defparameter *array* nil)
(defparameter *stream* nil)
(defparameter *running* nil)
(defparameter *loop-pos* 0)
(defparameter *sc-gpu-array* nil)
(defparameter *view-port* nil)
(defparameter *theta* .1)
(defparameter *split-counter* 0)
(defparameter *tex-array* nil)
(defparameter *texture* nil)
(defparameter *sampler* nil)
(defparameter *rotate-speed* 3)
(defparameter *num-splits* 0)


(defun-g vec3-2d-rotate ((thet :float) (vec :vec3))
  (v! (dot (v! (cos thet) (* -1 (sin thet)) 0) vec)
      (dot (v! (sin thet) (cos thet) 0) vec)
      (dot (v! 0 0 1) vec)))

(defun-g resize ((vec :vec3) (resize-factor :float))
	 (v! (* (x vec) resize-factor)
	     (* (y vec) resize-factor)
	     (* (z vec) resize-factor)))

(defun-g tri-vert ((vert g-pc) &uniform (offset :vec2) (thet :float) (resize-factor :float))
  (values (+ (v! (* .1 gl-instance-id) 0 0 0)
	     (v! offset 0 0)
	     (v! (vec3-2d-rotate thet (resize (pos vert) resize-factor)) 1))
	  (col vert)))

(defun-g tri-frag ((color :vec4))
  color)

(def-g-> prog-1 ()
  tri-vert tri-frag)

(defun make-sampler-from-file (file-name)
  (setf *texture* (make-texture (dirt:load-image-to-c-array file-name)))
  (setf *sampler* (sample *texture*)))

(defun quad-split (loop-pos &optional (x-off 0) (y-off 0) (recursion-depth 0))
  (let* ((offset-factor (* .5  (expt .5 recursion-depth)))
	 (resize-factor (expt .5 *num-splits*)))
    (oscilate-rotate loop-pos (v! x-off y-off) resize-factor)
    (if (< recursion-depth *num-splits*)
	(progn
	  (quad-split loop-pos (+ x-off offset-factor) y-off (+ 1 recursion-depth))
	  (quad-split loop-pos (- x-off offset-factor) y-off (+ 1 recursion-depth))
	  (quad-split loop-pos x-off (+ y-off offset-factor) (+ 1 recursion-depth))
	  (quad-split loop-pos x-off (- y-off offset-factor) (+ 1 recursion-depth))))))

(defun av (vec1 vec2)
  (v! (+ (x vec1) (x vec2)) (+ (y vec1) (y vec2))))

(defun scale (c vec)
  (v! (* c (x vec)) (* c (y vec))))

(defun oscilate-rotate (loop-pos offset resize-factor)
  (let ((theta loop-pos))
    (map-g #'prog-1 *stream*
	   :offset (av offset (scale .3 (v! (sin (* *rotate-speed* *loop-pos*))
					    (cos (* *rotate-speed* *loop-pos*)))))
	   :resize-factor resize-factor
	   :thet (sin (* 4 theta)))))

(defun step-demo ()
  (incf *loop-pos* .004)
  (incf *split-counter*)
  (step-host)
  (update-repl-link)
  (clear)
  (quad-split *loop-pos*)
  (swap))

(defun run-loop ()
  (setf *running* t
	;;*array* *sc-gpu-array*;;
	*array* (make-gpu-array *lisp-data* :element-type 'g-pc)
	*stream* (make-buffer-stream *array*))
  (loop :while (and *running* (not (shutting-down-p))) :do
     (continuable (step-demo))))

(defun stop-loop ()
    (setf *running* nil))

;;; "my-proj" goes here. Hacks and glory await!