+ View large.

+ View large.

Lots of new stuff learned over the weekend. Here’s a summary:

• Really understand basic OpenGL lighting now.
• Understand how to do basic material coloring now.
• Learned how to texture a quad!
• Starting to learn some things about the Boost C++ libraries.
• Finally remembered that OpenGL is a state machine.

I think I actually (finally) have enough know-how to execute what I’ve got going on in my head. It’s going to require some refactoring of code, but I don’t feel like I’m up against an unclimbable wall anymore, which is precisely how I felt by the end of the day on Sunday.

I still think this looks boring / uninteresting, but it’s just another step closer and a lot of lessons learned.

Here’s a video render of what it looks like in realtime:

Update on 04-29-2010: The C++ framework that I’m using has just been released to the public. It’s called Cinder. Big ups to Andrew Bell, Robert Hodgin, and The Barbarian Group for all the time and effort put into releasing such a powerful and fun open source framework for creative coding!

Below is a 60 second render from the data set captured from this drawing.

Aesthetically, this is completely off the mark from what I’ve got in my mind’s eye. But in doing each of these exercises, I’m getting more familiar with C++ programming and openFrameworks and the various add-ons that exist out there.

And I’m also refining my general goals for the first set of “pieces” I want to create with this Flow system:

1. Show the energy and motion of each stroke. This needs to be visible even in a static render.
2. Avoid random as much as possible. The work needs to exhibit clear intention.
3. Create something dimensional, structural.
4. Work within “moments” of the data set, not its entirety.

I’m going to try to make sure whatever it is I come up with adheres to these main goals for now.

Note: Super sorry about the seriously shaky footage above. Next time I’ll make sure it doesn’t happen.

Yesterday, I spent about 12 hours making what I thought would take “a couple hours” — the Flow Receiver module. In the video above, you can see me demoing the system. Everything is up and running and working seemingly well. This means it’s time to start creating “art.”

I designed the UI for this thing to be as simple as I could make it while also accounting for the fact that I’d be using it on a touch-enabled display. It only has three different “views” which you can see below.

+ View larger on Flickr.

+ View larger on Flickr.

+ View larger on Flickr.

Everything for Flow Receiver is built using Adobe AIR. It communicates with Community Core Vision using CCV’s built-in UDP->TCP bridge which sends out TUIO data associated with the tracked blobs.

Flow Receiver intercepts this TUIO data and displays the incoming data in the right-side panel. I’ll also use this software to interface with the Flow Storage back-end module for creating projects and recording the TUIO data to those projects.

When in “recording mode”, Flow Receiver buffers the incoming TUIO points until its internal “cache” is full, then sends that info via HTTP POST request to Flow Storage which dumps it into a MySQL database. I’m also storing a timestamp (to the millisecond) with each TUIO point collected so that I can later determine velocity data between “frames” as needed.

When it’s time to export a project’s data, I’ll use Flow Receiver to export the data as either an XML or CSV text file.

Not much else to it than that; it’s a super-simple application.

On a side note, I’m pretty amazed at what we can do with technology these days, the number of options from which we have to choose, and the speed at which we can produce this stuff. I’ve somehow managed to create a fully-functioning toolset in a total of about 20 man-hours, cobbled together from open source libraries, applications, and various other technologies — all at pretty much zero cost (aside from the time put in).

As I prepare for my new job which starts on January 4th, I’m taking some time to learn Derivative’s TouchDesigner. It’s a realtime procedural 3D / compositing tool. Well, it’s actually so much more than that, but it’s very difficult to describe.

Anyway, I’m trying to learn it. And I’ve found the best way to learn stuff (for me) is to take something I’ve already made and try to recreate it in the new environment. So, that’s what I’ve started doing here. I’m not sure how much further I want to go with this, but it’s nice to know that I could pull this much together after about an hour’s worth of work.

This software is terribly powerful, and more and more documentation / improvements / tutorial videos are being added all the time. It’s making me very excited about 2010.

+ View the piece on Flickr.

+ View the piece on Flickr.

+ View the piece on Flickr.

Some progress has occurred. C++ is becoming clearer. Here’s what progressed in the first couple images:

1. I created a Tween class for animating values. It’s modeled after CASA Lib’s Tween class. I’ll probably be releasing it to the community soon.
2. I hooked up my MIDI controllers to the piece, so I could have more control over tweaking values. I’m using a great add-on for openFrameworks called ofxMIDI.
3. Along the way, I learned how to implement openFrameworks event dispatchers and listeners. (Hint: search for “poco events” in the openFrameworks Wiki if you want to learn how.)

In doing all this, I was able to trigger light movements with a MIDI controller. I used my M-Audio Trigger Finger’s velocity-sensitive pads to animate two lights. Hard tap = fast movement.

+ View hi-res on Flickr.

Here’s a video of the animated lights in action. Please excuse the stutters; while this does run at 30fps in realtime, SnapzPro isn’t able to keep up because of the CPU usage of the piece.

Now after all this, I came to realize that I really wanted to be able to loop the Perlin noise that was creating the height map of the tube. Because, though you can’t see it, there’s an awful seam on the side facing away from the camera. By looping the noise, I could reliably look at it from all angles.

After some research, I came across a great library called libnoise. Took me a little while to get it to compile, only to realize that while it did the job, it dropped my framerate from a respectable 45fps to 9fps. Definitely not suitable for realtime noise generation.

So I went back to the fastest Perlin noise generator I could find (this class from John Ratcliff), and I decided to live with the seam in the back.

Amidst all this, I also stumbled upon this awesome blog post about Twisted Architecture. I thought it would be cool to implement something like that in my piece. So I did. But then I forgot about it.

It was only when I started twisting the “twist-associated” knob on my MIDI controller that the damn seam actually came to life. So, you can see how it starts to play out in the rest of the images here:

+ View hi-res on Flickr.

+ View hi-res on Flickr.

+ View hi-res on Flickr.

+ View hi-res on Flickr.

Also, in those last couple renders, I added a convex mesh to the background so that I could start incorporating background colors properly. Moreover, so I could get some light-generated gradients happening. More to come… more to come.

I recently discovered a huge disconnect between text-based 3D graphics programming and my brain. It was quite an unpleasant discovery.

Out of frustration, I decided to turn to a more graphical, procedural approach. For some reason when it comes to 3D, I really need a UI and “objects”. It’s all too abstract when I’m dealing with lines of code.

So I’m trying out visual procedural programming. And I’m starting with Derivative’s TouchDesigner. I was introduced to the application long ago, back in 2005 at FITC. But it’s gone through a complete rewrite and UI overhaul.

A certain Steve Mason (former coworker at Odopod and most recently at Obscura Digital) re-introduced me to the application a couple months ago. He’s done some seriously amazing stuff with it already.

And tonight, I made a spherical 3D particle cloud. Nothing revolutionary, but there is some serious power and possibility embedded in this application. The UI is absolutely next level and intriguing. I highly recommend you download it and have a run through the video tutorial screencasts. It’s a Windows-only application (sadly). And it’s still buggy since it’s in very active development. I’d recommend you download the latest experimental release. I had more luck with it than the main release on their Downloads page from May of this year.