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 (10×10x10 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.

Check out the following playblast to see the result:

Quick modeling

The geometry was simplified since it’s not the issue here. Create a sphere, tweak it a bit and name it balloon. Next create a NURBS cylinder and non-proportionally scale it so that it looks like a string (the name used in this example is string1 because Maya seems to reserve the name string for internal use). The cylinder should have enough spans to deform properly later. I used six spans here.

Delete history on both objects.

A sphere and a cylinder

A curve to deform the string

The cylinder itself could be turned into a soft body, but since it has volume (eight sections by default), deforming it directly will create irregularities in its thickness. Instead, we will use a curve.

In the side or front view, create a CV curve with six evenly spaced vertices going down straight through the cylinder. Use Snap to Grid (hold down the X key by default) in order to make it completely straight.

This curve will be used as a Wire deformer: when vertices move, they will deform the geometry they are attached to.

The deformation curve

The Wire Deformer

From the Animation menu set, select Deform > Wire Tool and set its options to the default. Following the prompts on the Help Line, select the shape to deform (string1), press Enter, then select the Wire curve (curve1) and press Enter. You can do this through the Outliner.

This creates a new node, curve1BaseWire. To see the results of this operation, select a CV on curve1 and move it around. The string should deform accordingly.

Undo any CV tweaks so that the curve is straight again.

The Wire Deformer

The Soft Body

Now for the soft body. Select the original curve (curve1) and from the Dynamics
menu set choose Soft/Rigid Bodies > Create Soft Body options. Set the options
shown to the right and click Create. In the Outliner, you will see a new Particle
object parented to the curve. This object has six particles, one for each CV
of the curve.

The curve has also been duplicated as copyOfcurve1 and is used as a Goal. This means the particles will tend to align themselves to the CVs of the duplicate curve, and while doing so will deform, or move, the CVs of the original curve.

We need to attach the string to the balloon, so that it follows it everywhere. To do this, parent the Goal curve (copyOfcurve1) to the balloon. Since that curve is hidden, the quickest way to do that is to use the Outliner: middle-mouse drag copyOfcurve1 onto balloon.

Creating the Soft Body

Relationship summary

The diagram to the right (“Parents and children”) sums up the relations we just set up. Make sure you understand the relationships and the role of each node.

Parents and children

Particle Goal Weights

If you now keyframe a motion for the balloon you’ll see the string move along with it, although it will remain quite stiff. This is because the Goal weight for the Particle object has been set to 1. You can lower it in the Particle object’s Attribute Editor section called Goal Weights and Objects, but this won’t be enough. We need to assign a specific Goal Weight to each particle, so that the top CV stays glued to the balloon while the lower ones move more freely.

The string is a bit stiff

Practice…

Go into Component Mode (F8), select a Pick Mask for Particles from the Status Line and drag-select the six particles in the perspective window (don’t select the particle object from the Outliner). This selects the individual particles. Go into Window > General Editors > Component Editor… and select the Particles tab. You will see a list of the particles (pt[0] through [5]) with several attributes columns. At the very end you’ll see goalPP, which is the Per Particle Goal attribute.

Modifying these values requires quite a bit of experimentation to get the proper look. Start with a value of 1.00 for the first particle (the one we want to keep glued to the balloon), 0.40 for the second particle and 0.20 for the remaining four. Tweak them until you’re satisfied with the motion. These values are multiplied by the particle object’s Goal Weight attribute (the one mentioned earlier), which is why you’ll want to keep it at a value of 1.00 to get predictable results.

Modifying GoalPP weights

…makes perfect

Now if you keyframe the balloon’s translation and rotation, you get something a little bit more interesting. The string now moves realistically.

This looks more natural

Keeping everything together

You might find that the particles stretch the cylinder out of proportion. It order to help the particles maintain the overall length and shape of the cylinder, select the particle object and add Springs to it (Dynamics menu set > Soft/Rigid Bodies > Create Springs). Choose All as the Creation Method. This creates springs between all the particles. Since there are only six of them, you won’t get much of a hit on interactivity and frame rate. You’ll now have to play around with Stiffness and Damping to get the proper behavior. Don’t go over 1 for Damping or the simulation will collapse. I took Stiffness up to 20 which kept the shape nicely while still allowing for a fluid deformation.

Some Springs might help

Conclusion

For some added randomness in the string’s deformation, add a Turbulence Field to the particles. Set its Attenuation to zero, and tweak its Magnitude and Frequency to get the look you want.

The rest is basically a tweaking process between several influences which are summed up in the diagram to the left. Remember that the string will “follow through” the movement of the balloon, which should be keyframed carefully. You can make the balloon into a Rigid Body if you want, but I found it too hard to control that way.

Compare the following playblast with the previous one. The only values changed were the goalPP weights:

This method has one disadvantage. Because the Goal curve is a straight line parented to the balloon, if the balloon comes to a rest while in a non-vertical position, the string will eventually settle down somewhat horizontally, depending on the direction of the Goal curve. That said, unless you’re going to follow the balloon into the stratosphere, you should be ok.

Summary of influences