For the last few weeks I have been working away on a fun little project to recreate / expand on a great bit of software for the monome called mlr. The original patch was written in Max/MSP which is great for putting together these sort of sample juggling applications. However Max/MSP remains a proprietary language / coding evironment meaning it's not possible to get in and hack around with the source code without owning a full copy (which unfortunately I don't). So in response, I decided to create a VST plugin in C++ which is fully open-sourced / modifiable. While my project (unoriginally named mlrVST) borrows heavily from existing incarnations, I hope to add plenty of my own features and ideas: in particular I've looked at adding several granular synthesis capabilities.
So what stage is the project at just now? Well I have a basic VST up and running. It has a GUI, it makes sound, it responds to the monome and can play back loops at varying speeds (set internally or by the VST host). Windows builds are available but I've not had access to OSX to try building a Mac version (the project uses the cross-platform JUCE library so it should work!). There is lots still to do: presets, live audio recording, resampling etc, but there should also be enough working to have fun playing around with! For more information (downloads / screenshots / source code), the best place to go is the monome.org forums, although the github project page should be useful too.
I hope to write some more articles about the technical side of the project (using JUCE etc) in the future so feel free to check back now and then!
As part of my preparation for my PhD, I've decided to have a look at other programming languages, partially just out of curiosity, but also partly due to the frustrating length of time it seems to take to get code up and running in Java/C++. Python is often mentioned as suitable scientific programming language so I decided to dive straight in. I've only been using it for about a week and already I've been very impressed with the speed with which I can get prototypes up and running. Coding in python seems more eloquent, concise, almost like writing pseudo-code at times. The community encourages writing "pythonic" code where the finding simplest, cleanest (and often fastest) method is highly valued.
So to test out the new language I decided to have a go at implementing a basic lattice-based Diffusion-Limited Aggregation model. The basic idea is set off a series of random walkers around a central "seed" - if they come into contact with the seed they stick to it and a new walker is released. The colors in the above diagram show how new that part of the crystal is (hotter - new, colder - old). The code is available over at github; the curious should also have a look at the faster version rewritten in the NumPy numerical library.
Just a quick tip about how to set up the code formatting tool astyle as an external tool for Visual Studio 2010. First download astyle for Windows and extract somewhere sensible (I chose C:\Program Files\AStyle\).
Then navigate to Tools -> External Tools..., you should see a dialog like the one below. Simply fill out the setting as appropriate, remembering you can set various style options using commandline flags (as described on the official site). The variables $(ItemPath) and $(ItemDir) are important - this lets astyle know which file to apply to. Then to use the tool, simply select astyle from the Tools menu (you will be prompted to reload the file).
Although the app still needs a little more testing and few more features, I've decided to release my androidome application onto the Android Market (download for mobiles here). Full instructions for installation are available on the Androidome page.
Things the app currently does (or should at least!):
- Connect to Max/MSP over WLAN.
- Respond to incoming led messages
- Provide multitouch input from phone to Max/MSP.
- Work with mlrV, polygome, boiingg, (hopefully many more too).
Doesn't yet respond to led_col, led_row, or tilt monome messages.Fixed OSC Packets occasionally drop leaving ghost LEDs still on/off when they shouldn't be.Fixed
- UI could use a little improvement.
QR Code (what's this?)
I've finally taken the plunge and gone and ordered myself a monome DIY kit. Its the cheapest way of getting your hands on one, that I've seen anyway, and I've been looking for a neat DIY project for the summer. Hopefully it should arrive sometime in August, but while I'm waiting for it to arrive, I have been busying myself trying to write an Android version. This seems like a sensible thing to do, as the phone has:
- multi-touch capabilities
- build-in directional sensors
- build-in accelerometers
which all can be accessed simply from within the app.
The project somewhat continues on from my initial ToneMatrix clone, so the basics are already there. The monome communicates via the OSC protocol, which lucky is fairly simple to get up and running in Java thanks to a neat library called JavaOSC. The difficulty is in getting the application to be responsive enough to be of any use. However, the app is currently functional with single button presses being registered correctly (no multi-touch yet). LED feedback is a little buggy/laggy so far, but essentially works. Alpha version should be up by next week.
Having recently rediscovered Andre Michelle's fantastic ToneMatrix synth, I was inspired to create an Android port for my HTC Desire. After a couple of days getting to grips with the Android SDK, I managed to produce a version that works reasonably well (at least on my Desire).
This is a very early version however, and I expect to add more features in the coming weeks such as different synths (possibly custom-built audio engine), speed control and better support for different screen sizes.
For the curious, the app is available as a download: ToneMatrix.apk (Android 2.1 or higher).
Instructions: It is pretty simple to use: horizontal axis is the time axis, vertical axis is pitch. Press the grid squares to enable that note. Enjoy!
Today marks the end of a 2 month investigation into various techniques of simulating reverberant sound. Using MATLAB, I developed two contrasting models:
- Image Source method
- Monte Carlo Ray Tracing method
The report in full is available to read here, though for a lighter overview, this poster is recommended. All sample output, including the odd phasing behaviour described in Section 4.1.2 can be downloaded here. Any feedback is greatly appreciated!
This historic moment marks the start of Pixeville, my latest programming project. Inspired by Shamus Young's Pixel City, I have decided to try and create a procedurally generated city in an isometric pixel art style.
Having grown up loving classic isometric games such as Rollercoaster Tycoon and Transport Tycoon (see below, now available from the open source project OpenTTD), it seems the perfect challenge. The aims of the project are to have a arbitrarily large city generated at random, along with random textures and detail, and possibly eventually basic animation. As with all such projects, it will probably get turned into a screensaver eventually, but that is a long way off.
I'm writing the app in Java for the time being (as that's what I know best) but I am considering a C++ port eventually for the screensaver etc. You can keep track of developments on my Google Code project page.