Week 1 – Houdini Recap

What was covered in the lecture:
Houdini:
– In industry, Houdini is used to model and build environments, and to create FX.
– Today, Houdini Solaris is used for lighting environments and rendering.
– Houdini is a procedural software: you work with nodes.
– Each node is like an instruction or step.
– Each Point has different attributes like position, normals etc…

Houdini Forum – OdForce: https://forums.odforce.net/forum/34-houdini/

The Interface:
Change the interface to Technical by going to Desktop->Technical
Add a Geometry spreadsheet:

– Tab to search something to insert into the scene
If we want our surface like that hit P:

Under the nodes section:
Blue – renders this node
Red – Lock – Everything is backed to the locked node

Yellow – Bypass – Hide this node

Operators:
SOP (Surface Operator): This is the context in Houdini where you build and modify geometry, such as points, polygons, and volumes
CHOP
DOP (Dynamic Operator): This is the context for simulations, like particle systems, rigid bodies, and fluids. DOPs contain nodes for the simulation’s setup and execution
POP (Particle Operator): A collection of DOP nodes specifically for particle simulations. MAT – Materials
SHOPS – Shader Operator
TOP – Task operators
Solaris / LOP – light operators
VOPS – Coding

– N – normals
– P – position
– V – velocity

Overview:
– The default tool is the camera (press ESC).
– Hold Option to move the camera.
– Hold CMD while creating geometry to place it at the centre.
– Adjusting the parameter label (the word) affects all channels; changing the value field affects only that channel.
– W = wireframe
– E = scale
– R = rotate
– U = go up one level
– Space + G = frame the selected object
– Shift+ S to change the links view.
Data Types:
Boolean – either 0 or 1, true or false
INT – whole number 1 2
Floats – non whole numbers 1.0 1.1
Vectors: (x,y,z)
– Vector is a bunch of 2/3/4 numbers (int or floats) – it can be used to things like colours (RGB), position (XYZ).
– A vector of ints takes less memory
– When we code, we need to select the right data type to save memory and be more efficient.
– If we want to convert a float to int, it will just ignore everything after the dot.
– To round it up or down we can do ceiling or floor the number.
String – Letters “abcd”

Procedural practice
– Don’t scale at the top (object) level.
– Inside the node, use a Transform node so everything stays fully procedural with true parameter values.
– The only things we change at the top level are cameras and lights.

Create a box (CMD + Box).
Go inside the object (OBJ) and add a Transform node. Set Scale Y = 3.
Add a Match Size node and set Justify Y = Min to place it on the floor.
Turn on Stash Transform to remember the original position. Later, if you add another Match Size, enable Restore Transform to put it back to the original location.

In Houdini – one unit is one meter.
In Houdini – Z is forward
Space + 1/2/3/4/5 changes the view

The Workshop Activity
Domino Practice:
1. At the Object level, press Tab -> create Geometry. Rename it to Domino.
2. Go inside the Domino node and press Tab -> create a Box.
3. Set the size in the Box node parameters.
4. To bevel the edges for a more realistic look, add a PolyBevel node. Adjust Distance and Divisions.

5. Add a UVunrwap node
6. Add a Match Size node and set Justify Y = Min to place it on the floor.
7. Bring in a Null Node to put it at the end of a network. Rename it to DOMINO_OUT

Curve:
Go inside Dominoes and create a curve node. Hit Enter to Turn on the Curve Tools. Change it to NURBS. Draw curves. Make sure “Show Handle” is turned on. Make sure you’re on a draw mode. To finish the curve press ESC .To edit the curve make sure “Show Handle” and that edit mode is turned on.

Add a “copy to points” node and link it like so:

Create “Resample” node between “curve” node and “copy to points” node to fix the spacing: Inside the resample node we can either use Maximum Segment Length or the Maximum Segment. In our case we will use the Maximum Segment. So enable the Max Seg and disable the length Seg. If there’s 21 segments so there’s 22 dominos.

To make it even smarter: go to the box node and copy the Y parameter. Go to resample node and paste “relative reference” in the length parameter. Multiply it by 0.9.
Distance Attribute – the distance between each attribute
Tangent Attribute – the tangent of the curve between each attribute – has 3 parameters.

To rotate the dominos in the right direction:
Turn on the Tangent attribute inside the resample node.

Go to resample node info. Turn on TangentU.

Make sure Visualizes is on, right click and choose the pen.

Change “Type” to “Marker” and “Style” to “Vector”. You can adjust the length of it.

Under resample node, change Tangent Attribute parameter to N. The Z axis now follows the Tangent

Because it is procedural, we can change the dominos geo to bigheads, and change the curve to circle curve (Orientation = ZX Plane)

To create a uniform scale (scale):
Using Attribute Create:
Under the Resample node, bring in an “attribute create” node.
Rename the “Name” parameter to pscale to affect the copies.
The “Size” is how much numbers (parameters) it will hold. In our case we want one parameter and we want it as a float.
Under the Value section, change the X to 1. Now we can adjust the size uniformly.

Using Attribute Wrangle:
Under the Resample node, bring in an “attribute Wrangle” node.
Write in:
f@pscale = 1; – changes the scale of the copies
v@N = set(1,0,0); – Set a Vector called capltle N. then use Set and do (1,0,0)
Using Attribute Adjust Float:
We can do constant scale, random scale and noise scale.

The Weekly Activity
Make the animation. go over last year notes.

Week 2 – Particles (POPs and SOPs)

What was covered in the lecture:
Nodes:
Assemble Node – Creates Packed Geometry

Simulation basics
– A simulation needs an initial condition (start frame).
– A solver does the maths frame by frame, updating what happens each step.
– The solver uses position, mass, and forces (like gravity) and calculates the new state each frame.

Vectors
– A vector is a number with direction, e.g. (2, 2), measured from a point in space.
– Velocity is a vector that tells us how far and in which direction to move each frame.
– We usually add velocity to position every frame:
p_new = p_old + v (e.g. (1,1) + (2,2) = (3,3)).

Note
– Particle simulation is the foundation for many effects.

DOP Network (DOP Net)
– In Houdini, simulations are usually built inside a DOP Network.

Simulation tab
– Substeps – the solver calculates multiple times per frame.
For fast-moving elements, increase substeps to get accurate results.
– Scale Time – usually leave it at 1. If you need slow/fast motion, retime the cached sim instead.

Cache
– For simulations, always cache your results.
– Make sure you’re on the first frame (CMD + Up) before caching.

$ – a variable
$OS – operator string

The Workshop Activity:
Particles Simulation:
Under Obj, create a geo and rename to MyParticles. Inside, create a DOP network node. Inside it, create a POP object node, because in order to build a simulation we need an object. Rename it to my_Particles

The next thing we need is a solver (to make the calculation). So bring in a “POP Solver” side and link it between the output and the POP Object.
We can create substeps in the solver, and its more efficient because you can select for each solver the substeps..
Now we need to have the particles itself, so create a “pop location” node and link it to the third input of the pop solver.
Under Geometry spreadsheet
When AGE = LIFE the particle dies
V – where the particle will go on the next frame

POP location – Birth
Birth Rate – rate of new particles per second
Impulse Count – emits a particle every substeps (and not per frame) for the solver.
Life expectancy – life attribute (in seconds)
Life Variance – will randomly generate the life expectancy between this numbers.
Jitter Birth Time – so the particles wont be born in exactly the same time – change to negative

Open a floating geometry spreadsheet by right click on one of the nodes and select spreadsheet. Filter the visualise the following information: age, dead (will be visible after frame one as it’s created by the solver), id and life.
We will never see dead = 1 because at this point it will just disappear from the spreadsheets.

POP location – Attributes
Velocity – the direction the particles movement.
The reason the particles keep moving forever and on the same direction is because we have no force (just like in space).

Therefore, we need to add Gravity. Link a gravity node after the solver.
Also, change the Y position of the POP object.

Static Objects – Colliders – things we want to add in the physics calculation without deforming them. For Example: Wall/Ground/Tennis Racket.
Static Objects are usually on the left side of the script.
For that, we need static solver. So bring in Static Solver node and Ground Plane node. Link everything like so:

To get a natural behaviour of the bouncing, go to the “POP Object” node (my particles), and under the physical tab, change the Friction to a parameter below 0.5.
To change the colour of the particles, link a popcolor node under the pop location node.
Under Color Tab:
Change it to Ramp.
normalised age – takes the age and squeeze it between 0 to 1.
Under Alpha Tab:
Change it to Ramp and make it fade away as the particles age.

What we have so far: DOP:

DOP network dealing with simulation Data, so we cannot create geometry data inside the DOPS. So to create a geometry, we need to go one level up (My Particles).
So, go the MyParticles Level and add a grid and a transform nodes.

Now inside the DOP network, create a pop source node and import the GRID null. In the pop source change it to negative.

Under the transform node:

sin($FF*50)*10
sin = sin wave – keeps the parameter between 0 to 1.
$FF = FF double – a smoother. if it was one F so it will be an integer
50 = how fast it is.
*10 = between 1 to 10 now

Now to inherit the velocity the right way we need to have a V. but we dont have one. to have one we need to add a trail node under the transform node.

Inside the DOPnet->pop source, go to attribute tab and change it to “Add inherited velocity”. adjust the settings accordingly:

Now, disable the grid and enable our poplocation node.
Under the (disabled) popcolor node add a popwrangle node
Write the following:
//If the hit total 0 change the colour to black
if ( i@hittotal == 0)
{
v@Cd = set(0,0,0);
};
//If the hit total 1 change the colour to red
if ( i@hittotal == 1)
{
v@Cd = set(1,0,0);
};
//If the hit total 2 change the colour to yellow
if ( i@hittotal ==2)
{
v@Cd = set(1,1,0);
};
//If the hit total is greater than 2 change the colour to green
if ( i@hittotal >2)
{
v@Cd = set(0,1,0);
};

PopStream affects all the particles.

The Weekly Activity:
Particles Simulation:
1. Have a play with pops and streams
2. Chain sops

Week 3 – Rigid Body Dynamics

What was covered in the lecture:
Nodes:
In Houdini, 1 unit is one meter
We should try and do a real world scale when we are dealing with gravity.

the initial setups should be in SOPs although we can sometimes do in inside the sim

Simulation basics
– A simulation needs an initial condition (start frame).
– A solver d

The Workshop Activity:
Create the Scene:
Under Obj, create a geo and rename to RBD. Inside, create a box node.
To place it on the floor, add a matchsize node and change “justify Y” = Min.
We can adjust the box’s dimension without using a transform node as we dont build this sim procedurally.
Create a sphere, change the primitive type to polygon, and adjust the dimensions accordingly.

Then add a transform node Translate Y=1, Z=-1.

RBD:
Create a RBD configure node. Link the ball null to
It creates bounce density and name attribute:
The problem with using mass is that we have a fixed number for different size of objects. So if we use density and calculate the mass using volume, we could receive different mass (and Houdini does it for us, and this is why Houdini uses density).
Bounce – how bouncy it is.
Density – the unit in Houdini is KG/m3. So if we want to get real life parameters we can google “concrete KG/m3”
Name – We are going to have different objects in a sim. it allows us to distinguish stuff. The name is critical. We need to have unique name for different objects.
To create a new name we can add a name node and change the name. It will inherit the attribute correctly.

We have different presets of density inside RBDConfigure node.

Create a DOP Network. Inside create two rbdpackedobject and rigidbodysolve node. Then bring in a gravity node. In rbdpackedobject node under SOP Path put the path of rbdconfigure1 from the level above (one for the ball and one for the wall).
Then we need to add a collider so add a ground plane and a static solver node and merge them both above the gravity node.

Create a point velocity node under the name node. Tick add velocity (Y=8, Z=11).

A Different way to do it:
Delete the DOPNET and the second rbdconfigure node.

Create two different attributes for the wall (concrete) and the ball (steel) inside the RBDConfigure node

Bring in a rbdbulletsolver node. Link everything like so and turn on the ground plane under the collision tab.

Now, let’s fracture the wall so it will be destroyed the way we want it.
Under the WALL Null node add a scatter node. Change the Force Total Count to 4, and untick the relax iteration.
Link a “voronoifracture” node and link it like so. The more force total count we have under the scatter node, the more pieces we will have.

Another way to do it – RBDmaterialfracture.
Link this node under the wall. Turn the FOG Volume to None.
Remove the second attribute.

Under Cell Points -> Scatter points = 250.
It will look like so.

If we will add one more attribute, it will add a layer of fraction for each chunk we have.
We can change the FOG Volume to get different patterns.

We can change the material type as well.

We can visualise the chuncks if we will link an explodedview node like so.

Now how to merge the wall and the ball?
We need to pack the RBD and then unpack it.
So link everything like so:

Under the RBD rbdconstraintproperties, adjust the glue parameter to see the different results:

Now, if we want to select what will stay active and what will not (on the wall), do the following:
From rbdunpack node, link a split node and a bound node.
Adjust these nodes like so: (@name=wall*)

Now, under the RBD configure, under the second attribute tab (wall), add * so it will select all the chunks. Then tick “use bounds” while its on 1.

We can visualise it as well.

To move rbdconstraintproperties1 so we wont need to go up the stream every time to adjust the settings: Move the location of it according to the screenshot.

Then under the rbdmaterialfracture of the wall, add to the fracture ID name “Wall”.
Then under rbdconstraintproperties – select the wall group.

To make it break more that the pieces its touching, adjust the Propagation Iteration parameter.

To make the the concrete more streching to achieve believable result:
Change to soft. Change the soft parameter to 60.

We want that the constrains will rotate where the point of contact and not where the pivot point is (the centre). So add rbdconvertconstraints node and link it like so:
Choose group: @constraint_tag=concrete_fracture_Wall and constraint tab = Faces

Now it works well up until frame 3.

We need to disable this softness from frame 3 so it will actually break.
To do so, we need to go to RBDSolver and under the constrain tab, select our wall group.

Then we can adjust each of the parameters to get our desired results. We can tell what we need to adjust and how much using the geometry spreadsheet.
We can adjust each of the parameters to get different results.
Visualise on the spreadsheet the following:

Mark likes Torque Threshold the most.

Final Result:

Week 4 – Rigids

What was covered in the lecture:
Final Project:
Improve the project from last year

The Workshop Activity:
Make it look realistic:
We need to create visual richness.
We need to change the low res geometry so it will be more accurate. We need make sure the padding is small:
Under RBDbulletSolver -> Visualisation -> Geometry – enable Collision Shape

Under RBDconfigure, on the wall tab, under the collision shapes, enable Colision Padding and add 3 more zeros so they will be tiny.

Now we want to cache the simulation:
Way 1: rbdio1
Geometry Only – not that useful – it will let us to just render it (just the first output)
Packed geometry constrains and proxy – 3 outputs – so it saves everything – a lot amount of disk space
Simulation Point – the most efficient – will write each chunk that represented by point (data out of the last output)

Bring in a RBDIO node and link all the streams.
Select “Packed Geometry, Constrains…..” and save to disk.
Then up the version, change to simulation points and save to disk again

Then instead of quick setup change to “Transform High Res Geometry”. It will create a node. Then link everything like so:

Derbis:
We dont have to use the transform geo if we are using debrissource node and linking it straight to the RBDIO like so: Left stream – high res geometry. Right stream – Points

Now we want to have just the wall. So link a split node to the left stream (high res geo).
We dont have a group. So write in the split node: @name=”wall*” and change to points

Under Derbissource node (11:00-11:10am)
Change the life span to “As Frame Duration”. Change the “Distance Threshold” to 0.01.
Tick “Remove Unreleased” and “Remove at life End”.

Fix the script like so:

Then add a pointWrangle node under the split node.
@P = set(0,0,0);
Bring in an Enumerate node under it. Enumerate – assign a point to each chunk.
Change the group type to Points. (11:25am)

Bring in a attribadjustinteger1 and link it under the DERBIS_SOURCE Null.
Change the attribute to “index” (just like the Enumerate node), change the Pattern Type to Random and change the Max value to the same amount of chunks we have (under info of the enumerate node)

Bring in a copy to point node and link everything like so

Bring in an Attribute Delete node and link it before the enumerate node.

Now link an “RBDSolver”. Turn on Emit RBDs. In collision, turn on the ground plane.

In RBD Configure, shrink the collision shape size and enable Emission -> RBD Bullet Emit.
Under Derbissource node enable Point Number Attribute:

Bring in an AttributeWrangle node after the copy to points node and write in:
s@name = “chunk” + itoa(i@pointnum);
itoa is converting the integer to the string.

Merge the chunks with the wall. (WALL_SIM_OUT and rbdbulletsolver2)
Now. Because all the chunks are at the same size. So add an “attribrandomize” under “attribadjustinteger” node. Inside it, change the Attribute Name to pscale. Change the Distribution to “Exponential”. Bring it down so the biggest chunks are a bit smaller than one we have on the wall.

To change the amount of chunks created, we could do so under debrissource node -> Density Scale

If we want to adjust the way the chunks rest:
Under RBDConfigure, change the type to concrete – concrete.
We could also add some air resistance by going to RBDBulletSolver, under forces, enable Drag.

Now cache everything.

Week 5 – Pyro

What was covered in the lecture:
Theory:
Volumetric Pixels = Voxels
Houdini – 1 unit is 1 meter
Change the background to dark so itll be easier to see the fog.
Also under display -> geometry change to following:

The Workshop Activity:
Using IsoOffset:
Create a geo node and inside create a Pig node.
Go out to the geo level. View where you want to have the light. Then CMD+spotlight (from the shelve).
Then bring in an “isooffset” node.
Rename to density. Change to “by size” = 0.02

A better way: VDB From Polygons
Link to the pig a VDBfromPolygons node. Rename it to vdbfrompolygons_dens
Change to Fog and change the Voxel Size to 0.02.

Copy and paste this node. Rename to vdbfrompolygons_vel.
Then add a pointvelocity node between the pig and VDB, enable “Add Curl Noise” and Scale = 5.

Then hit +, change the att and VDB name to the following and disable the fog

Pyro
Copy and paste vdbfrompolygons_dens and rename to vdbfrompolygons_temp
Change the FogVDB to “temperature”
Merge all 3 VDBs
Link a dopnet node. Inside bring in the following nodes and link them like so:
smokeobject_sparse1, pyrosolver_sparse1 and gravity1. 10:49
Then add a volume source node and link it like so:

Link a volumesource node to the third input of pyrosolver_sparse. Change the input to “First Context Geometry” 10:55-11:00

Then add temperature, density and vel like so:

Now again, in an easier way: 11:08
Bring in a Pig geo to the obj level.
Inside bring in a attribpaint and paint wherever we want the pig to burn.

Then bring in scatter node. Enable Density attribute and write in “mask”.

Another way is to link a pyrosource node to attribpaint.
Change the mode to Surface Scatter. Enable Density Att and write in “mask”
Then change Initialise to “source burn”. It will create two attribute tabs.
Change the Particle Separation to 0.027, and Particle Scale to 2.

Then bring in volumerasterizeattributes.
Under attribute write in “burn temperature”
Change: Voxel Size = 0.04, Particle Scale = 0.53, Minimum Filter Size = 0.75.

Then add solver:
Add a ground plane.

Under the Setup tab, change the Voxel Size to: 0.04
Then under Fields, change the following.
(Under this tab we can adjust the behaviour of the flame).

Under the Shape tab:
Shredding affects the flame. So we can change the shredding to 20 – add more life to it.
Enable Flame Expansion and change the rate to 10 – it adds a bit more body to the fire.

Under Field Tab:
Emit from Flame – smoke. Change the emission scale to 1 and the Frame Range between 0.1 and 0.2.
Temperature Cooling – Cooling Rate – the lifespan of the smoke. Change to 0.9.
Change the Dissipation to 0.01.

To add weight to the smoke so gravity will affect it:
Under Shape, Buoyancy, Gravity, enable Density influences Gravity and change the gravity scale to 3.

To break the shape of the mushrooms:
Our block size should be bigger than the resolution – around twice big.
Our resolution in this case is 0.04.
Under Shape -> Disturbance, Disturbance = 5.
Then enable use control field so the speed will affect it. when it slows down its less effective which is good.

To optimise and have less points without noticing:

To visualise it (shade it), add pyrobakevolume1 node.
Enable smoke. Enable fire.

To make the smoke look as if it lights by the fire (within), enable scatter.

Week 6 – Smoke + Render

What was covered in the lecture:
Theory:
Fire = Fuel
Velocity makes the sim move

Bring in a “Simple Billowy Smoke”

Change the texture resolution to 512

in volumerasterizeattributes node change the visible volume to density.

In “pyrosolver_billowy_smoke” -> Setup -> voxel size = 0.08
Shape ->

Output:

For shaders, we need to use Solaris.
Solaris is Houdini USD system and its a better way to render when working in big companies.
Desktop -> Solaris

Bring in a SOP Import node and link our pyro render null.

Visualise a nice angle, then CMD+Camera. Then click on unlock.

Then add a merge and link everything like so:

Then bring in one more merge node and material library node and link them like so:

In material library create a “karmapyromaterial1′ node.
Then outside, under the merge link “materiallinker” node.

Drag from the left to the middle and then the volume from the right to the middle top.

Create a spot light (CMD+Spotlight) and then unlock.
Bring in an “insertionpoint1” node and rename it to light. Then create one more light.
Then bring in a “karmarendersettings” node and choose the camera we want to render. And then “usdrender_rop”

Adjusting the Light:
Keep the intensity on one and adjust only the exposure. In lights, everything is about contrast.

In the shader (ima_pyroshader), we can change the Density Scale and the colour.
In density we can add a Ramp (linear) to make it look much better. Put it back to constant.
Ground explosion Pyro Shader\;
When enabling scattering, it lights the sim from within.
Fire (flame) – adds fire colour to it (for the hot spots).
Bear in mind forward scattering and back scattering.

Week 7 – Vellum:

What was covered in the lecture:
Theory:
we can bend geometry just around the vertices.
We usually don’t use DOP network.

The workshop activity:
Bring in a sphere, change it to Polygon Mesh and change the uniform scale to 0.5.
Bring in a transform in, and translate Y = 1.
Bring in vellumcloth node (left input – geometry | mid input – constrains | right imput – collision geometry).
Separate the outputs with nulls like so:

Then create a dop net, and inside create the following (without adjustments)
Now instead of DOP Net, bring in vellum solver, link it like so and turn on ground plane.

To increase the resolution (we can bend geometry just around the vertices) – the more edges, the between resolution we get. So change the sphere to polygons and increase the frequency number:

We choose the resolution by the material. To make it behave more realistically and get more interesting shape, we can increase the substeps in the vellum solver.

Resolution is a big player when it comes to how it looks like.
To change the thickness of the cloth, we need to adjust it under vellumcloth node -> edge length scale.

One more example
Now bring in a grid node. Adjust the following like so:
Then bring in a reverse node (optional) and a transform node (transform y = 1).

Then bring in a vellumcloth and vellumsolver nodes, and turn on the ground plane.

This is how it looks now (grid 10×20)

To make art seem more nice, we need to get more edges. so lets bring in a Remesh node (before the tranaform node).
Under element sizing->target size=0.016

Change the target size to 0.05 (remesh) and the substeps to 4 (solver).
NOT PROCEDURAL: Add a group node after the Remesh. change it to points and select couple of points at the top.|

Bring in a vellumconstraints after the vellum cloth node. adjust the settings like so:

PROCEDUAL:
Bring in a box and a match size node:

change the group settings:

Node tree:

Adding a pighead and a transform node. adjust the settings like so:

Then bring in a vellumconstraints node and adjust

Then above it link a pointvelocity node to make the pig move. Adjust the settings of the point velocity node like so:

To make the pig interact with the cloth as one more collider, we will have to pack, merge and unpack.

Another example:
Copy this node tree. Delete the match size and the boxes. Under the group node change the setting like so. Also, change the location of the group node so it will be after the Remesh.

Then add an edge fracture node. Adjust the settings like so:

We can adjust the bend and stretch. We need to make them stick to each other by (11:10 +)
Bring in a vellumIO node to cache out them sim.
We can bring in a post process node and refine the sim.

Week 8 – Vellum

What was covered in the lecture:
Theory:
Fire = Fuel

The Workshop Activity:
Vellum – Clothes:
Create a geo node and inside Create an object merge node.
Under the character shelve bring in a “mocapbiped”. Set the animation to rest (T-Pose).
To bring it in to our geo scene select the deform under its geo.

Space + 3 to visualise the front view to start creating the top.
Bring in a drawcurve1 node. Frame the character and visualise the drawcurve.
We will draw one curve for each stitch.

Let’s start with the shoulder. Paint them in order and make them intersect. Then to tidy it up, bring in a resample node and change the length to 0.05.

Then bring in a fuse node (which is like a merge node in Maya), and change the snap distance to 0.01 and make sure the points and the corners merged.

Now we want to convert it to a geometry. So bring in a Planar node – “planarpatchfromcurves”.

The issue with this, that it dont deform nicely on the edges when we increase the interior edge length because it doesnt add more points on the outside. So, change the interior edge length to 0.03 (3cm) and tick Resample Curve.
Also, tick SeamGroup to group them according to the name of the node. so rename the node to frontPatch.

Now transform it to the front of the man.

Create one more transform and move it to the back of the man. Then bring in a reverse node to flip everything to work more procedurally. Then we need to rename it so it will be the back of the shirt. So bring in a grouprename1 node.

Then merge both transforms like so:

Now bring in a “vellumcloth” node and a “vellumdrape” node. Link the object merge node to the third input of the vellum cloth node to make it as a collider.

Then under Vellumdrape, tick “Weld Additional seam” and seam the front and the back.

Do it to all the stitches:

Change the substeps on the vellum drape to 4. Change the bend under the vellumcloth to 0.000.001.

To make the cloth bigger:

To increase the resolution, reduce the “interior edge length” of the “frontPatch” node.

To attach a dress:
Create a Planar Patch node. Rename to dressFront. Adjust the settings like so:
The edge length is the same parameter as the shirt.

Then use a Transform node to move them and make sure the dark sides facing the inside:
Now, merge it with the main merge: (make sure transform6 is above backpatch)

Create the following links:

Then:

To make it more advanced, check Houdini 17 clothes masterclass online.
Video:

Week 10 – Grain

The Workshop Activity:
Bring in a Geo node. Inside it create the following nodes:

Matchsize: Justify Y = Min.
Grainsource: untick Uniform Radius. Tick Dither Surface. Change the point separation to 0.05.

Inside the PopSolver, go to the shelf and create a ground plane. Then Add a Gravity node and pop grains node. Copy the Grainsource point separation and paste relative reference on the pop grain node. It has to be the same.
Then Adjust the source first input like so:

The elements we want to adjust inside is Clumping ->Stifness
Now go back one level up and create a tube. Also bring in a transform node and place the rubbertoy above the surface and the tube. Turn on End Caps

Then inside the geo level, Hit static object from the shelf to make the tube collide with the grain. Then it will send you when level up. Select the tube and hit enter.

Then, under the pop grain solver change the neighbour to 2.3. Also, under the popsolver increase the min and max substeps to 5.

Then bring in a pop colour node and pop sprite node. Under the pop colour, change it to Ramp and choose a sand preset.

Then under the pop sprite, change the Sprite Map path to: $HFS/houdini/pic/sphere_matte.pic

Duplicate the top node (Geo1), rename the first one to popgrain and the second one to popvellum. Delete the following and bring in vellum constrains grain node.

Adjust the following parameters:

Now bring in a color node and vellum solver node.
Under the color node adjust the following:

Then under the vellum solver adjust the following:

Bring in a vellumconstraints node and link everything like so:

Under the vellumconstraints adjust the following:

Video: