Learn Houdini – Volume 3
Making Things Move With Nodes and Code
Welcome to Volume 3 of Adam Swaab’s Learn Houdini Tutorial series.
In this volume, we are going to make things move with nodes and code. (A lot of code, so buckle up!) In particular, we are going to do a lot of work with particle systems, both the built-in one in Houdini (POPS), and our own particle system that we will write from scratch! We’ll cover how particle systems work, how to influence and control them, and how to get around some common problems that can make or break a simulation.
We are also going to look at procedural motion, using Solver SOPS and transformation matrices.
This volume is for those looking to better understand how code-based motion works, and also looking to deepen their understanding of particle systems. As mentioned above, there will be a lot of VEX coding, so please make sure you have a decent grasp of VEX basics before jumping in. (Volume 2 of my series has a decent primer.)
Training Summary
Includes 10 Houdini hip files Deepen your understanding of Houdini. Working with POPS Code your own particles system Procedural motion using Solvers In depth VEX Code based motion
Recommended requirements
Houdini 20
Some 3D experience
Knowledge of VEX basics
Chapter Descriptions
00 – Intro (01:54)
A brief introduction to what we will be covering in this volume of tutorials.
01 – Prerequisite Info (10:46)
We’ll be doing a lot of vector math and working with physics equations in our lessons. Rather than dive right in, we take some time to go over the basics of vector addition and subtraction, cross and dot products, and simple physics definitions that we’ll need to build a particle system from scratch.
02 – Custom Particle System Intro (00:55)
A brief introduction to what we will be covering in the next few videos.
03 – Custom Particle System 01 (15:08)
The first step to building a particle system is creating a particle emitter. In this chapter, we’ll build a simple emitter that controls particle birth, setting mass, scale, initial velocity, lifespans, and id attributes for our particles. We also start setting up our basic particle integrator – the brains of the particle system.
04 – Custom Particle System 02 (09:46)
In this chapter, we learn how to add forces and acceleration into our particle system, accumulate them, and integrate them into updating our particle positions.
05 – Custom Particle System 03 (08:52)
We take some time to go over the algorithms and formulas we will use to do collision detection with static objects in our custom simulation. We’ll look at a fairly robust way of detecting the collisions, how to resolve them, and how to respond to them through bouncing.
06 – Custom Particle System 04 (18:06)
We implement the algorithms and formulas for collision detection, resolution, and response from the previous chapter into our simulation.
07 – Custom Particle System 05 (07:21)
We add friction into our simulation capabilities.
08 – POPS Quickstart Intro (00:23)
A brief introduction to what we will be covering in the next few videos.
09 – POPS Quickstart 01 (16:01)
In this chapter, we discuss the anatomy of a POP simulation and how data flows inside the DOP network for particle setups. We then discuss how streams and groups work in POPS, and why you might choose one working method over the other.
10 – POPS Quickstart 02 (11:27)
We spend some time looking at the POP Source node, explaining various options and settings there. We also take a brief look at how to handle fast-moving emitters there (more on that later).
11 – POPS Quickstart 03 (09:33)
Very often, particles need to collide with objects in the simulation. This chapter take a quick look at how to set up collisions and collision responses for particles with other objects in your Houdini scene.
12 – POPS – Fast Emitters (04:56)
We revisit the fast-emitter discussion to take a little more time to highlight effective methods of dealing with them, going into more detail and specifity about how to handle them and how to optimize substeps/emitter settings to get a good balance between speed and quality.
13 – Directing Particles Intro (00:29)
A brief introduction to what we will be covering in the next few videos.
How can we use controllers in SOPS to affecting the timing and choreography of our particles in POPS? This chapter shows you one of the methods I use in many of my setups. (Sample chapter below)
15 – Directing Particles – Point Clouds (19:31)
This chapter looks at how to use attributes on point clouds to influence and direct our particles. In this specific example, we are going to sample points from a template curve to drive particles along that curve, using both direct velocity and force-based approaches.
16 – Directing Particles – Wind Tunnels (15:04)
This is a rather complicated example that shows how to create a wind tunnel effect in POPS. The idea is that particles have a preferred direction of travel, yet they must flow around an object, with a soft falloff distance. We’ll look at how to calculate reflection vectors and how to smoothly interpolate between the current and reflected direction of travel using quaternions.
Making particles go where you want them to go is a key part of mastering particle simulations. In this first part, we go over how to directly modify the velocity attribute of a particle to send it to a specified goal location.
Part two of our lesson on particle goals, we now replace the direct velocity method with a force-based approach. We discuss particles as engines, with maximum speeds and accelerations, and we show how to implement these concepts into the simulation, for a very natural response.
19 – Directed RBDs With Code (09:41)
We take our knowledge from the Directing Particles using Particle Goals chapters and apply it to a rigid body simulation. Rather than rebuilding the project above, we look at the already-created project and break it down, node by node.
20 – Procedural Animation Intro (00:29)
A brief introduction to what we will be covering in the next few videos.
21 – Transformation Matrices And Quaternions (17:07)
Understanding how to move objects usually involves more than just manipulation of positions. We need to understand what transformation matrices and quaternions are and how to use them. This chapter is a short foundational lesson on both.
22 – Rolling Boxes Demo 01 (16:31)
Using our knowlege of transformation matrices, we create a rolling box animation. The first part of this demo sets up the initial steps of this setup.
23 – Rolling Boxes Demo 02 (13:30)
Continuing from the previous chapter, we add the finishing touches to our setup, creating a procedural bounce-back effect and learning how to cycle between 90 and 180 degree rotations for our box. Finally, we take a short look at the final render setup in Solaris.
