If you need your particles or points to be rendered with constant size according to your camera, in Houdini, this is what you could do.

• Add a UV Texture SOP.
  • Change texture type to Perspective from Camera.
  • Insert your Camera path.
  • Change attribute class to Point.

• Add a Point Wrangle SOP.
  • We want the scale of the particles to be connected to the distance of the camera. This is the @uv.z. We want also to control the overall size of the particles, so we add a control multiplier.
    • @pscale = @uv.z*chf('mult');

• In the /obj, be sure to check that Render Unconnected Points or Render Only Points are active. Here you can also control the size of the particles again. If you don’t want the particles to be rendered as Spheres, select Circles.

• Starting from the basics:
  • SOP: surface operator, geometry network
  • DOP: dynamic operator, dynamic network
  • VOP: vex operator, vex builder network
  • SHOP: shader operator, shader network
  • CHOP: channel operator, motion/audio network
  • COP: compositing operator, img network
  • ROP: render operator, out network
  • POP: particle operator, particle network
• Points, vertexex, primitives. Vertexes are part of a primitive. Points are the lowest level attribute of any data type you can have. Like weight, null, nurbs.  You can have a primitive in one point, for example. A point is where Houdini stores all the informations about something. Makes sense.  You move your camera in your viewport with your spacebar pressed.
• Set Driver / Set Driven in Houdini: to parent the position or whatever of one object to another, highlight the attribute, right click Copy parameter. On the second object Paste Copied Relative References. To see the expression, click on the attribute name. It will cycle between the value and the expression. Dark green on the values means that there’s an expression beneath.
  • The simple expression created to parent the position of one object to another is going to be ch("../circle1/tx")
  • ch means channel.tx means translate x
  • .. means going back one level, inside the same network, to the circle1, to the position x.
  • you can see that tx means translate hovering the mouse on position. You can get all the parameters names just hovering the mouse with ctrl pressed.
  • The expression is saying: I need to pull a channel from a node that it’s not myself, that is called circle1 and the value is tx.
  • We can change the values of our expressions as well.
    ch("../circle1/tx") + .05
  • If we hover the mouse on the value we added, we can use the value ladder clicking the MMB.
• Access variables in SOP: you have to use a grave accent `. So, for example, to use a @path variable in the material, you can use this snippet $HIP/tex/`@path`
• Write code in SOP, for example in group: don’t use spaces! For example, if you want to create a group with the type @type == 1, instead you have to write @type==1
• World coordinates: M
• Variables on parameters:
  • $F: frame

Going back doing another tutorial to better understand how Houdini works.
This series is specifically for who is coming from C4D.
recreating mograph in houdini -1 cloner object

in attribcreate you can add
pscale
scale
orient

$PT point
$NPT total number of points

with Attribute Wrangle you can easily create attributes.
f@fall = 0;

SOPs

• Resample: use it to generate tangent, curve, ptdist, curvenum.
  • CurveU goes from 0 to 1, from the beginning of the curve, to its end.
• Generate points from volume:
  • VDB from Polygon + Scatter
  • IsoOffset + Scatter
  • Points from Volume

FLIP

• Flip Object
  • Input Type: it could be Surface SOP if you have a polygon or Particle Field if you have already points

VEX

• VEX documentation
• to declare a variable:
  int nameofthevariable; // create a integer variable
  vector nameofthevariable; // create a vector variableFetching vector P
  ‣ @P // fetch first input P
  ‣ @opinput1_P // fetch second input
  ‣ @opinput?_P // fetch ?th input
  Fetching float foo
  ‣ f@foo // fetch first input foo
  ‣ f@opinput1_foo // fetch second input
  ‣ f@opinput?_foo // fetch ?nt input
  /*
my comment block
*/f@myattrib = 1.0; // f means floating point. This line means that I’m creating a new variable, called myattrib, it’s a floating number and it’s 1.
  @N = @N; // initialise the normals
  @UP = {0,1,0}; // this is the way we initialise the vectors, with the up on Y
  @Cd = @Cd; // initialise the colors
• Common functions
  • • fit() take a number between 2 values, fit it between 2 other values, usually 0-1.
      • Eg, remap @u from range -5,20 to 0-1: foo = fit(@u, -5, 20, 0, 1);
    • rand() generate a random number between 0 and 1.
      • Usually feed it the point id, so each point gets a random number: foo = rand(@ptnum);
    • sin(), cos() as you’d expect, but in radians.
    • radians() convert a number from degrees to radians: foo = radians(90);
    • length() measure the length of a vector. Eg, measure the distance of a point from the origin: dist = length(@P);
    • distance() measure the distance between two points: dist = distance(@P, v@mypoint);
    • abs()Returns the absolute (positive) equivalent of the number. For vectors, this is done per-component
• Built-in attributes
  • @ptnum – the point id
  • @numpt – total number of points
  • @Time – current time, in seconds
  • @Frame – current frame
  • @primnum – the primitive id
  • @numprim – the total number of primitives
• Create Floating Slider: @foo *= chf('name');

Expression functions

Reminder, check this link!

Expression functions are different from VEX expressions.
Expression functions are for Hscript, the expressions in network parameters.

npoints returns the number of points in a geometry. npoints(surface_node).
opinputpath returns the full path of the node connected to a given input. opinputhpath(“.”,0) it returns the input connected to the sop.
for example: npoints(opinputhpath(“.”,0)) it will return the number of the points of the curve connected to the attribute create sop.

$PT point number
$NPT Total number of point
$CR Diffuse point color red
$CG Diffuse point color green
$CB Diffuse point color blue
$PR Primitive or profile number
$NPR Total number of primitives or profile number
$F Frame number

The Copy sop has a great feature that is the stamp, where you can control the individual copies.
Check stamp inputs, write the variable.
You can then add $CY, number of copies.

With op:`opinputpath(".",1)` you connect through expression the sop to its second input.

Attrib Delete:
* to delete everything
^nameoftheattrib to save that attribute

Tutorial and classes

• Entagma
• Houdini Resources
• Flexmonkey
• Digital assets
• Johnny Farmfield
• Paint flakes
• Manhattan Voronoi
• Simon Fiedler Volume Trails
• Crystal
• Pepe

Video tutorial

• Sop Solver Effect

E-Books

Some free ebooks and pdfs I’ve found online about Houdini

• Houdini Foundations GDC 2018 Edition
• Procedural modelling in Houdini based on Function Representation
• 2011 SCM
  • 01 Getting started with Houdini
  • 02 Create copies with variations
  • 03 Using expression
  • 04 Audio-driven animation
  • 05 Image-driven animation
  • 06 Particle and metaball
  • 07 Pop network and particle rendering
  • 08 Rigid body dynamics 01
  • 09 L-System

You can download the Houdini project here. I had a bit of fun with Point VOPs, nothing crazy.
GastaLoop 103

Following this tutorial that creates trails from volumes.
Playing with some splines. In Houdini you create them with the Curves sop.
Resample to subdivide splines.
Polyframe to generate tangents from points.
Press X to create a Visualize node.

A nice way to invert tangents from points is with an Attribute Wrangle and this code
v@tangent = @tangent * -1;
Just be careful when declaring the type of variable. A tangent is a vector, not a float.

The Volume sop has some interesting parameters:

• Rank
• Scalar

, each voxel holds just one value.

• Vector

, each voxel holds three values.

• Matrix

, each voxel holds nine values.

If you want to use the tangents in your Volume, you have to use a Vector rank.
Careful about Name parameter of Volume sop. It’s not “just a name”. It’s absolutely important.

Naming volumes allows mantra and the Volume VOP to override the correct parameters with the values of the volume.

The input of the Volume sop is Bounding Source. It’s the Bounding Source of the geometry! When you create a Volume it will look at the boundary box of your object. If you want to increase the Volume boundary box, use a Bound sop, not a Volume Bound!

Volume Vop allows us to write vex for volumes.
When you’re working with vector, remember to change Bind export to vector!

These are Vops that I used in the Volume Vop.
Point Cloud Open: this node opens a point cloud file and searches for points around a source position.
Pount Cloud Filter: allows us to choose an attribute (channel) from the point cloud.
Length: it calculates the lenght of a vector.

Volume Trail sop: computes a trail of points through a velocity volume (from the help!).

Remember: VDB from Polygon to create a volume from polygons.

Some VEX here.
VEX stands for Vector Expressions.

SHIFT + R to reverse the node inputs.

The full list of VEX functions is here.

to declare a variable:
int nameofthevariable; // create a integer variable
vector nameofthevariable; // create a vector variable

Fetching vector P
‣ @P // fetch first input P
‣ @opinput1_P // fetch second input
‣ @opinput?_P // fetch ?th input
Fetching float foo
‣ f@foo // fetch first input foo
‣ f@opinput1_foo // fetch second input
‣ f@opinput?_foo // fetch ?nt input
/*
my comment block
*/

f@myattrib = 1.0; // f means floating point. This line means that I'm creating a new variable, called myattrib, it's a floating number and it's 1.
@N = @N; // initialise the normals
@UP = {0,1,0}; // this is the way we initialise the vectors, with the up on Y
@Cd = @Cd; // initialise the colors


In the past few days I’ve jumped between tutorials and, to be honest, the more I watch them, the more I understand.
The last one I’ve done is just brilliant, about reaction diffusion, by Entagma.
And, finally, I’ve been able to render an animation!

So, I’ve just finished the first big tutorial on Digital Tutors.
More free Houdini tutorials here:

http://www.gridmarkets.com/johnny-farmfield.html
https://vimeo.com/user2030228/videos

But before I start on those, I’ll dive into Dynamics a bit more with another Digital Tutors tutorial.

Cloth object

If some penetrations happen, check the cloth thickness in collisions.
The main controls for the Cloth are in Model, like C4D: stiffness, damping, density.
Stiffness: how much cloth is resisting deformations.
Density: how heavy is the cloth?
Damping: how quickly the cloth will settle down, it’s how much it’s springy

Houdini

Finally, we start to animate!
Alt + LMB on a parameter: add keyframe
Ctrl + LMB: remove keyframe
To align the handle to world coordinates press M!

And dynamics!

On the top shelf, select Rigid Bodies. The first tab is RBD object (RBD stands for Rigid Body Dynamics).
It creates an AutoDOP network, automatically generated Dynamics Operator Network.
Static Object  does what it says.

The Rest node is about how the textures are applied to the dynamic object.
DopImport node is like a bridge from the geometry to the AutoDOP network.
AttribCreate is a node that works like a bridge, but for static objects.
RigidBodySolver and the StaticSolver are set of rules, will tell how the objects are going to behave.
It’s better to move the dynamic objects in the object level than from the AutoDOP network, of course.

Like in C4D, we can create different types of collisions. There are different types of dynamic sims, I have tried only Bulled Data.
Anyway, if I select the object I want to change its collision type in AutoDOP network, I can click on Collisions tab, show guide Geometry and change the type of geometry representation.
Concave could work better, sometimes.
You can change the type of the solver in the solver, Solver Engine type.

Bullet Solver is the quickest. It’s the default dynamic solver in Houdini.

Object Merge node: create a null node anywhere you want. With this node you can change the container of any object. Change Transform “into this object”.
Shatter, from Model shelf, will fracture any object. It’s basically Thrausi but WAY better.
It creates three nodes.
The main one is Voronoi Fracture. Its first input is geometry, the second is Voronoi Points.
The geometry input is easy.
To generate the second one, it converts the geometry to a volume (IsoOffset) and generates random points with a Scatter (these are based on density).
You can change the number of the generated points (and the voronoi fractures) with “Force Total Count” on the Scatter.

RBD Fracture Object to work with this objects and make them dynamics