Context options are useful for scene-specific variables. For example, you can create a render_quality variable, and reference it in all your render nodes, and a shot_name string that you overlay on all non-final renders.

You can create context options using the context option editor or Python scripting, and then use them in expressions or in Python.

This can be particularly useful when you're using the same HIP file to render multiple shots. You can set up variables with shot-specific values, and change the variables when you change which shot you're working on.

Internally, context options can store either floating point number or string values, keyed to an internal name string. However, they also let you associate a “configuration string” with each option. The context option editor uses this string to store extra information such as a human-readable label, an order, and a user interface type.

You can reference context option values in expressions using @name. For example, if you create an option with the internal name render_quality, you could set the Quality parameter of your main render node to @render_quality and the Quality of a preview render node to @render_quality / 2.

You can also create and read context option values in Python scripts using hou.setContextOption() and hou.contextOption().

Some global context options are generated and maintained by Houdini. These “automatic” context options can be queried and modified like any other context option, and they can be overridden by individual nodes to alter their input’s cook context. But deleting such a context option will only clear the overridden value. The context option will still exist, but it will be once again controlled by Houdini. See hou.isAutoContextOption() for a list of these automatic options.

Additional context options are saved with the HIP file. A newly created HIP file has no context options aside from the automatic ones. If you always want to start new files with a default set of context options, you can export|#hom] the context options as a JSON file and import them in the 456.py HIP file creation script.

• In parameter expressions, you can use the value of a context option with @name.

• In a Python script, you can get the value of a context option with hou.contextOption().

Similar to other elements in Houdini such as parameters, context options have an internal name (the name you use in @name expressions and scripting) and a label (the human-readable name that appears in the option editor user interface).

Normally Minimum and Maximum set the slider range, but the user can still manually enter values less than the minimum or greater than the maximum. You can turn on Min locked and/or Max locked to enforce the minimum/maximum even on values the user enters manually.

import os
menu = []
for name, value in os.environ.items():
    if not name.startswith("HOUDINI"):
        continue
    item = ("$" + name, value)
    menu.append(item)
return menu

The following HOM functions let you script the values of context options:

• hou.contextOptionNames()

• hou.setContextOption()

• hou.contextOption()

• hou.setContextOptionConfig()

• hou.contextOptionConfig()

• hou.removeContextOption()

You can also script the Export and Import functions from the context option editor:

import contextoptions

# Export all context options in this scene to a JSON file
contextoptions.exportJson("options.json")

# Import context options from a JSON file and merge them over
# any existing options in this scene
contextoptions.importJson("options.json")

To clear any existing options before importing, you can just iterate over all existing options and delete them:

for name in hou.contextOptionNames():
    hou.removeContextOption(name)