Houdini to Unity: Advanced Production Pipeline

Houdini and Unity are two industry standard tools for Visual FX and game development. This course will teach you how to combine them and create a professional pipeline to generate your game assets faster than ever.
Course info
Level
Advanced
Updated
Aug 29, 2017
Duration
6h 23m
Table of contents
Course Overview
Course Outline and Project Setup
Game Art Setup
Coding Unity Mini-game
Start Houdini Project and HDA
Houdini Expressions and Coding
Houdini Pre and Post Render Scripting
Coding the Unity Main File Processing
Final Testing and Adjustments
Create Bulk Render Buttons
Description
Course info
Level
Advanced
Updated
Aug 29, 2017
Duration
6h 23m
Description

Game development pipelines are a critical part of any game studio. Whether you're a one-man show or a company of hundreds of employees, you'll need an efficient and stable way to create your game artifacts, and update them seamlessly with minimum effort or interruption to the total development process. In this course, Houdini to Unity: Advanced Production Pipeline, you'll learn the steps to create an efficient pipeline using Houdini and Unity3D – two of the most prominent game development tools. First, you'll explore how to setup your Unity project, so that artifacts created in Houdini will be imported automatically complete with animation controllers, animation states, and prefab construction. Next, you'll discover how to use Houdini to maximize your production when creating game artifacts to be imported into Unity. Finally, you'll cover how to use your new pipeline to update game assets quickly and seamlessly within Unity. By the end of this course, you'll be able to get your game to market faster than ever. Software required: Houdini and Unity.

About the author
About the author

Caesar is currently a professional software developer with over 17 years of experience focusing on user interfaces and middleware components. In his very recent past he was an instructor at a private academy teaching game programming using Unity3d and Softimage.

More from the author
Introduction to Houdini Digital Assets
Intermediate
3h 39m
Nov 23, 2016
Section Introduction Transcripts
Section Introduction Transcripts

Course Overview
Hi, and welcome to my course, an advanced game pipeline development using Houdini and Unity. Individually these tools are powerhouses on their own, but when combined, there's almost nothing that you can't accomplish. This course will take you from game prototype using rudimentary throwaway artwork used as placeholders to a complete game artwork pipeline where a Houdini digital asset that you'll create will be the central point of command for all of your game artifacts. You'll learn how to integrate the Houdini compositor with your digital asset in order to add post-processing effects on your renders, and share those effects quickly and easily with any game artifact you generate in Houdini. Once your pipeline is done, we'll finish up with some global render buttons that will allow you to bulk process all of your Houdini artwork, saving you tons of time if your game has hundreds of assets that require rendering. By the end of the course, you'll have a pipeline that will fit your needs or the needs of your studio, and help get your game to market faster than ever. I hope you'll enjoy the course as much as I had in creating it.

Coding Unity Mini-game
Welcome to module three of our course. In this module, we're going to go ahead and begin coding our Unity mini game. Some of the goals we want to achieve are we'll learn some simple debugging techniques in Visual Studio. We're going to go ahead and add components to our prefabs, things such as Rigidbody2D, Circle Colliders, and we'll go over their settings. We're going to create all of our shell scripts in C#. This will include components such as the DropCollider, our ExplosionSpawner, FollowMouse, et cetera. We'll go ahead and code our ship to give it some control with our PlayerControls class. We're going to go ahead and code our cursor prefab to allow it to move around the screen and follow our mouse. We're going to go ahead and code our GenericFX component, which will allow us to control our animations of each of our prefabs. We'll code our WeaponSystem component, which will allow our ship and anything else to fire projectiles. And finally, we will code our ExplosionSpawner, which will obviously spawn explosions. In the next clip, we'll go ahead and go over some simple debugging techniques with Visual Studio.

Houdini Expressions and Coding
Hi, in this clip we will be going over some of the goals of the module. We'll be doing a quick primer on HScript and Python methods using this course. We will be using both Python and HScript, depending on the situation. We use HScript expressions to reference channels. Using HScript, we can reference channels from within our digital asset up to the channels on the digital asset itself and vice versa. We'll use Python to create a dynamic list, control the camera, and the visibility of nodes. Python will be the better choice to access the Houdini objects as we will be needing to access the HOM, which is the Houdini Object Model, in order to create a dynamic list of composite effects, access our camera, and bring our geometry into focus and to be able to control the visibility of that geometry. In the next clip, we'll go over some of the HScript expressions and Python functions we'll be using in the course.

Houdini Pre and Post Render Scripting
In this clip, we're going to go ahead and cover the goals of the module. We're going to use Python to populate the global channels. We're going to go ahead and create a warping effect with the Houdini compositor. We're going to use Python to automatically reload files into our composite file nodes. We're going to use Python to stretch our COP keyframe animations, so that they can be reused with any number of frames that we generate from any of our digital assets. And finally, we're going to use Python to clean up redundant renders and sprites. In the next clip, we'll fill out our OpenGL post-render channel, which will populate our global channel.

Coding the Unity Main File Processing
Hi, in this clip we will cover the goals of this module. We'll go over the Unity event system. Unity has the design time event system that will allow us to hook into callback functions and process assets programmatically. We'll cover how the OnPostProcessAllEvents callback function works. This function is one of the design time events that we can use to manipulate assets after they've been imported. We'll write the pseudo code to establish a plan for all of our functions. We'll develop a helper function gather the directory names of all the sprites that are imported. We'll write some code to programmatically add all of the components necessary for our prefabs. And then we'll do a review and a quick test of our work. In the next clip, we will cover the Unity event that we will be exploiting to customize our prefabs.

Final Testing and Adjustments
In this clip, we'll go over what to expect in this module. So we've just about finished our pipeline digital asset in Houdini, so now it's time to field test it by replacing the placeholder artifacts that we created in a previous module with real production Houdini artwork. So we'll use our new Houdini pipeline digital asset to create our main ship artifact, create our animated cursor artifact, create our explosion artifact, our animated target artifact, our projectile artifact. Then we'll go ahead and code the Warp-Out effect for our main ship that we created in a previous module, and then we'll review and do a quick test. In the next clip, we'll use our pipeline to work on the main ship artifact for our game.

Create Bulk Render Buttons
Hi, in this clip, we're going to cover some of the goals of the module. First we'll do some quick adjustments to our Houdini project. Then we'll go ahead and create our shelf and toolbar buttons. Then we'll sketch out our goal in pseudocode. And then we'll go ahead and code the methods that will allow us to bulk render and comp from OGL or Mantra to Unity. We'll be able to bulk render and comp multiple Houdini digital assets at once. And finally, we'll be able to bulk render and comp multiple subnets of Houdini digital asset nodes. In the next clip, we'll get started with some quick changes to our Houdini project and then create our shelf and toolbar buttons.