So just like last year’s effort, I’d very much wish for and would like to produce another showreel of all the recent interesting projects & experiments done by YOURSELVES with the various library packages. The aim of this undertaking is simply to create a record, a snapshot, some overview and inspiration for other (possibly new) users of these libs. To make this happen I really do need your help & generous contributions in the form of footage, both video and still image assets. Finished projects are desirable, but often the work-in-progress stages are highly interesting too, so if possible, please do include these too. All work will be clearly credited and the reel will be premiered during my talk at Flash On The Beach on September 27, 2010. Afterwards the video will be hosted on Vimeo.

Like last year, the guidelines are remaining as follows:

• only submit projects you’ve worked on/own rights to/have permission to include
• project name, client (if any), year, author(s), project URL
• list of toxiclibs package(s) used
• video resolution 1280×720 (if possible, lower res might be fine too)
• screenshots/photos (if you have stills only, more than one would be extremely helpful)
• (optional) your vimeo username for crediting using their system

Please get in touch via email: toxiclibs at postspectacular dot com

I can provide FTP upload space if you don’t have any yourself. Alternatively, you might want to sign up with Amazon S3, Dropbox, Box.net or similar services…

Entry deadline is: Monday 20 September 2010, 12:00pm GMT

Your help is v.appreciated & I shall thank you dearly!!!!

Once more for the record, here’s the previous reel from 2009…

First up is Ricardo Sanchez, one of those guys who had been hindered by the lack of demos & documentation last year and has been in touch a few times about the physics engine. His questioning also directly triggered me to do a few more demos, which are now bundled with the last couple releases. A few days ago he excitedly told me that he’s finished his project and I wanted to share it with you here too:

You can download the Processing source code for this sketch from the project website and read some more about his process on his blog.

The other experiment I found is a nice showcase of the SphereConstraint in action to create a, well spherical, boundary for the physical simulation space. FYI the constraint can also be inverted and be configured to work as obstacle instead, not allowing any particles within the volume of the sphere. This can be achieved via a flag to its constructor.

The effect is quite interesting and somewhat reminds me of Mikkel Koser’s & shiftControl’s recent COP15 identity, although the behaviour of particles there is far more complex.

More detailed info about the most recent release and the behaviour changes it caused will be posted asap.

By Joe Turner

By DieTapete

By Stefan Mylleager

By Lia

I especially like the amount & colours of the contour layers used to visualize different densities. A similar (only in principle) thought also lead to the concept for the V&A Decode Identity completed recently. Just create a VolumetricSpace instance, use one of the preset VolumetricBrushes (or create your own one through sub-classing), use it to manipulate the “density” in the space and then pass the space instance to a IsoSurface to turn it into a TriangleMesh. Et voila! Example code for this basic approach comes with the volumeutils library download.

UPDATE: There’s also an older, alternative version which is using sensor inputs to control its growth (so maybe the above process is related or even the same)…

“this rhizome grows only if PIR sensor doesn’t detect movement [either nobody is in the room, or you stay still] amount of light measured by photocell influences branches girth. in this way, resulting form is a diagram of changing environmental conditions.”

So over the holidays I’ve been doing some research about kinetic & mechanical art and then started working on some additions to various classes in the core and physics packages. These in turn needed testing and inspired me to create the little New Year’s greetings below:

Amongst other things the new additions include:

• ParticleString class to automatically connect a list of particles with springs or create a string of particles along a line/ray
• ParticlePath is extending Spline2D/3D and can turn the spline into a ParticleString sampled at an uniform interval
• New ParticleContstraint implementations and improvements to existing ones:
  • AxisConstraint locks movement of a single axis
  • PlaneConstraint locks movement in a plane (only 1 axis left to move in freely)
  • CylinderConstraint creates a cylindrical obstacle in the simulation space
  • BoxConstraint turns an axis-aligned box (AABB) into an obstacle
  • SoftBoxConstraint uses an AABB as perimeter and slowly forces particles towards its centroid coordinates (per axis)
• Reworked (corrected) velocity handling and accessors for contraints to manipulate particle velocities upon collision

Even though these updates are not yet part of a new release, you can download the source code (as complete Eclipse project incl. compiled versions of the pre-release libraries) and interactive realtime versions for OSX & Windows from here:

xmas.postspectacular.com/2010/

To get the project into Eclipse, simply use the Import wizard:

File > Import… > Existing projects into workspace > Next > Select archive file > Choose the downloaded zip > Finish

Apart from the showing how to use these new classes mentioned above, Processing heads might also be interested in the elegance of XML parsing using JAXB (one of my favourite additions to Java 6). Last but not least, the project is also utilizing the custom vector shape alphabet system originally developed for the onedotzero festival identity last year.

Happy 2010 everyone!

The Processing source code for generating these meshes is available with the library download, with an excerpt shown also below. But first, here’s a brief overview of how to use these classes:

Waves & oscillation in general are very flexible & powerful tools for many different design tasks and shouldn’t always be thought of in an audio context. For example, a square wave can be used to flick between 2 values at a given frequency, without the need for any if() statements. I also often use sine waves to create cyclical, soft, harmonious value changes, be it for interface design, movement, animation or even the time based modulation of behavioural parameters of agents. The core library comes with the following pre-defined wave types:

• Sine (pure, frequency modulated (FM), amplitude & frequency modulated (AMFM))
• Sawtooth (FM)
• Square (FM and FM with harmonics)
• Triangle (FM)
• Constant (only provides a static value, e.g. useful as static source for input as FM)

All of these types are expressed as implementations of the AbstractWave class in the toxi.math.waves package. This abstract class defines all commonalities of what constitutes a wave: a phase, a frequency, an amplitude, a centre offset and a bunch of accessors and converters. The actual wave function then needs to be implemented by a concrete sub-class. Using poly-morphism and having an abstract super class makes a lot of sense in this case, since it allows for all this:

1. It frees our main application from having to know which exact wave type we’re going to use and so allows for easier/faster experimentation and generally more flexibility.
2. It enables us to plug-in any of the available wave types as input for frequency or amplitude modulation and so create highly (theoretically infinitely) complex waveforms.
3. It provides the basics of an extensible framework for creating new wave types.

These points are hopefully confirmed by you when looking at this method below (taken from the AdditveWaves demo, bundled since toxiclibscore-0015):

AbstractWave createRandomWave() {

  AbstractWave result=null;

  // create a randomized sine wave to be used as
  // FM input for the main wave chosen below
  // the order of parameters is:
  // start phase, frequency (in radians), amplitude, offset value
  AbstractWave fmod=new SineWave(0, random(0.005, 0.02), random(0.1, 0.5), 0);

  // pick a random frequency
  float freq=random(0.005, 0.05);

  // choose a wave type
  switch((int)random(7)) {
  case 0:
    result = new FMTriangleWave(0, freq, 1, 0, fmod);
    break;
  case 1:
    result = new FMSawtoothWave(0, freq, 1, 0, fmod);
    break;
  case 2:
    result = new FMSquareWave(0, freq, 1, 0, fmod);
    break;
  case 3:
    // harmonic square waves are created by
    // adding sine waves upto a number of octaves
    // above the base frequency
    result = new FMHarmonicSquareWave(0, freq, 1, 0, fmod);
    ((FMHarmonicSquareWave)result).maxHarmonics=(int)random(3,30);
    break;
  case 4:
    result = new FMSineWave(0, freq, 1, 0, fmod);
    break;
  case 5:
    AbstractWave amod=new SineWave(0, random(0.01,0.2), random(2, 3), 0);
    result = new AMFMSineWave(0, freq, 0, fmod, amod);
    break;
  case 6:
    result = new ConstantWave(random(-1,1));
    break;
  }
  return result;
}

The next snippet then quickly shows how this method would be used:

import toxi.math.waves.*;

AbstractWave wave=createRandomWave();

// updates the wave phase and computes the new function value
// this code doesn't care which wave type we're dealing with
float currValue=wave.update();

The generators have another useful feature, though: A state stack. If you’ve used Processing or OpenGL before, you have likely come across the concept in the form of pushMatrix()/popMatrix() calls to save and restore the state of the graphical transformation matrix. The wave generators implement the same idea and so can be easily used to create the 3D meshes above.

// save current wave state
wave.push();

for(int i=0; i<10; i++) {
  float lookahead=wave.update();
  // do something clever
}

// restore wave to previous state
wave.pop();

To make the project as widely accessible as possible to people, it was built in Processing, but obviously with a major helping of various toxiclibs too(core, color & volumeutils).

You can download, remix & recode the original piece and turn it into your own original artwork by downloading the app and/or source code from:

decode.googlecode.com

Some of these recoded versions might then even become the new Decode identity. Media partner, CBS Outdoor will be promoting the exhibition using the original piece across its large HD projection screens in platforms on the London Underground from Monday, November 30, 2009. All recoded works submitted via the V&A website before January 11, 2010 will then be put forward into a competition to appear in an advert on CBS Outdoor’s XTP screens, further promoting the exhibition.

UPDATE: I’ve posted some of my favourite “recodes” over here.

Some more images of the whole design journey are on flickr…

Edited in a non-stop 24h session, I’m really happy with the result & seeing these projects together in one piece gave me an immense buzz, but see for yourself!

We will be attempting to do another one of these later this year, so if you have built anything cool with any of the library packages you’d want to contribute, please do get in touch here, via email, flickr, vimeo or twitter.