Reference Operator Type Properties window

Controls how the folder contents are presented in the asset’s parameter editor interface for parameter folders. The default is to show the folder as a tab.

The Import block setting displays the contents “inline.” This is useful when you want to import a folder from a sub-node (see Import settings below) but don’t want the imported contents to appear in their own tab.

Internal name of the folder which cannot contain spaces.

Readable label for the folder, displayed in the interface. This name can contain spaces.

Default values for multi-parms.

This is useful when you are importing the node’s parameters but you want this folder to not be imported.

This folder and its contents are not visible in the parameter interface, they are only available for scripting.

Consecutive folders of type Tabs are turned into a set of tabs. If you want to separate a set of consecutive tab folders into two or more sets of tabs, turn this option on for the last tab of a set of tabs. The next folder of type Tabs will start a new set of tabs.

Turn this on have this folder import its contents from a folder on a node inside this asset.

The source to import from. The source can be either a sub-node, specified using op:<node_path>, or an external dialog script, specified using file:<file_path>. For example, to import parameters from a node named torus1 inside the asset, use op:torus1. To import from a node named sphere1 inside an object named geo1 inside the asset, use op:geo1/sphere1.

The entity to import from the source. You can import either a group of folders, a single folder, an import block, or all the parameters from the source.

To import a group of folders, use the Name of that set of folders. To import a single folder, use the Name of the folder, followed by a colon (:), followed by the Label of the folder you want to import. For example, to import a folder named folder1 with the label Shading, the token would be folder1:Shading. To import an import block, use the special token importblock, followed by a colon (:), followed by the Label of the import block you want to import. Finally, to import all the parameters from the source, leave the token blank.

You can obtain the name of a folder by selecting the sub-node and choosing Edit Parameter Interface from the Gear menu in the parameter editor. Alternatively, you can also find the desired folder in the From Nodes tree and MMB on it.

Only import parameters matching this mask.

Note that excluding a multiparm will not automatically exclude any existing instances. However, including a multiparm will exclude these individual instances as they are represented by templates of the multiparm.

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.

The data type this ramp parameter contains. This can either be RGB for colors, or Float for scalar values.

The initial number of ramp points when this paramter is created.

The default interpolation type for ramp points.

Specifies the starting number associated with the first ramp point. This only affects scripting, which refers to the internal names of the ramp point parameters.

Specifies rules for when to disable the ramp parameter. See disable when.

The dialogs in which the parameter will appear.

If enabled, the ramp controls panel will be open by default in Parameter dialogs.

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

Specifies the VEX variable names when used in a shader for the basis, keys, and values parameters.

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 or Python script to run when this parameter is changed by a UI event (or when the button is clicked, if Type is Button).

If your script is written in Hscript, 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.

If your script is written in Python, the same variables are accessible via a dictionary variable named kwargs. See Parameter Callback Scripts for more information.

For example, this Hscript 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.

Runs when the first instance of this operator type is created in a hip file. Runs before the node is created, and runs even if the operator is created while loading a hip file. To determine if Houdini is in the process of loading a hip file, use the opisloading expression function.

You can use this script to set up the external environment for your asset, such as copying texture maps to a required location or setting environment variables.

The user cannot “undo” the actions performed in this script. Use the After Last Delete script to undo any actions performed by this script.

Runs after a new instance of this operator is created. Runs after the creation script and after the default parameter values are set. This script does not run when loading a hip file, only when the user creates a new node interactively.

Runs after the node is loaded.

Runs when the definition for this operator is updated. Runs once for each instance of the operator in the hip file.

Runs immediately before Houdini deletes a node of this type. Runs before the node’s individual delete script.

To determine if Houdini is in the process of quitting a hip file, use the opisquitting expression function.

Runs after the last node of this type is deleted from the hip file.

You can use this script to clean up any actions performed in the “Before First Create” event script.

The user cannot “undo” actions performed in this script.

To determine if Houdini is in the process of quitting a hip file, use the opisquitting expression function.

Runs after an input connection to a node of this type is changed.

Houdini calls this script with the full path and class/type arguments described above, plus a third argument containing the index of the input connection that changed.

Runs after the name of a node of this type is changed.

In addition to the full path and class/type arguments described above, this script is called with a third argument containing the old name of the node.