Rigging and animating a bulkhead door in Blender

A screenshot of Blender, showing a part of the bulkhead door with a selected armature rendered in front of it. — One of the armatures I added to the door.

I like to move it

Move it! By rigging and animating the door, or at least learning how to do it first. After part one, creating the mesh; and part two, texturing the bulkhead door; I was ready to finally animate the door in Blender. Looking at what I've got so far, I've … wait a second, I did the main door wrong.

On closer inspection of Ron Cobb's sketch, my wife pointed out that the shadows on the door, which I thought were extruded parts, are actually insets.

Part of the bulkhead door sketch from Ron Cobb. In the middle a part of the outer door is highlighted, showing parts of it inset into the surface. — Comparing the sketch to the mesh I created, again.

Part of my bulkhead door model I made in Blender. In the middle, the outer door is highlighted, showing parts of it extruded from the surface. — Comparing the sketch to the mesh I created, again.

Does that mean I have to redo parts of the door? I didn't think so at first, but the ever-growing whisper of doubt crept into my ear. I cannot unsee it; I will always know the mistake I made. In the first part of this article series I wrote:

What I wanted was to recreate his drawing as well as I could, as close as possible, and this is what I set out to do.

And this is indeed what I will set out to do.

New year, new … door?

Looking at the drawing again, I found another oversight — a small inset running around the edge of the main frame of the door. With the extrusions on the door that are actually insets, this makes two mistakes I have to correct.

Image showing a comparison between Ron Cobb's sketch and my mesh. Highlighted is the rim around the main door-frame, compared to my model without. — My main door frame misses the inset rim around the entrance.

Taking this as an opportunity and applying all I learned throughout last year, I wanted to recreate the main door and change the frame. While on it, I will also rework parts of my topology and fully redo my, as I know now, horrible UVs*.

Adding the inset around the main door frame edge was quickly done. The actual door I rebuilt from scratch, this time with inset parts on the surface of the door, similar to the inner barrier doors. I also reduced the segment count on all bevels, decreasing the overall poly count, as I want to use the door in a game engine.

My textured bulkhead door mesh with extruded parts on the surface of the main door. — On the left is the old version, and on the right the new. I also moved some elements and reworked the proportions of the door.

My textured bulkhead door mesh with inset parts on the surface of the main door and reworked proportions. — On the left is the old version, and on the right the new. I also moved some elements and reworked the proportions of the door.

Here is the final version, both with the extracted barrier doors and the main door closed.

The textured bulkhead door with closed outer door in its final form. The frame of the door is a dark grey, the main door an off-silver. — The final form of my door, both with a closed and open main door.

The textured bulkhead door with open outer door in its final form. The frame of the door is a dark grey, the inner barrier doors are red with white diagonal warning stripes. — The final form of my door, both with a closed and open main door.

Happy, knowing I did what I could to finally recreate Ron Cobb's drawing as close as possible, I was able to move on, as I already did twice in the previous articles of this series.

Stop! Render time.

While texturing the door, even though I was happy with the workflow provided by Fluent: Materializer, there was one thing that kept me worried: my render times. Every single render I did from the door took roughly 15 to 25 minutes on my machine, an Apple MacBook Air with the M1 chip. This was due to the procedural materials and limitations of my system, so I assumed.

A reasonable fix would be to bake the procedural materials into static textures. Even though Fluent: Materializer comes with baking support, this never really worked for me. The main issue was that I was only able to bake one material at a time. In the end, I wanted to have one texture for everything.

One way I could solve that is by baking every material one at a time and, with some image processing software, combining those images into one texture. Thinking about an efficient workflow, this did not strike me as a scalable approach.

Simple bake, with SimpleBake

The Blender add-on SimpleBake got my back — no affiliation, just a happy user. To use it, I had to prepare some things. For one, I needed to ensure that my UVs do not have any overlapping islands; after my last rework, this was easy enough and already done.

Image showing the UV view in Blender, in blue colors the UV islands of the bulkhead door. On the right the settings panel of UVPackmaster 3. — I'm still learning, and UVs are hard. I acknowledge the empty space could be used better.

Second and last, I needed to configure SimpleBake: give it a list of objects to bake, what textures to create, texture resolution, how to export, and if a copy of the objects with the applied textures should be created inside the project.

Image shows a run-down of all the settings for SimpleBake I applied, to give an example. The details are not really important here. — There are quite a few settings to adjust, but it needs to only happen once.

After having this set up once for the project, I can bake and re-bake textures with one click. The results were amazing — my render times went from extremes like 25 minutes to 1 minute max with the static textures applied.

The texture-baked bulkhead door with closed outer door in its final form. The frame of the door is a dark grey, the main door an off-silver. — All textures are baked; the door still looks like before but renders a lot faster.

The texture-baked bulkhead door with open outer door in its final form. The frame of the door is a dark grey, the inner barrier doors are red with white diagonal warning stripes. — All textures are baked; the door still looks like before but renders a lot faster.

Being now able to quickly render the door, my worries baked away, I could continue with rigging.

Bones and Drivers

Before I found the Drivers Master Class for Blender video series from Level Pixel Level, I thought armatures and drivers were pure magic. Now that I have gone through that playlist, getting myself familiar with drivers, it still feels like magic, but right at my fingertips. Applying what I've learned, I threw some bones, or armatures, at my door.

The Blender viewport showing the clay version of the bulkhead door. All added armatures are rendered on top of the door. — My door bones, rendered in front of the mesh.

The plan then was to "drive" those bones through a controller, keeping everything together with a set of constrains. Starting off by right-clicking on the bone's y-location to add a driver.

The viewport of Blender, showing a part of the bulkhead door with an armature rendered in front of it. The armature is selected and the Drivers- and N-panel is open. — Adding a driver to the y-location, highlighted in purple.

In the Drivers panel, I defined the "scripted expression", connected it to my controller, and added limits to the movement of the bone to drive.

Image shows two settings panels for the bone driver, setting up the expression on controller on the left, and the limits on the right. — Example of the settings for my driver.

For the controller, I created an arrow out of a plane to which all bones are connected by their respective drivers. The arrow also gets an object constraint to limit the movement, just for my own convenience.

Part of the Blender viewport showing a green arrow to control the door and the open constrains panel. — The green arrow is what I will use to control the door.

Moving the arrow on the y-axis will move all the bones of the door, as defined by the driver's expression.

Showing the controller in action, driving the bones of the door.

All in all, drivers felt somewhat natural — with functions and properties resembling programming to a degree, giving me a kind of familiarity.

Move it!

With the door rig ready, I used the controller to drive the animation of the door. I know there are many ways to do this, but this way felt like a solid choice for me at the time.

Animating the door through the controller.

Watching my animation too many times left me feeling somewhat unsatisfied. I looked at a lot of reference doors, tried to tweak the animation timing, and made parts of the door animate at different times, all to get a more natural feel of the door moving.

I'm not quite there yet, but I will continue nonetheless. Maybe future me has some good ideas for improving the animation further.

Final animation

Door rigged, animation set up, time to hit export. For this, I exported an image sequence, which I then combined into a movie through Blender's Video Editing view.

Image showing the settings I used in Blender to export my animation as image sequence. As a base it needs the frame rate and range, where to output all the frames, and the file format. — The export settings for my animation.

I took the final movie of the animation into DaVinci Resolve 18, using it to make some slight color corrections.

Image showing the final animation open in the window of DaVinci Resolve 18. — Some last corrections to the animation, mostly because I also wanted to learn a bit of DaVinci Resolve 18.

And this is it; here is my final render of the bulkhead door animation.

It feels strange to me to see it finally move.

What comes next?

After having the basics of rigging, animation, and drivers covered, I want to deepen that knowledge — getting more modeling experience can't hurt either. Therefore, my next step will be to model a hallway incorporating the door, add some slight VFX, and animate a camera moving through the environment.

But that will be in part 4 of the project. Until then 👋🏻