How to Create Gorgeous Space Nebulas in 3D

Introduction

I'm Adam Swaab. I’m an independent contractor working in advertising, marketing, and feature films. In my career, I've done everything from concept work and visual development to 3D production and creative direction.

I am a self-taught 3D Artist. My introduction to 3D was in the early 2000s, working in Cinema 4D, which I used for many motion graphics projects. I spent several years at Blur Studio, using 3ds Max, and then started teaching myself Houdini when their first learning editions came out (a colleague at Blur recommended it to me). Since learning Houdini, it has become my primary tool – I really click with its procedural nature, and I love how comprehensive it is as a package.

The skills I have were acquired through a combination of inquisitiveness and getting involved in several online communities of 3D artists. In the past, I've typically been the only or the most experienced Houdini artist on my jobs, which have mostly been in smaller studios or with smaller teams in large studios. So, I never had much opportunity to learn through mentors or leads. It has always been self-directed, which means a lot of trial and error, a lot of testing and guessing at solutions, and a lot of research into areas I was unfamiliar with.

In terms of projects, I've had a long career. There have been a ton of projects all across the spectrum – motion graphics, music videos, commercials, films, and concert visuals. And, I've recently started doing work in the real-time space as well.

Inspiration

The reason I like using Houdini is that it is a very open piece of software. Meaning, as an artist, I am not limited to the tools that ship with the software. I can crack open and modify solvers, and I can author my own (as I did with some of the nebulas in this series). The procedural nature of the software is great for both repeatability of a setup and the ability to explore and make variations through adjusting parameters. I very much enjoy setting up systems and networks to create my artworks and come up with interesting ways (whether through code or nodes) to achieve my visions.

The inspiration for creating nebulas... I very much appreciate the scale and beauty of these celestial wonders, but I am by no means a space enthusiast. I've had several opportunities to make nebulas for commercial projects over the years, and I always felt like I came up short. So, recently, I finished up a rather large commercial project and decided it would be worth looking into with some seriousness. I don't have much of a plan with these – it's just a bit of a learning experience and some padding for my reel, to be honest. And, I like that the look and feel of these is very different from the personal work I've done over the last few years (very mechanical, geometric work).

The Process

I'll start by saying that the project is very much one of discovery and R&D. So, there's a lot of trying various techniques and seeing what works and what doesn't work, or what works best in which situations. So, there are several techniques at play, and each has its strengths and weaknesses.

My first exploration was to create nebulas entirely at render time using volume shader networks in MaterialX in Houdini. Part of the reason I initially went in this direction is that we can get incredibly high-resolution results with zero simulation time and disk usage. And, just adjusting some simple parameters would create an entirely new nebula – so, infinite variety. My issues with this technique were a few... First, because this all happens at rendertime, it is very hard to choreograph cameras and other elements in the scene (you have to render it to see it!). Second, the results didn't quite have the nebula feeling I was looking for – they felt very much like procedural noise. And third, they were nearly impossible to art-direct. The results were very random, and I couldn't hit targets for specific structures or types of elements I was looking for. I think there's a lot of use for shader-based systems, and I could see myself using the techniques I explored for quick projects, but for my goals with the project, it didn't cut it.

Above are early examples of a shader-based nebulas.

I spent a little time looking into particle-based solutions, but I've always had issues with rendering dense particle clouds, even ones with upwards of 30-40 million particles. You are always limited in how close you can get to them with the camera before the particles become apparent; the disk size and simulation iterations are too expensive; and your shading options are limited. The best case scenario was to rasterize the particles into a volume and continue to up-res and shape the volume from there. It worked pretty well as an organic base to play with, however, it lacked some of the softer, wispier qualities I felt were needed.

Here's an example of a particle-rasterized nebula element. 7.5 million particles rasterized into a volume, with post-volumetric advection for high-frequency details.

So, I was back to volumetric solutions, whether that meant rasterizing particles into a volume, driving volumes with particles, or creating purely volumetric systems. I think, depending on what type of elements you are creating, you will be either rasterizing particles or going in a purely volumetric route. One particular thing I like about working with volumes is that they can upscale nicely, and part of my work with the project was to come up with some ways of pushing the detail and resolution without going back into simulation. It makes iteration time much faster, and it also allows you to dial in additional resolution as needed.

Volumetric up-res technique, before and after:

One of the things that initially caused problems for me with volumes and volume tools is that smoke simulations have a very specific look – they are prone to mushroom-like shapes or more pyroclastic shapes. Looking at pictures of nebulas, it appeared to me that these fluid-like phenomena were not happening at this large of a scale, and perhaps not in the vacuum of space.

So, I needed a solution that allowed me to simulate volumes through velocity fields, flow, and advect in art-directable ways, and not have that typical smoke-simulation look. One solution I ended up with is essentially a rebuild of a smoke solver, but without the project non-divergent step. With this setup, I could add a lot of the usual enhancement microsolvers (turbulence, dissipation, disturbance, wind, dynamic resize, and even OpenCL compatibility) while staying away from the smoke look. Later, I enhanced that setup by introducing my own divergence field to fake-simulate the attractive gravitational forces with the gas clouds. With this setup, I can also inject rest fields or color fields, which can be used later in the shading networks.

The overall process is to art-direct both an initial density field (and a temperature field if needed) – seed it with the base nebula shapes, then run it through the custom solver, which then creates the gravitational attractive forces, advects the volume through the shaping velocities, and creates the low-frequency details. After the solver, it goes through my up-res process, where it gets sharpened and high-frequency detail is added. I go through this process for many elements. Both the smoke and emissive volumes (nebulas are usually made up of some combination of both) run through their own setups. I usually re-use the shaping velocity fields, as that provides cohesion to the elements, but allows for unique behavior with each element.

An example of one of the custom nebula solvers, with faked internal gravitational attraction:

The star fields are instanced volumetric puffs. Sometimes I will re-use one of the density fields from the simulation and scatter within there. Other times, just create another volume to scatter into. Nothing too fancy there.

I usually get some idea of how the nebula will look by adding lights into my scene at the object level, applying some basic volume visualization nodes in SOPS, and adjusting these in tandem with adjusting my simulations. But it is always exciting to bring it into LOPS for final lighting and rendering. All of my renders have been done with KarmaXPU in Houdini. It's great fun to move lights around, see how the volumes react, build layers of light and dark, and direct the eye and viewer focus. I tend to use a good amount of volume bounces (at least 4) to really make the lights penetrate naturally into the volumes. And, if there are emissive elements in the volumes, it goes a long way to integrate them. Of course, this does add to render time, but I think the results are worth it.

Tips

The best resource is to dive in and start making things! The second-best resource (shameless plug incoming...) is my tutorials available on my Gumroad page. But, in all seriousness, there really is no substitute for trying to make something you want to make. You might not have all the pieces and knowledge, but diving in and doing it lets you know what information you are missing and where you need to learn more. You may have several starts and stops, you may have to reduce the scope of your vision, you may even have to change course, but making steps forward, any steps forward, and seeing a project through to completion is a great way to learn.

On a practical level, I'd say memorizing nodes is not a very useful way to learn. It probably is better to pick one small part of the program that really excites you (procedural modeling, particles, fluids?) and learn just what you need to know to become proficient at that one thing. Then slowly branch out and learn more of the tools. It is such an immense and comprehensive package that it cannot be absorbed all at once. And, the pace at which it changes is so rapid that it feels bottomless! I personally have touched about only 70% of the software in any real depth – and this is after using it for many, many years. So, don't worry if you can't learn it all.

Adam Swaab, 3D Artist

Interview conducted by Gloria Levine