You can enter short bits of code, like mathematical expressions, in parameters to compute their values using math and variables such as the current frame number, the point number, random numbers, and so on. For example, to make a sphere rise over time without having to manually keyframe it, you could set its Y Position to equal the frame number divided by 5.

1. Create a new Geometry object and dive inside.

2. Create a Grid node.

3. In the parameter editor, set the Grid node’s Size fields to:

   $F / 10
   

   This makes the grid’s size relative to the current frame number. Trying playing back the animation using the playbar at the bottom of the main window.

• In numeric parameters (such as position, rotation, scale), the text in the parameter is evaluated as an expression.

• In string parameters (such as filenames, or the text created by the Font node), the text in the parameter is treated as text. Variables are expanded, but to use math or expression functions to generate part of the text you must place the expression within backticks. For example:

  frame`padzero(5, $F)`.pic
  

  …giving you filenames such as frame00001.pic, frame00002.pic, and so on.

(See expressions in filenames for more information about using variables and expressions in filename parameters).

Your expressions can use variables provided by Houdini:

• Global variables such as $F (the current frame number) and $T (the current time in seconds). See the list of global variables below.

• Geometry attributes. In HScript expressions on geometry you can reference the value of an attribute using @attributename. For example, you can use @pscale to get the value of the pscale (point scale) attribute on the current point.

  For vector attributes such as P (position), you can use dot notation to grab a component, for example @P.x. You can use .x/.y/.z or .1/.2/.3 or .r/.g/.b, whichever makes sense for the type of data.

• Local variables. Nodes often provide variables that are useful for expressions on nodes of that type. For example, a node that operates over the points in a geometry will have a @ptnum variable representing the point number of the current point. The help for a node will list the local variables you can use in expressions on that type of node.

• Environment variables such as $HIP (the directory containing the scene file) are available to expressions.

In HScript expressions you can reference the value of a parameter on a node using the ch function. This can be useful to make a number on one node follow or be relative to a number on another node.

ch("tz")

ch("/obj/lamp/tx")

ch("../grid1/ry")

The expression language is usually used for short one-line formulas to expression a relationship between a parameter value and other values (for example, making a ball move by setting its X position to $T * 2). If you want to do complicated scripting in a parameter expression, you may want to switch the parameter to use Python instead of the traditional expression language.

However, if you do want to do complex things with the traditional expression language, you can use multi-line expressions with blocks, if statements, and for loops.

• A block is a set of sub-statements, inside curly braces ({ and }).

• You must separate sub-statements with a semicolon character (;).

• Sub-statements may consist of:

  • Assignment. The right-hand side of the assignment can use expression syntax and functions. Specify the variable type (float or string) before the name is optional for floats but required for strings.

    For example:

    size = 0;
    float frame = ch("outputframe");
    string name = ch("name");
    

    Assigned variables are local to the outer {} block.

  • You can also use in-place modifying assignments such as j += 5; and i -= 1;, and C-style in-place increment/decrement such as i++; and j--; as statements.

  • if...then...else statements. See if statements below.

  • for and while loops. See for loops below.

  • return statements. The right-hand side of the return can use expression syntax and functions. When the return statement is executed, its expression is evaluated and used as the overall value for the outer {} block.

    You can have multiple and early return statements, for example inside an if block:

    {
        # ...
        if (evalmode == 4) {
            float slope = (ch("../inputrangey") - miniframe)
                        / (ch("../outputrangey") - minoframe);
            return miniframe + ($FF - minoframe) * slope;
        }
        # ...
    }
    

    (If no return statement executes, the outer {} block will evaluate to 0.)

  • A # character starts a line comment. The rest of the line after the # character is ignored.

{ 
    size = 0;
    if ($F > 10) {
        size = 23;
    } else if ($F > 20) {
        size = 47;
    } else {
        size = 50;
    }
    return size;
}

{
    float out = 0;
    for (i = 0; i < 10; i++) {
        out += i;
    }
    return out;
}

{
    float k = ch("parm");
    float i = 0;

    while (i < k) {
        i++;
        if (i % 2 == 0) continue;
    }

    return i;
}

• It’s easy to modify geometry in geometry nodes using HScript expressions and local variables in parameters. However, it’s much more efficient to modify geometry using a VEX snippet in a node such as the Point Wrangle or Attribute Wrangle.

  Future versions of Houdini will probably move toward encouraging use of VEX to modify geometry rather than parameter expressions.

• You can check the value of an expression by choosing Window ▸ HScript Textport and then typing:

  echo `expression`
  

• Houdini always creates each frame “from scratch” using the “recipe” of the network. Expressions always operate on the values they get from the initial setup of the node, not from the previous frame.

  For example, if you set up a Point geometry node to add a random offset to the Y position of each point in a grid:

  Position Y	@P.y + rand(@Frame * @ptnum)

  …when you play back the animation, the points will jump about randomly, instead of smoothly moving up and down. This is because at each frame the network starts with the flat grid and then applies the random movement to it. The expression does not run on the geometry from the previous frame.