If you're a developer working with special effects or 3D animation, odds are you've at least heard of Houdini. This software is mentioned on job postings and Twitter feeds constantly. It's been a game-changer for the film and game industries.
Houdini is in technical terms a VFX software, it has mostly been used for animation and visual effects primarily. Houdini does possess all the necessary tools required for 3D modeling to be done in its workspace.
Houdini is a node-based procedural language that allows you to describe how your data flows through your network. To give you a better idea of what procedural modeling is, let us take an example of programming languages, the algorithm is the flow of the code. Procedural modeling is exactly like the algorithm which helps in making models with predefined rules instead of creating models entirely through user input. This technique helps develop models with perfect geometry.
Houdini has a number of different formats that are supported for import/export purposes. The available formats on Houdini support image formats, channel/audio formats, scene description formats and geometry formats. External formats can also be integrated in Houdini through the use of converter formats.
Houdini has a number of versatile factors that tip artists in the favor of developing their skills according to this software. A number of very elite companies such as Disney, have been known to use Houdini for their projects. Houdini has a free version of its software available for students, newbies and freelancers. Additional plugins are not required to develop basic structures and models. The rendering ability of Houdini must be praised as well. Their rendering tool Mantra is extremely versatile and has a number of powerful options to help you get the best results possible.
In part one, we will look at the underlying structure of Houdini. This software consists of individual apps for specific tasks, strung together to create a master app focused on realistic, computer-generated simulations. Part two of this tutorial will take you through converting a 2D image into a 3D mesh object using glTF as the file format.
Working with Houdini on 3D models
The most generic way to describe working on 3D models with Houdini is that you can work on various shapes according to your model and then after that combine all those individual pieces together to form your masterpiece.
We will now look at a detailed view of what are the basic steps of 3D modeling on software and how Houdini helps artists in each of those steps.
The first step is making a rough base for your 3D model. Now you can either import objects of specific shapes in Houdini or import an already built base that you would like to work upon. As we have already discussed, models in Houdini are made up of various objects, to make these objects, the create tab can be used. The geometry created is defined by their geometry nodes. These geometries come in specific shapes and sizes. After importing the basic model geometries, they can be tweaked and edited according to the desired parameters.
By doing this and repeating the procedure of model development for each layer of the model body. After creating all those specific geometries, they can be added together through a number of different tools. For example, the blend object tool develops a parent child relationship between selected multiple geometries. This gives the artist control over various Houdini effects and how they work with each part of the model.
The next step is detailing the model blocks built. These details can be color, shading and other effects. The resolution of these details is heavily dependent on the number of polygons used on each object. Houdini gives you the option of adding various textures and materials to your model. The shade tool can be used to visualize bumps and other 3D effects on any surface. The combination of all these effects can turn the model into something that is quite well detailed and pleasing to the eye.
The next important step in #d model development is the rendering of the detailed model. The Mantra render tool of Houdini has already been discussed above. It is an extremely powerful tool with good results. However, the combination and mixture of all these steps and tools and their output result is heavily dependent on how an artist uses these tools together. So feel free to understand what works for you and what does not.
Houdini Modeling Tools
PolyExtrude: PolyExtrude lets you take points, curves or surfaces of the 3D model and pull or push at it to change the size of the extrusion as you wish.
TopoBuild: This tool lets you create and edit polygons placed on the 3D model. The number of polygons basically represents the resolution of the model.
PolyBridge: This tool creates a polygonal surface by connecting edge loops in one edge selection with boundary loops in another primitive selection.
PolyReduce: PolyReduce helps keep the original form of the model by not creating equilateral triangles. You can reduce the overall quality by increasing the Equalize lengths weight.
Edge Smoothness: Edge smoothness basically reduces the change in intensity of the point it is used upon. This stops the abrupt change of pixel values and rather changes the pixel values smoothly and slowly.
PolyBevel: Fillet polygons are inserted between edges and at corners by PolyBevel, with extensive control over the form of the fillet. This tool is capable of dealing with extremely complicated inputs and is capable of disregarding edges that are not required.
PolySplit: As the name of the tool suggests, this is used to divide a single polygon into multiple polygons. This is how the resolution of the 3D model is controlled.
glTF 3D In Houdini
Lighting, shading, and texturing are the most important components of 3D modeling. There are many ways to create your models in Houdini, but today we're going to talk about glTF as a file format and what makes it stand out.
glTF stands for GL Transmission Format. It's an open standard created by members and stakeholders of the Web3D Consortium. The consortium has over 500 members, including companies like Google, Microsoft, Adobe, and Autodesk.
The goal of the glTF format is to make 3D assets easily shareable across multiple platforms. When you export a glTF model from Houdini, you can import it into any other applications that support the format such as the p3d.in 3D model hosting and visualization framework.
Some of the benefits of using the glTF format include:
- Support for textures, materials, lights, and cameras
- Support for multi-material objects
- Support for animation with skinning, morph targets, weights, and more
- Support for skeletal animation
- Support for basic physics with collision detection using rigid bodies
glTF tools make it easy for artists to add glTF 3D model textures and work with the materials, and ultimately create 3D content that is suitable for online viewing, animation and interactivity using p3d.in and similar web tools.
Export To glTF
There are some restrictions on the export of the glTF format. You can export transparent plastic material by using the diffuse color only.
When you export a glTF model from this application, you can import it into any other application that supports the glTF format, such as the p3d.in 3D model hosting and visualization framework.
Ready to export your model? Click File, then export. Choose a file type from the dropdown menu, give it a name and location, and click Save.
Unit size: If a scene is not utilizing scene units, it is best to set the unit size because it tells the program how big your geometry should be in real-life measurements.
The texture resolution in dpi: Texture resolution in dots per inch (dpi) varies for each part. The higher the dpi, the crisper your textures will be. However, your file size will also increase if you use a large dpi.
Ambient occlusion: The baked texture will include it when you turn on ambient occlusion.
Use Draco to compress the geometry: Compressing a scene using Draco will significantly reduce the file size of the geometry but will not affect texture quality.
The number of samples: A low value will result in an image containing excessive amounts of noise. Raising the value of a commodity increases its time to export it.
Please choose only one option (Geometry Nodes or Textures): It is impossible to apply both Geometry nodes (bubbles, flakes, displacement) and textures on a single part. This decision will determine whether you prioritize the effects of one type over another.
Upload The glTF File into Another Application for Example: p3d.in
You can use your 3D application's exporter to generate a suitable glTF file and upload the model to p3d.in, you can upload any number of files with a size of up to 300 MB.
p3d.in support a wide range of 3D file formats including:
- GL Transmission Format .gltf/.glb
- Wavefront OBJ .obj
- FBX (Filmbox) .fbx
- STL format (.stl)
p3d.in is your trusted source for uploading and hosting glTF files.
Houdini's Structure and Procedural Techniques
Procedural techniques are used to generate geometry and textures, but you can also modify objects. To help you understand Houdini's platform, we have divided the tutorial into two parts:
- Part 1: Houdini's Structure
- Part 2: Procedural Techniques
Part #1: Houdini's Structure
After starting Houdini, you will see this standard layout in the build desktop.
If you install Houdini in a configuration other than the standard one, you will likely want to visit the configuration web page and choose "Build." Houdini is made of different modules, called contexts. Contexts are organized into networks. And the main area where we can switch between contexts is from the Networks panel (Other Networks).
The branch of a node tree-the neural network-where the most recent data is fed, is called the input layer. The branch of the node tree where the network's output is collected is called the output layer.
The Parameter area is used to set up parameters for individual nodes.
You have your main new port with the usual Alt navigation:
- Holding down Alt and pressing the left mouse button will rotate.
- Pressing the right mouse button zooms in and out.
- Pressing the middle mouse button will translate.
Let's get back to these modules here.
The Houdini menu shows how it can string together individual contexts, each of which is a particular application working with specific data types.
While the "obj" context generally handles 3D geometry data, you can process images in both the "img" or "IMG" contexts.
We'll be focusing on these three contacts here: "obj," "mat," and "out".
- "Obj" stands for the context that's working on geometry data. We will do procedural modeling, geometry building, and setting up lights and cameras.
- Then, there's the "mat" context, working on material and shader data.
- We'll set up materials and shaders here, rendering using the "out" context, which works on scene descriptions for generating them.
In each of those individual applications, you will use nodes to build a node tree to tell those applications what to do with the data running through them.
Some special subnetworks exist within the geometry network in the "obj" context: the simulation and the particles that live in a Dopnet. Dop stands for dynamic operators, while Popnet stands for particle operators.
Users will create dynamic simulations that simulate rigid bodies, soft bodies, smoke, fire, and hair. They will accomplish this by utilizing nodes, which allow them to manipulate data within the context of a particular simulation.
Another low-level way to create those individual nodes is to use scripting through VEX operators (VOPS), which is a visual kind of scripting using nodes. The other option is VEX, Houdini's built-in language to build those nodes and manipulate data-it's a C++ language.
The nice thing about both VOPS and VEX is that they're not tied to the "obj'' context, but available in most other contexts, such as needed when exporting into glTF for uploading to p3d.in or other web environments. They can also manipulate different data types, such as two-dimensional images or sound waves. Anything that can be programmed can also be set up using the nodes involved.
You don't have to learn VEX to be able to use Houdini. Even so, if you want to use Houdini's full potential, there might not be a way around VEX, which can be the single most determining factor that unlocks most of Houdini.
Unlike most other operators, VEX works in most contexts. The majority of those contexts have a VEX scripting area. Learn VEX once and you'll be able to use it throughout Houdini. We try not to use VEX as much as possible.
Part #2: Procedural Techniques
You can use the /mat level to build and contain a VOP network that produces an output material. This VOP network allows you to create a material that a geometry object can use.
The Material VOP network is a special type of VOP network. It uses a specific set of input and output variables, which allows it to operate as a material shader when assigned to an object. Houdini is the material shader used for p3d.in.
A Material VOP network has three levels: /obj, /mat, and /out. At the top level is /obj, where you place nodes that define attributes of your Shader, such as color and opacity.
Inside /obj are two sub-levels: /mat and /out. You build your actual shader node tree inside /mat using the normal VOP nodes and variables, just as you would for any other shader node tree.
The final output from your Material VOP network is connected to the material node inside /out. The output variable represents the result of your entire shading network.
We'll begin with the "obj" context and then drop down a Torus by pressing the tab and then creating the "Torus" node. We'll find the Torus on this screen, and either press Enter or click on it and then select where we want to place the node.
When other objects enclose an object, the outermost one has a layer called "obj." The polygons generated by an "obj" layer are drawn as if they were on the same plane as the object they belong to.
We're still on our "obj" level, so the node here is a wrapper for many nodes or a single node inside, generating the polygons here.
Let's open the Object Editor by hitting enter or typing "I" for "in." We're now in our "obj" context in our Torus Network. The single node here is generating the Torus. Let's zoom out a bit and drag this over. Here, we can set up the Torus geometry, which is much coarser than we would like it to be.
We will review the basic concepts of proceduralism and how to use them in Houdini. You will see this throughout Houdini. For artists coming from other tools such as Maya or Cinema 4D, this typically seems a bit cumbersome at the beginning. The Houdini plug-in also allows the use of p3d.in files in Cinema 4D, the application that has become the standard in 3D entertainment.
Normally, as an artist working in another DCC, you'll be used to that certain DCC taking care of errors for you. Usually, those TCC's also don't give you the flexibility or possibility to dial in those error details and error attributes.
So, let's start with defining attributes. Attributes are numerical values bound to specific parameters of your geometry, such as vertex position, normals, uvs or color values, and more.
Let's increase the number of rows and columns to 64 by 144, resulting in a high detail Torus.
By default, Houdini doesn't create normals. It calculates intrinsic normals to do the shading here, but we're not saving normals on our geometry. To create a glTF file with normals, we need to add normals to our geometry.
Let's create normals here using a normal SO (Surface Operator).
The Torus creates a geometric surface. When we press SHIFT+ENTER, the Torus node will be connected to our network. We call this normal SO-SO stands for the Surface Operator. Houdini calls the Torus node's surface operator.
Clicking the "normals" button will provide a preview of the normals of the selected geometry. Note that the vertices are assigned a green color to indicate that they use vertex normals.
If you zoom in on a polygon, you will see that it consists of vertices, or corners. Each vertex is connected to four normals, or directions, perpendicular to the polygon's surface. The reason is that each vertex stores which side of the polygon faces outward, and therefore, which way is up.
You can highlight the point display to see that a single point is connected to four vertices related to an individual polygon. These normals-or vectors-will be used later to move around each point in space.
Make sure that the normals are stored on the points rather than the vertices of the meshes. Therefore, select "Add Normals to Points." You can now see that this is shown by just a single normal stored on this individual point.
This is important in Houdini because, although you're used to normals being stored on points or vertices, you can store any data on points, vertices, polygons, or the whole geometry stream. You can create your data storing such as population density or an airport code if, for example, you'd want to visualize maps.
Yet another way to take advantage of this data is in the geometry spreadsheet. You can see the four modes in that section: points, vertices, primitives, and detail. Those are usually polygons, lines, splines, or holes, respectively.
In this points mode, we store six different numbers per point: three called PP, XY, and Z (the point's position), and three called N, XY, and Z (the normals). Here we are storing two vectors per point.
It's not relevant for now, but keep in mind this forms the basis of Houdini's usefulness.
Again, disable both the normal and point displays and select the few points around this area. We will push a Torus towards the inside to shape it more like a doughnut.
In this case, we will use a group node.
In this case, we will first select the points in our geometry; then, we will attach them to the normals. In doing so, we will disable the base group and enable it in bounding regions.
By selecting this single line of points, we can increase or decrease the object's size.
Next, we want to procedurally paint a weight attribute that determines how far the doughnut points will be displaced. We will then create an attribute called weight, a point attribute of size one, and a single float value.
The attribute's default value is 0 in the Group called Group One. We want to set the attribute value to 1.
Use the Geo spreadsheet in this resource and look at the weight column. You'll see that numerical zero is displayed at intervals throughout the list. The spreadsheet will prove useful when we later want to visualize the values in the list.
Let's go back to the viewport and drop down a visualize node which we're going to attach to the attrib_create here.
Highlight this.
In the visualizers tab, let's select our weight attribute and set this to be displayed as a ramp attribute.
By dragging the ramp down, we can choose the colors displayed. The highlighted section is a small range of values assigned to the value one.
To smooth out this area and blend it into the rest of the doughnut, we will push these adjacent points in slightly. Doing so moves the entire area closer to our desired outcome.
We set the attribute_blur to "blur" and increased the blurring iterations to blur our weight attribute.
Then use scripting to move points whose weight attribute is bigger than zero.
The VEX scripting language in Houdini is powerful, allowing designers to write custom functions that let them accomplish tasks that would be difficult or impossible otherwise.
This tutorial is intended for complete beginners. Most of you have probably never typed a line of code and may be afraid to try. We will use the VOPs visual editor to minimize the amount of typing involved.
That is called point scripting. Since we want to move around the points, we're going to use a pointvop
A VOP is a VEX operator, attaching this to the attrib_blur.
Let's add the Visualizer below the pointvop. Within this pointvop, we can create scripts by clicking some nodes.
These two nodes always exist by default. They're the global input and global output. The Houdini software has a variety of parameters that are useful when working with points, including position, velocity, force, color, and normal.
There's no information attached to the weight variable that we created. We will make some new nodes to connect data to this variable. The node we're going to use for that is called bind.
We will bind our weight attribute, called weight, to a slot on the ribbon. Through this slot, we can now access each point's weight attribute. All those nodes strung together will be executed on each point of the mesh simultaneously.
This construct that we create will be automatically multi-threaded. We want to move points along their normal.
We can use the displace modifier along a normal vector, which takes our current point position and normal displacement amount. We will use the object's weight as our displacement amount, and the output will be our displaced point position and the displaced point normal.
If we want to concentrate the force of the displacement effect along a particular axis, we can use a Displace modifier with the Scale property. We'll begin by highlighting this node, the Displacement node, and then dial in a displacement scale that would suit our needs. This is something like what is pictured with those outer sphere areas, with the higher weight pushed in a bit.
We can further enhance our Torus by pressing "u" to move up a level, which will bring us back to the original Torus matrix. However, the Torus looks much smoother as we push it inward to form a doughnut shape.
Let's use a mountain node.
Noise helps to distort your geometry a bit. Let's dial back its height to 20.1 and play with the size of this element to arrive at something we like. Noise has other settings you can tweak as you wish.
We want to apply color to this doughnut. We can color the doughnut while making it slightly different from our visualizer. Use the Weight attribute to color the doughnut. Let's set the color type to ramp from attribute.
We want to use our weight as an input to this ramp. Also, the weight has been blurred out significantly, so let's adjust the input range. Let's select a few colors closer to the tone of doughnuts than to mocha or cake icing. Let's start with a darker brown, going over to a lighter brown, then to an even more golden brown, and finally ending with white.
To create a better result, you can tweak this further. Here's our final object.
Conclusion
All Houdini nodes are procedural. It means that their behavior can change depending on the settings you use. This method is the main concept of proceduralism.
Houdini is overall, an extremely complex software. It has its benefits and uses but along with those benefits, it has to be mentioned that in order to use Houdini, you must be willing to take the time and learn all the requisites before you can start working on the software. You must have an extremely good understanding of how procedural flow works. A basic understanding of algorithms and programming. This is because Houdini should be described as a software that helps you develop a system that develops a model and animations. To understand and develop that system, you must develop the mentioned skills.
If you do not want to work with various software for animation and 3D modeling, Houdini may very well be the right software choice for you.
To that end, I hope that this tutorial will assist you trying to learn how to use Houdini.