Interface 27 from CyberPatrolUnit on Vimeo.

There has been a long tradition in live visuals and motion graphics, inherited from many other media, of maintaining a “secret sauce,” or the guarded formula of eleven herbs and spices. Ironically, for all you hear today “DIY” and “open source” in the same sentence, a lot of the motivation for doing something yourself has historically been doing something no one else can. Keep your secrets, and raise your value.

As our friend Bryant Place / CyberPatrolUnit sends over this latest set of live clips from a recent gig, and I browse through the comments, and reflect on the conversations I had last week at OFFF and during and following my own talk there, though, I’m struck.

The world has changed. First off, the Internet isn’t really about secrets. Your value is almost in direct proportion to how much you can share. Connections are forged through links of mutual exchange and good will. It’s not just about sharing your output or getting fans (the MySpace model), but sharing with a network of enthusiasts, and fellow artists. Those are the people from whom you often get real support (artistic, technical, and personal), gigs – and inspiration. (Even if you hate 8-bit music, that community is a really amazing model: their work to support each other and advocate for the whole subgenre has been I think the single biggest ingredient in their viral success.)

The visualist community increasingly itches not only to improve the quality of their own individual work, but everyone around them. A lot of us are in a battle for the future of this whole medium. Some parts of the world are devoid of live visuals, while others have mass-produced club visuals filling the nightlife.

Before I get carried away, the video itself is just the latest from the ongoing Interface 27 series. It employs a touch interface to control abstract visual pictures formed from streams of particles.

The reason I’m pulling back into the larger question is that these visuals are enabled by a library for Processing, a library we’ve seen here previously, developed by Memo Atken:

MSAFluid for processing (and Java)

If you’d rather use openFrameworks, there’s that version, too, as pictured below running blazingly fast:

ofxMSAFluid for openFrameworks

There’s even an ActionScript 3 port, in case you want to code Flash on the beach.

ofxMSAFluid for openFrameworks from Memo Akten on Vimeo.

What if one environment blended the code goodness of Processing with visual programming metaphors and patches, creating a single world for high definition video and OpenGL-powered 3D, with friendly-looking HyperCard-style inspectors, live coding, extensible graphical elements everywhere, an open-ended canvas, drawing with splines and images…

In other words, what if you could make anything, more easily?

That’s the vision of Field, a new authoring environment built on Java and Jython (Python on the Java VM). It’s Mac-only, with other platforms possible in the future (the underlying libraries are largely cross-platform, and apparently there’s the beginnings of a Windows build somewhere).

I asked Nick Rothwell to describe what it was about. Nick is collaborating with creator Marc Downie on choreographic generation and visualisation tools for Wayne McGregor’s Random Dance Company at Sadler’s Wells in London. Wayne, in turn, is choreographer in residence at the Royal Opera House and has worked on the Harry Potter Movies.

And Field can make your development environment feel, well, like a Muggle.

Field — Hybrid lines & code from OpenEndedGroup on Vimeo.

Here’s Nick’s capsule description:

Field is an open-source Mac-based media authoring system, built in Java by Marc Downie of the OpenEnded Group based on ideas formulated at the MIT Media Lab, and subsequently used for a variety of hi-def video installations and choreographic projects. It’s a graphical development environment attached to a high-resolution 3D OpenGL rendering engine, and applications are built on a display canvas with object boxes reminiscent of MaxMSP. But Field is different to MaxMSP because it’s language-based: the object boxes are individual containers of Python code, and the canvas is a flexible, scriptable interaction surface: Python code can draw on it using a 2D renderer, and user interactions and timing markers call back into the code.

There is a sophisticated editing environment for the code, and the canvas contents are version-controlled in a Mercurial repository which Field itself can inspect. Fieldis sufficiently self-referential to be regarded as a meta-environment: for example, click-and-drag editing operations on graphical elements cause Python code to be generated (and, of course, version-controlled). The text of the Python code itself can even contain embedded user interface components. Because Field is written in Java, it has access to all the Java libraries out there as well as portable Python libraries. Field can bridge to the Processing environment, allowing Processing to be scripted in Python and animated using Field’s canvas timelines and user interface components.

Wish granted!

Think 3D in the browser will never catch on? Think again. The folks at Google Labs have built an incredible-looking 3D API called O3D. It does just about everything you want, and then some:

• It’s multi-platform: Mac + Windows + Linux.
• It can render to both OpenGL and DirectX render pipelines.
• You can write your own vertex and pixel shaders. You have to use O3D’s own language for doing this, but that actually enhances compatibility, as frustrated shader coders may already know. (See the FAQ)
• It’s a scene graph, so managing complex 3D scenes isn’t a chore.
• It has powerful built-in functions like viewports and pickers (plus custom pickers), so you can actually get something up and running in a reasonable time.
• It has an import workflow with COLLADA, an open standard for 3D assets (and which, incidentally, has support in Google’s own SketchUp).
• You code in JavaScript, using the powerful V8 engine (developed for Chrome).
• Gears lets you run offline.

ofxMSAPhysics v2 from Memo Akten on Vimeo.

In a word: yummy. Or maybe that’s “bouncy.” Memo Akten’s brilliant ofxMSAPhysics brings open-source physics programming to the C++-based OpenFrameWorks environment, an artist-friendly combination with an elegant API. Coding physics doesn’t require an advanced degree. See today’s post on the beautiful My Secret Heart to watch this library in eye-popping action.

• particles
• springs
• attractions (+ve or -ve)
• collision
• replay saving and load from disk (temporarily disabled in current alpha release)
• custom particles (extend ofxMSAParticle and add to the system)
• custom constraints (extend ofxMSAConstraint and add to the system)
• custom force fields (extend ofxMSAParticleUpdater and add to the system)
• custom drawing (extend ofxMSAParticleDrawer and add to the system)

ofxMSAPhysics Project Page

By the way, don’t assume that the C++ folks get to have all the fun. Aside from the relatively simple but fast-and-useful traer.physics which inspired this more sophisticated outing, Java has stuff like:

jBullet
jME Physics 2 for jMonkeyEngine [wiki link]

There’s also a java.net project to bring the Open Dynamics Engine to Java, though I’m not sure that that’s terribly current. Java folks, feel free to chime in. But then, if you’re looking to migrate from Processing to OpenFrameWorks, this looks tasty indeed.

Perhaps it’s the church setting for the installation, or the strains of 17th-Century choral composition by Allegri. But Streetwise Opera’s My Secret Heart, binding together reactive visuals and post-Minimalist musical strains, has the feeling of a 21st Century passion play, a digital devotional piece.

My Secret Heart is a commission by Streetwise Opera, which develops work in the UK’s homeless centers, featuring performers from those shelters as stars, then transposing them to venues like Westminster Abbey. This work is a collaboration between electronic composer Mira Calix (Warp) with sound designer Dave Sheppard, and directed by video artists Flat-e with custom software programmed by visualist Memo Akten.

An installation, a film, and a performance, My Secret Heart’s 100 performers are wrapped in a virtual sonic and visual world, interwoven with digitally-generated, flowing tendrils, and driven by software that responds to sound and user interaction.

HD video on Vimeo

Director Flat-e and visualist Akten used a variety of techniques to create the organic fabric of the visuals:

• Filmed live action sequences and rendered After Effects sequences
• Visual components built in Quartz Composer, the free Mac developer tool
• Custom C++/OpenFrameWorks software for live performance
• Artificially-intelligent flocking behaviors, forming the particle strands that wend their way through the piece, as initially prototyped in Processing
• A new, original particle/physics engine built for OpenFrameWorks. Originally inspired by the open source traer.physics library for Processing, Memo’s library will support advanced features like recording and playback and pluggable force fields. (That makes me think of the Death Star tractor beam and the Millenium Falcon, but that’s probably just me.)
• A multi-dimensional spline interpolator for translating the particles into the flowing tendrils of the piece, also built for OpenFrameWorks.
• Cylindrical projection on a 16m-circumference “aquarium” rig by Gaianova