learn. Houdini. In Bloom

Overview of what we will create, a note on the project file and some prerequisites

Set up of our basic scene, loading our model and setting up our render cam.

Setup basic lighting in Redshift and add in our material for our hero branch model.  We set our render settings to give us quick feedback and we’ll set up some quickmarks for our scene so we can move around easily.

Here we look at the new scatter and align sop and why we’re not going to use it!

Instead, over the next few chapters, we’ll learn the basics of aligning instances in Houdini so we can create our own custom setups.  We prepare our geometry, setup scattering based on masking features and look at some of the ways we can adjust the scale of our instances with the new attribute adjust sop.

Here we look at aligning our clones with our point normal and an up vector to fix the rotation around that axis.

In this lesson we extend our knowledge to learn about quaternions. We see what they can do for us and how to convert our setup into orient attributes so that we can adjust our rotations of our instances easier.  This is a little heavy, but don’t let it put you off.  While it has some fairly complex vex functions going on, once we learn the main ones we can save as a preset for later use.  We even look at how we can set attributes via a simple falloff so that we can offset our rotations based on distance.

Here we build the first of our plant models, we model the stem and plant bulb procedurally to give us flexibility.  We’ll look at how we can rig our bulb so it can stay in alignment with our stem as we grow it on.

Next we start animating our flower, we’ll be using a mix of the new Kinefx tools to rig splines for keyframing, set up the growth of our stem and add a subtle noise setup to give our plant some additional movement.

Here we jump back to our main setup to test out our first flower in our setup.  We look at how we can adjust the angles using our orient setups and also look at how we can further randomise our pscale.  We set up our instances for render and add our first shader.

We set up our second plant here, using lines, noise, normals and instancing to create both branches and hairs along the ends.

Next we use a bend sop to curl up our branch and look at how we can use for loops to offset and stagger our animation across our 3 branches.

In this lesson  we’ll finish off our second plant model.

We’ll take a look at the primuv function and how we can use this on splines to create a carve style effect that will grow our splines down themselves and hence retain our point count for consistent motion blur later on.

This breakout video is a quick overview of the basics of matrix transformations.

We’ll have a look at what matrices are plus a few vex functions that will allow us to manipulate them on a per point basis.

By the end we’ll have created a simple twist style deformation and have learned how we can rotate normals on our model, which will set us up for future lessons.

We set up our third plant, starting with the stem.

We look at Kinefx again to rig this and use our matrix transform functions from the last lesson to see how we can generate a unfolding motion based on a curve based mask.

Next we set up our spine geometry and look at how we can stick our root positions to our moving geometry.

To finish off this plant, we will look into how we can animate our spines to unfold out as our main stem unrolls. We’ll also look at the lerp function and how we can use this to mix between alignments.

We start modelling our 4th plant here; this will involve a bit more traditional poly modelling mixed with some procedural parts. We’ll look at setting up construction lines that can be lofted into a surface and use polyextrude to generate more of our shape

We animate this time using point deform and a lower res version of our mesh to control its motion.  We’ll also look at distance along geometry and how it can help us generate an attribute to use later with shading.

Our final plant!

We build out our stem and our seeds.

We’re going to use our normals to align our seeds, but we’ll also use the cross product to generate tangents that flow out from our curve and we’ll revisit our matrix functions which will give us a really nice way to generate a Fibonacci spiral type effect for our seed arrangements.

Here we refine our setup a little more by looking at the measure sop and how we can use this to drive the scale of our plant over our animation.

With all of our plants finished, we bring the models into our main setup to set these up for instancing.

We look at how we can use both variant and the attribute from pieces sop to distribute our geometry.

We look at futher refining our plant arrangement by creating a control that will allow us to scale and reduce the number of each plant by type.

We’ll take a look at a first pass of rendering this and getting our colours from our geometry point colour.

In this chapter we talk about Redshift proxies and what they can do for our setup.

We’re going to clean up our plant geometries for export as proxies.

We’ll calculate our motion blur and learn how we can refer to the proxies by using the instancefile attribute.

Here we set up a proper system to generate our instancefile attribute. We can take our frame number and variant and use this to generate the full path to our Redshift proxies.

Looking to our shaders now, we learn how to override the materials in our proxy.  We also learn how we can override the userdata of our proxies.  We set up various shaders for each plant and adjust our colour palette to taste.

For this chapter we first look at removing a time dependency in our scene to make things a bit more efficient. We set up a distance attribute on our geometry and then we create a setup that allows us to control our cache and visualise our result.

We set up our camera move, exploring the fit function and how we can use this to control our animated parameters. We tweak our animation offset and finally we set up some quick render settings that will allow us to generate a fast Redshift preview.

Quick review of our render, we adjust some of our parameters to setup for our second test render.

We review our last render to see our changes.

We set motion blur for final rendering, adjust some of our shading attributes for our plants, and set up a control to speed up our rendering while doing look dev on our shaders.

At the end we set up our final settings for render.

Final review, we check out the result of our finished project.

For those who I scared off with talk of orients and quaternions, we take a look at the earlier part of our setup but using the scatter and align sop instead.

We also show that we can still use the functions we created as tools to modify our scatter and align.

One more advanced technique where we can look at how we can take our instances, manually delete or align some of them individually and run this back out to our proxies.

There’s a few gotchas along the way but with this we can literally have full control over each instance’s placement if we need to.