;; hackpact day 27 - edges
;; gabor papp http://mndl.hu/hackpact

(require scheme/math)
(require scheme/list)

(display (midi-info))(newline)

(midi-init 0)

(clear)

(scale #(20.2 16.2 1))
(translate #(-.5 -.5 0))

(define pxt (load-primitive "textures/disp.png"))
(with-primitive pxt
    (scale 0)) 

(define s 256)
(define px0 (build-pixels s s #t))
(with-primitive px0
    (scale 0))

(define px1 (build-pixels s s))
(with-primitive px1
    (scale 0))

(define p0 (ffgl-load "cidisplacementdistortion" s s))
(with-ffgl p0
    (ffgl-process px1 px0 pxt)
    (ffgl-set-parameter! #:scale .25))


(define px2 (build-pixels s s))
(with-primitive px2
    (scale 1))

(define p1 (ffgl-load "ciedges" s s))
(with-ffgl p1
    (ffgl-process px2 px1))


(define (moeb k l t [rot 0])
    (let* ([R 4]
           [r 4]
           [alpha 0]
           [addalpha (/ (* 2 pi) k)]
           [points
                (flatten
                    (for/list ([j (in-range k)]
                               [alpha (in-range 0 (* 2 pi) addalpha)])
                        (let ([x1 (* (+ R (* r (cos (* t alpha)))) (cos alpha))]
                              [y1 (* (+ R (* r (cos (* t alpha)))) (sin alpha))] 
                              [z1 (* r (sin (* t (+ alpha (* .3 (sin (+ alpha rot)))))))]
                              [x2 (* (- R (* r (cos (* t alpha)))) (cos alpha))]
                              [y2 (* (- R (* r (cos (* t alpha)))) (sin alpha))] 
                              [z2 (* (- r) (sin (* t (- alpha (* .3 (sin (+ alpha rot)))))))])

                            (let ([addx (/ (- x2 x1) l)]
                                  [addy (/ (- y2 y1) l)]
                                  [addz (/ (- z2 z1) l)])
                                (for/list ([i (in-range l)])
                                    (vector (+ x1 (* i addx))
                                        (+ y1 (* i addy))
                                        (+ z1 (* i addz))))))))])
        points))

(define cseg 256)
(define rseg 12)

(define p
    (with-pixels-renderer px0
        (blur .9)
        (texture (load-texture "textures/bogdan_08.png"))
        (backfacecull 0)
        (opacity .5)
        (hint-unlit)
        (hint-ignore-depth)
        (let ([p (build-polygons (* cseg rseg 4) 'quad-list)])
            (with-primitive p
                (let ([tja (/ 1 cseg)]
                      [tia (/ 1 rseg)])
                    (for* ([j (in-range cseg)]
                           [i (in-range (sub1 rseg))])
                        (let* ([op (* (+ (* j rseg) i) 4)]
                               [ti (/ i rseg)]
                               [tj (/ j cseg)])
                                  (pdata-set! "t" op (vector ti tj 0))
                                  (pdata-set! "t" (+ op 1) (vector (+ ti tia) tj 0))
                                  (pdata-set! "t" (+ op 2) (vector (+ ti tia) (+ tj tja) 0))
                                  (pdata-set! "t" (+ op 3) (vector ti (+ tj tja) 0))))))
            p)))

(every-frame
    (begin
      (with-pixels-renderer px0
        (let ([l (moeb cseg rseg (* 3 (midi-ccn 0 6)) (time))])
            (with-primitive p
                (identity)
                (rotate (vector (* 8.2 (midi-ccn 0 3) (time)) (* 1.1 (midi-ccn 0 4) (time)) (* .8 (midi-ccn 0 5) (time))))
                (for* ([j (in-range (sub1 cseg))]
                       [i (in-range (sub1 rseg))])
                    (let* ([o (+ (* j rseg) i)]
                           [op (* (+ (* j rseg) i) 4)])
                          (if (= j (sub1 cseg))
                            (begin
                              (pdata-set! "p" op (list-ref l o))
                              (pdata-set! "p" (+ op 1) (list-ref l (+ o 1)))
                              (pdata-set! "p" (+ op 2) (list-ref l (modulo (+ o rseg 1) (* cseg rseg))))
                              (pdata-set! "p" (+ op 3) (list-ref l (modulo (+ o rseg 0) (* cseg rseg)))))
                            (begin
                              (pdata-set! "p" op (list-ref l o))
                              (pdata-set! "p" (+ op 1) (list-ref l (+ o 1)))
                              (pdata-set! "p" (+ op 2) (list-ref l (+ o rseg 1)))
                              (pdata-set! "p" (+ op 3) (list-ref l (+ o rseg)))))))
                (recalc-normals 0))))
    (with-ffgl p1
        (ffgl-set-parameter! #:intensity (midi-ccn 0 2)))
    (with-ffgl p0
        (ffgl-set-parameter! #:scale (midi-ccn 0 1)))))