Here's a link to the Quicktime movie file of my first stab at an animation using my Puppet CHOP. The model is not complicated, and the texturing is anything but perfect, but... consider that once everything was rigged and setup I "performed" this animation with a Logitech Extreme 3D Pro joystick in about 30 seconds, in real-time.
I had a great session last evening working with the brand new Joystick CHOP I had constructed. I was able to accomplish three major things:
My puppet model was fairly simple. The goal was to build a muppet-like creature with spheres and half-spheres, and some other simple geometry and texture maps to create something reasonably interesting. For the purposes of the puppetry rig, I wanted something that had the following features:
I had a Logitech Extreme 3D Pro Joystick to work with, which provided a number of buttons and joystick axes to play with:
The joystick has the traditional X- and Y- axis, which I mapped to tilting the head backwards, forwards and from side-to-side. The joystick also has the ability to "twist" by turning the handle, so I mapped that to turning the head from side to side. There was a throttle axes on the rear of the device, which I attached to the eyebrows: full throttle was "angry eyes", and no throttle was "worried eyes". Finally, I attached the mouth opening and closing to trigger button (pressing the trigger opened the mouth), and a button near my thumb on the joystick handle mapped to closing (blinking) the eyes. For the mouth and blinking, the effect was binary - so they were either opened or closed.
The model took a while to construct (a couple of hours), even though it was fairly simple. It looks pretty "muppet"-like:
I created the various Joystick CHOP inputs and networked them together with a Merge:
In this snapshot of the CHOP network, you can see I have the Record data locked (the little yellow square): I had already recorded my performance, and flipped that flag on to preserve the motion I had created. I also piped the output through a Lag CHOP, which created nice "ease in/out" motions for the otherwise pretty binary and jittery buttons and joystick axes. The net effect of the Lag CHOP on the motion data is pretty natural and pleasing, I think.
Here are some snapshots of frames from the animation:
I was finally successful in writing a custom CHOP to accept real-time input from a Joystick.
I spent a fair amount of time mulling this over, writing code, discarding code, re-writing code, etc. until I finally did it right. The biggest challenge I faced was deciding what bloody parameters I needed in the CHOP. So I did some research on libararies I could use to input the Joystick data: that would, in turn, give me a good foundation on how I would design the CHOP.
I looked briefly at the DirectX APIs, but quickly decided that since Houdini was a cross-platform application I needed a cross-platform solution. I found the Simple DirectMedia Layer, or SDL at http://www.libsdl.org - an open source, cross platform media layer for doing cross platform games on Windows, Linux, Mac, etc.
Note that to make SDL work you either have to compile it yourself and install it on your computer, or you can pick up the pre-built binaries that exist on the SDL web site. I elected to just use the pre-built libraries. I copied the runtime DLL into my windows PATH (I confess, I just put it in c:/windows), and I put the .lib file as well as the SDL subdirectory containing the SDL header files in the directory where I was building the CHOP source code.
I was then able to use the following command line to build my CHOP:
hcustom -l SDL.lib -I ./SDL CHOP_Joystick.C
I'll also mention that as a starting point, I used the Houdini sample code CHOP_FifthGlove.h and CHOP_FifthGlove.C as reference for how to go about building the CHOP. In essence, this Joytick CHOP was going to poll the device values when requested to by the Houdini system, convert its values to "normalized" values and insert the values into the CHOP channels.
The SDL libraries provided APIs for accessing the Joystick, and after a bit of reading I decided I wanted to keep it simple in my first attempt. So, while SDL provides support for Joystick Axes, Buttons, Hats and Trackwheels, I decided to only support Axes and Buttons.
Initially I wanted to write a single CHOP that could read every Axis and every Button on a single Joystick, but I quickly realized that this was going to be very tricky... at least for me. I wasn't familiar with the fine details of CHOP programming and I didn't have access to deep API documentation either, so I was relying strictly on the sample CHOP programs provided by Houdini. So the concession I made was that my Joystick CHOP would output one single channel, as described by the CHOP. If the animator configured the CHOP to watch the X-axis, it would spit out the value of the X-axis. If the animator configure the CHOP to watch the trigger button, it would spit out the value of the trigger button. To build a system that read from all the various axes and buttons on a Joystick, you would have to create multiple Joystick CHOP objects and merge their outputs together.
I also decided that the axis would have values from [-1, +1] and that buttons would have values of 0 (not pressed) or 1 (pressed).
The Joystick CHOP interface would have main parameters:
After a few long evenings of re-learning C++ and playing with the various API calls in SDL to make it all work, it finally started compiling and working. Here's a screen shot of the Joystick CHOP in action:
And here's a snippet of source code from the CHOP itself - this is the actual call where we get the values from the Joystick hardware:
if (VALUE_TYPE() == JOYSTICK_TYPE_AXIS)
{
if (SDL_JoystickNumAxes(myJoystick) <= VALUE_ID())
{
cerr << "No joystick axis with index " << VALUE_ID()
<< " (max " << SDL_JoystickNumAxes(myJoystick)-1
<< ")" << endl;
return;
}
float axisValue = 0.0F;
axisValue = (float)SDL_JoystickGetAxis(myJoystick, VALUE_ID());
// cout << "axis = " << SDL_JoystickGetAxis(myJoystick, VALUE_ID()) << endl;
// cout << "joystick opened = " << SDL_JoystickOpened(0) << endl;
value = axisValue / -32767.5F;
}
else if (VALUE_TYPE() == JOYSTICK_TYPE_BUTTON)
{
if (SDL_JoystickNumButtons(myJoystick) < VALUE_ID())
{
cerr << "No joystick button with index " << VALUE_ID()
<< " ( max " << SDL_JoystickNumButtons(myJoystick)-1
<< ")" << endl;
return;
}
value = (float)SDL_JoystickGetButton(myJoystick, VALUE_ID());
}
else
{
cerr << "Unknown Joystick Value Type" << endl;
return;
}
If anybody is interested in getting a copy of the source code for the Joystick CHOP, let me know, and I'll gladly provide it.
One of the things I've always wanted to model is an armature system with a hydrolic "motor" that could move the arms, kind of like C3P0 on Star Wars (look at the little linkage between his upper arm and forearm):
I knew I wanted to use the LookAt feature of geometry. It took me about 30 or 40 minutes, but I came up with something kind of interesting. Here's what I did. First, I create an interesting model for one half of the armature, like this:
Note that the main axis of the armature extends up the y-axis, and the
center of the "pivot" is at (0,0,0). This isn't essential, but it made
it easier when I had to move things around later.
Then I went
back to the geometry level and duplicated that geometry (with a ^C ^V)
and parented the new geometry to the original. I rotated it 180 degrees
in the Y direction, and about 120 in Z, to give me:
Then I created two new geometry objects at the object level, filling their geometry with a single sphere SOP. I moved them so they were kind of embedded yet protruding from the individual armature. Each pivot is parented to each linkage, so any movement in the linkage moves the pivot along with it. The arm assembly with the pivots is show here:
After this, I created two "hydrolic" rods parented to the pivots. I used the Tube SOP for the rods, and made one slightly larger than the other, so that when they were "attached" it would look like one was sliding inside the other. For now, I created the tubes so that they extended in the positive direction down the Z axis. I did this because the LookAt transformation in Object points the Z-axis of the coordinate space towards the thing you are looking at:
At this point, note that the hydrolic rods are just extending in
opposite directions. This is because they are parented to the pivots,
the pivots are parented to the armature, and one of the armatures is
rotated in 180 degrees.
Next, we open hydrolic rod Objects and
select the LookAt from Transform tab. For each of the rods, we select
the LookAt object to be the pivot for the opposite rod. This will make
the rods always orient towards the opposing pivot, making them look
like they are always attached:
Now you can rotate the second armature (the "child" armature) and the hydrolic rods will be pinned to the pivots and will slide in and out of each other, like this:
I have a few simple projects in mind that I will eventually start posting here, but during the last few days I've found myself exploring a bit of a tangent with Houdini.
I want to try animating things in Houdini using external controllers. Nothing like motion capture suits like Flock of Birds, or expensive data gloves or anything - just regular cheap gaming peripherals like the Logitech Extreme 3D Pro joystick I have sitting on my desk.
My first inclination was to understand how things like that worked in Houdini, so I immediately loaded the program and began exploring the interface and help files. I ended up in the CHOPs (Motion and Audio) section of the interface, but couldn't find anything with respect to Joysticks. I played around with the Mouse CHOP, and actually recorded some simple data with it. But I couldn't find anything related to Joysticks - so I assumed that there must be a lower level way of doing this.
I found the PipeIn and Network CHOPs and thought that this would be a reasonable way of inputing the Joystick data. Eventually I was able to locate a description of the file format used by Houdini to parse the data from PipeIn. So being ambitious, I wrote a Python script (and yes, I still use Python) to connect to the Houdini Network CHOP. My plan was to use Python and PyGame, a set of open-source Python bindings to the OpenSDL gamine libraries (which provide Joystick support).
Unfortunately I couldn't get this to work, for whatever reason. I could create a server that could make connections and spit out random channel values, but I couldn't make it connect to the network CHOP. I went to bed thinking I would revisit my network CHOP in the days to come.
Then I think I had a dream. I dreamt that it would be really cool if there was some kind of software SDK that would let you extend Houdini with your own SOP/CHOP/POP/etc. code to do what you wanted. When I woke up from the dream, I was almost disappointed that I had only been dreaming... after all, that would be the perfect way to input Joystick data into a CHOP. So you can imagine my joy when I sat down to investigate this, and there was indeed a Houdini Development Kit that let you write your own CHOPs!!!!!
Here's what I learned about getting going with the HDK in Houdini:
So, if you follow that admittedly rough set of instructions, you can also get the Houdini HDK working with the Apprentice edition.
To cap off the night, I copied one of the sample programs and modified it to compile and link some SDL code. I tried running Houdini, and after playing around with where to put the SDL.dll file (I ended up putting it in c:\Windows\System) I successfully ran Houdini with my new hybrid CHOP that contained the code to initialize the joystick system. My Joystick CHOP doesn't yet read any Joystick data - that's my project for the coming days - but it does execute and initialize without bringing the whole system down. That's a good start. Here's proof:
And interesting note to end on: Working through the Houdini code
brought back a lot of memories of working at Side Effects almost 10
years ago! The code style is very similar to 1994!
To kick things off, I'm going to do a little excercise. This is not a difficult Houdini task - but I want to test the new Blogger.com image posting service and I want to get things rolling a bit.
I remember when I was first getting into CG, I badly wanted to render a wine glass. I have no idea why. I wanted to draw the profile of the wine glass and revolve it around to make a solid object. My first attempts at doing this were in the Computer Graphics Lab at the University of Waterloo with Alias PowerAnimator, back in the early 90s.
In computer programming, "Hello World" is often showcased as the introductory example when demonstrating a programming language. The wine glass is my "Hello World" and I'm going to make one, right here and right now.
Curiously, one of the most challenging things I had to learn when I was "relearning" Houdini, was how to draw a curve. Its actually quite easy, but I think requires a bit of hand-holding. First, go into "Objects" mode in the Houdini interface:
Create a new Geometry, and call it "wineglass", like this:
Select it, and press the 'i' key to edit the Geometry's SOP network. When you enter the SOP editor, you'll see a single "File" SOP, loading the classic Houdini "Axis Cube" - delete it, because we're going to start from scratch.
In the View Window (it will have "View" at the top left of the screen): click in the window to ensure you have focus. First, we want to go into an orthographic "front" view to draw the profile of our wine glass. To do this, hit 'T' with the cursor int he view window. The window will change to show all four views (Top, Front, Side and Perspective). Move the cursor into the "Front" view and hit 'T' again. This will expand the "Front" view so it consumes the entire viewing area.
With the cursor in the View area, hit TAB. From the menu that appears, select "Curve":
(you can type "Curve" to help narrow down the selection - play a bit with these menus, they're really powerful). The nice thing about doing it this way is that Houdini automatically enters you into "Edit" mode on the Curve SOP, so you're essentially ready to edit.
Draw the left-hand profile of a wine glass in the orthographic front view, something like this:
Now move over to the SOP network editor, and add a Revolve SOP after the Curve SOP, play with its parameters, and set its display flag:
Voila! A simple wine glass.
Houdini Gems is a way for me to chronicle my adventures in learning to use the amazing software package called Houdini by Side Effects Software.
The adventure started for me in 1994, when as a University of Waterloo student I had a co-op job at Side Effects. I was one of these new punks that was learning this "C++" language, and I was extremely passionate about CG. Kim and Greg were kind kind (and brave) enough to take me on board and I became a part (a short part) of the Side Effects family. I had an opportunity to work with some of the most amazingly brilliant people I've ever worked with: Mark E, Mark M, Cristin, Dale, Ramin, Kim, Greg (and Lee!), and others. Some of you aren't there any more, but that group of people is forever burned into my memory.
We were working on the "next generation" of Prisms - Prisms 7, I think we called it at the time (or was it 6?). It, of course, eventually became Houdini and I'm extremely proud to have worked on it. I don't know if any of my code remains in the Side Effects source code repositories, but I remember working on several of the SOPs while I was there: The basic primitives (circle, grid, etc.), Twist, and an early version of the LSystems SOP (and whoever took that over, I apologize - it was at the end of my work term, and I was rushing to finish it).
Over the years I've often peeked into Side Effects to see what was going on. When they released the Apprentice Edition a few years back, I was elated. I downloaded it and played with it a bit, but never found (or made) the time to immerse myself.
Now, with the release of Houdini 8 in Beta, I've decided I'm going to make a concerted effort to really learn this amazing piece of software. This blog is going to be an attempt at chronicling the learning process. I'm hoping its useful enough that complete noobs (like me) can use it as a starting point to learn the software.
Recent Comments