When sending rays, the list of objects to intersect against are typically limited by a “scope”, set in the Houdini UI. For example, sending a reflection ray will limit the objects which are tested for ray-intersection to the objects which match the reflection mask of the reflective object.

You can override which objects to test in the following functions:

For example,

Cr = reflectlight(bias, max_contrib, "scope", "geo1,geo2");

…will only cause objects “geo1” and “geo2” to be picked up in the reflections.

All Houdini scoping patterns (excepting group expansion) are supported:

• * - wild-card match

• ? - single character match

• ^ - exclusion operator

• [list] - character list match

An empty string will set the scope to nothing.

Examples:

• geo* - Matches all objects starting with “geo”

• geo*,^geo2 - Matches all objects starting with “geo” except “geo2”.

• leg*,arm[123] - Matches all objects starting with “leg” as well as “arm1”, “arm2”, and “arm3”.

This explains how VEX sets the initial value of L (light direction) in the Light and Shadow contexts. Although Houdini provides a value as explained below, you can set L to any value.

In Houdini, lights can have orthographic or perspective projections. An orthographic light represents an infinite (or very distant) light source with parallel light rays. A perspective light represents a point light source with radiating light rays.

When a perspective light shader runs, VEX sets L to P - Ps, where the P variable contains the position of the light source and the Ps variable contains the position of the surface point being shaded.

Orthographic lights, on the other hand, are initialized so that the direction of L is the same for each light ray emanating from the light source: L = Lz * dot(Lz, P - Ps);, where the Lz variable contains the normalized “z-axis” of the light source (that is, a unit vector pointing down the z-axis in the space of the light). So the scale of the L variable will be the orthographic distance from the plane of the light source and the surface point being shaded.

In the surface shading context, there are two separate variables to control transparency: Of (opacity) and Af (alpha) are related, but represent different things.

Of represents the opacity of the surface, when mantra resolves surface colors. For example,

Of = {1, 1, 1}

…makes a fully opaque surface the will occlude surfaces behind it.

Of = {0.5, 0.5, 0.5}

…makes a partially transparent surface.

Of = {1, 0, 0}

…makes the surface opaque to red, but pass through green and blue light. This creates a cyan-colored gel.

Af controls the alpha channel of the output pixel in an RGBA image. If a shader doesn’t set Af, mantra uses the default formula,

Af = avg(Of)

However, if you set this variable explicitly, the shader can control the value of the alpha channel of the output image. This lets you write shaders like “matte” or “shadowmatte”.

For example, the following shader simulates a blue screen effect:

surface bluescreen(vector clr=0)
{
    Cf = clr;
    Of = 1;
    Af = 0;
}

The default surface color is black (vector clr=0). The shader sets opacity to 1, meaning this surface will occlude other surfaces. However, the alpha value of the pixels in the output image corresponding to this surface will be 0 (fully transparent).

If you composite the output image over another image, the background image will be visible through the hole this surface left. You can use this technique to, for example, create a window in a wall without modifying the geometry.

You can set Af to a fractional number between 0 and 1 to create partially transparent areas in the output image.

There are several “special” variables you can give as parameters to shaders in the shading contexts. Typically, these are export parameters.