Week 1 – Introduction to Houdini and procedural modelling

Our first step was to get used to the interface and node creation/manipulation. We tested this by creating a primitive.

We then began making the tower. To start made a tube and aligned it to the world axis. To do this by setting the centre of the primitive to be the height of the object by two which is what the green expression is showing. We also added more subdivisions to it to represent the bricks

We then added some nodes to define the bricks more. The facet node allows us to specify that we want the geometry to have unique points. This means that the points can move independently which is what we want for creating the bricks. We then used a primitive properties node which allowed us to scale the bricks down.

This screenshot shows the bricks extruded.

We then learned about the group node and how to add and subtract elements from a group.

We then used a group polygons by range node in order to select rows of bricks within the geometry. To do this we set the range to be from 0 to the total number of polygons in the scene (that is what the nprims(0) syntax means). We then retrieved number of columns from the original tube geometry and used that number to select our rows. We created a calculation that selected a row and then found every second row.

We then took the geometry collected from each of those groups and independently transformed them. We rotated them as we wanted the bricks to be offset. It was at this stage that we extruded our geometry to give the bricks more volume.

We then set about filling the gaps in between the bricks where cement would be. To do this we made volumes out of the geometry. We extruded the original tube and made a volume out of that and we also did the same with the bricks. We then combined them with a VDB combine node and then we merged that with the bricks the made originally.

When making the volumes we did have to increase the resolution so that the detail would be more accurate to the desired result

This was a mistake that I made during the lesson so I wanted to highlight that under the attributes of the VDB combine, I need to choose the SDF difference operation.

We then added in stairs by making a helix.

This is the node graph for the helix, we extruded it out in Z space first. Then we made a group by range node in order to extract the data for every other face. Then we deleted those faces that we had selected with the group node and finally we extruded those steps upwards.

I like the fact that I knew how to scale the helix as I could copy the height data from the tube meaning I knew it would match.

I found this lesson really overwhelming as I was coming to Houdini from nothing. However I did ask for help in the lesson and we slowed down a lot which really helped. Additionally I decided to recreate the project in my own time which helped solidify it for me. Below is a screen recording of my carrying out the process independently.

Week 2 – Particle Simulation

This week we learnt how to create particle simulations. Our first step was to find some geometry to use, we ended up using test geometry which is provided inside Houdini. We used a text model of a character called Tommy. In order to access just the geometry we used two types of delete nodes. The standard delete node we used to remove his clothes. To do this, inside the delete node we were able to select components of the character. We selected body and then made the delete node use an operation which deleted everything that wasn’t selected, leaving us with just the body and nothing else. After this we removed the textures and materials. We did this using an attribute delete and selecting the material attributes. This left us with just the base geometry of the character

From here we made a pop network which is a network that store our partical simulation. This is the default things displayed when that network is created the model is blue as it is a guide for the network.

To show the particles the next step is to turn off the guide and give the particles a velocity and a lifespan

To improve the look of our simulation we made a colour ramp so that the colour of the particles would change over their lifespan. In this instance mine went from blue to orange.

To do this we added a point wrangle node and used an expression

v@Cd = chramp(“color”, (@age/@life));

This expression makes a ramp and tracks the particles age divided by it’s life, therefore allowing us to change the colour of the particle as it gets older.

One thing that I struggled with when following along with this technique was that I had to change the properties of the ramp in order to be able to pick colour. By default when ramps are created they want to recieve numerical float values rather than colour data. To change this we had to edit the parameter and change the colour parameter to accept colour data rather than a float

We then learnt another way to change the colour using a colour node. This is a very simple way to change the colour of the particles however by default it didn’t allow us to use a ramp to change them over time. To get around this we made a new attribute which calculated the same expression used when creating our first ramp (@age/@life). We then called this attribute “normalised age”. Further on from this in our colour node we were then able to create a ramp from an attribute, so we selected our “normalised age attribute” made a ramp from that data and set the colours this way.

Both methods work and achieve the same results, the difference is that one requires less scripting and is a bit easier to understand. But it could be said the the point wrangle method is more efficient if you are familiar with vex code.

The next step was to add a camera to our scene for this we simply aligned our viewport to a space where we wanted the camera to be and then found this menu in the top right of the viewport window and made a camera in the location. This was a very simple workflow and it was nice to be able to generate a camera so quickly in a location you knew would be suitable

After this we were tasked with just emmiting the particles from the back of the model so we got to work on reducing the faces that we selected.

Our first step was to create a group node which selected the faces the camera can see and then deleting them. The second group node selects the edge faces of the remaining faces as those are the ones we want to emit the particles from

This is the result of just emitting particles from those edge faces, it is a much more defined shape now, I also adjusted the velocity to make them move more slowly and look a bit more dense

We then learnt how to append spheres to the particles so that they could be seen in a render and also we learnt how to render out of Houdini using its basic built in renderer called Manta. This is my result, however shortened to 100 frames.

This is an aside but I wanted to document it so I remember. One of my classmates who is more advanced in Houdini showed me an alternative way to assigned a point scale by using an attribute float node and plugging it into whatever I wanted to scale. This was really useful to learn as the method we learnt in class was using scripting. Again, I am sure that scripting is more efficient however it was nice to discover there was a way to do it that was a bit easier to understand and more visual.

The last section of the lesson covered a more advanced technique where we made a tangent field to change the look of the particle around the head. The issue with our work so far was that the particles around the head would simply move up and down rather than swirl around the character like the others. So we made a tangent field and a volume and the added another force to our particles network so that all the particles would follow the path of the tangent field.

This more advanced technique created a result where the particles swirled around the body and original particle birth points in a more structured way rather than the points just bursting out of the figure in varying non structured directions.

Like last week I decided to recap the main elements of the lesson in my free time to cement my knowledge. I realised after I finished this recording that I didn’t include the nodes I used to render out the particles and attach them to spheres. So I’ve made a separate video covering that below

The render result of this at home trial

Week 3 – Pyro

This week we started learning pyro sims. We began the session by creating a small flume of smoke

We added a poly sphere to the scene and clipped it to make it half a sphere. We then added a poly fill so that it would be a complete shape.

We then create a pyro source and initialise it as a “source smoke” which adds two attributes for density and temperature.

We then rasterise these attributes so we can add them to a pyrosolver using volume rasterise attributes node (you can find the node by typing “var”). The pyrosolver takes the attributes of the density and temperature.

Pyrosolver -> shape -> buoyancy. This parameter adjusts the height and direction of smoke in the same menu the disturbance parameter gives smoke shape, it breaks up the shape into smaller pieces

File cache – file caching saves the output of the pyro solver so that Houdini doesn’t have to calculate it every time. We apply the material back to the cached data so that it looks the same as the solver input

To add a material after caching it you made a pryo bake node and then go in to Pyro bake -> quick set up -> get material

Press middle mouse button on output fields to show the corresponding location on the disk.

These are some renders that I made of the smoke, the first one was just the standard output. The second involves us adding more disturbance so that the two disturbance nodes have to balance each other out

Making a tornado

Our next exercise was to make a tornado. We started by making the spine of the tornado, to do this we created a line and added points to it. To give it movement we added a bend node. Within this we set the capture to program which part of the line we want to bend (for is this was the whole thing). We could set a constant number here but for our example we added an expression so that it would oscillate.

Out next step was to add a curve on the floor that our bended line could follow we did this in the top viewport, we also created a circle to emit the tornado particles from.

Within the tornado geometry node we constrained it so that everything we create will follow the curve path.

We added a force to our particle network that made the particles move up the spine and around.

Our last step was to add pyro to this particle network to make it look like a tornado. I didn’t have enough time to get a great result with this but I learnt a lot of concepts and hope to come back to it eventually

This is a render of the tornado, unfortunately I lost the ability to render the initial forming of the tornado. I tried to troubleshoot this but unfortunately didn’t come up with a solution

Week 4 – Making water

This week our project was to create a bus that was being driven through water.

This was the way to import the bus, we did end up scaling the bus down a lot as the defualt model and dimensions were very hard to work with in Houdini. We did this my using a secondary transform node and reducing the uniform scale

We then made a flip container for our water and the red box is indicating it’s size

We then wanted to isolate the wheels so that we could rotate them to do this we used a series of group nodes to isolate the wheels and then we used point wrangle nodes to identify them seperately.

From there we used a for each system to be able to flip between each of the wheels seprately applying their rotational pivot points to the center.

We then added rotation and merged the wheels with the bus so that the object would be one cohesive piece.

This screenshot is showcasing our caching workflow and how we set up compression and caches to try and make the water lighter to work with in Houdini.

Our final step was to add white water to the tips of the swells made by the impact of the buses wheels. To do this we added a version of a particle simulation that looked at our water container and analysed the areas that were curving the most, we then cached this too to make it easier to run

This screenshot shows just the white water particles that we isolated

With the simulation complete I tried to render everything out however the file was simply too heavy to accomplish this quickly. I ended up rendering it at home when I had more time.

Week 6 – Vellum Mountain

Week 7 – Rigid Body Destruction

This week we learnt the basics of rigid body destruction, which is breaking things apart

We started with a simple starter exercise where we used an RBD solver to shatter a cube and added noise parameters to add pieces to the inside and also wear on the inside pieces.

The next thing we did was to use a glass variation of the RDB solver called a material fracture. This meant we could feature the object like glass. To do this we applied two scatter point on the top face of the cube. This meant we were basically telling Houdini explicitly where the model would be impacted and then it would shatter accordingly (like glass)

Render of the generic cube breaking

Render of the cube breaking using the glass smash method

This is the node graph for these cube experiments. As you can see both experiemts were performed the the same box. The left most nodes are for the glass shatter and the middle set of nodes is for the generic cube smash.

The next exercise we did was working on the tower. This starter file was already supplied to us however it was the sam structure we started modelling in week 1.

We learnt how to make our own parameters here and ending up making a height parameter so that we could automatically adjust the height of our tower with a slider. We did this in the parameter menu and then we linked the result of this to the transform node of the tower

This node graph shows the nodes we used to break the tower.

Our first task was to simply apply the principles we had learnt from the cube onto the tower therefore breaking it

Render of the tower breaking

The second task was to take things a step further by adding in another object which would impact the tower. For we were supplied a pole that was already animated to fall. We had to link this up to the tower so that it would influence it’s destruction and also change the densities of the different elements so that they would interact with each other in a believable way

Render of the tower breaking influenced by force of pole.

This is the full node graph for the destruction of the tower. As an extension we also added some nodes to break the railing of the staircase, this is seen in the additional group combine nodes and different constraints being put on each group

Week 8 – Rendering and importing files from outside of Houdini

Here we looked at importing different types of files and also how to export the files back out. For example with an OBJ and Alembic file we can export out the same file type using a ROP node

Alembic files are most commonly used for Maya exports and imports so this was useful for me to know

Importing the USD

For the main portion of this lesson we used a USD file, this is a file that would be compatible with Unreal engine.

One change we had to make was that initially the USD file came with two sets of bathroom objects, therefore we had to select the geometry we wanted to import so that we only imported a single set

After that it was time to orientate it to the scene and size it correctly to work well in the Houdini environment. We rotated the geometry using a transform node and to get the scale correct we created a sphere object in Houdini to use as a guide for how big our new geometry should be. I chose to template the sphere so that I could see both elements at the same time

We then used an unpack node to be able to have more selectable pieces within our geometry this meant we could select each element of the scene individually and there are the elements we would add different materials to

To add materials we had to select all the geometry (from within a group) and then unpack it again. We also had to delete the geometries normal and colour values as those would be replaced by the attributes given by the materials we were adding.

To add the materials we added a material node and a material network. It is important to mention that this is all happening inside the object geometry node that we are working on. There is an external material network that we can use within the Houdini file but the reason we are using a network within the object is because if we wanted to copy this object into another scene, all the materials would come with it. Whereas having the materials in an external network would mean you would have to export more and relink everything when transferring to another file. Making the materials inside the object node just makes this process more streamlined

Here you can see I added my first material to an object, creating this green jar

From here we added an area light to create some directional light on the scene.

This is a render having made some more materials and adding those to the scene

Here you can see the node view of the material node where my shader and created and store, each one is for a different object and has different properties

After experimenting with adding materials we then went a step further by adding a displacement map to the towel material so that the towels would look more realistic

This is a render from later on in the class. You can see I experimented more with the metallic and reflectiveness of the surfaces, adding a light reflection to the mirror and making a couple of the jars more metallic, this was more a case of creating more materials and adjusting more parameters.

I also added another light through this class as well as set up the camera. We had a refresher on rendering the images out too even though I was quite familiar with that process.

Week 9 –  Working on Assignment 2

For assignment 2 I took inspiration from a tutorial I had purchased prior to starting the course. Initially to learn the techniques used I followed the tutorial however later on I took more steps to differentiate my work from the tutorial.

This is a link to the tutorial –

https://www.sidefx.com/tutorials/applied-houdini-particles-v-grains/

Here is my work

Render of the current state of the simulation

 

Week 10 – Revisiting pyro

Making the simulation without using the shelf tool

Week 10 – Expanding on work for Assignment 2

Showing the dates and time I worked on making the simulation

Early file where just ground geometry was created

Dates and times of renders made at various stages of the process

Explaining the node graph

Here I thought I would provide a more in depth explanation of the node graph to show that I understood the tutorial and what it was accomplishing

Overview of the obj nodes

Parameters in the “controls” node

Inside the sinkhole geometry node

Result of the mountain node

Explanation of my “blend by depth” attribute wrangle

Result of blend by depth

End of the sinkhole node graph

End result for sinkhole

Start of grains object (labelled source)

Result of the UV texture

A close up of the calc_kill attribute wrangle

Adding noise

Inside the creation of the class attribute where I made the noise for the grains

Result of the class attribute

A close up of the attribute wrangle that identifies which ones are the big chunks

Result of connect adjacent pieces

Result of the merge that merges the results from the split node

Node graph showing the bulk of the tree for this object

A closer look at the kill bridges attribute wrangle that separate clumps and make them isolated objects

Inside the creation of the attraction weight attribute, adjusting how strong the clumps are depending on their size

The end of the node graph for the grains. Allowing my to export out the geometry and both types of constraints

A closer look at the nodes where the crack is created

The result of the crack being created

A closer look at the attribute wrangle that stores whether the active node is true.

Close up of the attribute wrangle that allowed me to create attributes so that I could control how the clumps break

The simulation object node

The overview of the simulation node graph. Explaining why I used a multi solver and what everything is/does

The bottom of the simulation object node tree

Inside the SOP solver for the crack

Inside the lies attribute VOP. This is where I experimented with the value of the active attribute in order to create some organic movement from the crack

Overview of the out obj tree

This is where I optimised my simulation so that it would look better but not completely run my computer to this ground.

Explaining the attribute wrangle that’s placed after the cache, calculating how much detail to add or will be necessary to add to each point

A close up of that attribute wrangle

Nodes that are further down this tree

A close up of the attribute wrangle that positions the new points correctly

The render nodes

Inside the render node for the snow

Inside the render node for the ground

Remaking the scene again to differentiate it from the tutorial even further

To differentiate it from the tutorial I decided to remake the simulation and this time make the crack be diagonal. I also screen recorded the majority of this process, I’ve included it at 2x speed here

New diagonal sinkhole render

Process video