I’ve been working on this for the last few days. It basically takes Open Sound Control (OSC) packets- from any number of clients- which specify a DMX address, value and fadetime. The server is written in Processing, and uses the oscP5 library. Right now it uses the ENTTEC USB DMX Pro adapter to talk to DMX via serial comms, plus an excellent DMX class published on the Processing forums.

Why would you want this? Well, it means you can use anything that supports OSC to control your lighting and theatrical effects. Beat-syncing music is a piece of cake, controlling from an iPhone/iPod Touch likewise (Just write a little webapp and you’re good- or use a tool like TouchOSC). It’s stable (I threw strobe commands at all 512 channels for 12 hours and it was still running just fine afterwards), works a treat, and is perfect if you’re writing an OSC app and want a quick and easy way to hook into DMX controls.

The only documentation is this: It expects a message to /set with typetag iif, in the format address (1-<unisize>, default 128), value (0-255), and fadetime (0.0-n, where n is a large float). Other than that, run and enjoy. I’ll be throwing the odd update to this up but I expect the API to remain the same. I’m using this for a project where we want to do some interesting things with a large number of LED parcans very quickly, so performance is fairly vital- it’s designed to be quick, but I’m not Java genius, so suggestions are welcome.

Using the Ruby OSC library, you can whip up a simple client in seconds:

This sets channel 1 to snap on. Easy, eh? I’ve not tested this with bundles but it should work fine.

You can grab the source (Processing required to run) over here on Github.

I’m under a bit of time pressure at the moment but might end up writing this again in openFrameworks. It’s C++, so much faster, and should be more flexible in terms of sheer speed. Sub-second strobes and so on should be attainable. My next hardware project? Bodged strobe controller for Arduino….

The Obsessive Camera Direction library for Processing lets you do just that quite easily. Simply install the library and follow the guide for easy, awesome controls.

You need to be using some form of 3D rendering on your sketch already, be it OpenGL or P3D. You can do this by using the third argument to size- I use the GlGraphics renderer (an extension of the OpenGL renderer), so my setup function looks like this (more or less):

Now we move on and get down to business. We need to set up a few global variables.

Next, we modify our setup function to initialise the camera at it’s starting point.

And finally, we need to set up this camera as our active camera feed in our draw function.

And there you have it- almost! So far we’ve just added a camera. Now we need a lengthy function to map keyboard and mouse to the camera movement controls.

Right, finally done. This will map your mouse as follows:

• Left mouse button looks around
• Right mouse button moves backwards/forwards
• Centre mouse button (wheel click down on most mice) is left/right movement

Your keyboard also gets some controls:

• r – Resets view to the default position
• w – Moves view forwards
• s – Moves view backwards
• a – Moves view left
• d – Moves view right
• Control – Moves view down
• Space – Moves view up

All up/down/left/right is relative to the view axis.

Hope this helps someone else trying to achieve the same thing with Processing!

Sort of working!

I’ve ended up creating a custom database to run the app off based on the Empyrean Age 1.1 data export from EVE, and that’s hooked into Processing using the MySQL library. The systems (and jumps, now) get loaded into the sketch on load, and are stored in two arrays as classes. As a first Java project it’s interesting to note the differences between Ruby, PHP and Java. I think I’m going to look at Processing on Ruby soon.

Hopefully this will run smoothly enough to get some data hooked in with XML feeds off EVE Metrics to provide a nice way to visualise things outside the browser. OpenGL is a bit iffy when used in the browser with Java, but I’m not really that fussed about making this a part of the site, more of a cool tool if you want to tinker. I’ll throw it all up on Github once it’s gotten halfway decent.

It’s made me wonder, though- is there anything akin to Processing out there that isn’t Java? I’d be really interested to see anything either C-based or Ruby-based that goes for more of the ‘visual programming’ angle rather than the more generic frameworks that tend to flourish these days.

So very tired, but tomorrow brings rest, a fresh Stargate Atlantis episode, and the potential for loads of lounging about for a week of holiday. Bliss.