Introduction & Career
I’m Stephen Bester, a 27-year-old procedural artist and TD working in Sidefx Houdini software. I grew up in Johannesburg, South Africa, and I’m currently employed at a company called Luma Animation where I fill a lead technical and supervisory role. I’ve been producing high-end CG commercials with them for 5 years and also making some headway into real-time applications and long-form projects. Most recently I had the opportunity to contribute to a commercial for a local company, Avbob. This article will feature this work.
My first experience in animation took place when I was a kid. I would draw characters using custom shapes in Microsoft PowerPoint and move them over consecutive slides in a presentation like stop-frame animation. Later I got into Macromedia Flash and learned about keyframes and tweening. I even did some school presentations as animated versions of me and my classmates to receive mixed reactions from my teachers.
My first experience with 3D came in my mid-teens. After a LAN with some friends, I found a utility disk still in my PC which had an old copy of 3ds Max on it. Not having internet access at the time, I taught myself using the internal Help documents and developed a keen interest in 3D. It combined my mathematical prowess with my love of making drawings come to life. When it came time to choose a career path, I chose animation over computer science and continued my studies at The Open Window, School of Visual Communication, one of the few local institutions to offer a degree level course in animation at the time. This led to my job at Luma Animation where I developed my character animation skills early on before transitioning into the more technical role I hold today.
Flower & Sunbird
The flower and Sunbird were part of the aforementioned Avbob commercial. The story involved a large Baobab tree sheltering all manner of animals in times of storm and hardship and providing for future generations. The flower and Sunbird shots needed to show growth and natural beauty.
Both as a challenge and for technical reasons, I wanted the flower to be fully procedural in creation and animation. I had recently completed a personal project of popping procedural popcorn in slow motion. It used many of the same techniques as the flower opening, so I wanted to improve the system and further explore the versatility of Houdini.
For the bird, I wanted to attempt a proper feather rig. Because of their structure and movement, I think feathers are even more difficult than hair and fur. They have to maintain their arrangement without intersection and fold and stretch with the wings and body. While I don’t think I achieved perfect realism with this Sunbird, I definitely learned a lot and I’m proud of the result.
After some research into flower structure and that baobab flower specifically, I split the creation into its natural, visible parts: Pedicel (stem), sepals (outer shell), petals, stamen (pollen bits), and pistil (center column). I modeled each piece as a separate little procedural system, meaning any step from a single line to the final model could be retraced and changed at any time.
I knew that the flower needed to blossom, so I made sure to build in controls at key points during the creation that could animate a specific operation (like a bend) and have that change propagate smoothly down the line. In an animated procedural system, the model gets regenerated every frame, constantly going through nearly the whole process of creation. Therefore a change in the middle of a procedural system has to be compatible with all the operations in the list after it or else you get errors or unwanted effects. It is more work to manage, but it lets you pull off cool effects, like the sepals actually tearing as the flower bends open.
Another aspect was the fine hairs scattered on the flower. For consistency, this fur is generated once and then deformed to stick to the opening flower. This was tricky because the deformation required an unchanging topology on the flower to track the movement, but naturally, the tearing sepals’ topology changed every frame. I ended up referencing a hidden version of the mesh, which did not tear and had a constant topology, in order to drive the fur.
None of the elements were truly simulated in the traditional sense of forces, collisions, or requiring knowledge of previous frames in order to build the current one. Each frame of the flower animation could exist on its own, driven only by smart use of the exposed parameters.
Animation of the Flower
Animation is primarily driven by keyframed parameter sliders on certain operations within the flower’s creation. Lots of custom bends, several push and scale deformers, and a couple of blendshapes. An animated noise function created the movement variation in the stamen.
The wind moving the entire flower is actually the only traditionally animated aspect – I just hand-keyed the position of the parent to look natural. This could easily be substituted with a noise driver though.
Houdini has all the traditional animation tools of the other packages, and more, with greater versatility for procedural animation. I really enjoy the non-linear workflow where you can revert, split off, or improve your solution at any time. I think a strong feature of Houdini is its flexible data management. It still retains structures like points, primitives, vertices, and polygons, but any data can be treated as contextless, and copied or referenced to another part of the pipeline at any stage. This results in it being easier for geometry, animation, shaders, hair, pyro, cloth, and liquid to share and interact with each other natively. Houdini is known for its steep learning curve, but with all the systems working in a similar way, it’s easier to learn another aspect of Houdini once you understand the core concepts, and that learning curve eventually tapers off.
Every feather is technically unique at the end, but they come from a shared setup. Firstly, the general feather density, direction, length, and scale gets painted onto the base geometry as point attributes. Hundreds of points are then scattered on the surface of the body based on the density attribute in different areas. These points inherit the attributes of the body at their spawn location. One of four base feathers gets copied onto each point depending on their length attribute and gets rotated based on the direction attribute and the normal of the body surface at that point. Things stick out unnaturally at this point, so all the feather geometry then gets projected back onto the body surface to lie flat. Then all the feathers can all be made to stand up a little using a custom vex rotate deformer which gives control over the tilt, yaw, and roll from the feathers’ roots. A lot of procedural masks and groups are made to allow for local control over things like color, length variation, and fluffing. It’s more efficient to do these previous operations on all the feathers simultaneously as a single mesh rather than one feather at a time, but saved attributes allow every point to still retain an ID of which feather it belongs to. Now, based on that ID, each feather gets converted into Houdini’s packed geometry, which essentially freezes the geometry of each feather and lets it be transformed as a single point at its root. These final packed feathers are point-deformed to follow the skinned body animation, and also have animatable control over their rotation using ramps and sliders.
The larger wing feathers were generated individually using an HDA shared by a SideFX intern at the time, Tighe Rzankowski. Each feather gets packed and copied onto specific curves on the wing rig. The rig stretches multiple curves between the bases and tips of control bones. Each feather follows a location on a ‘root’ curve and points in the direction of a corresponding location on the ‘tip’ curve. This allows the wing to fold and splay using minimal controls, without adjusting every feather individually.
All the feathers were generated as curves making up their quills and barbs, but I decided to extrude all the curves into flat planes based on their width to show their final geometry, rather than let the curves get generated with thickness in the renderer. This gave me more control over the final look and properties of the feathers in the viewport, and I found the increase in render time an acceptable trade-off.
Feather Shader in Houdini
Houdini uses a node based system to build shaders like most other packages nowadays. One can connect many basic operations together to achieve pixel-level effects in the render. The main feather shader is just a principled shader with varying levels of roughness and specular. The maps used for this and for color were sourced from point attributes on the feather geometry that were created with noise and color ramps during modeling. I spent some RnD time at the start trying to get a true iridescent shader on the feathers, but I did not get a good solution, so we opted for control over that color sheen in compositing, using masks based on normals, lighting, and feather attributes.
The bump pattern is procedural inside the shader and creates the illusion of barbules on each little strand of a feather (barb). Each barb has UVs going from 0 to 1 down its length and across its width. Using this as the input, one can manipulate that value with just simple math like sine, add, and multiply to create the pattern on the surface. This plugs into a bump generator node like a regular black and white image. Then the pattern can be look-directed and varied using exposed sliders and ramps. The opacity is also controlled like this to soften the edges and the tips.
The base tree and main branches were sculpted to fit a specific design. Smaller branches were grown from scattered points on the trunk. A custom growth solver, written in vex, generates small sections of branching curves at each scattered point. It uses similar techniques to speed tree, in that branches grow in small-segment iterations, making decisions to rotate, split, or die based on input parameters. Another custom feature was the ability to limit growth only to regions inside user-defined geometry. A branch would stop growing if it went outside the geometry and thus a broad leaf canopy shape could be art directed.
Twigs get copied onto the ends of branches and leaves get copied onto the end of twigs. As the shots of this tree were from so far away, we could get away with just two leaf-cluster variations and two twig structures instanced around the whole tree. Like the feathers, all the twigs and leaves were packed geometry represented as single points. This meant that they could be rotated, scaled, or removed, very easily and efficiently, and in a random or controlled fashion, by manipulating attributes on the seed points. The packed geometry was also very efficient to render and fast to visualize in the viewport. Because so many of the parameters on the tree were driven by noise and random numbers, simply changing the random seed and a couple of parameters could result in an infinite number of branch and leaf variations using a single setup.
Advantages of Houdini
Overall, the biggest advantages of the procedural workflow are:
- Nonlinear editing. Changes filter down the node tree; you can go back and edit operation at the start, which would be difficult in a linear workflow.
- Save tools to speed up workflow. In Houdini, you can package up collections of node setups as HDAs (Houdini Digital Assets). These could handle one specific operation or contain an entire technical setup, which can be shared with other artists or reused on future jobs.
- Automation. In a well-defined setup, desired outputs can be generated just by feeding in new inputs (e.g. any shaped geometry could be turned into a unique house with a single click).
- Fast variations. Making a thousand semi-unique assets is as simple as changing a few parameters on a procedural generation setup.
- In summary, Houdini and its procedural workflow give one the freedom to solve problems with creative technical solutions.