# If-Then Block VOP node

Contains other VOP operators.

This node type is hidden. It is no longer supported.

This operator contains other VOP operators. The code for the contained operators is executed only if the value fed into the first input matches the criterion specified by the Condition parameter. At least one input must be connected to this operator.

Use this operator when you want something to happen only if a certain condition is met. The Condition Value is usually the output of a Compare operator, but any integer value can be used.

Any value that you wish to modify inside the If-Then Block operator must be provided as an input. The outputs of the If-Then Block operator will contain the modified versions of the inputs (if the condition was met) or the unmodified version of the inputs (if the condition was not met). The actual values wired into the If-Then Block operator inputs are never modified, and so can be connected to other operators in the network, but remember that the values from these operators will always be the values unmodified by the If-Then Block operator.

There is no place in this operator to specify what should happen if the condition is not met (i.e. an Else block). To achieve the same effect as an if-then-else statement, use two If operators. Connect the same output value to both Condition Value inputs of the two If-Then Block operators. Then set the Condition parameters of the two If-Then Block operators to be different. At this point one If-Then Block operator represents the “if” block, and the other represents the “else” block. Then connect your inputs to the “if” block operator. Then connect all but the Condition Value output from the “if” block into the inputs of the “else” block. Now the outputs of the “else” block are going to be what you would expect from an if-then-else statement. For simple if-then-else constructs, use the Two Way Switch operator instead.

## Parameters ¶

Condition

Specifies the condition that must be met by the first input for the contained code to be executed. Either the input value must be False (equal to 0) or True (not equal to zero).

## Inputs ¶

Condition Value

This integer input must be connected. The value connected to this input is compared to the requirements of the Condition parameter. Usually this input will be connected to the output of a Compare operator, or one of the logical operators (And and Or).

Next Input

Up to 64 inputs can be connected here. Each time an input is connected, a new input slot is added. All connected inputs mimic the properties of the output wired into them. They adopt the same help label and name as the output connected to them. If multiple outputs with the same name are connected, the names of the inputs are automatically incremented to make them unique.

## Outputs ¶

The list of outputs depends on the inputs connected to the Subnet Output operator contained in this operator. The data type and name of each output will match the corresponding input of the Subnet Output operator.

## Examples ¶

This is a simple example of using the If-Then Block VOP with the “true” value coming from outside the If-Then subnet, and the “false” value also coming from outside the If-Then subnet.

A Condition VOP is used based on the “t” Global Variable. When “t” is less then .5, the If-Then gets a “false” Condition, and when “t” is equal to or greater than .5, the If-Then gets a “true” Condition.

In this example, the red color is used if the value fed into the condition is not True, and blue if the condition being fed in is True.

This is a very simple example of using the If-Then Block VOP with the “true” value coming from outside the If-Then subnet, and the “false” value coming from inside the If-Then subnet.

In this example, the red color is used if the value fed into the condition is not True, and blue if the condition being fed in is True.

This is a very simple example of using the If-Then Block VOP with the “true” value coming from outside the If-Then subnet, and the “false” value also coming from outside the If-Then subnet.

In this example, the red color is used if the value fed into the condition is not True, and blue if the condition being fed in is True.

# VOP nodes

• Computes the absolute value of the argument.

• Outputs the sum of its inputs.

• Adds the specified constant value to the incoming integer, float, vector or vector4 value.

• Adds a KineFX joint to the geometry.

• Adds points to the geometry.

• Adds the point specified to the group given.

• Adds primitives to the geometry.

• Multiply steerforce by steerweight attributes and normalize results by total steerweight.

• Adds vertices to the geometry.

• Layers a wind force onto a simulation.

• Advects a position by a set of volume primitives stored in a disk file.

• Returns all of the animation clips that have been loaded for an agent primitive.

• Returns the length (in seconds) of an agent’s animation clip.

• Returns an agent primitive’s current animation clips.

• Samples an agent’s animation clip at a specific time.

• Returns the sample rate of an agent’s animation clip.

• Returns the current times for an agent primitive’s animation clips.

• Returns the blend weights for an agent primitive’s animation clips.

• Converts transforms between local space and world space for an agent primitive.

• Returns the transform that each shape in an agent’s layer is bound to.

• Returns the names of the current layers or collision layers of an agent.

• Returns the names of the shapes referenced by an agent primitive’s layer.

• Returns all of the layers that have been loaded for an agent primitive.

• Returns the child transforms of a transform in an agent primitive’s rig.

• Finds the index of a transform in an agent primitive’s rig.

• Returns the parent transform of a transform in an agent primitive’s rig.

• Returns the number of transforms in an agent primitive’s rig.

• Returns the name of each transform in an agent primitive’s rig.

• Returns the current local or world space transforms of an agent primitive.

• Computes a matrix representing the rotation around the axes normal to two vectors by the angle which is between the two vectors.

• Takes two values for alpha based on the surface orientation relative to the camera and blends between the two with a rolloff as the bias control, effectively removing the silhouettes of the geometry edges.

• Generates a color using ambient lighting model calculation.

• Performs a logical and operation between its inputs and returns 1 or 0.

• Generates anti-aliased (fractional brownian motion) noise by using the derivative information of the incoming position to compute band-limited noise.

• Generates anti-aliased noise by using the derivative information of the incoming position to compute band-limited noise.

• Adds an item to an array or string.

• Performs the atan2() function

• Checks whether a value exists in an array.

• Finds the first location of an item in an array or string.

• Finds all locations of an item in an array or string.

• Produces the length of an array.

• Computes attenuated falloff.

• Outputs the average of its inputs.

• Computes the average value of a vector argument.

• Tints a BSDF with separate control over colorization and luminance.

• Export shading for use in bake image planes

• Represents an attribute bound to VEX.

• Binds a KineFX point transform with a point index.

• Takes a float input as a bias to blend between three input regions.

• Blends between two KineFX transformation matrices.

• Marks the start of a code block.

• Marks the start of a for loop block.

• Marks the start of a for-each loop block.

• Marks the start of an if code block.

• Marks the end of a code block.

• Marks the end of a code block.

• Marks the end of a while code block.

• Returns two vectors representing the minimum and maximum corners of the bounding box for the specified geometry.

• Clips the line segment defined by p1 and p2 to the bounding box specified by the min and max corner points.

• Generates repeating filtered squares.

• Generates a brick pattern based on the parametric s and t coordinates.

• Outputs an angle that gives the appearance of a circular brush pattern when used with anisotropy direction.

• A basic brushed metal shader.

• Displaces surfaces along their normal using anti-aliased noise, and returns the displaced surface position, normal, and displacement amount.

• Compute a tangent-space normal map from a bump map

• Generates a burlap displacement pattern useful for simulating rough cloth or weave patterns.

• Returns float between 0 and 1 which defines a burlap pattern useful for simulating rough cloth or weave patterns.

• Returns a pixel value in one of the 4 input COPs connected to the VEX COP.

• A node that implements a CVEX shader using its children VOPs.

• Simulates car paint with embedded metallic flakes and a coat layer.

• Produces a surface displacement that simulates small surface damage using anti-aliased noise of various frequencies.

• Returns the smallest integer greater than or equal to the argument.

• Generates a cellular crack displacement suitable for simulating skin, leather, dried earth, and all kinds of crusts.

• Computes 2D, anti-aliased cellular noise suitable for shading.

• Converts an unicode codepoint to a UTF8 string.

• Returns number between 0 and 1 which defines a checkered pattern useful for visualizing parametric or texture coordinates.

• Clamps the input data between the minimum and maximum values.

• Flexible material including multiple reflection layers, subsurface scattering, refractions and displacement.

• A powerful, highly flexible, generic surface shader with displacement.

• Generates 1D noise used for cloud noise generation.

• Collides the specified joint with the target geometry.

• Provides a means to change the hue, saturation, intensity, bias, gain and gamma of the input color.

• Looks up a single sample of RGB or RGBA color from a disk image.

• Computes a blend (or a mix) of its two color inputs, and outputs the resulting color.

• Combines local and parent KineFX transforms with scale inheritance.

• Compares two values and returns true or false.

• Computes the complement of the argument by subtracting the argument from 1.

• Computes lighting using Physically Based Rendering.

• This node gives finer control over handling of the normal attribute in VOPs.

• Compute surface tangents in different ways.

• Outputs a physically correct reflection factor for conductive materials.

• Clamp the reflectivity of a bsdf to 1.

• Outputs a constant value of any VEX data type.

• Increases or decreases contrast for values at the bottom of the input range.

• Takes a single input of any data type.

• Performs a cosine function.

• Returns float between 0 and 1 which defines a crackle pattern useful for simulating the fine grain texture in skin or on a much larger scale dried mudflats.

• Creates a new point group with the name specified.

• Computes the cross product between two vectors, defined as the vector perpendicular to both input vectors.

• Creates divergence-free 3D noise using a curl function.

• Creates divergence-free 2D noise using a curl function.

• Computes surface curvature.

• Positions and orients KineFX points from a curve and a list of segment lengths.

• An OTL that performs composting of texture maps.

• Works on an image which was rendered as a z-depth image, returning the distance from the camera to the pixel (or plane) in question.

• Computes the determinant of a 4×4 or 3×3 matrix.

• Produces the keys of a dictionary.

• Produces the length of a dictionary.

• Internal VOP used to compute direct lighting.

• Computes the direction to a KineFX joint’s child.

• Computes the direction to a KineFX joint’s parent

• Masks crevices or exposed edges

• Displaces surface position and modifies surface normals.

• Displaces the surface along the surface normal by a given amount.

• Modifies normals and/or positions based on a texture map.

• Returns the distance between two 3D or 4D points.

• Returns the closest distance between a point and a line segment defined by two end points.

• Outputs the result of dividing each input value by the next.

• Divides the incoming integer, float, vector or vector4 value by the specified constant value.

• Computes the dot product between two vectors.

• Outputs sanitized dual rest values based.

• Sanitizes dual rest attribute data for easier use.

• Creates a smooth roll-off of the input color from the center of the geometry to the edges, based on the surface normal.

• Returns a new surface normal (N) which has a slight fine grained bump on it.

• Result 1 if the string ends with the specified string.

• Sets the environment map (on an infinite sphere) and returns its color.

• Builds a quaternion with the given euler rotation.

• Computes the exponential function of the argument.

• Computes a local transform for a KineFX point using its and its parent’s world transforms.

• Extracts the translation, rotation, scale or shear component of a 4×4 transform matrix.

• Outputs and opacity value which can be used to approximate caustic lighting effects.

• Sends a ray from the position P along the direction specified by the direction D.

• Generates a 2D, fiber like cloud pattern.

• Provides a fallback value for a field/attribute if the field does not exist or the given field name is an empty string.

• Provides a fallback value for a field/attribute if the field does not exist or the given field name is an empty string.

• Find a point in an array and return the transforms in the corresponding arrays.

• Filters the input.

• Sends a ray from the position P along the direction specified by the direction D, a…

• Computes the anti-aliased weight of the step function.

• This function returns the square root of the area of a 3D input or the length of the derivative of a float input, such as s or t.

• Find a point on a given geometry and return its transforms.

• Takes the value in the source range and shifts it to the corresponding value in the destination range.

• Takes the value in the source range and shifts it to the corresponding value in the destination range.

• Converts a float value to an integer value.

• Converts sixteen floating-point values to a 4×4 matrix value.

• Converts four floating-point values to a matrix2 value.

• Converts nine floating-point values to a matrix3 value.

• Converts three floating-point values to a vector value.

• Converts two floating-point values to a vector2 value.

• Converts four floating-point values to a vector4 value.

• Generates a 2D, locks of wool like cloud pattern.

• Returns the largest integer less than or equal to the argument.

• Generates 1D and 3D Perlin Flow Noise from 3D and 4D data.

• Perform the same operation on an array of transforms.

• Computes the fractional component of the argument.

• Generates a 2D, ragged, broken up like cloud pattern.

• Computes the Fresnel reflection/refraction contributions given a normalized incident ray, a normalized surface normal, and an index of refraction.

• Transforms a position from normal device coordinates to the coordinates in the appropriate space.

• Transforms a position from normal device coordinates to the coordinates in the appropriate space.

• Converts polar coordinates to cartesian coordinates.

• Returns the front facing normal of a surface, given a surface normal (N) and an incident ray (I).

• Provides outputs representing commonly used input variables of fur guide shader network.

• Provides inputs representing the output variables of a fur guide shader network.

• Creates a set of hair-like curves across a surface at render time.

• Provides outputs representing commonly used input variables of fur skin shader network.

• Provides inputs representing the output variables of a fur skin shader network.

• Displaces the surface along the surface normal by an amount equal to the value of an anti-aliased cosine wave.

• Performs a fuzzy and operation between its inputs and returns a value between 0 and 1.

• Performs a defuzzify operation between its input fuzzy sets and returns a crisp value.

• Performs a fuzzy inference operation over each input to determine the truth of the fuzzy set defined on this node.

• Performs a fuzzify operation that calculates a fuzzy value given a membership function and an input crisp value.

• This operator performs a fuzzy not operation on an integer or float value.

• Detects obstacles in an agent’s field of view.

• Performs a fuzzy or operation between its inputs and returns a value between 0 and 1.

• Sends rays into the scene and contains a subnetwork of VOPs to operate on the information gathered from the shaders of surfaces hit by the rays.

• Generates a random number fitting a Gaussian distribution.

• Generates a random number fitting a Gaussian distribution.

• Computes the Fresnel reflection/refraction contributions and vectors for objects with or without depth.

• Provides outputs that represent all the global variables for the Attribute VOP network types.

• Simple output variable for Geometry VOP Networks.

• Compute the reflectivity of a bsdf.

• Returns a CHOP attribute value in one of the 4 input CHOPs connected to the Channel VOP.

• Returns a transform value built from 9 channels from one of the 4 input CHOPs connected to the Channel VOP.

• Returns a sample value in one of the 4 input CHOPs connected to the Channel VOP.

• Returns a sample value in one of the 4 input CHOPs connected to the Channel VOP.

• Traverse the hierarchy from a given point and return their transforms.

• Gets a specified value from dictionary.

• Gets a specified element from array.

• Retrieve configuration values for the Physical Full-Body IK solver from point attributes.

• Return the computed center-of-mass for the given KineFX geometry.

• Computes a set of orthogonal axes centered at a KineFX joint.

• Obtains a value of the export variable added to the Shader Layer struct.

• Extracts a 4×4 matrix component.

• Extracts a 2×2 matrix3 component.

• Extracts a 3×3 matrix3 component.

• Gets the transform matrix of a named object in camera (current) space.

• Finds the parent of a joint within a KineFX skeleton.

• Gets the transformation of a joint’s parent within a KineFX skeleton.

• Returns a point transform for a given point index.

• Returns arrays of point transforms given an array of point IDs.

• Extracts a vector component.

• Extracts a vector2 component.

• Extracts a vector4 component.

• Evaluates a CHOP channel and return its value.

• Evaluates a channel (or parameter) and return its value.

• Evaluates an OBJ node’s transform

• Generates anti-aliased gingham checks similar to a tablecloth pattern.

• Provides outputs that represent all the global variables for the current VOP network type.

• Returns the gradient of a single channel 3D texture image at a specified position within that image.

• Converts HSV color space to RGB color space.

• Generates a normal vector which always faces the camera, parallel to the incidence vector.

• A powerful, highly flexible, general model for hair/fur shading.

• Returns 1 if the specified input (0-3) is connected.

• Returns if a dictionary has a key.

• Computes a mix of high and low frequency, anti-aliased noise with a wide range of applications.

• Cooks a SOP asset for each point in the source geometry and instances the generated curves onto the point.

• Cooks a SOP asset for each point in the source geometry and instances the generated points onto the point.

• Uses the shift value to move the hue of the input color along the color wheel by the amount influenced by the amplitude.

• Positions and orients points from a root position, end effector position target, and twist position using KineFX Inverse Kinematics.

• Passes through the value of the first input if the first input is ultimately connected.

• Only available in Surface VOP networks.

• This procedural will generate an iso-surface from a 3D texture image (.i3d file).

• This procedural will generate a volume from a 3D texture image (.i3d file).

• Imports attribute data from the OP connected to the given input.

• Imports the value of the specified variable from a displacement shader and stores it in var.

• Imports the value of the specified variable from a light shader and stores it in var.

• Imports a color space property from Open Color IO.

• Imports the value of the specified variable sent from a trace() function and stores it in var.

• Imports the value of the specified variable from a surface shader and stores it in var.

• Returns 1 if the point or primitive is in the group specified by the string.

• Internal VOP used to compute indirect lighting.

• Write VEX code that is put directly into your shader or operator definition.

• Inserts an item, array, or string into an array or string.

• Runs hscript for each point in the source geometry and instances the generated geometry to the point.

• Converts an integer value to a float value.

• Computes the intersection of a ray with geometry.

• Computes all the intersections of a ray with geometry.

• If given a 3×3 or 4×4 matrix, this operator computes its inverse (or just returns the input matrix if it detects singularity).

• Computes the irradiance (the global illumination) at the point P with the normal N.

• Result 1 if all the characters in the string are alphabetic.

• Outputs 1 if the input is ultimately connected, otherwise it outputs 0.

• Result 1 if all the characters in the string are numeric.

• Returns 1 if the number is a normal number, ie, not infinite or NAN.

• Returns 1 if the shader is being evaluated from within a fog shader.

• Returns true if the normal of the surface is forward facing, and false if it isn’t.

• Returns 1 if the number is not a number.

• Returns 1 if the shader is being evaluated for shadow rays.

• Concatenate all the strings of an array inserting a common spacer.

• Gets the angle at the given joint in a KineFX skeleton.

• Creates a shading signal for output to an AOV, as well as the render vars.

• Generate a smooth roll-off between surface normal and the camera ray.

• A physically-based hair and fur material with medulla support

• A physically-based hair and fur material.

• Seamless texturing and normal mapping without visible repetitions based on provided UV coordinates.

• Seamless texturing and normal mapping without visible repetitions involving triplanar projections and based on P.

• Karma Light Filter that controls how the light intensity/color changes over distance.

• Karma Light Filter that adds barndoors to a cone light.

• Karma Light Filter that adjusts the color, intensity, or diffuse/specular of a light source.

• Karma Light Filter that projects the light source through a texture.

• You can use this utility node in a light filter network to get the UV coordinates of the current ray in the light’s projection space.

• Apply Karma geometry properties via shaders.

• Transforms color spaces using Open Color IO.

• A pre-made lens shader implementation with controls for most common lens shader effects, such as bokeh, chromatic aberrations, and tilt/shift.

• The stripped down version of the physical lens.

• This node opens a point cloud file and searches for points around a source position then returns a value of geometry attribute imported from pointcloud

• Creates a color value used to control the emission component of volume shading used for fire.

• Creates emission to control the emission component of volume shading used for fire.

• Creates a color value used to control the emission component of volume shading used for explosions.

• Creates emission to control the emission component of volume shading used for explosions.

• Flexible, production-quality smoke, cloud, fire, and explosion shader.

• Creates a color value used to control the scattering and absorption component of volume shading.

• Look up the color/float at a certain index in a ramp.

• Attenuate values based on bounces.

• Imports the value of the specified variable from Karma.

• Generates an interior room map

• Creates a parallax projection of a room interior onto a flat plane

• This is the Karma UV rendering lens shader.

• Karma XPU compatible node for building MaterialX volume shader

• Generates Voronoi noise

• Generates Voronoi noise

• Generates a color using the Lambert diffuse lighting model calculation.

• Combines two layers using standard compositing operations.

• Outputs a mix of the two input layers, blended using the alpha value.

• Creates a Layer from individual shading components.

• Unpacks the individual shading components from a layer.

• Computes the length of an array

• Computes the length of a 3D or 4D vector.

• A VOP that can generate different kinds of bokeh.

• A VOP that can generates the tint and index of refraction for chromatic aberration effects.

• A VOP that creates the jittered coordinates for Karma lens shaders.

• A VOP that generates the offsets required to distort a Karma lens shader.

• A VOP that generates the Karma lens shader inputs.

• A VOP that generates a time offset to simulate rolling shutter in digital lenses.

• A VOP that manipulates the time distribution of lens shutters.

• Performs a lighting model calculation to generate a color.

• Selectively clamps values to a minimum and/or maximum value.

• Computes the natural logarithm function of the argument.

• Computes a 3×3 rotation matrix to orient the z-axis along the vector (to - from) under the transformation.

• Applies a KineFX Look At constraint to a transform.

• Computes the luminance of the RGB color specified by the input parameter.

• Builds a general 4×4 transform matrix derived from the standard copy/instance attributes

• Returns the transformation matrix to transform from a transform space such as an object’s transform space to another space, such as world space.

• Builds a general 4×4 transform matrix.

• Generates a Mandelbrot pattern.

• Creates a dictionary that maps one KineFX point to another.

• Unpacks a 4×4 matrix into its sixteen components.

• Unpacks a 4×4 matrix into its rows.

• Unpacks a 2×2 matrix2 into its four components.

• Converts a 2×2 matrix to a 3×3 matrix.

• Converts a 2×2 matrix to a 4×4 matrix.

• Unpacks a 2×2 matrix into its rows.

• Unpacks a 3×3 matrix3 into its nine components.

• Converts a 3×3 matrix to a 2×2 matrix.

• Converts a matrix3, representing a rotation, to a quaternion representing the same rotation.

• Unpacks a 3×3 matrix into its rows.

• Converts a 4×4 matrix to a 2×2 matrix.

• Implements a matte shader that occludes geometry behind the surface being rendered.

• Computes the maximum value of a vector argument.

• Outputs the maximum value from its inputs.

• Takes a handle generated by the Meta-Loop Start operator and will import attributes…

• Takes a handle generated by the Meta-Loop Start operator and will iterate to the …

• Opens a geometry file and initializes the handle to iterate through all metaballs at the position specified.

• Returns the value of the given point attribute at the specified position in the metaball field.

• Returns the density of the metaball field at the specified position.

• Transforms the specified position into the local space of the metaball.

• Returns the metaweight of the geometry at a given position.

• Returns true if the specified metadata exists.

• Returns metadata from one of the 4 input COPs connected to the VEX COP.

• Represents a method inside a class-based shader.

• Invokes a given method on a given struct or co-shader object.

• Represents a method argument list inside a class-based shader.

• Represents a method inside a class-based shader.

• Computes the minimum value of a vector argument.

• Outputs the minimum value from its inputs.

• Given a position in world space, returns the position of the closest point on a given geometry.

• Computes a blend (or a mix) of its input values using linear interpolation.

• Computes the modulo of two values.

• Constructs a VDF for pure light absorption.

• A new MaterialX Node

• A new MaterialX Node

• Constructs a VDF scattering light for a participating medium.

• Returns the radiant emittance of a blackbody radiator with the given temperature.

• A BSDF node for Burley diffuse reflections.

• 2D cellular noise

• Checkerboard pattern.

• A circle shape.

• Pattern of circles or rings.

• A cloverleaf shape.

• A reflection BSDF node based on a microfacet model and a Fresnel curve for conductors/metals.

• Increase or decrease contrast of incoming float/color values using a linear slope multiplier.

• A cross-hatch pattern.

• A reflection/transmission BSDF node based on a microfacet model and a Fresnel curve for dielectrics.

• A constructor node for the displacement shader.

• Measure distance between two points.

• Generate a smooth roll-off between two vectors.

• Zero-centered 3D Fractal noise.

• A new MaterialX Node

• A new MaterialX Node

• A new MaterialX Node

• A reflection/transmission BSDF node based on a microfacet model and a generalized Schlick Fresnel curve.

• A fresnel EDF.

• A new MaterialX Node

• A new MaterialX Node

• A new MaterialX Node

• A new MaterialX Node

• A grid pattern.

• A hexagon shape.

• Adjust the hue, saturation and value of a color.

• Samples data from a single image, or from a layer within a multi-layer image.

• A new MaterialX Node

• A new MaterialX Node

• A line shape.

• Output a grayscale luminance of a color.

• Constructs an EDF emitting light according to a measured IES light profile.

• 3D Perlin noise.

• A BSDF node for diffuse reflections.

• Texture sets for MtlX Standard Surface.

• Transform incoming UV texture coordinates for 2D texture placement.

• Random RGB color pattern.

• Random float pattern.

• A new MaterialX Node

• Rotate a vector2 value about the origin in 2D.

• Adjust the saturation of a color.

• A microfacet BSDF for the back-scattering properties of cloth-like materials.

• A new MaterialX Node

• A new MaterialX Node

• A new MaterialX Node

• Translation shader from Standard Surface to USD Preview Surface.

• A BSDF for true subsurface scattering.

• Constructs a surface shader describing light scattering and emission for closed 'thick' objects.

• An unlit surface shader node.

• Adds an iridescent thin film layer over a microfacet base BSDF.

• A constructor node for two-sided objects.

• A tiled-circle pattern.

• A tiled-cloverleaf pattern.

• A tiled-hexagon pattern.

• Samples data from a single image, with provisions for tiling and offsetting the image across uv space.

• A BSDF node for pure diffuse transmission.

• A triangle-wave pattern.

• Manually set UDIM texture coordinates.

• Extract the UDIM patch from texture coordinates.

• MaterialX flavor of USD Preview Surface shader

• MaterialX flavor of USD Primvar Reader

• MaterialX flavor of USD Transform 2D shader

• MaterialX flavor of USD UV Texture shader

• MaterialX flavor of USD UV Texture 2.3 shader

• An EDF node for uniform emission.

• A constructor node for the volume shader type.

• A volume material.

• A PBR shader from glTF-2.0.

• A new MaterialX Node

• Returns complementary float value.

• Returns complementary RGB color

• Outputs the product of its inputs.

• Multiplies the incoming value by a constant.

• Finds closest point in a given geometry file.

• Negates the incoming integer, float, vector or vector4 value.

• Count the number of connected points from a given point in a given geometry file (or op:path)

• Finds the nth neighbouring point for a given point in a given geometry file.

• Retrieves an array of indices to the points connected to the given point.

• A non-deterministic random number generator.

• Generates a falloff value based on the relationship between the normal and incident vectors.

• Normalizes a vector.

• This operator performs a logical not operation on an integer value, returning 1 if the input is zero, and 0 if the input is non-zero.

• Passes the inputs to the output with an optional name change.

• Transforms color spaces using OpenColorIO.

• Transforms color spaces into a View using OpenColorIO.

• Computes ambient occlusion at the point P with the normal N.

• Sample ocean values from layered ocean spectra at the specified position and time.

• Offsets a KineFX transformation matrix by the given transform.

• Returns the number of coarse faces in the subdivision hull

• Returns the patch of the first patch for a given face in the subdivision hull.

• Evaluates a point attribute on the limit of a subdivision surface.

• Outputs the Houdini face and UV coordinates corresponding to the given coordinates on an OSD patch.

• Outputs the OSD patch and UV coordinates corresponding to the given coordinates on a Houdini polygon face.

• Returns the number of patches in the subdivision hull

• This operator performs a logical or operation between its inputs and returns 1 or 0 .

• Generates a color using the Oren-Nayar diffuse lighting model calculation.

• Reorients a vector representing a direction by multiplying it by a 4×4 transform matrix.

• Returns an anti-aliased cosine or sine wave.

• Computes the outer product of a pair of vectors.

• Provides inputs representing the writable output variables of the shader network.

• Makes a shaded surface emissive.

• Produce a hair BSDF.

• Produce a hair BSDF.

• Produce a hair BSDF.

• Evaluate Lighting Using PBR.

• Computes metallic reflections.

• Computes reflections and refractions for dielectric (non-metallic) materials.

• Creates an approximate SSS BSDF.

• Creates a Single Subsurface Scatter BSDF.

• Represents a user-controllable parameter.

• Blends between KineFX transforms with an offset computed from the given bind transforms.

• Constrains a KineFX point’s parent to a new world transform.

• Generates 1D and 3D Perlin noise from 1D, 3D and 4D data.

• Computes 1D, 3D, and 4D tileable Worley noise, which is synonymous with cell noise.

• Performs photon russian roulette.

• Outputs surface color based on a physically-based subsurface scattering model. This node an do physically correct single scattering and/or multiple scattering.

• Produce a normalized diffuse bsdf.

• Returns the area of the current pixel after being transformed to the new UV coordinate uvpos.

• Returns U and V derivatives of the current pixel.

• Clips the line segment defined by p1 and p2 against the 3D plane defined by the following equation: plane.

• Returns the number of planes in the input.

• Returns the name of the plane with the index plane_index in input input_index.

• Returns the index of the plane with the name plane_index in input input_index.

• Returns the name of the plane with the index plane_index in input input_index.

• Returns the number of components in the plane with the index plane_index in input input_index.

• Returns two vectors representing the minimum and maximum corners of the bounding box for the specified geometry.

• This node closes a point cloud handle opened by pcopen.

• This node exports point data while inside a pcunshaded loop.

• This node finds the farthest query point produced by pcopen.

• This node filters the points queried by pcopen.

• Returns a list of closest points from a file

• Returns a list of closest points from a file taking into account their radii.

• This node imports point data while inside a pciterate or pcunshaded loop.

• This node imports point data from a pcopen.

• This node advances to the next iteration point returned by pcopen.

• This node returns the number of points found by pcopen.

• This node opens a point cloud file and searches for points around a source position.

• This node advances to the next unshaded iteration point returned by pcopen.

• This function writes data for the current shading point out to a point cloud file.

• Returns the number of points for all primitives in the given geometry.

• Returns 1 if the point specified by the point number is in the group specified by the string.

• The underlying procedural when using Fast Point Instancing with the instance render parameters.

• Only available in Image3D VOP networks.

• The Point Replicate Procedural takes a number of input points and multiplies them, and processes the result using a CVEX script.

• Removes the last element of an array and returns it.

• Compute the difference between point transforms on two SOP skeletons.

• Raises the first argument to the power of the second argument.

• Evaluates an attribute for a given primitive at the specified uv parametric location.

• Evaluates an intrinsic on a given primitive.

• Returns the normal of a primitive (defined by its number) at the given uv parametric location.

• An artist-friendly shader that can model a large number of materials realistically.

• An artist-friendly shader that can model a large number of materials realistically.

• Generate a formatted text string.

• Promotes the export variables from the Shader Layer struct to the parent shader

• Converts a temperature value into color (chroma) and intensity according to the blackbody radiation model.

• Provides color correction functions.

• Provides constant, artistic, and physically correct (blackbody) tint as well as color correction functions.

• Provides functions for editing color fields by conditioning the field values, adding noise, filtering, and color correction.

• Provides functions for editing fields such as density by conditioning the field values, adding noise, and filtering.

• Flexible, production-quality smoke, fire, and explosions shader.

• Flexible, production-quality fire and smoke shader.

• Provides the core functionality needed to build a high-quality volumetric shader.

• Takes an angle and an axis and constructs the quaternion representing the rotation about that axis.

• Computes the conjugate of a quaternion.

• Computes distance between quaternions in radians.

• Takes an quaternion inverts it..

• Performs a quaternion multiplication with its two inputs.

• Converts a quaternion to angle/axis form.

• Converts a quaternion to a vector representing euler angles.

• Converts a vector4, representing a quaternion, to a matrix3 value, representing the same rotation.

• Converts RGB color space to HSV color space.

• Sends rays into the scene and contains a subnetwork of VOPs to operate on the information gathered from the shaders of surfaces hit by the rays.

• Generates a non-repeating rainbow color ramp by modulating the hue over the range of the parametric coordinate s and using the given saturation and value to compute the HSV color.

• Adds anti-aliased analytical filtering to the output of a Ramp Parameter VOP.

• Represents a user-editable ramp parameter.

• Generates repeating filtered ramps.

• Generates a random number based on the position in one, three, or four dimensions.

• Generates a random number in a BRJ sequence.

• Generates a random number in a Sobol sequence.

• Returns the current ray-bounce level.

• Returns the amount that the current bounce level will contribute to the final pixel color.

• This operator sends a ray from the position P along the direction specified by the direction D, and returns the distance to the object intersected or a negative number if not object found.

• Sends a ray starting at origin P and in the direction specified by the normalized vector D.

• Propagates rotation from the arm to the clavicle point in a KineFX skeleton.

• Returns the vector representing the reflection of the direction against the normal vector.

• Computes the amount of reflected light which hits the surface.

• Computes the refraction ray given an incoming direction, the normalized normal and an index of refraction.

• Sends a ray starting at origin P and in the direction specified by the normalized vector I.

• Finds the given regular expression in the string.

• Finds all instances of the given regular expression in the string.

• Result 1 if the entire input string matches the expression.

• Replaces instances of find_regex with replace_regex.

• Splits the given string based on regex match.

• Returns the relative position of the point given with respect to the bounding box of the specified geometry.

• Returns the relative position of the point given with respect to the bounding box of the specified geometry.

• Removes an item at the given index from an array.

• Removes an item at the given key from a dictionary.

• Removes points from the geometry.

• Removes an item from an array.

• Gets state information from the renderer.

• Reorders items in an array or string.

• Optionally report a custom VEX error or warning.

• Modulates input value using a variety of methods.

• Returns the pixel resolution of an input.

• Resolves a mapping dictionary attribute to a KineFX point number.

• Checks if the geometry attribute rest is bound and, if so, uses it as the rest position for shading.

• Generates a return statement inside a method or a function defined by the parent subnet.

• Adds an item to an array or string.

• Rotates the foot around custom pivots specific to a reverse foot KineFX set-up.

• Generates repeating filtered rings.

• Generates repeating ripples.

• Applies a rotation by 'angle' radians to the given 3×3 or 4×4 matrix.

• Rotates a vector by a quaternion.

• Rounds the argument to the closest integer.

• Generates repeating filtered rounded hexagons.

• Generates repeating filtered rounded five-pointed stars.

• This procedural will run an external application in order to generate geometry at render time.

• Adds energy conservation functionality and additional controls to the Physical SSS VOP.

• Samples the interior or surface of the unit circle, sphere, or hypersphere, within a max angle of a direction.

• Scales a 3×3 or 4×4 matrix by 'amount' units along the x,y, and z axes.

• Generates a scale-like pattern and returns the displaced position, normal, and displacement amount.

• Requests the rendered color from a specified direction

• Returns an average direction, color, depth, and strength.

• Renders the surrounding environment

• Requests the rendered depth from a specified direction

• Saves the rendered panorama to a specified output file

• Saves sensor data to image files.

• Sets the current animation clips for an agent primitive.

• Sets the current times for an agent primitive’s animation clips.

• Sets the blend weights for an agent primitive’s animation clips.

• Sets the current layers or collision layers of an agent primitive.

• Overrides the transforms of an agent primitive.

• Sets a CHOP attribute value.

• Sets a transform value when evaluating a Channel VOP in Tranlate/Rotate/Scale mode.

• Sets a channel value when evaluating a Channel VOP in Channel/Sample modes.

• Sets the value at the specified key.

• Sets the element at the specified index.

• Sets a layer’s components to new values.

• Assigns a value to one of the matrix’s components.

• Assigns a value to one of the matrix2's components.

• Assigns a value to one of the matrix3's components.

• Sets one point transform at a given point ID.

• Sets arrays of point transforms at an array of point IDs.

• Assigns a value to one of the vector’s components.

• Assigns a value to one of the vector2's components.

• Assigns a value to one of the vector4's components.

• Represents export parameters in a shader call.

• Represents global variables that are bound as output parameters in a shader call.

• Computes the shading area of the given variable.

• Computes the derivative of a given variable with respect to the s or t parametric coordinate.

• Creates a parameter to appear in the signature of the VEX function defined by the VOP network (VOPNET).

• Computes the normal at the location specified by the P position.

• Shadow Map treats the depth map as if the image were rendered from a light source.

• Implements a shadowmatte shader that occludes geometry behind the surface being rendered.

• Returns -1 if the input is less than 0, otherwise it returns 1.

• Performs a sine function.

• A skin shader with three levels of subsurface scattering.

• Creates a sky noise pattern with volumetric clouds.

• Slices a sub-string or sub-array of a string or array.

• Computes a number between zero and one.

• Returns the closest equivalent Euler rotations to a reference rotation.

• Runs a VEX snippet to modify the incoming values.

• Increases or decreases contrast for values at the top of the input range.

• Generates repeating soft dots.

• Returns the array sorted in increasing order.

• Generates a color using the selected specular lighting model calculation.

• Generates a color using a specular lighting model with a Fresnel falloff calculation.

• Computes a spherical linear interpolation between its two quaternion inputs, and outputs the intermediate quaternion.

• Generates a splatter pattern and returns the splatter amount.

• Computes either a Catmull-Rom (Cardinal) spline or a Linear spline between the specified key points, given an interpolant (u) in the domain of the spline.

• Splits a string into tokens.

• This procedural will render points as sprites.

• Computes the square root of the argument.

• Result 1 if the string starts with the specified string.

• Stashes a KineFX transform matrix as a constant.

• Returns the length of the string.

• Converts an UTF8 string into a codepoint.

• Strips leading and trailing whitespace from a string.

• Generates repeating filtered stripes.

• Creates, modifies, or de-structures an instance of a structured datatype.

• Bundles input values into an instance of an ad-hoc struct.

• Extracts one or more values from a struct by member name.

• Contains other VOP operators.

• Represents an input or an output (or both) of the parent VOP subnet.

• Allows the connection of operators outside a subnet to operators inside the subnet.

• Allows the connection of operators inside a subnet to operators outside the subnet.

• Outputs the result of subtracting all its inputs.

• Subtracts the specified constant value from the incoming integer, float, vector or vector4 value.

• Generates a basic color with a choice of tinting with the point color and/or a color map.

• Finds the shortest distance between a point and a source point group.

• Switches between network branches based on the value of an input.

• Use a different bsdf for direct or indirect lighting.

• Rearranges components of a vector.

• Rearranges components of a vector2.

• Rearranges components of a vector4.

• Performs a tangent function.

• Transform an input normal to UV/tangent space

• Transform an input normal from UV/tangent to current space

• Exports shader normals as a render plane.

• Returns primitive number of an adjacent tetrahedron.

• Returns vertex indices of each face of a tetrahedron.

• Computes a filtered sample of the texture map specified and returns an RGB or RGBA color.

• Returns the value of a 3D image at a specified position within that image.

• Queries the 3D texture map specified and returns the bounding box information for the given channel in the min and max corner vectors.

• Computes the thin film reflection and refraction contributions given a normalized incident ray, a normalized surface normal, and an index of refraction.

• Generates staggered rectangular tiles.

• Generates staggered hexagonal tiles.

• Returns the frame range and rate of the given input.

• Returns a string that is the titlecase version of the input string.

• Returns a string that is the lower case version of the input string.

• Transforms a position into normal device coordinates.

• Converts cartesian coordinates to polar coordinates.

• Returns a string that is the upper case version of the input string.

• Uses the vex gather function to send a ray and return with the reflected or refracted colors.

• Transforms a vector to or from an object’s transform space, or one of several other spaces, such as world or camera space.

• Constructs a KineFX transform matrix from a position on a path.

• Constructs a KineFX transform matrix from a position on a geometry’s surface.

• Translates a 4×4 matrix 'amount' units along the x,y,z and possibly w axes.

• Performs a variety of trigonometric functions.

• Can compute three types of 1D and 3D noise with the ability to compute turbulence with roughness and attenuation.

• Perform a simple two-bone IK solve

• Generates a two sided surface.

• Takes an integer input.

• Provides outputs representing commonly used input variables for processing USD primitive attributes inside an Attribute VOP LOP.

• Represents a standard USD primitive for transforming texture co-ordinates.

• Represents a standard USD primitive for looking up texture values.

• Returns texture coordinates or geometric s and t, depending on what is defined.

• Disturbs the incoming parametric s and t coordinates using anti aliased noise generated from the Surface Position input.

• Computes UV co-ordinates projected along a single axis, derived from the position of an object, and generates a mask relative to the projection axis.

• Assigns texture coordinates based on the specified projection type.

• Transforms texture coordinates by the inverse of the matrix consisting of the translation, rotation, and scale amounts.

• Projects texture maps along X, Y, and Z axes and blends them together at the seams.

• Generates a 2D, wave like cloud pattern.

• Presents a unified interface and uniform output range for all the noise types available in VEX.

• Presents a unified interface and uniform output range for all the noise types available in VEX.

• Provides outputs that represent all the global variables for the Force VOP network type.

• Simple output variable for VOP Force Networks.

• Converts between different vector types.

• Unpacks a vector into its three components.

• Takes an angle/axis vector and constructs the quaternion representing the rotation about that axis.

• Converts a vector to a vector4.

• Converts rows values to a 3×3 matrix value.

• Converts a vector to a vector2 and also returns the third component of the vector.

• Unpacks a vector2 into its two components.

• Converts a vector2 to a vector.

• Converts a pair of vector2s into a vector4.

• Converts rows values to a 2×2 matrix value.

• Unpacks a vector4 into its four components.

• Converts rows values to a 4×4 matrix value.

• Converts a vector4 to a vector and also returns the fourth component of the vector4.

• Converts a vector4 to a pair of vector2s..

• Generates an anti-aliased vein pattern that can be used in any VEX context.

• This procedural will generate a volume from a CVEX shader.

• Exports a vis_ prefixed attribute.

• Computes the opacity of a uniform volume given a density.

• Calculates the gradient of a volume primitive stored in a disk file.

• Gets the value of a voxel from a volume primitive stored in a disk file.

• Calculates the position of a voxel in a volume primitive stored in a disk file.

• Gets the vector value of a voxel from a volume primitive stored in a disk file.

• A shading model for volume rendering.

• Calculates the voxel closest to a voxel of a volume primitive stored in a disk file.

• Gets the resolution of a volume primitive stored in a disk file.

• Samples the value of a volume primitive stored in a disk file.

• Samples the vector value of a volume primitive stored in a disk file.

• Provides outputs that represent all the global variables for the Volume VOP network type.

• Simple output variable for Volume VOP Networks.

• Computes 1D, 3D, and 4D Voronoi noise, which is similar to Worley noise but has additional control over jittering.

• Computes the wave vector for a given index in a grid of specified size.

• Simulates rolling waves with choppiness of various frequencies, and outputs the positional and normal displacements as well as the amount of displacement.

• Returns float between 0 and 1 which defines a wire grid pattern useful for simulating screens or visualizing parametric or texture coordinates.

• Computes 1D, 3D, and 4D Worley noise, which is synonymous with cell noise.

• Simplified smoke, fire, and explosions shader for Karma XPU.

• Finds closest position on a primitive in a given geometry file.

• Performs a logical xor operation between its inputs.

• Returns the indices of a sorted version of an array.

• Blends the normals between faces within specified radius.