In the previous module, we discussed the basics of cloth simulation inside Houdini. 

In this module, we are going to discuss some advanced concepts involved in cloth setup in Houdini, so let's dive right into it.

Typically, we would create clothing for our characters inside a third-party tool like marvelous designers, cloth 3d etc. However, we can actually create the cloth geometry right inside of Houdini in the same manner we do inside marvelous designer. 

Let's learn how to do that.

We will begin by importing the character base model into a geometry SOP level.

We should also scale it to match Houdini scene.

Let's create the outline of the cloth with a curve.

Create a  node. Then we go to the front view to make it easy to create.

Enable the grid and also turn on the 'snap to grid' button on the left panel.

Then draw out the curve.

We will use a mirror node to mirror the curve to the other side.

We will also use a fuse node to combine the two curves into one closed curve.

Now, let's create the cloth geometry.

Create a planar patch from curves node. This node allows us to fill out a closed curve with polygon meshes. On the node, perform the following settings:

Let's duplicate this node for the front and back sides of the cloth.

We will also use transform nodes to position them at the front and back of the character mesh. For the back cloth piece, we will use a reverse node to reverse it's normals.

Our setup should look like below:

Now that we have the front and back parts of the cloth piece, let's stitch them together.

Let's create a vellum configure cloth node to setup the cloth.

Then we will use a vellum post process node to visualize and adjust the thickness of the cloth.

Perform the following settings on the vellum cloth node to adjust the thickness:

To stitch the cloth pieces together, let's create a vellum drape node. This node is very similar to the vellum solver node, except that it has some additional drape tab that the vellum solver does not have.

Let's enable the 'weld additional seams' on the vellum drape node.

This will now allow us to select the points on the geometries that we want to stitch.

Click the arrow next to the Group field and select the points on the front part of the cloth that are to be stitched. Press ENTER when done.

Click the arrow next to the Target Group field and select the points on the back part of the cloth we want to stitch the front parts to. Press ENTER when done.

When we do this correctly, it will create seam lines connecting the corresponding selected points as shown below:

If we go to the world properties tab, we can set the welding frame delay to 1 to make sure the stitches snap together from the first frame. This will prevent the cloth from entering inside the character's body.

Next, let us add the character geometry as a collider by connecting it's output to the collider input on the vellum drape (or cloth) node.

If we play the simulation now, we will see the cloth pieces get stitched together as shown below:

We can also use planar patch for creating different cloth pieces.

1. If we are using the planar patch node to create different pieces of our clothing, it is very important that for every new single pieces that we create using a planar patch, their edge length parameter MUST be the same. This is to ensure that the stitching process via the vellum drape happens without any issue.

A way to ensure that the edge lengths are all the same on all the planar patches is by relative referencing. This way, we are guaranteed that the number of points being stitched together are exactly the same, and we will not get any weird result after stitching.

Now, you should know that reducing the edge length is going to populate the mesh with more subdivisions, and this may slow down our simulations.

2. Suppose we don't want to have too many subdivisions on the cloth pieces, but we want to ensure that the number of seam points (where the stitching happens) on the different cloth pieces are the same, the best way to do that is to enable the seam points attribute on each of the planar patch nodes for the different cloth pieces, and set their number of seam points to same numbers across board.

Right now, every time we play the simulation, the cloth pieces are always going to get stitched before anything else. We don't want to be seeing this all the time, so let us set the initial state of the cloth to the later frames after the cloth has settled after stitching (as shown below) so that the simulation will always start from this settled state.

To do that, we will turn on "freeze at frame" on the vellum drape node, and then input the frame number where the cloth is now settled to use as the initial state. In our case, it's frame 120, so we input it.

Next, we can also cache out this frame to disk as a ".bgeo.sc" format.

So if we scrub back to frame 1, the initial state of the cloth is now set.

Next, let us connect a vellum post process node to weld all the seams together, so that when we simulate the cloth, they will not fall apart. So enable 'apply welds' on the post process node.

To add additional layers such as a skirt base sleeve to the base dress, we will need to first create this sleeve. 

For our purpose here, we will export the base dress as an alembic to Maya. Then inside Maya, we can create the geometry for the skirt base sleeves. Then we will export it again and import back into Houdini. 

Next, we will create some groups. These groups are what we will use to attach the sleeve to the base dress.

Let's create a group node and set it's type to Edge. Then we will select the edge loop where we want it to connect with the base dress and create an edge group out of that selection. Name the group appropriately.

Then we will use a group promote node to convert from "Edges" to "Primitives", and choose the edge group we earlier created in the dropdown.

If we connect a null output node to the dress initial state and check it's attributes in the attributes window, we will see that we have a lot of attributes that are not necessary. These are going to bug down our simulation down the line, so let's clean them up.

So let's connect a clean node and enable the 'remove attributes' parameter. If we type in * in the field, it is going to delete all attributes. If we want to keep some attributes, we will use the ^ symbol, followed by the attribute name that we want to keep.

In this case, we want to keep both Color and Cusp Angle attributes, so we will type:

* (gets rid of every attributes)

Let's prep the target stitch points on the base dress. These are the points where we want to attach the skirt sleeve to on the base dress.

We will create a new group node and select the points at the open border of the base dress where we want to connect the sleeve to.

Before we simulate the sleeves, let's freeze the base dress in place so that it does not simulate. This way, we can easily attach our sleeves.

Let's create a group node for the base dress renamed "static dress", make it a points group type, then select all the points on the base dress and add them to the group.

Then we will add a vellum constraint (cloth) and vellum drape for the base dress, rename it as "dress static". Then we will perform the following settings:

If we play the simulation, the dress is going to stay in place.

Attach the Sleeves:

We will use a merge node to combine the sleeve and the base dress together in the simulation:

If we play the animation, the base dress will stay in place while the skirt sleeve falls.

Let's create a group to store all the points on the skirt sleeve, renamed as "skirt sleeve entire".

Then we will create a vellum constraint specifically for that skirt sleeve, and in the group section, we will choose the point group above. This vellum constraint (cloth) will only affect the skirt sleeve, and nothing else because of the group specification.

Our network should look like below now:

If we playback, the sleeve should stay put on the base dress.

But we are not done.

We have only used this vellum drape node to attach the skirt sleeve to the base of the skirt. 

We still need to add another vellum constraint with the constraint type set to "stitch to points" to stitch the points on the base dress and sleeve together.

Finally, we will add a new vellum solver node for the final simulation. We animated the collider geometry just to test this out, and when we play the simulation, it works as expected!

We can now individually control the properties and behaviour of both the base dress and the sleeve.

Here's the result:

We did a complex multilayered cloth simulation inside Houdini as a test using the whole concepts learnt in this module so far.

We utilized vellum constraint nodes, vellum pack, and vellum unpack to combine the cloth setups for different parts of the complex clothes together as we can see in the setup image below.

Following the tip above, we were able to simplify the resulting network into what we have below:

Here's the render of the test done in Maya:

We will discuss the intricate details that we didn't mentioned in the earlier sections here. We will also recap a lot of things that we've learnt about before as well.

We will be demonstrating this with a basic multilayer simulation which was the same technique used in simulating the multilayered clothes in the rendered video above.

We've modelled two basic cloth pieces for our character in Maya and imported them into Houdini.

Connect the inner skirt to a vellum configure cloth node, and then to a vellum solver node.

Also connect the character output into the vellum cloth collider input.

Without changing anything, if we play the simulation, the cloth will fall straight down along the character's body.

We will attach the skirt to the character's body.

Create a new vellum constraint node and choose "attach to geometry". Rename it appropriately so that it's clear what the node will do.

By default, this will create constraints (white points) all over the cloth and attach them all to the character just as we can see below:

However, what we need is to constrain the inner edges of the skirt to the body of the character.

To specify what parts of the skirt we want to constrain, we will use the geometry group tab.

Currently this group is empty, so this tells Houdini to use all parts of the skirt in the constrain. This is why we had the above image result.

Let's change the group type to 'edges' (you can use any group type, but edges are easier to select) and use the arrow next to the group dropdown to allow us select the edges on the skirt that we want to constrain.

So we select the inner edge loop like below:

If you press the ENTER button, it will create the constraints on these selected edges.

Without doing any other thing, if we play the simulation, the skirt will now be attached to the character.

However, we see that there is still too much gap between the constrained edges and the character's body. 

To make those edges snap properly to the character body, we will need to reduce the stretch rest length parameter on the vellum constraint node to about 0.1 (or any other value that works). This parameter will shrink the distance between the constrained points and the geometry.

Now the skirt snaps properly to the body of the character.

Another issue we will notice is that, even though the constrained edges are properly snapped to the character, they are still looking zig-zagly and not smooth around the edges.

To get rid of the zig zag look on the edge, we will use another vellum constraint node set to distance to fix this.

Once again, we will select the same inner edges that we constrained earlier in the geometry group of this new constraint node;

Also, we will set the stretch rest length scale on this new constraint node to the same value we set the earlier constraint (that is, 0.1).

If we play again now, we will see that the zig zag edges has now been smoothened out. This looks much better!

Let's stitch the outer skirt to the inner skirt.

Firstly, we need to convert the outer skirt to a vellum cloth as well. So let's create a new vellum configure cloth for it and rename it appropriately.

We will connect the character output into it's the cloth's collider input as well.

In order to link it with the existing vellum solver, we will need to first pack it with a vellum pack node which takes in two inputs.

This node has only one output which we can connect to a merge node. We can use this merge node to combine different vellum pack node's outputs as well.

So let's create a vellum pack node and connect the outputs of the outer skirt cloth node to it.

Let's also use a vellum pack node to pack the outputs of the inner skirt cloth node as well.

Now we have two vellum pack nodes for each of the cloth piece.

Then the output of these two vellum pack nodes will go into a merge node.

Next, we will connect a vellum unpack node (has one input and two outputs) after the merge node, and this vellum unpack node will go into the existing vellum solver.

Lastly, we will reconnect the character directly into the vellum solver's collider input as well.

Our connection will now look like this:

If we play the simulation, everything will all work. The outer skirt falls straight down because we have not constrained it yet.

Now, how do we cleverly stitch this outer skirt to the inner skirt?

Because we are using different vellum cloth nodes for different cloth pieces that are separate objects, we can not directly use a vellum stitch constraint. This vellum stitch constraint works best when the different cloth geometries are combined or fused together and also share the same vellum cloth node.

Like in the test case below:

In order to stitch cloth pieces that use different vellum cloth nodes, we are going to use a vellum drape node for that.

So create a vellum drape node and connect it before the vellum solver. We will also temporarily disable the vellum solver so that we can use the vellum drape to stitch the outer skirt to the inner skirt first.

On the Draping tab, let's enable 'Weld Additional Seams'.

We will see two fields: Group and Target Group. The Group is the group of points that we want to stitch. The Target Group is the group of points where we want to stitch to.

In the Group, we will select the points loop on the outer skirt inner border.

In the Target Group, we will select the points loop on the inner skirt body where we want the outer skirt to snap to.

In the Weld Properties tab, let's change the Weld Frame Delay to 1 so that the points snaps on exactly the first frame when we play the simulation.

Finally, let's crank up the magnitude of the gravity so that the pull on the skirts is more and they can settle faster.

If we play the simulation, the outer skirt will snap to the inner skirt, and the whole simulation will work together.

We can now set the Initial State of the skirts by enabling the 'freeze at frame' parameter on the vellum drape node. In our case, the skirt settles at frame 80, so we freeze the cloth at that frame.

If you scrub back to frame 1 now, the skirt's settled state is now it's initial state.

So basically now, this vellum drape node helps us to combine multiple vellum cloth nodes under one umbrella. 

We can now add a new vellum configure node after the vellum drape node, and whatever settings we perform on this new cloth node is going to affect both the inner and outer skirt geometry as though they are combined meshes.

We can now continue our simulation from there on by enabling the vellum solver again.

If we animate the character rotating for example, the cloth would be simulated accordingly.

This was the exact method that was used to create the multilayered clothes in the Maya render we saw earlier.

We will now fine tune the look of the inner skirt. 

We can create different kind of looks for our cloth simulations, for example, silky, denim, leather, etc.

Let's take a look at all the important parameters that can influence the look of the cloth:

Mass: If we change mass to set uniform, we can set a uniform mass value to the cloth. This is how heavy or light the cloth is supposed to be. Increasing the mass makes the cloth appear heavier during simulation, and it sags more.

Thickness: This is how thick we want the cloth to be. It is always a good idea to set it to uniform and keep this in a reasonable low value, unless we are trying to simulate a really thick clothing. We can use the vellum post process to visualize the thickness and adjust it to our needs. The default value works well in most cases. Very low thickness will create more wrinkles in the cloth.

Thickness set to 0.01:

Drag: This is the resistance to the motion of the cloth. It is set to 10 by default. If we reduce the drag, the cloth will experience lesser resistance while in motion and fall faster. If the drag is set to a high value, the cloth will experience more resistance to motion and fall slower.

Pin to Animation: This is how we can pin selected points on the cloth geometry to a point and those points will not be affected by the vellum solver. You should note that this pin to point will always try to keep the cloth in place.

Stretch Stiffness: This is the resistance of the cloth to stretching. This default value is infinitely high, so that means the size of the triangulated constraints in the cloth mesh will not change much, thus, the cloth will not stretch. If we reduce the stretch stiffness, the resistance of the triangle constraints to change in size will be decreased, and then they will increase in size, causing the cloth to stretch more; and vice versa. The default value works perfectly in most cases.

Damping Ratio: This is how fast the stretching of the cloth will settle (or lose energy). The higher this damping ratio value, the faster the cloth settles, and vice versa. The default value works perfectly in most cases.

Rest Length Scale: This is a very important setting on the vellum constraint. By default, the value is 1, this means the distance between the points in the cloth mesh will remain the same. If we increase this value, this will also increase the distance between the points in the cloth mesh, making the cloth to increase in size or expand. This can generally result in more folds. If we decrease the value, this will decrease the distance between the points in the cloth mesh, causing the cloth to reduce or shrink in size.

Compression Stiffness: If we have a highly dense cloth geometry, it is always a good idea to increase this compression stiffness greatly to maintain the overall shape of the cloth during simulation. If the subdivisions on the cloth is lesser, the default value works just fine.

Bend Stiffness: This is the most important settings for achieving different looks for the cloth. It is the resistance of the cloth to bending. If the bend stiffness is high, that means the resistance to bending will be high and the cloth will not bend easily and we will get less folds and wrinkles in the cloth (this can give the behaviour of a paper or cardboard). If the bend stiffness is low, that means the resistance to bending is low and the cloth can bend more easily, and we will get more folds and wrinkles (this can give the behaviour of a silky cloth, or a t-shirt or denim). 

If we are creating a soft body with jiggle effect, we can also use this to achieve jiggly behaviour of a softbody object by increasing the bend stiffness to a very high value.

Damping Ratio: This is how fast the bending of the cloth will lose energy. If the damping ratio is set to high values, the cloth loses energy fast and also settles fast. If the damping ratio is set to low values, the cloth will lose energy slowly, and takes sometimes to settle.

Combining this damping ratio with the bend stiffness can give us a wide range of looks for the cloth object.

If we enable plasticity under the Bend tab, we can tweak the settings there to achieve a denim or leather look for the cloth. This setting can be used to introduce some level of elasticity to the cloth.

For instance, if we perform the following settings:

We get the following denim/leathery result:

Threshold: If we want to achieve add some plasticity look to the cloth, we have to keep the threshold to a very low value like 0.1 or lesser.

Rate: This is how fast the cloth become plastic. Increasing the Rate will make the cloth become more elastic quickly, and reducing it makes it become more elastic slowly.

Hardening: This parameter increases the stiffness in the cloth during deformation. Increasing the Hardening to a high value makes the cloth to become stiffer during deformation, and reducing it makes it less stiffer during deformation.

A good permutation and combination of these settings will give us different results with the cloth.

In order to tear a vellum cloth in Houdini, there are a couple of setups that we have to put in place.

1. Let's create a planar patch geometry, and adjust the size. We can increase the number of subdivisions by lowering the edge length parameter. This mesh will serve as our cloth.

Let's also enable the left seam. We will use this seam to hold the cloth in place during simulation.

2. Let's define the parts of the cloth that we want to tear. To do that, we will create a edge fracture node and connect our cloth geometry into it's first input.

If you enable primitive faces and click the pin icon, it's going to randomly create different faces for the cloth. These are the individual cloth pieces that will remain after fracturing (or tearing in the case of cloth). The edge border lines between each pieces are where the tearing will happen.

You can increase the number of fractured pieces by increasing the initial pieces.

If we want to preview the separated pieces, we can connect a explode view node.

3. Now let's setup the basic cloth by creating a vellum configure cloth node and a vellum solver node and connect them as usual.

If you play the simulation, you'll see that the cloth tears right away. This shows that the fracturing work. However, we don't want the cloth to tear right away. We want it to only tear after a force has been applied to the cloth (such as tension or compression forces etc.

So, to hold the cloth pieces together in place, let's first pin the left seam of the cloth in place.

In the vellum cloth pin to animation section, let's choose the group of the planar patch left seams.

Next, create a vellum weld points node. This node is preferred for tearing clothes because it creates weld seams between separated cloth pieces and these seams can later be broken under the influence of external forces.

Connect it between the cloth and solver node as shown below. We don't need to select any groups as the node will automatically detect the fractured edges. 

This node will automatically apply weld seams to the borders separating the fractured pieces as we can see below:

If we play the animation now, we will see that the cloth does not tear like before. This is what we wanted.

Now let's create a force to tear the cloth.

Double click on the vellum solver node to go inside it's inputs.

Then let's create a pop force node and connect it to both the force and source output nodes.

We will give some magnitude and direction on the force, and also add a bit of noise.

If we play the simulation, we see that the cloth is pulled or blown in the direction of the force, but it does not tear still.

To make it tear, let's go back and select the vellum weld points node. If we scroll down, we will see a parameter called 'breaking'. Let's enable this parameter.

The threshold here is simply the least amount of force needed to break the weld seams. If the force magnitude exceeds this threshold, the cloth will tear.

By default we see that the cloth still doesn't tear when we play the simulation. So if we reduce the threshold value, the cloth will now tear as expected.

We can also choose a different type of breaking to get a different tear result.

Here's another cloth tearing test we did:

We briefly mentioned the pin to animation aspect of vellum simulation earlier. We are going to see how it works in this section.

Suppose you want to simulate a cloth and you want parts of the cloth to stay put, we can achieve that with pin to animation. 

The way it works is, we will select a group of points on the cloth mesh that we want to keep in place, and assign them into the pin to animation group select and they will stay put during animation. These points can also be animated.

Start by creating a planar patch geometry, move it up a bit, and increase it's subdivisions.

We are going to pin the four corners of this planar patch mesh, so let's create a group node and assign all the points on the four corners to this group.

Now, let's setup the vellum cloth. 

By default, if we play the simulation, the cloth falls straight down.

If we select the vellum cloth node and navigate to the pin to animation section, we can choose the pin group we created earlier.

If we play now, those four corners will stay in place while the cloth settles.

We can also animate this pin group. Let's create a transform node and connect it after the pin group.

Right click on the translate y of the transform node, and use a wave motion FX expression to drive the animation of this pinned points.

By default, this animation affects the entire planar mesh. So, let's choose the pin group instead so that it only affects the pinned points. Now the pinned points move up and down in space.

Let's go back to the vellum cloth node and enable 'match animation'. We get the result below:

In the above example, we used the pin to animation directly on the cloth node itself. 

We can also use a vellum constraint with the type set to 'pin to target' to achieve exactly the same result as what we got above.

We will specify the pin group in the geometry field, and we also have access to the 'match animation' check box (if the pinned points are animated) which is the same as what we had on the vellum cloth itself. 

In many cases, we may want to use this as this allow us to focus on the pinned points on the cloth rather than the vellum cloth itself.

If we want to remove or disable the constraint at any point, we have to do two things:

1. Firstly, we will set the pin type to 'soft'. 

You should note that setting it to 'permanent' means the constraint can never be broken, but if we want to break the constraint at any point in time, then using soft will allow us to do that.

2. Create a node called 'vellum constraint properties'. We can use this node to override the properties settings on our vellum constraint. We just have to make sure we enable the properties we want to override.

Connect this node after the vellum constraint.

In the constraint group, let's type the VEXpression: @type = pin. This expression will let this node to override the pin constraints settings available in our vellum setup.

If you scroll down and enable 'remove' and set it to 1, this will remove the pin constraint. If we play the simulation, we will see that the pin constraint no longer holds the cloth in place. If we set remove to 0, the pin constraint will be activated again.

To break the pin constraint at some point, all we need to do is change the remove parameter from 0 to 1 (animated), but we need to do that inside the vellum solver DOP level. 

First delete the vellum constraint properties node, then double click on the vellum solver node to enter into it's DOP level.

Then let's create the vellum constraint properties node inside this DOP level and connect it to the force output.

Then specify the pin group type like we did before and also enable the remove parameter.

We can now manually animate the remove from 0 to 1 on the timeline.

We can also use the VEXpression to do that instead. Enable the 'use VEXpression' and type in the following code:

where the FrameNumber is an integer value of the frame where we want the remove to activate.

We get the following result:

If we used a pin to target constraint, we can enable the stretch output group and give it it's own unique name such as 'pin_stretch' for example.

Inside the vellum solver DOP level, we can simply specify the 'pin_stretch' group in the group field instead of typing the @type=pin expression.

And we can animate the remove parameter to remove the pin constraint at any point like before.

We use painted masks to also drive the attributes of vellum simulation.

To demonstrate how this works, we are going to use the example from above. We will use the paint mask to pin painted parts of the cloth mesh so that they stay put. So let's remove the pin group we added earlier.

To do this, let's create an 'attribute paint' node and connect it. Let's give a unique name to this node, say "effect", under the attributes tab.

Immediately we gave it a name, we will see that the plane turned purplish (which represents zero value and nothing will happen). Anywhere we paint on this mesh will represent a value of 1 and something will happen.

If we hit the ENTER button on the keyboard in the viewport, we can now paint on the mesh.

Follow the instructions on the screen to know how to use the paint tools. We painted something like below:

Now let's apply this mask.

Select the vellum cloth node and navigate to the pin to animation attribute.

Type the following into the input field: @effect = 1.0

Notice how we used the name of the mask:

If you play the animation, you'll see that the mask now takes effect, and the painted parts stay in place.

In the above example, we applied the mask directly to the vellum cloth pin to animation field. What if we want to apply the mask on a pin to target constraint, how do we do that?

Let's first create a new vellum constraint and set it's type to pin to target and connect it accordingly.

We will apply the mask in the Stretch parameter section. 

Let's change the scaling of the stiffness to 'scale by attributes' (or 'scale by both' for a more manual input).

We already created a paint mask called 'mask' as we can see in the connection in the image above. 

In the stiffness attribute field, let's remove the stretchstiffness there and type in the name of the painted mask, that is, 'mask'.

Now the mask effect will take hold.