messing about with solid 3D geometry

by pixelpusher on Thursday 10 December 2009
[Blog, Visuals, video]

Just a sketch, playing with “extruded shapes” – basically, 3D geometry in a big long cheese log, doped up with some sinusoidal harmonics.

Some code:

(require fluxus-016/shapes
scheme/list)

(clear)

(define l (build-list 20 (lambda (i)
(vector 0 0 (+ 10 (* -1 i))))))

(define w (build-list 20 (lambda (i)
(* 1 (+ 1 (sin (* 3.14156 (/ i 20))))))))

;(define w (build-list 10 (lambda (i) 4)))

(hint-wire)

(define (sinuside circ complexity)
(define (_ c n)
(cond [(< n 1) empty]
[else
(cons (vadd (car c) (vmul (car c)
(* 0.3 (sin (* (* complexity 3.1415) (/ n (length circ)))))))
(_ (cdr c) (- n 1)))
])
)
(_ circ (length circ))
)

(define circle (sinuside (build-circle-points 80 1) 16))

(define pe
(with-state
(rotate (vector 0 0 90))
(build-partial-extrusion circle l 1)))

(recalc-normals 1)

(define (draw-extr e)
(with-primitive e
(partial-extrude
;(* (length l) (+ 0.5 (* 0.25 (+ (sin (time)) 1))))
(length l)
(sinuside (build-circle-points 80 1) (round (* (time) 16)))
l
w
#(0 1 0)
1)
)
)

(define (animator)

(draw-extr pe)
)

(every-frame (animator))

Featured on SketchPatch

by pixelpusher on Sunday 6 December 2009
[Blog, Visuals, images]

I’m proud to announce that the gang at SketchPatch.net were kind enough to make me the featured artist this month!

For those of you who haven’t seen it, SketchPatch is a playground for Processing sketches, where you can create, edit, share, and copy others’ sketches.  All sketches on the site are Creative Commons  3.0 attribution licensed, which means you can copy the code and use it as long as you give credit to the original author(s).

Toad Circle particle system

by pixelpusher on Friday 4 December 2009
[Blog, Visuals, video]

Click to Play

Code:

; a simple script that looks like it could be made into a
; water simulation of some kind

(clear)

(require fluxus-016/shapes)

(hint-ignore-depth)

; dimensions of the circles
(define elems 20)
; angle between each element
(define elem-angle (/ 3.14156 elems))

; simulation constants
(define max-dist 10)
(define max-dist-sq (* max-dist max-dist))

(define min-dist 4)
(define min-dist-sq (* min-dist min-dist))

(define max-vel-mag 0.1)

; stops the simulation going out of control
(define max-vel (vmul (vector (cos elem-angle) (sin elem-angle) 0) max-vel-mag))
(define max-vel-sq (vdist-sq max-vel (vector 0 0 0)))
(define trans 0.008)  ; the amount the energy transmitted to
; the neighboring vertex

; feedback velocity per frame
(define feedback 0.1)

; complexity of initial positions (sin peaks, basically)
(define complexity 4)

; make a list of points in a circle
(define circle-points (build-circle-points elems 1))

(define tex (load-texture "/Users/evan/cvs/newflx/fluxus/textures/whitetoady.png"))

(define s (build-particles elems))

(with-primitive s

    (pdata-add "vel" "v")
    (pdata-add "v0" "v")
    (pdata-add "p0" "v")

    (pdata-index-map!
        (lambda (i p)
            (list-ref circle-points i))
        "p")

    ; copy default pos at radius 1
    (pdata-copy "p" "p0")

    ; scale circle radius
    (pdata-index-map!
        (lambda (i p)
;            (vmul p (+ (* (* 0.5 (+ 1 (sin (* 3.4156 (/ i elems)))))
;                (- max-dist min-dist)) min-dist)))
            (vmul p (* (* 0.5 (+ 1 (sin (* complexity (* 3.4156 (/ i elems)))))) max-dist))) 

        "p")

    ; start off the simulation with random point distances
;    (pdata-index-map!
;        (lambda (i p)
;            (vadd p (vmul p (* (* max-dist 0.4) (crndf)) )))
;        "p")

    (pdata-index-map!
        (lambda (i vel p)
            (vmul p (/ max-dist 10)))
        "vel" "p")

    ; store initial velocity
    (pdata-copy "vel" "v0")

    ; start off the simulation with random colours
    (pdata-map!
        (lambda (c)
            (rndvec))
        "c")

    ; start off the simulation with random colours
    (pdata-map!
        (lambda (s)
            (vector 2 2 0.6))
        "s")
    )

(define (simulate n)
    (cond [(< n 0) 0]
        [else

            (let* [(result (pdata-get "vel" n))
                    (p (pdata-get "p" n))
                    (p-sq (vdist-sq p (vector 0 0 0)))]

                (cond [(> p-sq max-dist-sq)
                        ;                        (display "max")(newline)
                        ; we are above "sea level" head down
                        (pdata-set "vel" n (vmul (pdata-ref "vel" n) -0.9))
                        ;                        (pdata-set "vel" n (vmul (pdata-ref "v0" n) -1))
                        (pdata-set "p" n (vmul (pdata-ref "p0" n) max-dist))
                        ]
                    [(< p-sq min-dist-sq)
                        ;                        (display "mIN")(newline)
                        ; we are below "sea level" head up
                        ;                        (pdata-set "vel" n (pdata-ref "v0" n))
                        (pdata-set "vel" n (vmul (pdata-ref "vel" n) -0.9))
                        (pdata-set "p" n (vmul (pdata-ref "p0" n) min-dist))
                        ]
                    [else

                        (let [(pv (* (vdist (pdata-get "vel" (- n 1)) (vector 0 0 0)) trans))
                                (nv (* (vdist (pdata-get "vel" (+ n 1)) (vector 0 0 0)) trans))]

                            ; mix in the surrounding verts to transmit energy around
                            (set! result (vadd result
                                    (vmul result pv)))

                            (set! result (vadd result
                                    (vmul result nv)))

                            ; add the result to the existing velocity

                            (pdata-set "vel" n (vadd (pdata-get "vel" n) (vmul result feedback)))
                            ;(pdata-set "vel" n (vadd (pdata-get "vel" n) result))
                            )
                        ]
                    )

                (let* [
                        (v (pdata-get "vel" n))
                        (v0 (pdata-get "v0" n))
                        (vmax (vmul v0 max-vel-mag))
                        (v-sq (vdist-sq v (vector 0 0 0)))]
                    ; clamp the velocity - this stops the
                    ; simulation going too fast and blowing up
                    (cond [(> v-sq max-vel-sq)
                            ; divide by mag to get sign, mult by max-vel
                            (pdata-set "vel" n (vmul (vmul v (/ 1 (vmag v))) max-vel-mag))
                            ]
                        )
                    )

                )

            (simulate (- n 1))
            ]
        )
    )

(define (render)
    (set! feedback (* 0.4 0.5 (+ 1 (sin (* 0.3 (time))))))
    (with-primitive s
     (rotate (vector 0 0 2))
        (texture tex)
        (simulate (pdata-size))
        (pdata-op "+" "p" "vel")
;        (recalc-normals 1)
        )
    )

(every-frame (render))

The Cane Toad Orchestra at Space Studios pt 2

by pixelpusher on Monday 9 November 2009
[Blog, Visuals, video]

Click to Play

Pixelpusher and The Cane Toads at Shunt

by pixelpusher on Wednesday 23 September 2009
[Blog, Past Performances, Performances, Software, video]

The Cane Toads at Shunt 1 Oct 2009

The Cane Toad Orchestra featuring PixelPusher (or so I like to call it) is playing Shunt next Thursday, Oct 1, 2009, as part of Toplap’s Livecode stage.  That’s right, we’ll have no choice but to make some livecoded music and visuals, and that means sonic and visual anarchy of the most chill quality, kind of like a nice late-season muscat dessert wine, full of bite but thick with sweetness like a long summer day.  (I think that was a triple-simile, and I might have twisted my ankle landing that one.)