Tutorial: Houdini, AliceVision, and Sketchfab

Back to overview

Hey there!

Hi! My name is Paul Ambrosiussen. I’m a Technical Artist at SideFX, which is known for developing the software called Houdini. Houdini is an advanced procedural modeling, animation, effects, simulation, rendering, and compositing package. To talk a bit about my relationship with Sketchfab, I should explain that I’m not a person that creates a lot of content which could get uploaded to Sketchfab, but instead am a person that builds the tools allowing others to do so. Think of it as me creating the brush and paint an artist uses to paint, so that they don’t have to worry about that part. In the same way, my colleagues and I built the Sketchfab uploader tool so that others don’t have to, and can upload straight away!

The Power of Houdini

Houdini’s power is based on procedural workflows, which involve creating networks of nodes connected together that describe the steps to accomplish a task. These operations or procedures together give you a very powerful toolkit, including the ability to modify the data inside of the node tree at any given time.

The Sketchfab Uploader

Houdini has had a Sketchfab uploading tool for quite a while now, and it has seen a lot of use from the community so far. The tool was originally developed by Luiz Kruel, and has been maintained by Luiz, myself and Mike Lyndon ever since. Considering the tool has been available for free for the public for quite some time already, I’ll do a quick run-through of the basic functionality that had already been built, and follow that up with some of the newer improvements afterwards.

What We’ll Be Doing

Once you’ve read this tutorial you will be able to create a high resolution scan using the AliceVision plugin (Part I) and convert it into an optimized mesh and automatically upload it to Sketchfab (Part II). In Part III, we’ll also explore how to export a Skeletal Mesh (bone-based animation) directly onto the Sketchfab website straight from inside of Houdini.

Decimating high-poly geometry is a fairly common problem, especially for people getting started with 3D scanning and Sketchfab. Imagine you have this awesome scan of an object, but it’s millions of polys. You would like to upload it to Sketchfab, but also keep all of the nice details of the original object without making it turn into a blobby shape.

The workflow for getting something from a high resolution object down to something consumable by Sketchfab usually entails cleaning up and reducing your mesh down to something more optimal, generating UVs for your new mesh, and transferring the high resolution data as texture maps. At SideFX we’ve built a collection of tools that can do every single step mentioned above in a quick, effective, and high quality manner.


For this tutorial we’ll be using the latest version of Houdini (Houdini 17.5) which you can get at our website, as well as the GameDev Tools, which is a set of tools to help you with common (game) workflows. To use Houdini, make sure you at least have the System Requirements found here.

So first off we’ll start off with a clean scene in Houdini. This is what you will see when you first open Houdini. Next up, we will need to install the GameDevToolset, which contains the free Sketchfab Uploader along with all the other tools we will need. To install it, follow the tutorial found here.

Part I: Content Creation Using Photogrammetry

To create our content, which we will upload to Sketchfab, I have decided to use Photogrammetry. We will be using AliceVision for our Photogrammetry pipeline. To set up your Houdini environment for the first time you use AliceVision in Houdini, check out this tutorial.

Once we have captured our images (seen above), we could optionally do some cleanup on the images to improve the quality of the produced output, but that falls outside the scope of this walkthrough. (And we’ll see that the quality produced is actually pretty good, even without image cleanup.)

Creating our Procedural Network

In the Network Editor, found in the bottom right corner of your Houdini interface, press TAB, and type Geometry. Once you have done that and hit enter, a geometry node has been created. This will hold all the geometry that our Sketchfab uploader will need. Double click on the created node to dive inside. This is an essential step, because it tells Houdini what kind of data we are creating, and what to name it.

Photogrammetry with AliceVision

We will repeat the process of pressing TAB inside the network editor, but will this time create a node called “GameDev AV Photogrammetry”. Once we have done that, we should be presented with what is seen on the image below.

We can see that we now have something called a “Parameter Interface”, seen just above the node we created. Please note that I have set the parameter called “AliceVision Directory”, just like the AliceVision tutorial told us to do in the linked tutorial.

Processing our Images

By pressing the Add Images button on the Parameter Interface, we can tell the AliceVision nodes inside of Houdini which images to process. Browse to the folder where you have your images, and select all of them.

Once we have done that, we can hit the button on the Parameter Interface labeled “Cook” and wait for it to finish. Please note that this process can take quite a while depending on the number of images and the hardware you are using. I’m processing 59 images, which on my 2018 Razer Blade laptop took around an hour to complete.

Part II: Model Optimization and Upload

Refining our Geometry

The result of this process gives us a High Resolution mesh of around a million polygons. To navigate around the viewport you can use SpaceBar + LMB (left mouse button) to rotate around the object. Spacebar + MMB (middle mouse button) to pan around, and Spacebar + RMB (right mouse button) to Zoom. You can also zoom in on your object to see the wireframe; if it’s not showing up for you hit Shift + W. What we need to do next is decimate, generate UVs and bake the texture maps.

Decimating, UV’s and Baking

In the network editor seen on the right, I created a few nodes and wired them together. An important concept in Houdini is the network of nodes. Connected nodes essentially represent the flow of data (through a series of events). This is why our node network will have nodes connected to each other from the top down. One action happening after each other, just like steps in a recipe.

So in the image above (zoomed in on the image below), we can take a closer look at what I did. The output (bottom connector) of the Photogrammetry node we created earlier goes straight into the input (top) of the Polyreduce node. This allows us to decimate to a desired polycount.

After decimating, we need to generate some optimized UVs. We can generate these really easily using a node called GameDev AutoUV. To create it, once again simply hit TAB, and search for it like we did before with the other nodes.

We now have both a Lowpoly (Target), and a Highpoly (Source) mesh. This allows us to bake details such as vertex colors into textures. This can be done in a matter of seconds with the GameDev MapsBaker tool. Tick the checkbox for the desired maps, set the export folder and hit Bake.

Uploading to Sketchfab

The final step of our “recipe” is to create and connect a GameDev Sketchfab node in the network editor attached under the baking tool. Set the parameters with whatever information you would like. Things like the Title and Description of your Sketchfab upload. Next up, set your Sketchfab API key in the parameter interface. (You can get it by pressing the “Find API token” button on the parameter interface.) Then finally hit “Render” to directly upload your asset. Once it has finished uploading, a popup will appear and bring you to the Sketchfab webpage.

The Result

Voila! All done. 🙂

With only 5 nodes we went from Photogrammetry to extract a high poly 3D mesh from a set of images, all the way to a game ready low poly version live on the Sketchfab website.

Part III: Animated Geometry

In the walkthrough above we saw how to upload Static Geometry to Sketchfab from inside Houdini. It is, however, also possible to upload Animated Geometry to Sketchfab. To do this, we need to create a bone-based animation containing a rig and an animation.

To create a really quick example, I just set up a simple Vellum simulation. To learn more about Vellum and how to use it, I recommend this tutorial.

Converting Vertex Animation to Skeletal Animation

I used the GameDev SkinningConverter to convert my vertex animation to a skeletal animation. Most game engines (Sketchfab included) do not support vertex animation, which is why we used this tool to automatically create a rig with animation for us. Note that this is an optimization, meaning you will always lose some precision.

Once we hit the “Convert to Bones” button on the tool, we will get a new node next to the Geometry node we created at the top level.

Note that this is not the only way to rig geometry in Houdini. The software also offers traditional rigging tools, about which more can be found here.

Exporting our animation

To export our animation, we will need to export from something called a ROP (Render Output Driver). You might ask why we didn’t do this for the static geometry. Well, that is because we saved you the hassle of having to create a ROP and link a lot of things together, since we’re only dealing with geometry data all stored in the same place. (If you feel adventurous, try diving inside of the Sketchfab exporter we used previously to see how that was done.) The animated export, however, needs more than that. It needs the geometry, the bones and the animation. That’s why the exporter needs to be in a different location.

If we then create a Sketchfab node inside of that ROPnet node, we can see that we have a slightly different parameter interface. We can now specify a frame range! Once again fill out all the details you like, specify your API Token and hit Render at the top.

Once complete, our browser will once again open and show us our live Sketchfab animation!


After following all the different steps we did above, we should now have at least two Sketchfab uploads! We learned several things in this tutorial, including how to create high resolution geometry using Photogrammetry in Houdini, how to decimate it, add UVs and bake some textures for it. Once we had a great looking Apple, we uploaded it straight onto the Sketchfab website in a manner of seconds. We then briefly explored the process of creating and uploading some Animated Geometry. All straight from inside of Houdini. This means you now know how to best share your wildest Houdini creations with your friends and family! 🙂


About the author

Paul Ambrosiussen

Technical Artist at SideFX


Leave a Reply

Your email address will not be published. Required fields are marked *

Related articles