We’re back with another project breakdown!

This time with a more in depth project. One that I’d consider “project ready”. Meaning we have a full environment created from scratch, with heightfields → materials → lookdev → custom modeled props → instancing layout → rendering → and compositing. And a full environment that can be now repurposed for later ideas ;)

In this email I’ll be breaking down the process of creating the full environment and these renders right here.

This breakdown will give you a full overview of the workflow used.

But if you’re interested in going into more detail - the entire process for creating this project node-by-node is already recorded, organized, and included in LEVEL UP: Houdini. In fact this section is over 15 hours of content specifically focused on the workflows in this environment and the topics discussed in this email. Everything from the planning, to initial organization, and final Houdini implementation - it’s all there.

It’s one of the many Boss Battle projects we complete, and if you want to learn EXACTLY how to create this project and more, you can get instant access inside the program today! (See the bottom of this email for information on how to join).

So without any further delay, let’s get started.

Enjoy!

Step 1: Plan!

This project was completed as a “Boss Battle”. Meaning every step, from the first look at the reference to the final composited pixels was done step by step.

As all Boss Battles begin, before we begin the actual Houdini work, we take time to review our references and plan out the entire project scope.

In this planning section, we write out every single step of the project that we’ll need to complete. This process is incredibly helpful for planning effectively and getting us ready for the next step of organization inside Houdini.

The result of this step 1, is a collection of “sticky notes” inside Houdini (pictured above). Where we can see the exact set of tasks we’ll need to complete in order to deliver this project.

By breaking down the reference image into smaller chunks, and individual tasks, this lets us better get a sense of the overall scope and also plan a good approach that can allow for an effective and scalable workflow.

Step 2: Organize Based on our Plan

The next step is possibly my most favorite of them all (I know I say that a lot haha..). In this step, we take the finalized list of tasks and goals (the sticky notes from step 1), and we create our Houdini “outline” that we’ll use as the main workflow for the project.

Pictured above here, are the Geometry containers and the LOP Networks we created in this step and plan to use for this project.

In the end, I decided to go with 3 geometry containers and 2 LOP networks which broke down as follows.

GEO CONTAINER → “our_main_desert_geometry”

• In this geometry container I planned on creating the main heightfield setup for the desert. Creating the landscape, the details, the dunes, and preparing all the “shaping” detail I’d need to create the final result

GEO CONTAINER → “our_layout_scattering”

• In this geometry container, I imported the result of the final desert geometry and then used this to prepare my scattering for layout and instancing in Solaris later. I like to separate the scattering workflow from the base geometry for the environment, because it lets me stay better organized - and then if I make plans later to expand the environment, or add additional details (such as buildings, natural formations, or larger props). I have a nice separation between the two parts of the workflow where I can add in those extra steps.

GEO CONTAINER → “our_props_geo”

• Because this project was created 100% from scratch. We also needed to create some plant and rock models procedurally. So this container is what I used to create those. We ended up with three variations of “dead grass”, two variations of “alive grass”, one “twig model” and four variations of a basic “rock”. This allowed us to get plenty of detail and variation when we were doing the layout. A HINT You can get surprisingly far in layout with just a few prop variations, often times I use fewer than 5 total props like this to get the detail and variation I need.

LOP NETWORK → “studio_environment”

• Since this project was a bigger environment, and I wanted the workflow to be scalable (across multiple shots, and even extending this environment for future projects). I decided to do all prop materials + lookdev inside a separate LOP Network. Because I split this out into it’s own network, I was able to focus just on the props lookdev without having to worry about the environment. This organization also has the added benefit of allowing me to export these as individual assets later, if I need to reuse them across multiple projects ;)

LOP NETWORK → “ our_main_layout_for_our_desert”

• (very descriptive name I know haha). But this LOP network was where I did… you guessed it! The main layout for the desert. I imported the main environment, the individual props to scatter, and the points to instance on (the points themselves were imported into a LOP Instancer, which is a common workflow we do a lot) - and then added in here the materials, lighting, cameras and render settings as well. Most of the main look-dev work was completed here, and the lighting and final look was dialed in to get it looking exactly how I wanted it.

Step 3: Begin Implementation: Procedural Props!

These first two steps were pretty thorough, and now that the organization and hard part of the planning is out of the way. We now switch our brain to “the engineer” mode of our “3 Artist Roles”. (this artist-role-concept is something we cover on the YouTube channel, so check that out if you want to work more effectively in Houdini).

We begin the engineer role with the implementation, and I decided to start the procedural plants first! In total there were 6 plants created, and four rock variations.

The main workflow for the plants (grass and stick variations), was achieved by creating some points, adding noise, and the copying individual lines to each of the points.

From there, we created multiple variations of this base shape to result in our nice looking plant variations! Pictured below are all the variations we create.

Next up we needed some rocks!

Those were created in a very simple way, with just some base spheres, remeshing, displacing and adjusting based on some noises.

(Although the size of these all look the same in the preview here, the smallest rock is about 10cm across and the biggest one is about 30cm across).

In case you want to see what these look like from a network view, pictured below is the final section of our network that was responsible for creating all these props.

This section (pictured above) might look like a lot of nodes, but once we go step by step creating this from scratch, you start to see that it’s just a few simple steps of logic that are implemented in Houdini with a certain chain of dependencies that we designed. (we learn a lot about dependencies inside the program, and in specific, how we can take references and problems and design a collection of steps that lets us fully leverage Houdini’s procedural power!).

Step 4: Procedural Props Look-Development (lookdev)

Look development (shading + materials + some lighting), is probably my all-time favorite area of 3D.

This is where the base shapes and models that we created, all start to come to life.

To keep this nice and tidy, I used that separate LOP Network (remember that one we created in Step 2?) This let me work on the look / materials of the assets, and also gave me the flexibility to export them later as individual assets if I want to use them across multiple projects ;)

The lookdev scene we create in the final lesson files ended up being really simple (it's all available now inside LEVEL UP: Houdini, and all created live node-by-node if you want to learn the exact details)

We just needed to get the base materials down, and see how the assets all look when placed together. Since this is Houdini, we always have the option to come back later and revise the look if we need to.

The layout scene we used to create this, ended up looking like this (pictured below) inside LOPS. But it also gave us a starting point, for expanding this in future projects (this is something I like to do a lot, if you haven’t already been able to tell).

Step 5: Heightfield Environment Prep

The heightfield section for our environment was also probably one of my favorite parts of this project - it’s all my favorite, but each step has its own unique challenges.

We started by creating a simple heightfield, and actually ended up designing our own heightfield custom “Dune-Tool” to hand place, modify, and art direct individual dunes we could layer on top of each other.

This image pictured above is the result of adding a single use of our “Dune Tool”, but with the tool we were able to modify the placement, shaping, height, and noises across each dune one by one.

The final result of what the workflow looked like, was this image here pictured below.

On the left (of the image above), you can see the Houdini scene view of our dunes layered on top. The pink nodes in the middle each represent their own “dune”, and then the parameters pane on the right represents the custom heightfield VOP we created to better art-direct it all.

This tool we create, is one of the many setups we do inside the program to help art direct our projects. It’s a relatively advanced topic (creating custom nodes, that can later be built into robust HDA’s), but we introduce it all from scratch inside LEVEL UP: Houdini.

Inside the program we cover VOPS, the basics of how they work, and then explore parameters, creating custom parameters, editing parameters, and even linking and organizing the menus and tabs needed to keep all this information organized.

WORKFLOW HINT: When creating custom tools + setups like this, it’s also important to find a balance between “art-direct-ability” and staying efficient with the number of parameters you expose. A trick that I’ve learned from experience, is to only expose parameters (build and add these parameters into you parameter menus) if you find yourself needing that exact control multiple times.

A common mistake is creating too many options and settings for modifying your tool, and resulting in clunky setup that is more confusing to use than helpful.

This topic of custom nodes is relatively advanced, but if you’re interested in learning this all in depth, and becoming a Houdini wizard who can design these scenes yourself 100% from scratch, then LEVEL UP: Houdini is perfect for you (you can get info on how to join at the bottom of this breakdown).

But back to the breakdown!

Step 6: Heightfield Scattering Prep

As always, when we start to get ready for scattering we want to be as efficient as possible. So our first step is to get our camera, and then cull based on what is visible within the camera’s field of view.

We do that, by first converting our heightfield to geometry, then getting the camera from LOPS, and removing anything not inside the field of view (in this case we project UVs from the cameras position and delete based off those), but we could also cull by a volume we create with the camera.

The result of that step is this image below.

Also - look now nice our dunes look from this angle!

Here’s another image of the dunes (pictured above) where we can see those exact details we were able to create with our custom dune tool we created in the last step!

This is looking pretty good so far, but we’re not even close to being done.

Step 7: Environment Scattering (Our Instancing Prep for Layout)

This step was a really fun one as well (it’s all fun, I love this stuff too much…)

But in this stage, we needed to create the points we’ll later instance our props onto.

Because we had three types of props (rocks, dead grass, and alive grass). I decided to create three groups of points. I split them into three separate geometry streams, so I could import and work with them individually in Solaris. (I could have also used the **"s@name" attribute or **"s@path" attribute to do something similar and have these split with a single Solaris import [don't worry if this doesn't make sense, it's something we cover in the course], but sometimes sticking with separate nodes to import can keep your network more readable.

But remember! Just because you could do something a certain way (maybe saving space, or using fewer nodes), doesn’t mean you have to. Sometimes the setup that is more readable, and easier to adjust ends up being the better one! (even if it isn't "as elegant" or if it uses more nodes).

To get some interesting variation, we set up some custom scattering logic (with some simple VOPS + VEX) and also utilized some attributes we created on the ground geometry itself that we then used as a density value for our scattering.

Here’s a preview of our scattering with and without the desert environment.

If you look closely, you’ll notice the red, blue, and green objects (in this image represented by small shapes) all have their own characteristics of where they are placed. This natural formation resulted in a really organic looking placement for these props.

Bonus Note: At this point in the workflow, I had only partially decided which props I would instance onto which points, so keeping these three groups of points (red, green, and blue) separate let me have more flexibility once I did make that decision.

Step 8: Solaris Layout + Instancing

Now, we had all the individual parts ready to go, so we just needed to create the main setup in Solaris, start to organize it all, and the create our final lighting and camera settings.

We imported our desert environment, our props, and our instancing points and after some organization and work inside LOPS - we ended up with this result below.

Here’s another image of the “top-down” view of what we have.

If you look closely in the image above, you can see the individual props we’ve instanced across our points!

HINT: In Solaris you have the option to randomly (or intentionally) instance multiple props to the same collection of points. So with all my “green” points from earlier for example, I could randomly choose between the different grass variations that were instanced onto each point. I could then adjust the look of each individual instance if I wanted to. I can also adjust the relative frequency of each individual instance.

Step 8 BONUS: Additional Material Variation

Since our props were just random selections of the same three alive grass, three dead grass, a stick, and then the four rock variations. I wanted to do another layer of variation across the scattered props.

This (which I realize is a bit hard to see in the renders) very subtle effect was done with creating a collection of attributes (noises, rest positions, and other values) on the points we were instancing our props ONTO. We could then copy these attributes onto the props, and use these inside the materials to modify the color of the props, the individual UV’s of each instance, or any number of things we wanted to change. (this is a relative advanced topics as well, and quickly can get super complex to do some super cool things! But inside the course we introduce complex ideas like this all in a nice to follow, and well structured way. So although they might seem overwhelming now, they end up being very intuitive and easy to plan. This is how I like to teach - with intuition and understanding as a core part of the lessons, I'm not just telling you the technical implementation / buttons to click, but I'm guiding you through how to make those decisions yourself)

In this project, I ended up blending between a few different triplanar textures based on world position, noise values, and some randomized values as well. This gave me good variation across all parts of the scene.

Pictured in these two images above is the rendered environment. Because we culled the geometry and landscape by what was visible in just the final camera, we were able to optimize the scene and get quicker renders as well!

Step 9: Lighting!

This step technically came before some of the material variations, but these two steps (adding lighting and finalizing the materials) is often something I go back and forth between. Since the balance of these two parts of the project plays such a significant role in how the final image looks, it’s good to stay flexible and always remain open for improvements here.

Pictured below are renders of the individual contribution that each light gave to the scene (with the top right being the full un-composited beauty render).

I really like this workflow of splitting lights into their individual contributions (split by LPE tag within Karma), because it allows you to combine and composite a single set of renders to get vastly different results! HINT → We do that next ;)

Step 10: Rendering!

Rendering was pretty standard, we rendered all these beauty renders with the individual contributions from each light, as well as a couple extra “utility passes”.

The two extra utility passed I decided to render, were a depth map (pictured below on the left), and a Crypto Matte (pictured below on the right).

A really cool thing about the Crypto Matte, is that you can use the individual USD primitives to create the colors inside the matte.

So if you organize your USD Stage (the Scene Graph Tree) effectively you can easily split up the individual layers later in compositing. (This idea is also something we talk a lot about in the course, how by determining the way we organize and plan our information + data, we can help our "future-self" with saving time later! In fact, this topic is a huge part of LEVEL 3, inside the program.).

Pictured below, is a preview of my Scene Graph Tree for this project (note, this graph isn't full expanded, so some primitives are still hidden). And the nice organization of the Props let me recolor each individual prop by themselves in compositing.

Bonus Tip: If you look closely, you’ll notice I have materials for my landscape (under /landscape) and materials for my props (under /props), the reason I split these materials up is something we talk a lot about inside LEVEL UP: Houdini (in specific, a lot in LEVEL 2), this organization would let me modify or repurpose parts of the scene effectively. And also lets me stay organized when my scene increased in complexity.

I mentioned earlier, that part of my initial plan was to have the props work in other scenes as well. So because they were created in their own LOP Network, and imported individually, I now have the option to either export them as USD assets, OR just copy and paste the entire LOP Network that I used to create them!)

Bonus Bonus Tip: If you work with LOPS and Solaris a lot, you’ll start to see ways to reuse parts of your scene, in a similar way with SOPS and object merges (how you can move and rearrange information inside your SOP network for use in different parts of your network, something we do a lot of in LEVEL 4), you can also use a “Fetch” node inside LOPS to rearrange and reorganize different parts of your scene graph tree. This becomes INCREDIBLY powerful once we start doing FX and simulation workflows - where we’ll need to start planning and rendering our scenes in multiple layers. (And yes, FX and simulations are also covered in Level Up: Houdini, that program truly is the only Houdini program you'll need).

It’s not uncommon to have 30-50+ render layers for a FX shot, where each effect of sparks, fire, smoke, debris, and dust all have their own individual render layers and individual utility passes.

If that’s a lot of information I'm throwing at you, don’t worry. Some of these topics are relatively advanced, but if you're interested in truly understanding this all, we learn and go into depth exploring and practicing it all inside of LEVEL UP: Houdini.

The program is nearly ~80 hours (in fact 78 hours 39 minutes and 28 seconds last time I counted) of robust learning, problem solving, and slow step-by-step explanation of EXACTLY what is happening and why I choose every node that I do. All covered from the absolute basics (and taught in my nice to follow teaching style ;)

If you enjoy the way I teach, then I think you’d be a fan of how well put together the course is. The course also comes with a 30 day 100% money back guarantee. I’m here to help you learn Houdini, not trap you into a course that doesn’t deliver.

But!

For now let's get back to our breakdown, and we’ll now take a look at my (other) favorite part of this project!

Step 11: Compositing!

The final step of this project is compositing which was all done inside COPS (for this project, and the other projects inside LEVEL UP: Houdini)

COPS (or Copernicus) is Houdini’s native image context by the way!

The main purpose of the compositing for this project was two-fold, 1) I wanted to showcase multiple compositing workflows for recombining and modifying our image to get different results and 2) I wanted to try and create a few different “lighting” times of day, with just the same set of initial renders.

The render layers we had to work with are these 8 picture below.

And our final results after compositing where these three unique variations down below.

This first look (picture above) was a full day-time look of our desert. We intentionally wanted some over exposure on the back sky with a nice glow and haze that we ended up creating by using our depth pass utility render.

The second look (pictured above), was a night-time look from the same render layers. This one had a small spotlight focus in the center of the dune, which was used to create an interesting focal point on the "hero" dune.

The third and final look, was an sci-fi themed “mars” looking environment. I wanted to push this one hard into the reds, and get a nice hazy look with the back side of the distant environment. This one here is 100% my favorite render.

We also did a cool trick with the depth map, and remapped specific parts of the depth layer to get a laser that “scanned” across the environment from the nearside all the way to the back (You can see this better in the final animation)

It really is crazy how much variation you can get with just some basic renders. By combining and layering them together in different ways, you can dial in light intensities, exact coloring of materials, and even change the whole mood of the shot.

Step 12: Bonus Post-Mortem.

This project was a ton of fun to create, and over the course of 15 hours of content inside LEVEL UP: Houdini we go step by step to create it all from scratch ;)

I’ll also be expanding on this project in the future!

But to improve it I think there’s a few main things I’ll focus on.

The sand / dunes themselves I think could use some more detail and variation to the sand texture (specifically some displacement or small scale ripples) that I think would look really nice.

The props, could be better integrated into the environment themselves. We did one pass at scattering, but I think with some of the bigger plants, it would make sense for them to have smaller debris, dead sticks, and even smaller pebbles near by. There would also be some variation to the sand (buildup and other ripples) that might be caused by the plants obstructing the wind or other natural erosion forces.

But overall - the image itself turned out really well! Tons of information was covered, and there was lots to learn here that will prove to be helpful for future projects.

If you're interested in learning more Houdini and want the skills to implement projects like this yourself (all 100% from scratch), then you can join today and get instant access to all 78+ hours of content.

​https://wttrlabs.mykajabi.com/levelup​

The program LEVEL UP: Houdini is continually expanding, and more and more content is being added each week.

And if this breakdown was interesting, too complicated, or too simple, then do let me know! It's a tough balance to find between getting a good amount of explanation, and also still staying simple enough for a nice quick breakdown.

Thanks for reading :)

And stay curious,

Will

P.S. The **"s@name" and the **"s@path" attributes are string attributes (denoted by the "s" prefix to the @) that we can use to modify how our geometry is imported from SOPS to LOPS. By creating these attributes, we can have the geometry imported into unique primitives inside our Scene Graph Tree (USD primitives, not polygon primitives... it's confusing I know haha).

This is all covered from scratch (and much more) inside the program, so if you're curious on learning it all, then definitely check that out!

P.P.S. A string attribute just means we're able to use characters and letters like "a", "b", "c", "/" or full words like "Houdini_is_really_cool" inside the values of our attribute (instead of numbers). This is different from a float attribute, an integer attribute, or a vector attribute. (We learn all these differences and more inside the program!)

P.P.P.S. An attribute is a piece of information we're able to store in Houdini. Specifically, we store these attribute on certain parts of our geometry / data inside Houdini. And by setting, modifying, and creating these attributes in the correct order - we can bring full worlds to life and create anything we could possibly think of. In fact... everything you see in Houdini is just data and attributes, but it's arranged and interpreted in certain ways based on rules that we have the power to create! (Houdini is absurdly cool, and I could talk about this all day)