Reference Edit Parameter Interface window

The internal name of the parameter. You will use this name to refer to the parameter’s value in expressions. It must be unique within this operator type. This name cannot contain spaces or slashes.

A readable label for the parameter. This name can contain spaces.

Turn off the associated checkbox to hide the label. This is especially useful when you lay out parameters side-by-side using the Horizontally join to next parameter option.

The data type this parameter contains.

When Type is Operator path or Operator list, this option lets you restrict the types of nodes shown in the picker UI. For example, if this parameter should contain a surface shader, set Op filter to SHOP: Surface only. This makes it easier for users to pick surface shader by filtering out other node types from the picker.

For RenderMan Shader assets, this lets you set the RenderMan datatype to use for this parameter in the output.

Houdini’s file chooser only recognizes the Read and Write mode and is used for opening files for all three options.

The OS X only recognizes the Read Only and Write Only modes, and fakes the Read and Write mode (needed by Data File DOP, for example) by using Write Only mode. In this mode you cannot create a new file; however, using Write Only mode is still better than Read Only, since Read Only mode presents existing files as not selectable.

On Linux and Windows, you are limited to Houdini’s browser.

When Type is Integer, Float, or Angle, sets the number of components in the parameter (1 to 4).

The default value for the parameter. If Size is greater than 1, you can specify defaults for each component.

Do not show this parameter in the asset’s user interface.

If you have two short, related parameters stacked in the interface, you can turn this option on to lay out the options side-by-side to save space and clarify their relationship.

For numeric datatypes, specifies the range for the slider in the interface.

Click the lock icons to lock/unlock the low and high limits. When a limit is unlocked, the slider uses the limit, but the user can enter values beyond the limit using the text entry box. When a limit is locked, the slider uses the limit, and Houdini prevents the user from entering values beyond the limit.

HScript command to run when this parameter is changed by a UI event (or when the button is clicked, if Type is Button).

In your script, the name of the changed parameter is available in $script_parm, and the value is in $script_value. If the parameter has multiple components, you can access them as $script_value0, $script_value1, and so on.

For example, this callback command would open a small window showing the path to the operator and the name of the parameter plus the new value:

message `oppwf()`/$script_parm = $script_value0

Often, you will call a script stored as a section (an embedded file) in a digital asset. For an object type named asset_name, you can run the script in the section named section_name using the following command as the callback:

source opdef:/Object/asset_name?section_name

See how to access the contents of an asset and the source command.

The scripting language to use to interpret the Callback script.

Whether this parameter should be expanded without quotes within VOP code blocks. A common use is to allow strings from menus to be placed verbatim in a code block. Only available for string parameters in a VOP definition.

Whether this parameter is imported by import folders on a parent asset. See about importing folders from a sub-node above.

The dialogs in which the parameter will appear.

Specifies conditions where the parameter is disabled.

The syntax of the conditions is…

{ parm_name operator value ...} ...

That is, one or more sets of comparisons inside curly braces. Inside the curly braces are one or more comparisons between a parameter and a value, where the operator is one of:

If all of the conditions are true inside any of the curly brace lists, the parameter is disabled.

For example:

{ type == 1 count > 10 } { tolerance < 0.1 }

The parameter will be disabled if…

• The type parameter equals 1 and the count parameter is greater than 10

  or

• The tolerance parameter is less than 0.1.

You can omit the operator, in which case it’s assumed to be == (equals). For example…

{ type 1 } { type 2 }

…will disable the parameter if type equals 1 or 2.

You cannot use expressions in the disable when rules. The best you can do is to create an invisible parameter containing the expression you need, and reference it in the disable when rules.

Help string for the parameter. This is displayed in the tool tip when the user hovers over this parameter in the parameter editor.

Turn on the checkbox to make this parameter into a menu. Use the pop-up menu to choose the type of menu to create.

Choose “Menu items” to specify a list of static token/label pairs to populate the list. Use this option if the list does not need to change based on runtime conditions.

Choose “Menu script” to specify the list of token/value pairs using a script. Use this option if the contents of the list change based on the current conditions in Houdini (for example, a menu that lets you choose from the currently selected objects).

Click a row in the list to select it.

Use the two text boxes above the list to edit the token and label of the currently selected row.

Use the arrow buttons to reorder the list, and the X buttons to delete rows.

Enter a script here whose output populates the menu. You can write these scripts using either Hscript or Python.

Hscript menu scripts output is a space-separated list in the form:

token "label" token "label" ...

For example:

all "All objects" sops "Surfaces" dops "Dynamics objects"

In general you would use a for or foreach loop to generate a list of token/label pairs from a list.

For example, this script will create a menu where the tokens are the point groups in the current node, and the labels are just the group name converted to upper case.

result = ""
foreach groupname ( pointgroupmask("." + opinput(".", 0), "*") )
    result = $result + " $groupname " + `toupper($groupname)`
end
echo $result

In this example, the menu lists the node’s inputs, where the tokens are the full paths to the nodes, and the labels are the node names:

here = `execute("oppwf")`
result = ""
for index = 0 to `opninputs($here)`
    result = $result + " " + `opfullpath($here + "../" + opinput($here, $index))` + " " + `opinput($here, $index)`
end
echo $result

Python menu scripts return a sequence of strings of the form

("token1", "label1", "token2", "label2", ...)

Houdini uses the same rules for evaluating Python menu scripts as it does for evaluating Python parameter expressions: if the script contains only one line, it is evaluated as an expression. If it contains multiple lines, it is evaluated as the body of a function. Also note that hou.pwd returns the node containing the script.

In this example, the menu lists the node’s inputs, where the tokens are the full paths to the nodes and the labels are the node names:

result = []
for input_node in hou.pwd().inputs():
    result += [input_node.path(), input_node.name()]
return result

See Parameter Menu Scripts for more information on menu scripts written in Python.