One of the difficult things to handle, for me at least, has been bidirectional communication between the interface (TouchOSC) and the sound generator (Logic Pro, in my case). Translating OSC events from TouchOSC to MIDI messages that Logic Pro can understand is fairly easy, thanks to OSCulator. However, getting things such as toggle buttons to work properly and reliably is something that has proven to be somewhat intellectually challenging (in a relative way, of course). I was therefore quite happy when I discovered I could find still another use for an iPhone, iPod Touch or – better still – iPad: a fully-functional recording light. You’ve seen it all over the place: the kind of luminescent fixture which says “ON AIR” or “RECORDING” or something to that effect, and which essentially warns the person about to open the door to the studio that the tape (or what’s left of it these days) is currently running. This tutorial will show how you can turn your $200-$700 iOS device into a recording light, saving you at least $111 in the process (and helping you show your clientèle how hip, classy or frivolous you are by hanging iPads and iPhones all over your studio).

I’d also like to point out that TouchOSC is $4,99 and OSCulator is around $20. Plus you get to pick up your recording light at the end of the day to check your mail.

Start by designing your recording light. With the free TouchOSC Editor, this is easy. I named the page “RecordingLight”, added a couple of Toggle Buttons (called, surprisingly, “toggle1″ and “toggle2″ in my setup). They won’t be used for input — obviously the recording light will be protected behind a glass fixture. I’ve also created a “Label V” object which will, soon enough, hold a “RECORDING” text string (it’s a V object rather than an H because the entire Layout Orientation is horizontal, a quirk which should someday be fixed). The label’s text size has been set to 70, but the text string itself is empty, so that nothing is displayed unless recording is taking place. Upload the TouchOSC file into the iOS device as usual.

Now, in Logic Pro, add a Recording Light control surface device (Logic Pro > Preferences > Control Surfaces > Setup…, then go through New > Install > (other) Recording Light). Set the device’s Out Port to “OSCulator In (8000)” (presuming you’re using the defaults) and the Input to “OSCulator Out”. This makes sure the device’s bidirectional communication is going through OSCulator.

With this basic setup out of the way, start recording in Logic. If everything is working properly, OSCulator will add a new event based on what it received from Logic. It should be something akin to “/midi/note/2″ with three parameters (pitch, velocity and trigger). Click on “0: pitch” and select Edit > Demux. Then start recording in Logic again. The event in OSCulator will change to the specific note sent by the Recording Light device: “/midi/note/2 > 25″.

If you’d like to know what’s happening in more detail, use Kurt Revis’ excellent (and free) MIDI Monitor software. This will show you that the “Recording Light” control surface in Logic simply sends a C#0 Note On message when recording, and a corresponding Note Off message when recording stops.

Now we need to tell OSCulator to send these events to the two toggle buttons we’ve created in TouchOSC so that they light up at the proper time. On the “1: trigger” line, select the Event Type “OSC Routing”. This means we’ll be translating the MIDI event into a custom address (or destination). Under “Value” select New and create a new Rewrite address called “/RecordingLight/toggle1″ (remember, this is the name we gave to the first toggle button in TouchOSC). Then duplicate the “1: trigger” event by pressing Command-D. This allows us to send the trigger to another control, the “toggle2″ button. Under “Value”, select New and add a Rewrite address called “/RecordingLight/toggle2″. The toggle buttons in TouchOSC will automatically react properly to Note On and Note Off messages.

Finally, when recording takes place, we’d want the (initially) empty label we created to say “RECORDING”. This should be replaced by an empty string when recording stops and needs to be set up manually. The two different message rewrites will be defined using an option in OSCulator’s Route Editor. Duplicate the “1: trigger” once more and set its Rewrite address to “/RecordingLight/label1″. Double-click on the “Arguments” cell, delete everything in the Arguments field that pops up and type RECORDING followed by a space. This will have the effect of setting the label1 control to the string “RECORDING” whenever recording in engaged in Logic. At the bottom of the window, set “Route when” to “The value goes from 0 to positive”.

Duplicate the “1: trigger” event one last time and set its Value to the new Rewrite address “/RecordingLight/label1″ with a new argument: Alt-Space (the only way I could figure out of sending an empty string to TouchOSC – it will look a bit funny in OSCulator but it works). Set the options to Route when “The value goes from positive to 0″. This will make sure the empty string is set when recording is stopped.

The above setup works flawlessly in Logic. The on/off states of the recording look like this, assuming you’ve hanged your iOS device somewhere in sight:

Off

On

This is a pretty basic application of using TouchOSC to fake an “official” control surface in Logic. I was trying to do the same thing with more complex devices, hoping to remote control Logic with a customized interface. By that I mean, of course, proper bidirectional communication (such as getting Cycle, Metronome & Record buttons to stay lit and mirror the state of the sequencer, or displaying SMPTE timecode). Remote controlling Logic with simple one-way messages in TouchOSC is another story, is very easy to do and has been done many times.

A one-way remote controller

The devices I’ve tried to analyze — Mackie Control, Logic Control, iControl and TranzPort — all proved difficult to emulate with the current state of OSCulator and TouchOSC documentation. Whether using SysEx or Continuous Controller events, the above devices’ messaging schemes are a pain to figure out and translate both ways properly (at least in the limited time I have for such experiments). If anyone cares to study further I’d be glad to hear about it.

DISCLAIMER: My knowledge of linux is superficial. I write the following with the intent of helping out newbies such as myself. Do not hold me reponsible if you follow my method and end up with a system that’s pushing up the daisies.

NOTE: This method has been tested on GNOME, the default desktop environment for my distribution. I haven’t tried it with KDE and, now that it’s finally working, I don’t think I will.

ACKNOWLEDGEMENT: I would never have gotten Python 2.6.1 and Ubuntu to work together if it hadn’t been for the precious help of wacky, a member of the Python forum, who saw me through several nightmarish reinstallations of both Ubuntu and Python. Several of his suggestions have been incorporated into the steps below.

I suggest you read through the entire list of steps so that you have an idea of what’s going to happen before actually running any command.

1. Install a fresh copy of Ubuntu 8.10 if your system has been hopelessly pulverized by repeated tests, errors and packages scattered in the wrong places.
2. Before doing anything directly related to Python, you need to install the packages listed below. The list is an amalgam of several suggestions I found around the web, so one package or more might not be absolutely essential. But since it works, here’s the list:
   • build-essential
   • libncursesw5-dev
   • libreadline5-dev
   • libssl-dev
   • libgdbm-dev
   • libbz2-dev
   • libc6-dev
   • libsqlite3-dev
   • libdb-dev
   • tk-dev

   The easiest way to install a package is to use the aptitude command. Make sure you’re connected to the internet, open a terminal session and type the following: sudo aptitude install package-name You will be prompted for your password the first time you invoke the sudo command, which executes everything typed after it as a “superuser” (or “root” user). Instead of entering the command for each and every package, you can may prefer to enter them all at once (all of the following should be typed on a single line): sudo aptitude install build-essential libncursesw5-dev libreadline5-dev libssl-dev libgdbm-dev libbz2-dev libc6-dev libsqlite3-dev libdb-dev tk-dev

3. Download and extract the Python 2.6.1 source. From inside the source directory, enter (still and always, one single line):
   ./configure --prefix=/home/yourusername/python/2.6This will setup Python to install into a ‘python/2.6′ directory inside your home directory, far away from anything system-like. You may choose to simply name the directory ‘python’, but the ’2.6′ subdirectory will help separate the installation from yet another custom setup, such as version 3.0, if you ever need to install one. Note, though, that this doesn’t mean I’ve tested the steps described in this tutorial with Python 3.0.
4. Compile Python with the standard command:makeWhen the compile process finishes, read the few last lines it printed: you might get a couple of modules which can’t be found. I don’t remember their names but from searching around I gather that a lot of people can’t seem to find them and that nobody really cares. Most importantly, make sure that you don’t get a module missing error for zlib or readline, which are essential for the following steps. The packages installed previously will have taken care of that, though.
5. Install Python. I tried to do a make altinstall (after going through the Python source readme file), but for some reason I ended up without an executable. So just go through a regular install. Since you’re installing the Python files into your home directory, you don’t need to use sudo:
   make install
6. Now, if you enter python in the terminal you should get the default Python version that comes with Ubuntu (currently 2.5.2). Typing which python should point to /usr/bin/python, not to the directory you just installed 2.6.1 into. All of this is normal and is actually what you’re looking for.
7. Optional: if you need an additional Python module (such as Numpy), install it from its source directory by typing: /home/yourusername/python/2.6/bin/python setup.py install --prefix=/home/yourusername/python/2.6 This runs the setup script using the 2.6.1 interpreter and installs the module into the 2.6.1 directory structure (since we’re using the same prefix we specified when installing Python itself).
8. Create a symbolic link to the 2.6.1 interpreter so that the next step doesn’t blow up in your face: sudo ln -s /home/yourusername/python/2.6/bin/python /usr/local/bin/python2.6 It is important that you do not use a different name of your fancy for the link. Now, if you enter python you’ll still have 2.5.2, whereas entering python2.6 will launch, well, 2.6.1. This will also make sure that non-system versions of Python have to be run explicitly. Keeping the ‘python’ command reserved for the exclusive use of the system’s Python version is likely to avoid headaches in the future.
9. In order to use the easy_install command which facilitates the installation of additional modules, you first need to install setuptools: download the egg file for Python 2.6 and enter: sh setuptools-0.6c9-py2.6.egg This is the reason why the symbolic link created in the previous step must be called ‘python2.6′ (the setuptools script runs a python2.6 exec command and will complain about a missing 2.6 version if it’s not linked with ‘python2.6′).
10. Optional but highly recommended: install IPython, an enhanced command-line environment for Python. Do not download anything manually. With setuptools installed, you can simply go into your Python bin directory (with cd /home/yourusername/python/2.6/bin) and type: ./easy_install IPythonApparently you may also enter the following directly, which saves you the directory switching part: easy_install-2.6 IPython I haven’t tried it myself, though. Anyway, download and install will be automatic.
11. You have to add the path to IPython to your terminal environment, so that the executable can be launched from any directory. Add the following line to the end of the .bashrc file which is located in your home directory. PATH=$PATH:/home/yourusername/python/2.6/bin I suppose you could create a symbolic link instead but i haven’t tried it.
12. If you use Geany for Python development, you need to edit one of its configuration files so that the application’s Run command executes the proper interpreter: sudo gedit /usr/share/geany/filetypes.python Modify the run_cmd line to read: run_cmd=python2.6 "%f" This will use the symbolic link you created earlier.

You can now run IPython, develop in the Geany IDE, and still install packages through aptitude or the Synaptic Package Manager without all hell breaking loose. If you’re using a tiny screen and touchpad I strongly recommend installing GNOME Do to avoid mousing around too much. Enjoy.

Simple model, nice lighting

First steps

I had spent two days trying to light this thing, using preposterous light arrays (10x10x10 attenuated omnis), domelights, whatever. But I found that the following method works well, simply because it gives you precise control over every surface. It’s a bit more tedious, but it works (at least it did for me).

Start by adding one Omni Light in the middle of the scene. A very warm color, a low multiplier (0.2) and a progressive attenuation, it will act as an ambient light surrounding the area where the sunlight hits the floor. It also simulates the subtle yellow light reflected from the beige floor. It shouldn’t affect specular highlights so I turn this off.

Start with almost nothing

Light from the Sun

Next comes the sunlight itself, which is a Direct Light. It shines through a skylight above which is actually modeled, so I don’t need a projection map. The light multiplier is set at 0.8 and there’s no need for attenuation. With shadow-mapped shadows at their defaults you get this, which is an OK shadow.

Add direct lighting

Separate the walls

What I do now is simply separate lights and surfaces using the Exclude/Include function of each light. Now, for example, I add a spotlight which includes all the objects on the front wall, as well as the wall itself.

Almost everything about the light is at its default setting, except the attenuation which start a bit in front of the wall, and ends behind it. Since the spot is at an angle, the attenuation factor varies over the surface and looks quite nice.

Light the back wall

Simulate attenuation

The left wall (and all its associated objects) is going through the same treatment. The spot shines a bit from behind, and has its attenuation factor set to achieve the same principle described above.

Same drill for the right wall.

Light the left wall

And the right one

Finishing touches

In order to obtain a natural-looking light for the floor and the railing, two spots were added (including only the required objects, of course). They are pointing at the floor from opposite directions and are set up so as to attenuate progressively over the surface. Both have their Multiplier at around 0.8 – this prevents overexposure of the surface but still keeps a nice strong light.

And the floor

Because the right door was to be rendered closely, I dedicated two more spotlights to it. This was enough to consider the image finished.

Conclusion

Another advantage of this technique is that it allows you to quickly render any part of your scene, from almost any angle, without worrying about the lighting at all.

The finished image

Don’t expect to get perfect results the first time. It took a lot of tweaking to get the attenuation, color and multiplier right for each light. 3D artists should consider this as fun, although I had some persons asking why I didn’t just photograph the bloody thing. Anyway, I hope this gave you some ideas.

Quick modeling

Create three Nurbs spheres, and move and scale them so that you get a very rough representation of a body with a couple of wings. Name the wings “rWing” and “lWing”, and name the body “bug” or whatever. Throw a basic texture on them if you wish.

It's a bird!

Move the pivot points of both wings so that they can rotate around the proper axis.

Proper pivoting...

Parent the wings to the main body so that they move with it.

...and parenting

The Expression Editor

Open the Expression Editor (Window > Animation Editors > Expression Editor…). You’ll find it useful to assign a hotkey to that (ALT+e is unassigned by default and is a good choice).

The not-so-daunting Expression Window

On the left you’ll see your currently selected object, and on the right the list of its keyable attributes. Expression are typed into the bottom box. It’s important to know that expressions do NOT relate to the currently selected object. You can write expressions for anything, another object, a shader, whatever you want. If have an object selected, though, it’s easier to know the exact name of an attribute you want to control, since all keyable attributes at listed on the right.

Type “wingFlap” into the Expression Name box, and type the following into the Expression box at the bottom of the dialog box:

lWing.rotateX = time * 10;

Click “Create”. This creates the expression.

Your first expression

The syntax is very simple: you type the object name (or, rather, the node name), followed by a period and the attribute you want to control. In this case, we want to control the X rotation of the left wing’s transform node. The “time” attribute is a built-in value in Maya, which returns the current time of the animation in seconds. Its multiplied by ten so that the result is more immediately visible (the flapping is faster). The semicolon simply marks the end of every statement in Maya. Click “Play”, and the you’ll see the wing rotate as time goes by. Check the Hypergraph, and you’ll see lWing controlled by the wingFlap expression. Also, in the Channel Box, lWing’s rotateX attribute turns orange to show that it’s controlled by something and that you can’t change it directly.

A transform node controlled by an expression

The Sine function

The simplest way to create a back-and-forth motion is to use a sine function. Modify the expression so that it looks like this:

lWing.rotateX = sin (time * 10) * 40;

If the expression has disappeared from the Expression Editor, simply click Select Filter > By Expression Name and click on wingFlap.

Finding lost expressions

The result of the sine function is multiplied by forty so that the motion describes a larger arc. Otherwise, the flapping goes back and both between two very small values.

Click “Edit”. This button, which replaced the “Create” button, updates the expression to reflect the changes you’ve made. If you get the message “Error: Expression invalid after edit”, check your syntax. If you play the animation after this error without correcting it, Maya evaluates the last valid expression that you entered.

Play the animation. The wing flaps back and forth.

The wing flaps. Wow.

To get both wings to flap, copy and paste the expression into the line below, but change lWing to rWing, so that the whole expression now reads:

lWing.rotateX = sin (time * 10) * 40;

rWing.rotateX = sin (time * 10) * 40;

You’ll see a motion which isn’t at the cutting-edge of aerodynamics. This is because the X rotation of the opposite wing should be reversed.

You're going the wrong way

Add a minus sign before the sine function of the right wing, to read:

lWing.rotateX = sin (time * 10) * 40;

rWing.rotateX = -sin (time * 10) * 40;

Play the animation. The bug now has more chances of survival.

That's more like it

Controlling the wing speed

Now suppose you want to control the wings’ flapping speed. Currently, the speed is determined by the *10 part of the expression. Let’s create an attribute for wing speed that would allow us to change the speed dynamically, and even keyframe it. In the Attribute Editor, select the bug’s transform node (the one simply called “bug”), and choose Attributes > Add Attributes.

Creating a new attribute

Type WingSpeed into the Attribute Name field, make sure Float is selected, and set 0 as Minimum value, 10 as Maximum and 5 as the Default value. Make sure that “Make Attribute Keyable” is checked (so that is shows up in the Channel Box), and click on OK.

The Add button allows you to add several attributes without closing the window every time.

The new wingSpeed attribute

In the Extra Attributes folder of the bug’s transform node, you now have a fresh new attribute called wingspeed, nicely displayed with a space (Wing Speed) because of the capital S. It’s set at the default of 5, and doesn’t do anything at the moment.

Back in the Expression Editor, change the 10 value to bug.WingSpeed in both lines. They should now read:

lWing.rotateX = sin (time * bug.WingSpeed) * 40;

rWing.rotateX = -sin (time * bug.WingSpeed) * 40;

Conclusion

Notice a couple of things: the capitalization (it’s very important to type the attribute name exactly as you defined it) and the fact that we’re controlling the wings via an attribute which belongs to the bug node, hence the bug.WingSpeed. Move the Wing Speed slider around and see how it affects the wings’ motion.

Final expression

Play around with this in order to get a feel for the almost infinite possibilities it offers. Try to control the size of the wing arc (currently 40) with another, new attribute. Also, you can attach the bug node to a turbulence field, and try to control the wing speed via, for example, the translateY attribute of the bug, so that its wings flap more quickly when it approach the ground. Bear in mind that you’ve still haven’t set a single keyframe. Enjoy.

What this node basically does is take two vector inputs (such as Translate X, Y and Z), calculate the distance between them, and then output the result into a distance attribute. This allows for some very basic effects to be achieved with little fuss.

The distanceBetween node doesn’t have to have translate values as inputs, but they are the best way to explain how it works. So here goes.

The distanceBetween node

A simple vector

Creating the node

In the Command Line, type the following MEL command:

createNode distanceBetween

and press Enter.

Now isn't that user-friendly

As you probably figured out, this command creates the node. Following the logic which dictates that this node should be hidden from most mortals, it doesn’t appear in the Outliner, Hypershade or Hypergraph. You’ll need to go to the Outliner, and turn off DAG Objects Only from the Display menu.

Still invisible...

Tada. Since you’ll spend quite some time hunting for it later, you might find it useful to create a button which selects it for you. Just select another node and then select the distanceBetween1 node again. Open the Script Editor, highlight the “select -r distanceBetween1 ;” command which will show up there and middle-drag it to a shelf.

...but not for long

A simple application

Now for the fun part. Create a couple of spheres and assign the same material to both of them. Give it a nice, popular color such as red. Open the Connection Editor (Window > General Editors > Connection Editor…), select one of the spheres and click Reload Left. Select the distanceBetween1 node (either through the Outliner or with your shelf button), and click Reload Right.

Connecting the node

Towards the bottom of the list on the left, click the Translate attribute. On the right-hand side, click the Point1 attribute. This connects the sphere’s XYZ translate values to the distanceBetween node’s first input.

Select the second sphere and click Reload Left in the Connection Editor. This time, connect the Translate attribute to the Point2 attribute. Check the Hypergraph to see how the nodes are connected.

Two vector inputs

The resulting value, which is contained in the distanceBetween1.distance attribute, can be used in an infinite number of ways. Let’s assume that we want the spheres to glow when they get close to one another. You could connect the distance attribute to, say, the incandescence R, G & B values for the material you assigned (remember that distance is a float value, so it goes into each channel separately), but this can be problematic. The distance is measured in world units, and unless your spheres stay within a 0 to 1 distance from each other, you can get funky results. It’s better to write an expression for it.

Mapping the Distance to Incandescence

An expression for more control

Assuming the material assigned to both spheres is called blinn1, create a new expression with the following lines (ignore any line breaks, and you might double check your spelling if you get an error, incandescence is a particularily treacherous attribute to type in):

blinn1.incandescenceR = (10-distanceBetween1.distance)/8 ;

blinn1.incandescenceG = (10-distanceBetween1.distance)/8 ;

blinn1.incandescenceB = (10-distanceBetween1.distance)/8 ;

An expression might be more handy...

What this does is take the distance and subtract it from 10, so that the spheres glow when they approach each other, instead of when they move away. The 10 value determines at what distance the glow starts. The result is then further divided by 8 so that the transition of the glow is more gradual. Move the spheres around in textured mode to see it in action. Also, try this with different values and see what happens.

There’s still a problem. When the spheres are farther than 10 units apart in this example, the incandescence becomes negative and they go completely black. Remedy this by adding a clamp function, so that the expression reads:

blinn1.incandescenceR = clamp(0,1,(10-distanceBetween1.distance)/8) ;

The same should go for the Green and Blue channels.

...if it's written correctly

What this does is specify Minimum and Maximum values (the 0 and the 1) to be allowed for the third value in the function (the distance value in this case).

For some eye candy, move the spheres apart so that they don’t share any axis, and attach them both to a Newton field positioned between them.

Nicolas Aithadi has created a Cornell Box simulation using the distanceBetween node. I actually wrote this tutorial because I got confused half way about what should be connected where.

Emmanuel Campin, author of the SkyLightControl MEL Script, has an even more involved example which fakes soft shadows with Dmaps.