I often email myself links to articles and blogs that I want to read later. It’s generally something that I only want to read once and then forget so it doesn’t seem appropriate to bookmark the links using my delicious account. But an inbox full of emails isn’t working either so I’ve decided to create a blog post where I can store all the links to pages that I still want to re-visit or re-read.
I discovered monome a couple of years ago and have been desperate to one day either buy one of the limited edition devices that they produce or buy one of their kits and solder and build my very own Monome.
Getting started. There are a few options for getting your hands on your very own monome device. Firstly you can buy a pre-built momone from monome.org however these can often be quite expensive and have a very limited number that only become available every now and again. Another option which many people decide to take is to buy the basic electronic components which are the logic chip, driver and keypad from monome.org then buy a soldering iron, some LEDs and a case to hold your own monome and to solder and build the entire device from scratch. There is a stack of information and step-by-step instructions on the monome website as well as other blogs to help you build a monome from scratch.
Once you’ve soldered all the electronic components and fastened the case together you are ready to plug the monome device in to a computer via a usb cable and run a max5 patch to setup, test and configure the monome initially (there are also comprehensive instructions on downloading and installing Max on the monome website).
Playing. Once you’ve built your monome and run the setup patch you are ready to upload existing patches written in Max and ChucK and start exploring your monome.
Extending. The most exciting point about a monome device is that it is not restricted to any default applications and they are simple there as a hello world set of examples. You are able and encouraged to develop your own Max patches , to upload and test them on your monome and then to upload and write about them on the monome website so that you can share you findings and experiments with the community.
You can also communicate with the monome device using the OSC protocol and there is an article on that here (http://docs.monome.org/doku.php?id=tech:protocol:osc). This means that you can control a monome and receive button presses from a monome using software like Processing, openFrameworks, VVVV, PureData and even in Flash using a proxy server like flosc. This opens up fantastic opportunities to use the monome as a tactile input device for a piece of custom software or installation.
On Monday and Tuesday last week I was one of a team of six who travelled to Cardiff for a ReacTickles/openFrameworks lab at the Touch Trust. I joined Joel Gethin Lewis, Memo Atken, Marek Bereza, Will Pearson and Ben Jones and together we produced a series of audio and visual interactions that were projected on the wall of the at the centre for the children to interact with. These were used as an extra level of playfulness and expression, developed to fit in with their existing activity routine.
The Touch Trust is a centre that offers creative, touch-based art, movement and dance programmes for individuals affected by Autism Spectrum Conditions (ASC) and Profound Learning Difficulties (PLD). I was introduced to ReacTickles at an openFrameworks lab at the V&A museum in February since then I’ve been keen to develop more interactive pieces for the project, to hopefully engage and help people affected by ASC or PLD as well as their family and carers.
Utilizing an inspire-play-create-appropriate methodology, the aim of the lab was to generate ideas for experiential interfaces that compliment the therapeutic activities offered at the Touch Trust. Central to ideation has been the inclusion of end users and those who care for them in a rapid process of playful co-creation in authentic, real world settings.
You can see a selection of photographs that document the positive results of the interactions we produced on the ReacTickles’ flickr page here.
I often find myself searching for the same snippet of code to create a certain affect. Such as making a sprite follow the mouse but with a little bit of ease or elasticity. I also keep meaning to to explore better ways of containing data such as object pools and linked lists. So I’ve decided to drop any useful snippets of code in to this post so I always have somewhere to refer to quickly.
// Embed flash using swfobject but with a redirectif(swfobject.hasFlashPlayerVersion("6.0.0")){// Embed Flash here}else{// no Flash
location.href="no_flash.html";
}
// Find the amount of time between one point in time and another
t = getTimer();
elapsedTime = 1000/(getTimer() - t);
// Use object poolsfunction getThingInstance(param){if(pool.length){ o = poop.pop(); }else{ o = new Thing(); }
o.init(param);
return o;
}
While I was developing a recent project I needed to figure out how to use a multiply blend mode in openFrameworks. After a little research I discovered that it’s as simple
as setting the blend function in OpenGL. As openFrameworks uses OpenGL as a core graphics library it’s very easy to use OpenGL functions to create visual affects that go beyond the absolute basics.
All I needed to do to create a multiply effect was add the following two lines of code to the setup function. This enabled me to use OpenGL and calling the depth test allows OpenGL to configure itself to avoid any weird effects (although I’m basing that on what I’ve read as I haven’t excluded this code to test the effects yet).
glEnable(GL_DEPTH_TEST); // enable depth testing to avoid problems
glDepthFunc(GL_LEQUAL); // set the type of depth testing
Then in the draw function I enable OpenGL and call the glBlendFunc function and pass in two parameters to tell OpenGL how I want to treat the existing graphics and the new graphics. I then looped through my points and draw an ellipse for each one, using one of three colours which I set when the application first starts, these were hexadecimal equivalents of cyan, magenta and yellow which can blend together to create black/keyline (the K in CMYK). Finally I call the glDisable function to stop OpenGL from applying the blend mode to anything else I might want to draw.
glEnable(GL_BLEND); // enable blending
glBlendFunc(GL_DST_COLOR, GL_ZERO); // set the type of blend mode
for (int i = 0; i < NUM_BOIDS; i++) {
ofSetColor(boids[i].colour);
ofEllipse(boids[i].position.x, boids[i].position.y,
minDistance, minDistance);
}
glDisable(GL_BLEND); // disable the blending
For a project I’m currently working on I wanted to explore flocking behaviours and track relationships between points within a real-time simulation. The final piece has been completed now (but more on that another time) and in the meantime I’ve created a video of the prototype I was using to test the simulation and aesthetics.
I created a simple flocking simulation and then tracked the relationship between each point in the flock and it’s neighbouring points. As the simulation runs the points effect one another’s position and direction, rather than tracking each point I track the relationship each point has on it’s neighbours. The relationships between the points are then represented using an anaglyph image that creates a stereoscopic 3D effect. The two rules that influence the distance between points can be changed in real-time and can cause significant effects with the slightest of changes.
I recently finished reading Studio Culture from Unit Editions. I’ve always been interested in the various ways that design studios are run and by the physical studio itself and this book gives a fantastic behind-the-scenes look at a number of very well-established studios across the globe. It’s certainly not a particularly new book, it’s been sitting on my bookshelf for a while but I’ve finally found some quiet time on the train in the mornings to read through it thoroughly.
As a freelancer I am already in a lucky position where I can go in to a studio and work closely with a team, anywhere from a couple of days to several months. I’ve always found this experience rewarding as I meet new people and make new friends and work contacts and I also take away from the studio all the positive ways of working that I’ve seen whilst I’ve been with them. Eventually my goal is to apply all the things I have seen over the past few years – that I feel work successfully – to my own studio and hopefully create something that produces great work and is exciting to be a part of.
Studio Culture provides a unique glimpse into the inner workings of 28 leading graphic design studios. In a series of penetrating interviews, the mechanics of building and maintaining a vibrant studio culture are laid bare with disarming frankness.
I’ve spent a little more time exploring the relationship between each Boid in my flocking simulation. I still need to add some more features to the simulation and then I will be able to start exploring the design and aesthetics in more detail.
For an upcoming project I’m going to be using a simple flocking simulation to produce a series of generative artworks based on time. These pieces are being produces in openFrameworks so it’s another great opportunity to experiment more with this fun tool. I’ve been struggling to find the time to work on this up until very recently, so hopefully over the next few weeks I can start to produce something very interesting.
I’m planning on assigning some more of the core flocking functionality to gui sliders so that I can start to make adjustments to the simulation in real-time (I’m using Memo Atkens ofxSimpleGuiToo addon for this). Once I’ve got a behaviour that I’m happy with I can start to explore ways of recording and mapping the relationships within the simulation to hopefully achieve something interesting.
