Plant Eyes v7

A new way of growing roots… In this version you move through space (using the ‘f’ key) and leave a trail of ‘breadcrumbs’ that the root follows. This means that we can slow the growth right down.

I’ve also been experimenting with some shaders to work up the look of the thing a little more, and some particles to indicate absorbing of nutrients from the soil. Also – this version has the rocks I mentioned a few days ago which block your growth.

I’ve put a mac binary version up here, but it’s not loading the shader on my test machine – however the game works the same. As usual, code is on the foam git repo.

Soft shadows

A realtime shadow that softens as it recedes from the edge of the object. This is done by projecting the object’s geometry onto the plane from the direction of the light source – which essentially flattens it out like a pancake. Do this lots of times, jittering the light position a bit each time, and accumulate the result by using a suitable blendmode. Fluxus code here.

3D Stones and OSX version

I’ve made my first ever OSX binary release of version 6 of plant eyes, making it truly cross platform! 🙂

Things are moving a bit slowly with the game at the moment. I seem to have the whole thing in pieces on the floor, metaphorically – but I’ve added stones which block the roots from growing, and added some much needed structure to the soil. Here’s a not really very impressive screenshot:

Pulling faces in the name of progress

Testing how my face gets expressed in eigenface space as I change my expression. The face on the left is my face synthesised by the trained algorithm. Ideally, there would be no expression on any of the faces in the face database, and my synthesised eigenface would remain the same no matter what silly face I pulled – I want to be able to distinguish between users regardless of their expression. Of course the catch is that people’s appearance is all to do with their normal expression, so it picks up on some, particularly the grimacing for some reason 🙂

Of course, with a bunch of training images with expression in, it would be possible to track expression – which I might try soon.

More eigenfaces

This time using Dr Libor Spacek’s face database which comprises about 400 individuals. The faces along the top express the 30 most significant eigenfaces found in the data, and the three faces along the bottom are the average face, my face, and my face expressed in terms of the eigenfaces – i.e. generated from the properties the algorithm has learnt from other people’s faces.

Plant Eyes Version 6

Lots of new features requiring asterisks and exclamation marks:

*** NEW!!! – root steering with the camera! ***
*** NEW!!! – follow roots from the seed to the tip and back again! ***
*** NEW!!! – grow roots on your previously grown roots! ***
*** NEW!!! – garish textures! ***

Of course, it also comes with lots of exciting new bugs too…

Camera control : cursor or wasd keys
Root follow in/out: q/z keys
Grow root: space bar

Linux Version
Windows Version

Extrusions revisited

I’ve improved and tidied up the extrusion code and added it to the fluxus collection. Here’s an animation and the documentation:

(build-extrusion profile-list path-list width-list tex-vscale up)
Returns primitive-id

Returns an indexed polygon primitive made by extruding the profile
along path and scaling using values in width. The path and width
lists need to be the same size. tex-vscale allows you to scale
the texture coordinates along the length of the extrusion. An
up vector is needed for aiming the profile along the path.

     (build-circle-profile 20 0.3)
         (vector 0 0 0)
         (vector 0 1 2)
         (vector 0 -1 4)
         (vector 0 0 6))
     (list 0 1 1 0) 1 (vector 0 1 0))

(build-partial-extrusion profile-list path-list tex-vscale)
Returns primitive-id

Builds a primitive ready to be used with partial-extrusion. Use
this is for animating growth along extrusions.

(partial-extrude profile-list t profile-list path-list width-list up grow-value)
Returns primitive-id

Animates growth along extrusions. t is a value between 0 and the
length of the path, and controls how far along the extrusion to
calculate. Grow value is a scale to control how much the profile
is scaled to change it’s width as it grows.


 (define profile (build-circle-profile 10 0.3))
 (define path (build-list 20 (lambda (i) (vector (crndf) (crndf) i))))
 (define width (build-list 20 (lambda (_) 1)))
 (define p (build-partial-extrusion profile path 1))
     (with-primitive p
         (partial-extrude (* (length path) 0.5 (+ (sin (time)) 1)) 
             profile path width (vector 0 1 0) 0.1))) 

xxxxx-micro-research fluxus workshop

I spent last weekend in Berlin, on Saturday we has a fluxus workshop at pickled feet where I introduced livecoding and fluxus, and then had a quick play with the groworld game prototypes.

On Sunday I tried some audience participation livecoding. I think it went quite well, people were playing al jazari quite happily from the moment I got it set up, so I never really got the chance to explain anything – but it didn’t seem to matter too much. I just joined in with them, first doing some classic fluxus livecoding using the sounds they generated, then accompanying them with scheme bricks and finally al jazari myself, where I messed around with the bpm a bit too much and broke everything (slightly on purpose…)

I’d like to explore this form of audience inclusive performance more, I think it could work better if I was more in an audience role myself and not a separate entity – there is a bit of a performer/audience barrier to overcome.