- 
        
            
        
        
            
                APEX Add Groom
            
         Adds a groom to an existing APEX Character. 
- 
        
            
        
        
            
                APEX Add ML Deformer
            
         Procedurally add a ML Deformer to an APEX rig 
- 
        
            
        
        
            
                APEX Add Wrinkles
            
         Procedurally add a Wrinkle Deformer to an APEX rig 
- 
        
            
        
        
            
                APEX Animation from Skeleton
            
         Adds animation from a source skeleton to an animation scene. 
- 
        
            
        
        
            
                APEX Autorig Builder
            
         Interactively applies and configures rig components in the viewport. 
- 
        
            
        
        
            
                APEX Autorig Component
            
         Procedurally adds a rig component to an APEX rig. 
- 
        
            
        
        
            
                APEX Build FK Graph
            
         Creates an FK rig APEX graph from skeleton geometry. 
- 
        
            
        
        
            
                APEX Configure Character
            
         Configures the character-level properties of an APEX character. 
- 
        
            
        
        
            
                APEX Configure Controls
            
         Configures the look and behavior of controls on APEX rigs. 
- 
        
            
        
        
            
                APEX Configure Graph
            
         Configure the parameters and bindings for a constraint or component graph. 
- 
        
            
        
        
            
                APEX Control Extract
            
         Extracts APEX rig controls to a KineFX skeleton. 
- 
        
            
        
        
            
                APEX Control Update Parms
            
         Computes TRS parameters for an APEX rig from a KineFX skeleton. 
- 
        
            
        
        
            
                APEX Graph
            
         Directly authors APEX graphs. 
- 
        
            
        
        
            
                APEX Invoke Graph
            
         Invokes an APEX graph with the connected inputs, and fetches the results. 
- 
        
            
        
        
            
                APEX Layout Graph
            
         Lays out the nodes in an APEX graph. 
- 
        
            
        
        
            
                APEX Map Character
            
         Stores a reference on an APEX control to a point in a skeleton geometry. 
- 
        
            
        
        
            
                APEX Merge Graph
            
         Merges together two APEX graphs. 
- 
        
            
        
        
            
                APEX Pack Character
            
         Packs a character’s skin, rest pose, and animated pose into a character folder structure. 
- 
        
            
        
        
            
                APEX Scene Add Animation
            
         Adds animation to an animation scene. 
- 
        
            
        
        
            
                APEX Scene Add Character
            
         Adds a new character to an animation scene. 
- 
        
            
        
        
            
                APEX Scene Add Prop
            
         Adds a prop with a single control to an animation scene. 
- 
        
            
        
        
            
                APEX Scene Animate
            
         Edits the animation on an APEX scene. 
- 
        
            
        
        
            
                APEX Scene Copy Animation
            
         Copies the animation in an animation scene. 
- 
        
            
        
        
            
                APEX Scene Invoke
            
         Evaluates geometry from an APEX scene. 
- 
        
            
        
        
            
                APEX Script
            
         Executes code snippets written with the APEX Script syntax. 
- 
        
            
        
        
            
                APEX Unpack Character
            
         Unpacks a character and outputs its skin, capture pose, and animated pose. 
- 
        
            
        
        
            
                Adapt to Terrain
            
         Adapts a character’s skeleton to conform to terrain. 
- 
        
            
        
        
            
                Adaptive Prune
            
         Removes elements while trying to maintain the overall appearance. 
- 
        
            
        
        
            
                Add
            
         Creates Points or Polygons, or adds points/polys to an input. 
- 
        
            
        
        
            
                Agent
            
         Creates agent primitives. 
- 
        
            
        
        
            
                Agent Animation Unpack
            
         Extracts animation or MotionClips from an agent primitive. 
- 
        
            
        
        
            
                Agent Character Unpack
            
         Extracts the rest geometry, skeleton, and animation from an agent primitive. 
- 
        
            
        
        
            
                Agent Clip
            
         Adds new clips to agent primitives. 
- 
        
            
        
        
            
                Agent Clip Properties
            
         Defines how agents' animation clips should be played back. 
- 
        
            
        
        
            
                Agent Clip Transition Graph
            
         Creates geometry describing possible transitions between animation clips. 
- 
        
            
        
        
            
                Agent Collision Layer
            
         Creates a new agent layer that is suitable for collision detection. 
- 
        
            
        
        
            
                Agent Configure Joints
            
         Creates point attributes that specify the rotation limits of an agent’s joints. 
- 
        
            
        
        
            
                Agent Constraint Network
            
         Builds a constraint network to hold an agent’s limbs together. 
- 
        
            
        
        
            
                Agent Definition Cache
            
         Writes agent definition files to disk. 
- 
        
            
        
        
            
                Agent Edit
            
         Edits the properties of agent primitives. 
- 
        
            
        
        
            
                Agent Layer
            
         Adds new shapes and layers to an agent primitive. 
- 
        
            
        
        
            
                Agent Look At
            
         Adjusts the agent’s skeleton to look at a target. 
- 
        
            
        
        
            
                Agent Metadata
            
         Adds custom data to an agent definition. 
- 
        
            
        
        
            
                Agent Pose from Rig
            
         Updates an agent primitive’s pose from a geometry skeleton. 
- 
        
            
        
        
            
                Agent Prep
            
         Adds various common point attributes to agents for use by other crowd nodes. 
- 
        
            
        
        
            
                Agent Proxy
            
         Provides simple proxy geometry for an agent. 
- 
        
            
        
        
            
                Agent Relationship
            
         Creates parent-child relationships between agents. 
- 
        
            
        
        
            
                Agent Terrain Adaptation
            
         Adapts agents' legs to conform to terrain and prevent the feet from sliding. 
- 
        
            
        
        
            
                Agent Transform Group
            
         Adds new transform groups to agent primitives. 
- 
        
            
        
        
            
                Agent Unpack
            
         Extracts geometry from agent primitives. 
- 
        
            
        
        
            
                Agent Vellum Unpack
            
         Extracts geometry from agent primitives for a Vellum simulation. 
- 
        
            
        
        
            
                Agent from Rig
            
         Creates an agent primitive from a geometry skeleton. 
- 
        
            
        
        
            
                Alembic
            
         Loads the geometry from an Alembic scene archive (.abc) file into a geometry network. 
- 
        
            
        
        
            
                Alembic Group
            
         Creates a geometry group for Alembic primitives. 
- 
        
            
        
        
            
                Alembic Primitive
            
         Modifies intrinsic properties of Alembic primitives. 
- 
        
            
        
        
            
                Alembic ROP output driver
            
         
- 
        
            
        
        
            
                Armature Capture
            
         Represent a pose as a float point attribute. 
- 
        
            
        
        
            
                Armature Deform
            
         Map a pose to a simulated skin. 
- 
        
            
        
        
            
                Assemble
            
         Cleans up a series of break operations and creates the resulting pieces. 
- 
        
            
        
        
            
                Association Select
            
         Select a single association from a set of associations 
- 
        
            
        
        
            
                Attach Joint Geometry
            
         Creates control geometry for SOP-based KineFX rigs. 
- 
        
            
        
        
            
                Attribute Adjust Array
            
         Modifies array attribute values. 
- 
        
            
        
        
            
                Attribute Adjust Color
            
         Modifies values for a vector-type color attribute on the incoming geometry. 
- 
        
            
        
        
            
                Attribute Adjust Dictionary
            
         Modifies dictionary attribute values. 
- 
        
            
        
        
            
                Attribute Adjust Float
            
         Modifies floating point attribute values on the incoming geometry. 
- 
        
            
        
        
            
                Attribute Adjust Integer
            
         Modifies integer attribute values on the incoming geometry. 
- 
        
            
        
        
            
                Attribute Adjust Vector
            
         Modifies values for a vector-type attribute on the incoming geometry. 
- 
        
            
        
        
            
                Attribute Blur
            
         Blurs out (or relaxes) points in a mesh or a point cloud. 
- 
        
            
        
        
            
                Attribute Cast
            
         Changes the size/precision Houdini uses to store an attribute. 
- 
        
            
        
        
            
                Attribute Combine
            
         Combines multiple attributes into a new attribute. 
- 
        
            
        
        
            
                Attribute Composite
            
         Composites vertex, point, primitive, and/or
detail attributes between two or more selections. 
- 
        
            
        
        
            
                Attribute Copy
            
         Copies attributes between groups of vertices,
points, or primitives. 
- 
        
            
        
        
            
                Attribute Create
            
         Adds or edits user defined attributes. 
- 
        
            
        
        
            
                Attribute Delete
            
         Deletes point and primitive attributes. 
- 
        
            
        
        
            
                Attribute Expression
            
         Allows simple VEX expressions to modify attributes. 
- 
        
            
        
        
            
                Attribute Fade
            
         Fades a point attribute in and out over time. 
- 
        
            
        
        
            
                Attribute Fill
            
         A low-level node that can solve combinatorial versions of some partial differential equations on an edge-connected point cloud. 
- 
        
            
        
        
            
                Attribute From Pieces
            
         Assigns an attribute to points specifying which of a set of models should be copied/instanced to that point, randomly or based on various rules. 
- 
        
            
        
        
            
                Attribute Interpolate
            
         Interpolates attributes within primitives or based on explicit weights. 
- 
        
            
        
        
            
                Attribute Mirror
            
         Copies and flips attributes from one side of a mirror to the other
side. 
- 
        
            
        
        
            
                Attribute Noise
            
         Adds or generates noise in geometry attributes. 
- 
        
            
        
        
            
                Attribute Paint
            
         Interactively paint point attributes, such as color or deformation mask values, directly on geometry. 
- 
        
            
        
        
            
                Attribute Promote
            
         Promotes or demotes attributes from one geometry level to another. 
- 
        
            
        
        
            
                Attribute Randomize
            
         Generates random attribute values of various distributions. 
- 
        
            
        
        
            
                Attribute Remap
            
         Fits an attribute’s values to a new range. 
- 
        
            
        
        
            
                Attribute Rename
            
         Renames or deletes point and primitive attributes. 
- 
        
            
        
        
            
                Attribute Reorient
            
         Modifies point attributes based on differences between two models. 
- 
        
            
        
        
            
                Attribute Sort
            
         Sorts a component of an attribute. 
- 
        
            
        
        
            
                Attribute String Edit
            
         Edits string attribute values. 
- 
        
            
        
        
            
                Attribute Swap
            
         Copies, moves, or swaps the contents of attributes. 
- 
        
            
        
        
            
                Attribute Transfer
            
         Transfers vertex, point, primitive, and/or
detail attributes between two models. 
- 
        
            
        
        
            
                Attribute Transfer by UV
            
         Transfers attributes between two geometries based on UV proximity. 
- 
        
            
        
        
            
                Attribute Transform Compute
            
         Computes transform matrices using vector and matrix point attributes. 
- 
        
            
        
        
            
                Attribute Transform Extract
            
         Decomposes transform point attributes into their component pieces and applies an Euler filter to the rotation component 
- 
        
            
        
        
            
                Attribute VOP
            
         Runs a VOP network to modify geometry attributes. 
- 
        
            
        
        
            
                Attribute Wrangle
            
         Runs a VEX snippet to modify attribute values. 
- 
        
            
        
        
            
                Attribute from Map
            
          Samples texture map information to a point attribute. 
- 
        
            
        
        
            
                Attribute from Parameters
            
         Creates a dictionary attribute filled with parameter values. 
- 
        
            
        
        
            
                Attribute from Volume
            
         Copies information from a volume onto the point attributes of
another piece of geometry, with optional remapping. 
- 
        
            
        
        
            
                Bake GSplat
            
         Converts to Houdini’s GSplat Attributes. 
- 
        
            
        
        
            
                Bake ODE
            
         Converts primitives for ODE and Bullet solvers. 
- 
        
            
        
        
            
                Bake Volume
            
         Computes lighting values within volume primitives 
- 
        
            
        
        
            
                Ballistic Path
            
         Generates ballistic projectile paths from the incoming points. 
- 
        
            
        
        
            
                Bend
            
         Applies deformations to captured geometry such as bend, twist, taper, and squash/stretch. 
- 
        
            
        
        
            
                Blast
            
         Deletes primitives, points, edges or breakpoints. 
- 
        
            
        
        
            
                Blend Shapes
            
         Computes a 3D metamorphosis between shapes with the same topology. 
- 
        
            
        
        
            
                Block Begin
            
         The start of a looping block. 
- 
        
            
        
        
            
                Block Begin Compile
            
         The start of a compile block. 
- 
        
            
        
        
            
                Block End
            
         The end/output of a looping block. 
- 
        
            
        
        
            
                Block End Compile
            
         The end/output of a compile block. 
- 
        
            
        
        
            
                Bone Capture
            
         Supports Bone Deform by assigning capture weights to bones. 
- 
        
            
        
        
            
                Bone Capture Biharmonic
            
         Supports Bone Deform by assigning capture weights to points based on biharmonic functions on tetrahedral meshes. 
- 
        
            
        
        
            
                Bone Capture Lines
            
         Utility node that supports Bone Capture Biharmonic by creating lines from bones with suitable attributes. 
- 
        
            
        
        
            
                Bone Capture Proximity
            
         Supports Bone Deform by assigning capture weights to points based on distance to bones. 
- 
        
            
        
        
            
                Bone Deform
            
         Uses capture attributes created from bones to deform geometry according to their movement. 
- 
        
            
        
        
            
                Bone Link
            
         Creates default geometry for Bone objects. 
- 
        
            
        
        
            
                Boolean
            
         Combines two polygonal objects with boolean operators, or finds the intersection lines between two polygonal objects. 
- 
        
            
        
        
            
                Boolean Fracture
            
         Fractures the input geometry using cutting surfaces. 
- 
        
            
        
        
            
                Bound
            
         Creates a bounding box, sphere, or rectangle for the input geometry. 
- 
        
            
        
        
            
                Box
            
         Creates a cube or six-sided rectangular box. 
- 
        
            
        
        
            
                Bulge
            
         Deforms the points in the first input using one or more magnets
from the second input. 
- 
        
            
        
        
            
                COP Network
            
         Imports COP network layers as geometry. 
- 
        
            
        
        
            
                COP Preview Material
            
         Applies a preview material to geometry. 
- 
        
            
        
        
            
                COP2 Network
            
         Imports 2d geometry from a Composite network. 
- 
        
            
        
        
            
                Cache
            
         Records and caches its input geometry for faster playback. 
- 
        
            
        
        
            
                Cache If
            
         Chooses whether to cook the input or re-use cached output based on configurable conditions. 
- 
        
            
        
        
            
                Capture Attribute Pack
            
         Converts array attributes into a single index-pair capture attribute. 
- 
        
            
        
        
            
                Capture Attribute Unpack
            
         Converts a single index-pair capture attribute into per-point and detail array attributes. 
- 
        
            
        
        
            
                Capture Correct
            
         Adjusts capture regions and capture weights. 
- 
        
            
        
        
            
                Capture Layer Paint
            
         Lets you paint capture attributes directly onto geometry. 
- 
        
            
        
        
            
                Capture Mirror
            
         Copies capture attributes from one half of a symmetric model to the other. 
- 
        
            
        
        
            
                Capture Override
            
         Overrides the capture weights on individual points. 
- 
        
            
        
        
            
                Capture Packed Geometry
            
         Rigidly captures packed geometry to a SOP skeleton. 
- 
        
            
        
        
            
                Capture Region
            
         Supports Capture and Deform operation by creating a volume within which
points are captured to a bone. 
- 
        
            
        
        
            
                Carve
            
         Slices, cuts or extracts points or cross-sections from a
primitive. 
- 
        
            
        
        
            
                Chain
            
         Repeats one or more pieces of geometry along a curve. 
- 
        
            
        
        
            
                Channel
            
         Reads sample data from a chop and converts it into point positions
and point attributes. 
- 
        
            
        
        
            
                Channel Primitives from MotionClip
            
         Generates a collection of channel primitives from a MotionClip geometry. 
- 
        
            
        
        
            
                Character Blend Shape Channels
            
         Creates node parameters and/or detail attributes on the character’s skeleton to drive its blend shapes. 
- 
        
            
        
        
            
                Character Blend Shapes
            
         Applies blend shapes to a KineFX character’s geometry using the weight attributes on its skeleton. 
- 
        
            
        
        
            
                Character Blend Shapes Add
            
         Adds blend shapes to a character’s skin geometry. 
- 
        
            
        
        
            
                Character Blend Shapes Extract
            
         Outputs one of a character mesh’s blend shapes. 
- 
        
            
        
        
            
                Character I/O
            
         Packs Character mesh, capture pose and animation, saves them to disk, and loads them back again. 
- 
        
            
        
        
            
                Character Pack
            
         Creates a packed geometry primitive from a rest geometry, skeleton, and animation inputs. 
- 
        
            
        
        
            
                Character Unpack
            
         Extracts the rest geometry, skeleton, and animation from an packed geometry primitive. 
- 
        
            
        
        
            
                Circle
            
         Creates open or closed arcs, circles and ellipses. 
- 
        
            
        
        
            
                Circle Spline
            
         Evaluate and resample blended interpolating splines defined by one or more control polygons. 
- 
        
            
        
        
            
                Circle from Edges
            
         Transforms selected geometry into a circle. 
- 
        
            
        
        
            
                Clean
            
         Helps clean up dirty models. 
- 
        
            
        
        
            
                Clip
            
         Removes or groups geometry on one side of a plane,
or creases geometry along a plane. 
- 
        
            
        
        
            
                Cloth Capture
            
         Captures low-res simulated cloth. 
- 
        
            
        
        
            
                Cloth Deform
            
         Deforms geometry captured by the Cloth Capture SOP. 
- 
        
            
        
        
            
                Cloud Adjust Density Profile
            
         Controls the volume density based on a signed distance field. 
- 
        
            
        
        
            
                Cloud Billowy Noise
            
         Applies a billowy cloud like displacement noise to a fog volume. 
- 
        
            
        
        
            
                Cloud Clip
            
         Splits a fog volume in half using a clipping plane. 
- 
        
            
        
        
            
                Cloud Light
            
         Fills a volume with a diffuse light. 
- 
        
            
        
        
            
                Cloud Noise
            
         Applies a cloud like noise to a Fog volume. 
- 
        
            
        
        
            
                Cloud Shape Generate
            
         Creates primitive spheres used to model cumulus cloud-like shapes. 
- 
        
            
        
        
            
                Cloud Shape Replicate
            
         Generates primitive spheres used to model cumulus cloud-like shapes around existing primitive spheres. 
- 
        
            
        
        
            
                Cloud Shape from Intersection
            
         Creates primitive spheres used to model cumulus cloud-like shapes at geometry intersection. 
- 
        
            
        
        
            
                Cloud Shape from Line
            
         Creates primitive spheres used to model cumulus cloud-like shapes around a line primitive. 
- 
        
            
        
        
            
                Cloud Shape from Polygon
            
         Fills a polygonal mesh with adaptively-sized primitive spheres used to model cumulus cloud-like shapes. 
- 
        
            
        
        
            
                Cloud Wispy Noise
            
         Applies thin feathery like fine displacement noise to a fog volume. 
- 
        
            
        
        
            
                Cluster
            
         Low-level machinery to cluster points based on their positions (or any vector attribute). 
- 
        
            
        
        
            
                Cluster Points
            
         Higher-level node to cluster points based on their positions (or any vector attribute). 
- 
        
            
        
        
            
                Collision Source
            
         Creates geometry and VDB volumes for use with DOPs collisions. 
- 
        
            
        
        
            
                Color
            
         Adds color attributes to geometry. 
- 
        
            
        
        
            
                Comb
            
         Adjust surface point normals by painting. 
- 
        
            
        
        
            
                Compute Rig Pose
            
         Evaluates a multiparm of transform parameters and applies them to the input skeleton. 
- 
        
            
        
        
            
                Compute Transform
            
         Recomputes world space or local space transforms for points in a hierarchy. 
- 
        
            
        
        
            
                Configure Clip Info
            
         Edits properties of a skeleton animation or motion clip. 
- 
        
            
        
        
            
                Configure Joint Limits
            
         Configures joint rotation and translation limits. 
- 
        
            
        
        
            
                Configure Joints
            
         Configures joint properties like local center of mass and transformation limits and creates a center of mass joint. 
- 
        
            
        
        
            
                Configure Rig Vis
            
         Determines which input skeleton components are visible for a KineFX character. 
- 
        
            
        
        
            
                Connect Adjacent Pieces
            
         Creates lines between nearby pieces. 
- 
        
            
        
        
            
                Connectivity
            
         Creates an attribute with a unique value for each set of connected primitives or points. 
- 
        
            
        
        
            
                Control
            
         Creates simple geometry for use as control shapes. 
- 
        
            
        
        
            
                Convert
            
         Converts geometry from one geometry type to another. 
- 
        
            
        
        
            
                Convert HeightField
            
         Converts a 2D height field to a 3D VDB volume, polygon surface, or polygon soup surface. 
- 
        
            
        
        
            
                Convert Line
            
         Converts the input geometry into line segments. 
- 
        
            
        
        
            
                Convert Meta
            
         Polygonizes metaball geometry. 
- 
        
            
        
        
            
                Convert Tets
            
         Generates the oriented surface of a tetrahedron mesh.  
- 
        
            
        
        
            
                Convert VDB
            
         Converts sparse volumes. 
- 
        
            
        
        
            
                Convert VDB Points
            
         Converts a Point Cloud into a VDB Points Primitive, or vice versa. 
- 
        
            
        
        
            
                Convert Volume
            
         Converts the iso-surface of a volume into a polygonal surface. 
- 
        
            
        
        
            
                Convex Decomposition
            
         Decomposes the input geometry into approximate convex segments. 
- 
        
            
        
        
            
                Copy and Transform
            
         Copies geometry and applies transformations to the copies. 
- 
        
            
        
        
            
                Copy to Curves
            
         Copies geometry in the first input onto curves of the second input. 
- 
        
            
        
        
            
                Copy to Points
            
         Copies geometry in the first input onto the points of the second input. 
- 
        
            
        
        
            
                Crease
            
         Manually adds or removes a creaseweight attribute to/from polygon
edges, for use with the Subdivide SOP. 
- 
        
            
        
        
            
                Cross Section Surface
            
         Creates a surface around cross sections. 
- 
        
            
        
        
            
                Crowd Assign Layers
            
         Assigns layers to a crowd to produce geometry variations. 
- 
        
            
        
        
            
                Crowd MotionPath
            
         Creates motion paths from a crowd’s animation clips or a simulation. 
- 
        
            
        
        
            
                Crowd MotionPath Arcing Layer
            
         Blends between a set of animation clips based on the motion path’s turn rate. 
- 
        
            
        
        
            
                Crowd MotionPath Avoid
            
         Deforms motion paths to avoid other agents and obstacles. 
- 
        
            
        
        
            
                Crowd MotionPath Edit
            
         Deforms motion paths to match target positions. 
- 
        
            
        
        
            
                Crowd MotionPath Evaluate
            
         Evaluates motion paths at a specific frame. 
- 
        
            
        
        
            
                Crowd MotionPath Follow
            
         Deforms motion paths to follow guiding curves. 
- 
        
            
        
        
            
                Crowd MotionPath Layer
            
         Layers additional animation clips onto an agent’s motion path. 
- 
        
            
        
        
            
                Crowd MotionPath Retime
            
         Adjusts the timing of motion paths. 
- 
        
            
        
        
            
                Crowd MotionPath Transition
            
         Blends an agent’s motion path into a new animation clip. 
- 
        
            
        
        
            
                Crowd MotionPath Trigger
            
         Defines a trigger that can be used to activate transitions between animation clips. 
- 
        
            
        
        
            
                Crowd Source
            
         Populates a crowd of agent primitives. 
- 
        
            
        
        
            
                Curve
            
         Lets you interactively draw Bézier curves using tools similar to 2D illustration programs, as well as polylines and NURBS. 
- 
        
            
        
        
            
                Curve Intersect
            
         Finds the intersections (or points of minimum distance) between two
or more curves or faces. 
- 
        
            
        
        
            
                DOP Import
            
         Imports geometry or transforms from a DOP simulation. 
- 
        
            
        
        
            
                DOP Import Fields
            
         Imports scalar and vector fields from a DOP simulation. 
- 
        
            
        
        
            
                DOP Import Records
            
         Imports option and record data from DOP simulations into points with
point attributes. 
- 
        
            
        
        
            
                DOP Network
            
         
- 
        
            
        
        
            
                Debris Source
            
         Generates point emission sources for debris, pyro, or particle sources from separating fractured rigid body objects. 
- 
        
            
        
        
            
                Deflate
            
         Deflate regions of a mesh. 
- 
        
            
        
        
            
                Deformation Wrangle
            
         Runs a VEX snippet to deform geometry. 
- 
        
            
        
        
            
                Delete
            
         Deletes input geometry by group, entity number, bounding volume,
primitive/point/edge normals, and/or degeneracy. 
- 
        
            
        
        
            
                Delete Joints
            
         Delete Joints on a SOP Rig. 
- 
        
            
        
        
            
                DeltaMush
            
         Smooths out (or relaxes) point deformations. 
- 
        
            
        
        
            
                Dem Bones Skinning Converter
            
         Converts any non-changing topology deforming mesh sequence into a bone-based animation. 
- 
        
            
        
        
            
                Dem Bones Skinning Converter
            
         Generates and assigns capture weights to points based on the Smooth Skinning Decomposition with Rigid Bones algorithm. 
- 
        
            
        
        
            
                Detangle
            
         Attempts to prevent collisions when deforming geometry. 
- 
        
            
        
        
            
                Dissolve
            
         Removes edges from the input polygonal geometry merging polygons with
shared edges. 
- 
        
            
        
        
            
                Distance along Geometry
            
         Measures the distance of the shortest path along the geometry’s edges or surfaces from each start point. 
- 
        
            
        
        
            
                Distance from Geometry
            
         Measures distance between each point and a reference geometry. 
- 
        
            
        
        
            
                Distance from Target
            
         Measures distance of each point from a target. 
- 
        
            
        
        
            
                Divide
            
         Divides, smooths, and triangulates polygons. 
- 
        
            
        
        
            
                Draw Curve
            
         Creates a curve based on user input in the viewport. 
- 
        
            
        
        
            
                Draw Guides
            
         
- 
        
            
        
        
            
                Dynamic Warp
            
         Dynamically Time-warps the first input (the Source) using the second input
(the Reference) as a reference. 
- 
        
            
        
        
            
                Each
            
         Culls the input geometry according to the specifications of the
For Each SOP. 
- 
        
            
        
        
            
                Edge Collapse
            
         Collapses edges and faces to their centerpoints. 
- 
        
            
        
        
            
                Edge Cusp
            
         Sharpens edges by uniquing their points and recomputing point
normals. 
- 
        
            
        
        
            
                Edge Divide
            
         Inserts points on the edges of polygons and optionally connects them. 
- 
        
            
        
        
            
                Edge Equalize
            
         Transforms selected edges so that all edges are of equal length. 
- 
        
            
        
        
            
                Edge Flip
            
         Flips the direction of polygon edges. 
- 
        
            
        
        
            
                Edge Fracture
            
         Cuts geometry along edges using guiding curves. 
- 
        
            
        
        
            
                Edge Relax
            
         Moves points such that edge lengths match a reference. 
- 
        
            
        
        
            
                Edge Straighten
            
         Straightens selected edges. 
- 
        
            
        
        
            
                Edge Transport
            
         Copies and optionally modifies attribute values along edges networks and curves. 
- 
        
            
        
        
            
                Edit
            
         Edits points, edges, or faces interactively. 
- 
        
            
        
        
            
                Ends
            
         Closes, opens, or clamps end points. 
- 
        
            
        
        
            
                Enumerate
            
         Sets an attribute on selected points or primitives to sequential numbers or strings. 
- 
        
            
        
        
            
                Error
            
         Generates a message, warning, or error, which can show up on a parent asset. 
- 
        
            
        
        
            
                Exploded View
            
         Pushes geometry out from the center to create an exploded view. 
- 
        
            
        
        
            
                Export Object Transforms
            
         Export transform attributes to object nodes. 
- 
        
            
        
        
            
                Extract Centroid
            
         Computes the centroid of each piece of the geometry. 
- 
        
            
        
        
            
                Extract Contours
            
         Extracts the contour edges of the input geometry as viewed from a perspective camera 
- 
        
            
        
        
            
                Extract Locomotion
            
         Extracts translation and orientation from a character using a given input joint. 
- 
        
            
        
        
            
                Extract Point from Curve
            
         Creates new points where an interpolated attribute has a certain value on a curve. 
- 
        
            
        
        
            
                Extract T-Pose
            
         Extracts the t-pose position from the input bone, muscle, or tissue geometry. 
- 
        
            
        
        
            
                Extract Transform
            
         Computes the best-fit transform between two pieces of geometry. 
- 
        
            
        
        
            
                Extrude
            
         Extrudes geometry along a normal. 
- 
        
            
        
        
            
                Extrude Volume
            
         Extrudes surface geometry into a volume. 
- 
        
            
        
        
            
                FBIK Configure Targets
            
         Configures joint properties used by full-body inverse kinematics solvers. 
- 
        
            
        
        
            
                FBX Animation Import
            
         Imports animation from an FBX file as a geometry-based skeleton. 
- 
        
            
        
        
            
                FBX Character Import
            
         Imports a skinned character with animation from an FBX file. 
- 
        
            
        
        
            
                FBX Skin Import
            
         Imports skin geometry from an FBX file. 
- 
        
            
        
        
            
                FEM Deform
            
         Deforms a solid piece of geometry (tetrahedral mesh) using the FEM quasistatic solver. 
- 
        
            
        
        
            
                FEM Validate
            
         Visualizes the quality of a tetrahedral mesh. 
- 
        
            
        
        
            
                FEM Visualize
            
         
- 
        
            
        
        
            
                FK Transfer
            
         Transfer forward kinematic motion to a SOP-based skeleton 
- 
        
            
        
        
            
                FLIP Boundary
            
          Creates a surface or density VDB for sourcing or deleting SOP FLIP fluid particles.  
- 
        
            
        
        
            
                FLIP Collide
            
         Converts connected geometry and volumes into collision object for SOP FLIP fluids. 
- 
        
            
        
        
            
                FLIP Container
            
         Creates a domain for a SOP FLIP fluid simulation. 
- 
        
            
        
        
            
                FLIP Solver
            
         Evolves an object as a FLIP fluid object inside a SOP network. 
- 
        
            
        
        
            
                FLIP Source
            
          Creates a surface or density VDB for sourcing FLIP simulations.  
- 
        
            
        
        
            
                FLIP Volume Combine
            
         Combine FLIP fields of different resolutions. 
- 
        
            
        
        
            
                Facet
            
         Controls the smoothness of faceting of a surface. 
- 
        
            
        
        
            
                Feather Barb Tangents
            
         Computes tangent space information for the surface spanned by barbs. 
- 
        
            
        
        
            
                Feather Barb Transform
            
         Transform barb vectors between feather space and object space. 
- 
        
            
        
        
            
                Feather Clump
            
         Clumps/Splits the barbs of a feather. 
- 
        
            
        
        
            
                Feather Deform
            
         
- 
        
            
        
        
            
                Feather Deintersect
            
         Moves intersecting feathers apart. 
- 
        
            
        
        
            
                Feather Instance Pool
            
         Creates a feather primitive for each combination of template weights found in the input curves. 
- 
        
            
        
        
            
                Feather Match Uncondensed
            
         Transfers attributes from uncondensed (expanded) feathers to single-curve feathers. 
- 
        
            
        
        
            
                Feather Minimum Distance
            
         Finds the closest point to each barb point on another geometry. 
- 
        
            
        
        
            
                Feather Noise
            
         Adds noise to the barbs of a feather. The noise amount can be controlled separately along each axis (along normal, tangent, or bitangent). 
- 
        
            
        
        
            
                Feather Normalize
            
         Normalizes the length and straightens feathers. 
- 
        
            
        
        
            
                Feather Primitive
            
         Generates feather primitives (Agent primitives with GPU-skinning). 
- 
        
            
        
        
            
                Feather Ray
            
         For each point on a feather, find the closest point on some other geometry. 
- 
        
            
        
        
            
                Feather Resample
            
         Resamples the shaft or barbs of a feather. 
- 
        
            
        
        
            
                Feather Shape Organize
            
         Organizes loosely drawn curves by name, so they can be input into Feather Template from Shape. 
- 
        
            
        
        
            
                Feather Surface
            
         Converts feather primitives to polygon surfaces. 
- 
        
            
        
        
            
                Feather Surface Blend
            
         Makes feather follow the curvature of a polygon mesh. 
- 
        
            
        
        
            
                Feather Template Assign
            
         Assigns feather templates from the second input to curves in the first input. 
- 
        
            
        
        
            
                Feather Template Interpolate
            
         Blends the barb values of a set of template curves. 
- 
        
            
        
        
            
                Feather Template from Shape
            
         Generates a feather template from shape curves. 
- 
        
            
        
        
            
                Feather Uncondense
            
         Expands the virtual barbs on feather curves to real curve primitives. 
- 
        
            
        
        
            
                Feather Utility
            
         Provides a collection of helpful functions for working with feather curves. 
- 
        
            
        
        
            
                Feather Visualize
            
         Changes the visualization of feathers in the viewport. 
- 
        
            
        
        
            
                Feather Width
            
         Sets the curve widths of feather shaft and barbs. 
- 
        
            
        
        
            
                Fiber Groom
            
         Defines the fiber direction vector for input solid muscle geometry. 
- 
        
        
            
                Filament Advect
            
         Evolves polygonal curves as vortex filaments. 
- 
        
            
        
        
            
                File
            
         Reads, writes, or caches geometry on disk. 
- 
        
            
        
        
            
                File Cache
            
         Caches (writes out once and then reads from) geometry (possibly animated) to disk. 
- 
        
            
        
        
            
                File Cache
            
         Caches (writes out once and then reads from) geometry (possibly animated) to disk. 
- 
        
            
        
        
            
                File Cache
            
         Caches (writes out once and then reads from) geometry (possibly animated) to disk. 
- 
        
            
        
        
            
                File Merge
            
         Reads and collates data from disk. 
- 
        
            
        
        
            
                Filmbox FBX ROP output driver
            
         
- 
        
            
        
        
            
                Find Instances
            
         Find instances of the same geometry pieces and replace them with packed geometry instances. 
- 
        
            
        
        
            
                Find Shortest Path
            
         Finds the shortest paths from start points to end points, following the edges of a surface. 
- 
        
            
        
        
            
                Flatten
            
         Flattens 3D geometry onto a plane. 
- 
        
            
        
        
            
                Fluid Compress
            
         Compresses the output of fluid simulations to decrease size on disk 
- 
        
            
        
        
            
                Font
            
         Creates 3D text from Type 1, TrueType and OpenType fonts. 
- 
        
            
        
        
            
                Force
            
         Uses a metaball to attract or repel points or springs. 
- 
        
            
        
        
            
                Fractal
            
         Creates jagged mountain-like divisions of the input
geometry. 
- 
        
            
        
        
            
                Franken Muscle
            
         Assigns multiple muscle_id identities within a single muscle geometry. 
- 
        
            
        
        
            
                Franken Muscle Paint
            
         Modifies muscle_id identities within a Franken Muscle using a paint interface. 
- 
        
            
        
        
            
                Full Body IK
            
         Transfer a motion to a SOP-based skeleton using full-body inverse kinematics algorithm. 
- 
        
            
        
        
            
                Fur
            
         Creates a set of hair-like curves across a surface. 
- 
        
            
        
        
            
                Fuse
            
         Merges or snaps points. 
- 
        
            
        
        
            
                GLTF Animation Import
            
         Imports animation data from a glTF file as a geometry-based skeleton. 
- 
        
            
        
        
            
                GLTF Character Import
            
         Imports a skinned character with animation from a glTF file. 
- 
        
            
        
        
            
                GLTF Skin Import
            
         Imports skin geometry from a glTF file. 
- 
        
            
        
        
            
                Gaea Terrain Color Visualizer
            
          This utility tool allows you to switch between RGB and Mask visualization on Terrains.  
- 
        
            
        
        
            
                Gaea Terrain Processor
            
          This bridge allows you to run .terrain files from Gaea inside Houdini.  
- 
        
            
        
        
            
                Glue Cluster
            
         Adds strength to a glue constraint network according to cluster
values. 
- 
        
            
        
        
            
                Grain Source
            
         Generates particles to be used as sources in a particle-based grain simulation. 
- 
        
            
        
        
            
                Graph Color
            
         Assigns a unique integer attribute to non-touching components. 
- 
        
            
        
        
            
                Grid
            
         Creates planar geometry. 
- 
        
            
        
        
            
                Groom Blend
            
         Blends the guides and skin of two grooms. 
- 
        
            
        
        
            
                Groom Fetch
            
         Fetches groom data from grooming objects. 
- 
        
            
        
        
            
                Groom Pack
            
         Packs the components of a groom into a set of named Packed Primitives for the purpose of writing it to disk. 
- 
        
            
        
        
            
                Groom Switch
            
         Switches between all components of two groom streams. 
- 
        
            
        
        
            
                Groom Unpack
            
         Unpacks the components of a groom from a packed groom. 
- 
        
            
        
        
            
                Group
            
         Generates groups of points, primitives, edges, or vertices according to various criteria. 
- 
        
            
        
        
            
                Group Combine
            
         Combines point groups, primitive groups, or edge groups according to boolean operations. 
- 
        
            
        
        
            
                Group Copy
            
         Copies groups between two pieces of geometry. 
- 
        
            
        
        
            
                Group Delete
            
         Deletes groups of points, primitives, edges, or vertices according to patterns. 
- 
        
            
        
        
            
                Group Expand
            
         Expands or shrinks groups of Edges, Points, Primitives, or Vertices. 
- 
        
            
        
        
            
                Group Expression
            
         Runs VEX expressions to modify group membership. 
- 
        
            
        
        
            
                Group Find Path
            
         Constructs groups for paths between elements.  
- 
        
            
        
        
            
                Group Invert
            
         Invert point, primitive, edge, or vertex groups. 
- 
        
            
        
        
            
                Group Joints
            
         Group Joints on a SOP Rig. 
- 
        
            
        
        
            
                Group Paint
            
         Sets group membership interactively by painting. 
- 
        
            
        
        
            
                Group Promote
            
         Converts point, primitive, edge, or vertex groups into point, primitive, edge, or vertex groups. 
- 
        
            
        
        
            
                Group Range
            
         Groups points and primitives by ranges. 
- 
        
            
        
        
            
                Group Rename
            
         Renames groups according to patterns. 
- 
        
            
        
        
            
                Group Transfer
            
         Transfers groups between two pieces of geometry, based on
proximity. 
- 
        
            
        
        
            
                Group by Lasso
            
         Groups points and primitives by lasso. 
- 
        
            
        
        
            
                Group from Attribute Boundary
            
         Creates a group that includes the boundaries of the specified attribute. 
- 
        
        
            
                Groups from Name
            
         Creates group for each unique name and adds elements to that group. 
- 
        
            
        
        
            
                Guide Advect
            
         Advects guide points through a velocity volume. 
- 
        
            
        
        
            
                Guide Clump Center
            
         Generates center curves representing each guide clump. 
- 
        
            
        
        
            
                Guide Collide With VDB
            
         Resolves collisions of guide curves with VDB signed distance fields. 
- 
        
            
        
        
            
                Guide Deform
            
         Deforms geometry with an animated skin and optionally guide curves. 
- 
        
            
        
        
            
                Guide Fill
            
         Adds guides to points lacking corresponding guides based on a Guide Interpolation Mesh. 
- 
        
            
        
        
            
                Guide Find Strays
            
         Identifies stray guide curves based on root distance and other metrics. 
- 
        
            
        
        
            
                Guide Groom
            
         Interactively creates and modifies guide curves. 
- 
        
            
        
        
            
                Guide Group
            
         Creates standard primitive groups used by grooming tools. 
- 
        
            
        
        
            
                Guide Initialize
            
         Quickly give hair guides some initial direction. 
- 
        
        
            
                Guide Interpolation Mesh
            
         Given a set of guide curves and a skin mesh, generates a mesh that can
be used to interpolate guide curve influences at any point. 
- 
        
            
        
        
            
                Guide Mask
            
         Creates masking attributes for other grooming operations. 
- 
        
            
        
        
            
                Guide Partition
            
         Creates and prepares parting lines for use with hair generation. 
- 
        
            
        
        
            
                Guide Process
            
         Modifies guide or hair using one or more operations. 
- 
        
            
        
        
            
                Guide Skin Attribute Lookup
            
         Looks up skin geometry attributes under the root point of guide curves. 
- 
        
            
        
        
            
                Guide Surface
            
         Positions points on a triangulated mesh based on guide or fur curves. 
- 
        
            
        
        
            
                Guide Tangent Space
            
         Constructs a coherent tangent space along a curve. 
- 
        
            
        
        
            
                Guide Transfer
            
         Transfer hair guides between geometries. 
- 
        
            
        
        
            
                Guide Volume
            
         Generates volumetric representations from guide curves. 
- 
        
            
        
        
            
                Hair Card Generate
            
         Converts dense hair curves to a polygon card, keeping the style and shape of the groom. 
- 
        
            
        
        
            
                Hair Clump
            
         Clumps guide curves together. 
- 
        
            
        
        
            
                Hair Generate
            
         Generates hair on a surface or from points. 
- 
        
            
        
        
            
                Hair Growth Field
            
         Generates a velocity field based on stroke primitives. 
- 
        
            
        
        
            
                Heat Geodesic
            
         Measures the distance of each point to a group of source points along a polygonal surface. 
- 
        
            
        
        
            
                HeightField
            
         Generates an initial heightfield volume for use with terrain tools. 
- 
        
            
        
        
            
                HeightField Blur
            
         Blurs a terrain height field or mask. 
- 
        
            
        
        
            
                HeightField Clip
            
         Limits height values to a certain minimum and/or maximum. 
- 
        
            
        
        
            
                HeightField Copy Layer
            
         Creates a copy of a height field or mask. 
- 
        
            
        
        
            
                HeightField Crop
            
         Extracts a square of a certain width/length from a larger height volume, or resizes/moves the boundaries of the height field. 
- 
        
            
        
        
            
                HeightField Cutout by Geometry
            
         Creates a cutout on a terrain based on geometry. 
- 
        
            
        
        
            
                HeightField Deform
            
         Deforms geometry by a changing HeightField 
- 
        
            
        
        
            
                HeightField Distort by Layer
            
         Displaces a height field by another field. 
- 
        
            
        
        
            
                HeightField Distort by Noise
            
         Advects the input volume through a noise pattern to break up hard edges and add variety. 
- 
        
            
        
        
            
                HeightField Draw Mask
            
         Lets you draw shapes to create a mask for height field tools. 
- 
        
            
        
        
            
                HeightField Erode
            
         Simulates hydraulic and thermal erosion at a specific scale to create more realistic terrain. 
- 
        
            
        
        
            
                HeightField Erode Hydro
            
         Simulates the erosion from one heightfield sliding over another for a short time. 
- 
        
            
        
        
            
                HeightField Erode Precipitation
            
         Distributes water along a heightfield. Offers controls for adjusting the intensity, variability, and location of rainfall. 
- 
        
            
        
        
            
                HeightField Erode Thermal
            
         Calculates the effect of thermal erosion on terrain for a short time. 
- 
        
            
        
        
            
                HeightField File
            
         Imports a 2D image map from a file or compositing node into a height field or mask. 
- 
        
            
        
        
            
                HeightField Flatten
            
         Flattens a masked region of a heightfield terrain. 
- 
        
            
        
        
            
                HeightField Flow Field
            
         Generates flow and flow direction layers according to the input height layer. 
- 
        
            
        
        
            
                HeightField Isolate Layer
            
         Copies another layer over the mask layer, and optionally flattens the height field. 
- 
        
            
        
        
            
                HeightField Layer
            
         Composites together two height fields. 
- 
        
            
        
        
            
                HeightField Layer Clear
            
         Sets all values in a heightfield layer to a fixed value. 
- 
        
            
        
        
            
                HeightField Layer Properties
            
         Sets the border voxel and compression policies on a height field volume. 
- 
        
            
        
        
            
                HeightField Mask by Feature
            
         Creates a mask based on different features of the height layer. 
- 
        
            
        
        
            
                HeightField Mask by Geometry
            
         Creates a mask based some other geometry. 
- 
        
            
        
        
            
                HeightField Mask by Occlusion
            
         Creates a mask where the input terrain is hollow/depressed, for example riverbeds and valleys. 
- 
        
            
        
        
            
                HeightField Noise
            
         Adds vertical noise to a height field, creating peaks and valleys. 
- 
        
            
        
        
            
                HeightField Output
            
         Exports height and/or mask layers to disk as an image. 
- 
        
            
        
        
            
                HeightField Paint
            
         Lets you paint values into a height or mask field using strokes. 
- 
        
            
        
        
            
                HeightField Patch
            
         Patches features from one heightfield to another. 
- 
        
            
        
        
            
                HeightField Pattern
            
         Adds displacement in the form of a ramps, steps, stripes, Voronoi cells, or other patterns. 
- 
        
            
        
        
            
                HeightField Project
            
         Projects 3D geometry into a height field. 
- 
        
            
        
        
            
                HeightField Quick Shade
            
         Applies a material that lets you plug in textures for different layers. 
- 
        
            
        
        
            
                HeightField Remap
            
         Remaps the values in a height field or mask layer. 
- 
        
            
        
        
            
                HeightField Resample
            
         Changes the resolution of a height field. 
- 
        
            
        
        
            
                HeightField Scatter
            
         Scatters points across the surface of a height field. 
- 
        
            
        
        
            
                HeightField Slump
            
         Simulates loose material sliding down inclines and piling at the bottom. 
- 
        
            
        
        
            
                HeightField Terrace
            
         Creates stepped plains from slopes in the terrain. 
- 
        
            
        
        
            
                HeightField Tile Splice
            
         Stitches height field tiles back together. 
- 
        
            
        
        
            
                HeightField Tile Split
            
         Splits a height field volume into rows and columns. 
- 
        
            
        
        
            
                HeightField Transform
            
         Height field specific scales and offsets. 
- 
        
            
        
        
            
                HeightField Visualize
            
         Visualizes elevations using a custom ramp material, and mask layers using tint colors. 
- 
        
            
        
        
            
                Hole
            
         Makes holes in surfaces. 
- 
        
            
        
        
            
                IK Chains
            
         Creates and evaluates Two-Bone IK solvers on a SOP skeleton. 
- 
        
            
        
        
            
                Inflate
            
         Deforms the points in the first input to make room for the
inflation tool. 
- 
        
            
        
        
            
                Instance
            
         Instances Geometry on Points. 
- 
        
            
        
        
            
                Intersection Analysis
            
         Creates points with attributes at intersections between triangles and/or polygon curves, either within a single input geometry or between a first and a second input geometry. 
- 
        
            
        
        
            
                Intersection Stitch
            
         Composes triangle surfaces and curves together into a single connected mesh. 
- 
        
            
        
        
            
                Invoke Compiled Block
            
         Processes its inputs using the operation of a referenced compiled block. 
- 
        
            
        
        
            
                Invoke Graph
            
         Processes its inputs using operations defined by a geometry graph. 
- 
        
            
        
        
            
                IsoOffset
            
         Builds an offset surface from geometry. 
- 
        
            
        
        
            
                Join
            
         The Join op connects a sequence of faces or surfaces into a single
primitive that inherits their attributes. 
- 
        
            
        
        
            
                Joint Capture Biharmonic
            
         Captures skin geometry to a SOP skeleton for use with Joint Deform. 
- 
        
            
        
        
            
                Joint Capture Paint
            
         Lets you paint capture weights directly onto geometry. 
- 
        
            
        
        
            
                Joint Capture Proximity
            
         Supports Joint Deform by assigning capture weights to points based on distance to joints. 
- 
        
            
        
        
            
                Joint Deform
            
         Perform skin deformation from KineFX skeleton animation. 
- 
        
            
        
        
            
                Kelvin Wakes Deformer
            
         Deforms input geometry in the shape of water wakes that form behind objects
moving at a constant speed. 
- 
        
            
        
        
            
                L-System
            
         Creates fractal geometry from the recursive application of simple rules. 
- 
        
            
        
        
            
                LOP Import
            
         
- 
        
            
        
        
            
                Labs 2D Wave Function Collapse
            
          The main WFC node: The solver.  
- 
        
            
        
        
            
                Labs AV Analyze Images
            
          Match all features between candidate image pairs using Alicevision.  
- 
        
            
        
        
            
                Labs AV Depth Map
            
           Retrieves the depth value of each pixel from the cameras using Alicevision.  
- 
        
            
        
        
            
                Labs AV Initialize
            
          Configure which images to process using Alicevision.  
- 
        
            
        
        
            
                Labs AV Meshing
            
           Creates a dense geometric surface representation of the scene using Alicevision.  
- 
        
            
        
        
            
                Labs AV Photogrammetry
            
           The complete Alicevision photogrammetry pipeline.  
- 
        
            
        
        
            
                Labs AV Structure from Motion
            
          Detects 3D points with position and orientation and calibrate the cameras accordingly using Alicevision.  
- 
        
            
        
        
            
                Labs AV Texturing
            
           Texture the generated mesh using Alicevision.  
- 
        
            
        
        
            
                Labs Align and Distribute
            
         Aligns and arranges geometry pieces in linear or grid layouts. 
- 
        
            
        
        
            
                Labs Attribute Value Replace
            
          Allows you to replace attribute values with others.  
- 
        
            
        
        
            
                Labs Auto UV
            
          Automatically Generates UV Attributes  
- 
        
            
        
        
            
                Labs Automatic Trim Texture
            
          Automatic Trim Texturing node.  
- 
        
            
        
        
            
                Labs Biome Attributes Evolve (Beta)
            
         Evolve all the attributes on the terrain to create more realistic results. 
- 
        
            
        
        
            
                Labs Biome Curve Label (Beta)
            
         This node sets the necessary attributes on curves created in Houdini to use with Labs Biome Region Assign SOP. 
- 
        
            
        
        
            
                Labs Biome Define (Beta)
            
         Define the biome attributes. 
- 
        
            
        
        
            
                Labs Biome Define (Beta)
            
         Define the biome attributes for the Biome Toolset. 
- 
        
            
        
        
            
                Labs Biome Definitions File (Beta)
            
         This node reads biome information from the disk file or writes to the disk file from input Biome Define SOP nodes. 
- 
        
            
        
        
            
                Labs Biome Plant Define (Beta)
            
         Defines the plant attributes for the Biome Toolset. 
- 
        
            
        
        
            
                Labs Biome Plant Definitions File (Beta)
            
         This node reads plant information from the disk file or writes to the disk file from input Biome Plant Define SOP nodes. 
- 
        
            
        
        
            
                Labs Biome Plant Scatter (Beta)
            
         Scatters plant species points across the surface of an input heightfield by matching input plant types with their preferred environmental conditions. 
- 
        
            
        
        
            
                Labs Biome Region Assign (Beta)
            
         Delineates biome regions for the Biome Toolset workflow. 
- 
        
            
        
        
            
                Labs Boolean Curve
            
          Does a boolean on a polycurve.  
- 
        
            
        
        
            
                Labs Box Clip
            
          Clip geometry to a resizable box region.  
- 
        
            
        
        
            
                Labs Boxcutter
            
          Viewport interactive boolean for hardsurface modeling.  
- 
        
            
        
        
            
                Labs Building Generator
            
         Converts low-resolution blockout geometry into detailed buildings using a library of user defined modules. 
- 
        
            
        
        
            
                Labs Building Generator Utility
            
          Create base modules to use with the building generator, as well as override base module behavior.  
- 
        
            
        
        
            
                Labs Building from Patterns
            
         Creates buildings from blockout geometry defined by a pattern of floor modules.  
- 
        
            
        
        
            
                Labs CSV Exporter
            
          Export geometry attibutes to a CSV file.  
- 
        
            
        
        
            
                Labs Cable Generator
            
         Creates and simulates cables based on curve or geometry input. 
- 
        
            
        
        
            
                Labs Calculate Slope
            
          Calculate the slope of a surface by comparing to a direction, and optionally blur and remap the result.  
- 
        
            
        
        
            
                Labs Calculate Thickness
            
          Vertex Based Thickness Calculation  
- 
        
            
        
        
            
                Labs Calculate UV Distortion
            
          Calculate UV distortion of a piece of geometry  
- 
        
            
        
        
            
                Labs Capsule
            
         Generates a capsule mesh. 
- 
        
            
        
        
            
                Labs Chaotic Shapes
            
         Generates different chaotic maps. 
- 
        
            
        
        
            
                Labs Clean Seams
            
         Removes from an edge group all the edges that are not borders between different primitive islands identified by an island attribute. 
- 
        
            
        
        
            
                Labs Color Blend
            
          Blends Color data on 2 separate meshes based on common algorithms  
- 
        
            
        
        
            
                Labs Connectivity and Segmentation
            
         This node segments geometry based on connectivity, UV islands, proximity clustering, and custom attributes. This is very useful when paired with the multithreaded functionality of compile blocks. 
- 
        
            
        
        
            
                Labs Cook with Timeout
            
         Documentation coming soon… 
- 
        
            
        
        
            
                Labs Coord Swizzle Quaternion
            
          Swizzles Quaternions in order to change rotation spaces  
- 
        
            
        
        
            
                Labs Coord Swizzle Vector
            
          Reorders Vector Components  
- 
        
            
        
        
            
                Labs Curve Branches
            
          Scatters curves over curves, with many intuitive controls to go from clean geometric branches to organic vines. Duplicates of this sop can be chained together for recursive growth, approximating the look of L-Systems but much more controllable.  
- 
        
            
        
        
            
                Labs Curve Resample by Density
            
         Redistributes curve points based on density. 
- 
        
            
        
        
            
                Labs Cylinder
            
          Create a tube from a curve, with UVs and normals.  
- 
        
            
        
        
            
                Labs Decal Projector
            
          Project a decal (localized piece of geometry and a texture) onto geometry. 
- 
        
            
        
        
            
                Labs Delete Small Parts
            
          Removes pieces based on connectivity and size   
- 
        
            
        
        
            
                Labs Delight
            
          Remove light and shadow variation from photogrammetry textures. 
- 
        
            
        
        
            
                Labs Destruction Cleanup
            
          Prepare rigid body simulation results for export, reducing redundant geometry, cleaning normals, cleaning attributes.  
- 
        
            
        
        
            
                Labs Detail Mesh
            
          The Detail Mesh SOP allows you to project a so called detail mesh onto template geometry.  
- 
        
            
        
        
            
                Labs Dirt Skirt
            
          Create a geometry 'skirt' where an object and ground plane intersect, to be used as a soft blend in a game engine.  
- 
        
            
        
        
            
                Labs Disc
            
          Create a polygon disc with UVs 
- 
        
            
        
        
            
                Labs Dissolve Flat Edges
            
          Remove edges on flat surfaces.  
- 
        
            
        
        
            
                Labs Distance From Border
            
          Calculates the distance for each point from the nearest unshared edge  
- 
        
            
        
        
            
                Labs Edge Color
            
          Color sharp edges on geometry  
- 
        
            
        
        
            
                Labs Edge Damage
            
          Adding procedural damage on inputs  
- 
        
            
        
        
            
                Labs Edge Group To Curve
            
          Converts an Edge Group to a Poly Curve  
- 
        
            
        
        
            
                Labs Edge Group to Polylines
            
         Converts edge groups to polylines. 
- 
        
            
        
        
            
                Labs Edge Smooth
            
          Smooth an edge-group found in input geometry.  
- 
        
            
        
        
            
                Labs Export UV Wireframe
            
          Allows you to export the UV wireframe for texturing  
- 
        
            
        
        
            
                Labs Extract Borders
            
          Extract curves from Meshes  
- 
        
            
        
        
            
                Labs Extract Filename
            
          Utility SOP to store the filename of a file SOP as its detail attributes to be then used in other SOPs.  
- 
        
            
        
        
            
                Labs Extract Silhouette
            
          Create an outline of an object projected from either an axis, or from a camera.  
- 
        
            
        
        
            
                Labs FBX Archive Import
            
           Import an FBX as an archive similar to how the Alembic Archive sop works.   
- 
        
            
        
        
            
                Labs Fast Remesh
            
         This node performs Houdini’s native remeshing operation on partitioned geometry, processing each piece in parallel which greatly reduces the calculation time of traditional remeshing. 
- 
        
            
        
        
            
                Labs Flowmap
            
          This utility tool sets up a flowmap template on your input geometry.  
- 
        
            
        
        
            
                Labs Flowmap Obstacle
            
          The flowmap obstacle SOP allows for easy modifications on the flowmap based on geometry.  
- 
        
            
        
        
            
                Labs Flowmap Shader
            
          The flowmap SHOP is a GLSL based viewport shader to preview flowmap shaders.  
- 
        
            
        
        
            
                Labs Flowmap Visualize
            
           A high quality realtime preview of a flowmap texture in the Houdini viewport.  
- 
        
            
        
        
            
                Labs Flowmap to Color
            
          The flowmap to color SOP converts the flowmap data to vertex colors  
- 
        
            
        
        
            
                Labs GameRes
            
          Full Pipeline Node to Take High Res Models to Low Res  
- 
        
            
        
        
            
                Labs Games Baker
            
          Generate Textures based on a High Poly to Low Poly match  
- 
        
            
        
        
            
                Labs Gas Expand from Temperature
            
         Creates divergence from temperature change.  
- 
        
            
        
        
            
                Labs Gas Flamefront
            
         A simple flamefront combustion model.  
- 
        
            
        
        
            
                Labs GoZ Export
            
          Sends Houdini Mesh data automatically to Zbrush  
- 
        
            
        
        
            
                Labs GoZ Import
            
          Contains GoZ data sent from Zbrush  
- 
        
            
        
        
            
                Labs Group Curve Corners
            
          Creates Groups for Inside and Outside corner points  
- 
        
            
        
        
            
                Labs Group Invert
            
         Invert any number of specified groups 
- 
        
            
        
        
            
                Labs Group by Attribute
            
          Converts Attributes to Groups  
- 
        
            
        
        
            
                Labs Group by Measure
            
          Allows for grouping geometry based on properties that can be measured  
- 
        
            
        
        
            
                Labs Guide Flowmap
            
          The Guide Flowmap modifies a flowmap based on a guide curve.  
- 
        
            
        
        
            
                Labs HF Combine Masks
            
          Simplifies the process of blending masks together in Heightfields  
- 
        
            
        
        
            
                Labs HF Insert Mask
            
          Allows you to insert a layer from another heightfield.  
- 
        
            
        
        
            
                Labs Hexagon Grid
            
         Generates a hexagonal grid. 
- 
        
            
        
        
            
                Labs Houdini Icon
            
          Geometric representation for Houdini icon  
- 
        
            
        
        
            
                Labs Impostor Camera Rig
            
          This OBJ sets up a camera rig to be used with the Impostor Texture ROP  
- 
        
            
        
        
            
                Labs Impostor Texture
            
          The impostor tool creates texture sheets to fake 3D objects in your game engine.  
- 
        
            
        
        
            
                Labs Inside Face UVs
            
          Create UV’s for inside faces of Voronoi fractured geometry.  
- 
        
            
        
        
            
                Labs Instance Attributes
            
         Summary. 
- 
        
            
        
        
            
                Labs Instant Meshes
            
          This tool allows you to run geometry through InstantMeshes and generate a quad mesh.  
- 
        
            
        
        
            
                Labs LOD Create
            
          The LOD Create SOP allows for easy LOD generation.  
- 
        
            
        
        
            
                Labs LOD Hierarchy
            
          Create and export an LOD Hierarchy as FBX  
- 
        
            
        
        
            
                Labs Lightning
            
          Generate lightning effect around meshes  
- 
        
            
        
        
            
                Labs Loop Volume
            
         Takes one or two input volume sequences and creates a seamlessly looping volume animation. 
- 
        
            
        
        
            
                Labs Loops from Selection
            
         Finds edge loops or quad loops from manually or procedurally selected start edges. 
- 
        
            
        
        
            
                Labs Lot Subdivision
            
         Divides polygons into panels. 
- 
        
            
        
        
            
                Labs ML CV Directory Import
            
         Imports the assets from a directory. 
- 
        
            
        
        
            
                Labs ML CV Keypoint Metadata
            
         Prepares the keypoint metadata. 
- 
        
            
        
        
            
                Labs ML CV Label Metadata
            
         Prepares the label metadata. 
- 
        
            
        
        
            
                Labs ML CV Promote Synth Attribute
            
         Converts an attribute into a format compatible with COCO JSON. 
- 
        
            
        
        
            
                Labs ML CV ROP Annotation Output
            
         Outputs a ground truth JSON per frame and then aggregates them all into a COCO JSON file for the full dataset. 
- 
        
            
        
        
            
                Labs ML CV Texture Mask
            
         Adds geometry attributes needed for the mask ground truth pipeline. 
- 
        
            
        
        
            
                Labs ML CV Vector Data
            
         Creates the ground truth for 3D vectors. 
- 
        
            
        
        
            
                Labs ML CV Visualize Keypoints
            
         Visualizes keypoints and their connections. 
- 
        
            
        
        
            
                Labs Make Loop
            
          Takes a mesh or volume that is animated and loops them.  
- 
        
            
        
        
            
                Labs Maps Baker
            
          Generates textures bakes from a high resolution to low resolution model at near interactive speeds.  
- 
        
            
        
        
            
                Labs Material to Override
            
          Generates material_override attributes per primitive based on the assigned material.   
- 
        
            
        
        
            
                Labs Measure Curvature
            
         Measures the convex and concave curvature of a model. 
- 
        
            
        
        
            
                Labs Merge Small Islands
            
          Consolidates Small UV Islands into Larger Neighbors  
- 
        
            
        
        
            
                Labs Merge Splines
            
         Merges disconnected Polylines together like the Polypath Sop, cutting them at intersections. 
But with specified conditions, while preserving and merging attributes and groups. 
- 
        
            
        
        
            
                Labs Mesh Sharpen
            
          Sharpens the geometry based on curvature 
- 
        
            
        
        
            
                Labs Mesh Slice
            
          Clips the geometry into multiple submeshes based on a 3d grid pattern  
- 
        
            
        
        
            
                Labs Mesh Tiler
            
         Makes packed geometry lying on a plane tileable. 
- 
        
            
        
        
            
                Labs Min Max Average
            
         Multiple Min/Max/Average analyses in a single node. 
- 
        
            
        
        
            
                Labs Motionvector Shader
            
          Viewport shader for motion vector textures  
- 
        
            
        
        
            
                Labs Multi Bounding Box
            
          Generate Several Bounding Boxes For the Input Mesh   
- 
        
            
        
        
            
                Labs Name from Capture Weight
            
          Detects what the bone name of the highest skinning weight influence is.  
- 
        
            
        
        
            
                Labs Niagara ROP
            
          Export point caches to be used with Unreal’s Niagara particle system.  
- 
        
            
        
        
            
                Labs OBJ Importer
            
           Import an OBJ File including its materials and textures.  
- 
        
            
        
        
            
                Labs OSM Buildings
            
          Generate Buildings from OSM Data  
- 
        
            
        
        
            
                Labs OSM Filter
            
          Isolates Specific OSM Data Layers  
- 
        
            
        
        
            
                Labs OSM Import
            
          Imports Open Street Map Data  
- 
        
            
        
        
            
                Labs PBR Shader
            
          Physically Based Viewport Shader  
- 
        
            
        
        
            
                Labs PCG Export (Beta)
            
         Takes a point cloud with attributes and exports them as 2 CSV files to be used with Unreal Engine PCG system. 
- 
        
            
        
        
            
                Labs PDG Work-Item Import
            
          Import input and output files attached to a work-item in PDG  
- 
        
            
        
        
            
                Labs Path Deform
            
          Deform geometry along a curve.  
- 
        
            
        
        
            
                Labs Pathfinding Global (Beta)
            
         This node creates paths between points of interest on a given terrain based on cost and avoidance attributes. 
- 
        
            
        
        
            
                Labs Physical Ambient Occlusion
            
         Computes ambient occlusion, generates dirt masks, as well as identifies peaks and valleys on meshes. 
- 
        
            
        
        
            
                Labs Physics Painter
            
          Physics Painter is a SOP that allows users to paint physics objects onto any other object.  
- 
        
            
        
        
            
                Labs Pick and Place
            
          Allows you to interactively place individual objects in a scene.  
- 
        
            
        
        
            
                Labs PolyDeform
            
          Warps a source mesh to match the shape of a target   
- 
        
            
        
        
            
                Labs PolyScalpel
            
         Slices new polygonal edges or points into the primary input geometry from the secondary input in various configurations. 
- 
        
            
        
        
            
                Labs PolySlice
            
          Slice polygons into polygons or polylines  
- 
        
            
        
        
            
                Labs Post Animation Deform
            
         Apply modeling changes to deforming geometry 
- 
        
            
        
        
            
                Labs Procedural Smoke
            
          The procedural smoke SOP will generate an animated volume to represent smoke.  
- 
        
            
        
        
            
                Labs Progressive Resample
            
          Resamples a curve progressively based on an attribute  
- 
        
            
        
        
            
                Labs Quad Sphere
            
         Creates a quad sphere 
- 
        
            
        
        
            
                Labs Quadrangulate
            
          Simple Node to take a triangulated mesh and attempt to collapse the diagonal edges to return the mesh to a quad dominant state  
- 
        
            
        
        
            
                Labs Quick Basic Tree
            
         Creates a quick basic tree 
- 
        
            
        
        
            
                Labs RBD Edge Strip
            
          Generate polystrips on fractured geometry for extra destruction detail in game engines.  
- 
        
            
        
        
            
                Labs RBD to FBX
            
          This tool allows for fast export of an RBD Sim to bone based FBX  
- 
        
            
        
        
            
                Labs Random Selection
            
          Randomly selects a subset of input points or primitives.  
- 
        
            
        
        
            
                Labs Regions from Image
            
         
- 
        
            
        
        
            
                Labs Remove Inside Faces
            
          This tool removes inside faces for objects that are intersecting.  
- 
        
            
        
        
            
                Labs Remove UV Distortion
            
          Remove UV Distortion tries to reduce UV distortion by inserting new seams  
- 
        
            
        
        
            
                Labs Repair
            
          Quickly Spot Heal a Mesh  
- 
        
            
        
        
            
                Labs RizomUV Optimize
            
         Enables the use of RizomUV and performs a UV optimize inside Houdini 
- 
        
            
        
        
            
                Labs RizomUV Processor
            
         Enables the use of RizomUV within Houdini. 
- 
        
            
        
        
            
                Labs RizomUV Rectangularize
            
         Enables the use of RizomUV and performs a UV rectangularize inside Houdini 
- 
        
            
        
        
            
                Labs RizomUV Unwrap
            
         Enables the use of RizomUV and performs a UV unwrap inside Houdini 
- 
        
            
        
        
            
                Labs Road Generator
            
          Generate roads from curves or OSM data  
- 
        
            
        
        
            
                Labs SciFi Panels
            
          Example HDA from the Rebirth Project to generate Sci Fi Panneling  
- 
        
            
        
        
            
                Labs Settlement Connections (Beta)
            
         This node generates connections between points of interest based on angle and distance calculations. 
- 
        
            
        
        
            
                Labs Simple Baker
            
          SOP Based Baking of Texture Maps  
- 
        
            
        
        
            
                Labs Simple Retime
            
          Simple Interface to Change the Timing of an animation  
- 
        
            
        
        
            
                Labs Simple Rope Wrap
            
          Generate a rubber band like rope around an object based on inputs.  
- 
        
            
        
        
            
                Labs Simple Shapes
            
         Creates simple 2D shapes. 
- 
        
            
        
        
            
                Labs Sine Wave
            
          Deforms a mesh based on a sine wave curve  
- 
        
            
        
        
            
                Labs Sketchfab
            
          Uploads geometry to Sketchfab  
- 
        
            
        
        
            
                Labs Skinning Converter
            
          Skinning Converter is a SOP that can convert any non-changing topology deforming mesh sequence into a bone based animation.  
- 
        
            
        
        
            
                Labs Snow Buildup
            
          Creates geometry to an input mesh that mimics snow build up.  
- 
        
            
        
        
            
                Labs Soften Normals
            
          Soften Normals is a convenience SOP that is frequently used to prepare geometry for baking.  
- 
        
            
        
        
            
                Labs Sort
            
         A wrapper around the default Sort SOP that adds a Circular (Around Vector) mode. 
- 
        
            
        
        
            
                Labs Spiral
            
          Creates a spiral curve  
- 
        
            
        
        
            
                Labs Splatter
            
          Creates a POP Fluid simulation setup for splattering.  
- 
        
            
        
        
            
                Labs Split Primitives by Normal
            
          Split primitives into separate outputs based on normals  
- 
        
            
        
        
            
                Labs Static Fracture Export
            
          The Static Fracture SOP takes static geometry data from sop level, and separates them into newly generated geometry containers on object level  
- 
        
            
        
        
            
                Labs Straight Skeleton 2D
            
          Generate the central curve (straight skeleton) for 2D input shapes.  
- 
        
            
        
        
            
                Labs Straight Skeleton 3D
            
          Generates a curve based on the internal structure of a mesh  
- 
        
        
            
                Labs Straighten
            
          Orients a mesh based on UP and FRONT groups  
- 
        
            
        
        
            
                Labs Substance Material
            
           Loads a Substance Archive and assigns it as a material  
- 
        
            
        
        
            
                Labs Superformula Shapes
            
          This tool creates 2D shapes using the superformula equation.  
- 
        
            
        
        
            
                Labs Sweep Geometry
            
          Sweeps geometry along a curve.  
- 
        
            
        
        
            
                Labs Symmetrize
            
          Clips and mirrors geometry along an axis.  
- 
        
            
        
        
            
                Labs Terrain Analysis (Beta)
            
         This node analyzes a HeightField and generates cost and avoidance attributes. 
- 
        
            
        
        
            
                Labs Terrain Layer Export
            
          The terrain layer export SOP exports a heightfield with the correct settings for Unreal.  
- 
        
            
        
        
            
                Labs Terrain Layer Import
            
          The terrain layer import SOP exports a heightfield with the correct settings from Unreal.  
- 
        
            
        
        
            
                Labs Terrain Mesh ROP
            
          The Terrain Mesh Output allows you to convert the plugged in heightfield into (tiled) geometry.  
- 
        
            
        
        
            
                Labs Terrain Texture ROP
            
          The Terrain Texture Output renders image data from a heightfield.  
- 
        
            
        
        
            
                Labs Test Geometry: Luiz
            
          A scan of Luiz Kruel  
- 
        
            
        
        
            
                Labs Test Geometry: Paul
            
          A scan of Paul Ambrosiussen  
- 
        
            
        
        
            
                Labs Texel Density
            
          Calculates and corrects texel density of an asset.  
- 
        
            
        
        
            
                Labs Thicken
            
          Extrudes a mesh along it’s averaged normals  
- 
        
            
        
        
            
                Labs Trace PSD File
            
          Generates Curves from Photoshop file layers.  
- 
        
            
        
        
            
                Labs Tree Branch Generator
            
          Generates tree branches  
- 
        
            
        
        
            
                Labs Tree Branch Placer
            
          Manually place tree branches  
- 
        
        
            
                Labs Tree Branch Placer
            
            
- 
        
            
        
        
            
                Labs Tree Controller
            
          Controls other tree nodes  
- 
        
            
        
        
            
                Labs Tree Hierarchy
            
         This tool extracts geometry and pivot points from trees created with Labs Tree Generator tools for use with Labs Unreal PivotPainter. 
- 
        
            
        
        
            
                Labs Tree Leaf Generator
            
          Generates leaves on branches  
- 
        
            
        
        
            
                Labs Tree Simple Leaf
            
          Simple leaf generator for visualization purposes  
- 
        
            
        
        
            
                Labs Tree Trunk Generator
            
          Generates a tree trunk  
- 
        
            
        
        
            
                Labs Trim Texture
            
          Interactive version of the Trim Texture node.  
- 
        
            
        
        
            
                Labs Trim Texture Utility
            
          Helps preparing trim texture geometry for a Trim Texture workflow  
- 
        
            
        
        
            
                Labs Triplanar Displace
            
          Displacing geometry based on a triplanar projection  
- 
        
        
            
                Labs Turntable
            
          Rotates the input geometry around itself based on the timeline  
- 
        
            
        
        
            
                Labs UDIM Tile Number
            
         Creates a UDIM tile number attribute on primitives, points, or vertices. 
- 
        
            
        
        
            
                Labs UV Remove Overlap
            
         Marks and optionally repairs UV overlaps. 
- 
        
            
        
        
            
                Labs UV Transfer
            
          Transfer UVs between a source and target geometry.  
- 
        
            
        
        
            
                Labs UV Unitize
            
          Converts every primitive to 0-1 UVs   
- 
        
            
        
        
            
                Labs UV Unwrap Cylinder
            
         Unwraps cylindrical shaped meshes. 
- 
        
            
        
        
            
                Labs UV Visualize
            
          Different methods of visualizing UV Data  
- 
        
            
        
        
            
                Labs Unreal Groom Export
            
         Exports hair to Unreal Engine. 
- 
        
            
        
        
            
                Labs Unreal Pivot Painter
            
          Pivot Painter stores model pivot and rotation information for geometry used in a shader.  
- 
        
            
        
        
            
                Labs Unreal Spline (Beta)
            
         Takes a curve and turns it into an Unreal Spline, it can import and export multiple splines. 
- 
        
            
        
        
            
                Labs Unreal Worldcomposition Prepare
            
          Prepare heightfield and actor instances for use with World Composition in Unreal  
- 
        
            
        
        
            
                Labs VDB Transform Properties
            
         Converts the input volume/VDB field to a VDB vector field and updates how the vector field will respond to transformations downstream. 
- 
        
            
        
        
            
                Labs Validate Geometry Type
            
         This node evaluates the geometry types of the input geometry and returns a warning message if the specified geometry type and type count are not found. 
- 
        
            
        
        
            
                Labs Vector Field Export
            
          Export a vector field, compatible with Unreal Engine.  
- 
        
            
        
        
            
                Labs View Vertex Order
            
         A simple utility that creates arrow indicators on poly primitives displaying their vertex order. 
- 
        
            
        
        
            
                Labs Visualize Vector
            
         Visualizes vectors as arrows. 
- 
        
            
        
        
            
                Labs Volume Adjust Look
            
         Adjusts volume visualization mode (default / normals / motion vectors), density, colors (including greyscale colors), emission, and viewport rendering quality. 
- 
        
            
        
        
            
                Labs VolumeTexture Export
            
          Take a volume as an input and export a texture of the density field.  
- 
        
            
        
        
            
                Labs WFC Initialize Grid
            
          A utility tool to initialize a WFC grid to be used with the WFC Solver  
- 
        
            
        
        
            
                Labs WFC Sample Paint
            
          A utility tool to paint attribute values on a grid used by the WFC Solver  
- 
        
            
        
        
            
                Labs Wang Tiles Decoder
            
          A decoder that decodes color information into Wang Tilesets.  
- 
        
            
        
        
            
                Labs Wang Tiles Sample
            
          Sample tiles that can be used as Wang Tilesets.  
- 
        
            
        
        
            
                Labs XYZ Pointcloud Exporter
            
          Export a pointcloud to XYZ file.  
- 
        
            
        
        
            
                Labs ZibraVDB Compress
            
         Compresses a VDB sequence and caches it to disk as a single  .zibravdb file. 
- 
        
            
        
        
            
                Labs ZibraVDB Decompress
            
         Loads a single .zibravdb file from disk and decompresses it as a VDB sequence. 
- 
        
            
        
        
            
                Labs ZibraVDB File Cache
            
         Performs compression and caching, or loading and decompression, of a VDB sequence to or from a single .zibravdb file. 
- 
        
            
        
        
            
                Laplacian
            
         Computes a discrete Laplacian matrix. 
- 
        
            
        
        
            
                Lattice Deform
            
         Deforms geometry based on how you reshape control geometry. 
- 
        
            
        
        
            
                Lattice from Volume
            
         Create a point cloud, connected polyline, tet or hex mesh around the active region of volumes. This node creates a deformation lattice for use with the Volume Deform node. 
- 
        
            
        
        
            
                Lidar Import
            
         Reads a lidar file and imports a point cloud from its data. 
- 
        
            
        
        
            
                Line
            
         Creates polygon or NURBS lines from a position, direction, and distance. 
- 
        
            
        
        
            
                Linear Reduce
            
         Compute the components of a reduced loss function. 
- 
        
            
        
        
            
                Linear Solver
            
         Solves system of linear equations. 
- 
        
            
        
        
            
                MDD
            
         Animates points using an MDD file. 
- 
        
            
        
        
            
                ML Attribute Generate
            
         Generate multiple copies of the input geometry with specified attributes randomized. 
- 
        
            
        
        
            
                ML Deform
            
         Use an ML model to deform the skin of a character. 
- 
        
            
        
        
            
                ML Example
            
         Create examples from input components and an optional target components 
- 
        
            
        
        
            
                ML Example Decompose
            
         Obtain the input components and the optional target components from examples 
- 
        
            
        
        
            
                ML Example Import
            
         Import examples from a raw file 
- 
        
            
        
        
            
                ML Example Partition
            
         Partition examples into parts that each have a specified maximum size 
- 
        
            
        
        
            
                ML Extract Example
            
         Extract a single example from a set of examples 
- 
        
            
        
        
            
                ML Pose Deserialize
            
         Obtain a pose from a float point attribute. 
- 
        
            
        
        
            
                ML Pose Generate
            
         Generate a set of random poses. 
- 
        
            
        
        
            
                ML Pose Serialize
            
         Represent a pose as a float point attribute. 
- 
        
            
        
        
            
                ML Regression Inference
            
         Apply a model trained using ML Train Regression in a geometry network. 
- 
        
            
        
        
            
                ML Regression Kernel
            
         Determine an output based on a kernel model that optimally fits given labeled examples. 
- 
        
            
        
        
            
                ML Regression Linear
            
         Determine an output based on a linear model that optimally fits given labeled examples. 
- 
        
            
        
        
            
                ML Regression Proximity
            
         Determine an output based on the proximity of a query input to the inputs of labeled examples. 
- 
        
            
        
        
            
                ML Volume Tile Component
            
         Crops volumes so they can be used with other ML SOPs as training examples 
- 
        
            
        
        
            
                ML Volume Tile Inference
            
         Runs an ONNX model on volume tiles 
- 
        
            
        
        
            
                ML Volume Upres
            
         Increases the resolution of an input volume using an ONNX model 
- 
        
            
        
        
            
                MPM Collider
            
         Defines VDB colliders to bounce or kill MPM material. 
- 
        
            
        
        
            
                MPM Container
            
         Defines the simulation resolution, start frame, and domain limits of a MPM simulation. 
- 
        
            
        
        
            
                MPM Debris Source
            
         Extracts points of potential emission for secondary simulations derived from a primary MPM simulation. 
- 
        
            
        
        
            
                MPM Deform Pieces
            
         Transfers the dynamics of the MPM simulation onto the renderable geometry. 
- 
        
            
        
        
            
                MPM Post-Fracture
            
         Fractures the renderable geometry represented in a MPM simulation using the final state of the simulation. 
- 
        
            
        
        
            
                MPM Solver
            
         Solves the MPM simulation described by its inputs and parameters. 
- 
        
            
        
        
            
                MPM Source
            
         Creates MPM particles from a geometry mesh or volume. 
- 
        
            
        
        
            
                MPM Surface
            
         Generates a surface based on a MPM simulation. 
- 
        
            
        
        
            
                Magnet
            
         Deforms geometry by using another piece of geometry
to attract or repel points. 
- 
        
            
        
        
            
                Map Points
            
         Stores a reference on a point to a point in another geometry. 
- 
        
            
        
        
            
                Mask by Feature
            
         Creates a point attribute mask based on visibility/lighting, letting you limit the effect of other nodes to areas that are visible, or facing a certain direction, or in shadow. 
- 
        
            
        
        
            
                Match Axis
            
         Aligns the input geometry to a specific axis. 
- 
        
            
        
        
            
                Match Size
            
         Resizes and recenters the input geometry to match a reference bounding box. 
- 
        
            
        
        
            
                Match Topology
            
         Reorders the primitive and point numbers of the input geometry to match some reference geometry. 
- 
        
            
        
        
            
                Material
            
         Assigns one or more materials to geometry. 
- 
        
            
        
        
            
                Measure
            
         Measures area, volume, or curvature of individual elements or larger pieces of a geometry and puts the results in attributes. 
- 
        
            
        
        
            
                Measure Thickness
            
         Measures point-wise thickness. 
- 
        
            
        
        
            
                Merge
            
         Merges geometry from its inputs. 
- 
        
            
        
        
            
                Merge Packed
            
         Merges and names geometry from its inputs. 
- 
        
            
        
        
            
                MetaGroups
            
         Defines groupings of metaballs so that separate groupings are treated
as separate surfaces when merged. 
- 
        
            
        
        
            
                Metaball
            
         Creates metaballs and meta-superquadric surfaces. 
- 
        
            
        
        
            
                Mirror
            
         Duplicates and mirrors geometry across a mirror plane. 
- 
        
            
        
        
            
                Mocap Import
            
         Parses and imports motion capture data as geometry. 
- 
        
            
        
        
            
                Mocap Stream
            
         This SOP outputs live motion capture data from various devices 
- 
        
            
        
        
            
                Motion Mixer
            
         Combines animation clips and effects to generate character animation. 
- 
        
            
        
        
            
                Motion Mixer FX
            
         Defines Motion Mixer Effects. 
- 
        
            
        
        
            
                Motion Mixer Fetch
            
         Fetches the motion mixer’s internal geometry when cooking a MotionClip effect. 
- 
        
            
        
        
            
                Motion Mixer Retime
            
         Defines a Motion Mixer Retime Effect. 
- 
        
            
        
        
            
                Motion Mixer Setup
            
         Initializes a Motion Mixer. 
- 
        
            
        
        
            
                Motion Mixer Smooth
            
         Defines a Motion Mixer Smooth Effect. 
- 
        
            
        
        
            
                Motion Mixer Transform
            
         Defines a Motion Mixer Transform Effect. 
- 
        
            
        
        
            
                MotionClip
            
         Converts a skeleton animation to a MotionClip. 
- 
        
            
        
        
            
                MotionClip Blend
            
         Blends the animation of one MotionClip on top of another 
- 
        
            
        
        
            
                MotionClip Cycle
            
         Smoothly loops a section of a MotionClip 
- 
        
            
        
        
            
                MotionClip Evaluate
            
         Evaluates a single frame of a MotionClip. 
- 
        
            
        
        
            
                MotionClip Extract
            
         Extracts the motion of joints over a set of frames from a MotionClip. 
- 
        
            
        
        
            
                MotionClip Extract Key Poses
            
         Identifies the key poses of an animation 
- 
        
            
        
        
            
                MotionClip Extract Locomotion
            
         Extracts the locomotion from a MotionClip and manages its representation. 
- 
        
            
        
        
            
                MotionClip Pose Delete
            
         Removes the specified poses from the MotionClip. 
- 
        
            
        
        
            
                MotionClip Pose Insert
            
         Adds a new sample to a MotionClip containing the given pose 
- 
        
            
        
        
            
                MotionClip Retime
            
         Adjusts the timing of a MotionClip 
- 
        
            
        
        
            
                MotionClip Sequence
            
         Concatenates two MotionClips. 
- 
        
            
        
        
            
                MotionClip Update
            
         Update a MotionClip using the given point list. 
- 
        
            
        
        
            
                Muscle Adjust Volume
            
         Adjusts volume of muscle geometry. 
- 
        
            
        
        
            
                Muscle Auto Tension Lines
            
         Creates a tension line for each muscle by finding the longest line between muscle ends. 
- 
        
            
        
        
            
                Muscle Constraint Properties Otis
            
         Creates and modifies the muscle Otis constraints for the input solid muscle geometry in preparation for the muscle simulation. 
- 
        
            
        
        
            
                Muscle Constraint Properties Vellum
            
         Creates and modifies the muscle Vellum constraints for the input solid muscle geometry in preparation for the muscle solver. 
- 
        
            
        
        
            
                Muscle Deform
            
         Deforms muscles based on rest and target bone geometry using a fast, quasi-static solve for realistic volume-preserving motion. 
- 
        
            
        
        
            
                Muscle Deintersect
            
         Separates intersecting muscle geometry by resolving collisions. 
- 
        
            
        
        
            
                Muscle Flex
            
         Activates and animates the contraction and relaxation of input solid muscle geometry. 
- 
        
            
        
        
            
                Muscle ID
            
         Creates and assigns Muscle IDs to each connected cluster of primitives on the input geometry. 
- 
        
            
        
        
            
                Muscle Merge
            
         Merges muscle geometry from its inputs. 
- 
        
            
        
        
            
                Muscle Mirror
            
         Duplicates muscle geometry with symmetry. Muscle attributes are also copied/renamed with symmetry. 
- 
        
            
        
        
            
                Muscle Paint
            
         A stroke-based paint tool for modifying muscle attributes. 
- 
        
            
        
        
            
                Muscle Preroll
            
         Transitions input bone, muscle, tissue, or skin geometry from their static t-poses into the start frame of their animated sequence. 
- 
        
            
        
        
            
                Muscle Properties Otis
            
         Creates and modifies the physical properties for the input solid muscle geometry in preparation for the Otis solver. 
- 
        
            
        
        
            
                Muscle Properties Vellum
            
         Creates and modifies the physical properties for the input solid muscle geometry in preparation for the Vellum muscle solver. 
- 
        
            
        
        
            
                Muscle Solidify
            
         Converts input surface geometry to a tetrahedral mesh for use as muscles. 
- 
        
            
        
        
            
                Muscle Solver Vellum
            
         Computes the dynamics simulation for the muscle pass using Vellum. 
- 
        
            
        
        
            
                Muscle Tension Lines
            
         Creates and attaches line segments to input bone surface geometry that then drive muscle flexion. 
- 
        
            
        
        
            
                Muscle Tension Lines Activate
            
         Calculates activation values for tension lines based on the position of the animated bones and the settings specified on the node. 
- 
        
            
        
        
            
                Muscle Transfer
            
         Transfers muscle and bones geometry between characters. 
- 
        
            
        
        
            
                Name
            
         Creates a naming attribute on points or primitives allowing you
to refer to them easily, similar to groups. 
- 
        
            
        
        
            
                Neural Point Surface
            
         Turns a point cloud into a VDB surface using a pretrained convolutional neural network. 
- 
        
            
        
        
            
                Normal
            
         Computes surface normal attribute. 
- 
        
            
        
        
            
                Null
            
         This node passes its input through to its output unchanged. It can act as a fixed place in the network for path references. 
- 
        
            
        
        
            
                ONNX Inference
            
         Applies inference from an ONNX Machine Learning model. 
- 
        
            
        
        
            
                Object Merge
            
         Merges geometry from multiple sources and allows you to define the manner in which they are grouped together and transformed. 
- 
        
            
        
        
            
                Ocean Evaluate
            
         Deforms input geometry based on ocean spectrum volumes. 
- 
        
            
        
        
            
                Ocean Foam
            
         Generates particle-based foam 
- 
        
            
        
        
            
                Ocean Source
            
         Generates particles and volumes from ocean spectrum volumes for use in simulations 
- 
        
            
        
        
            
                Ocean Spectrum
            
         Generates volumes containing information for simulating ocean waves. 
- 
        
            
        
        
            
                Ocean Waves
            
         Instances individual waveforms onto input points and generated points. 
- 
        
            
        
        
            
                OpenCL
            
         Executes an OpenCL kernel on geometry. 
- 
        
            
        
        
            
                Orient Joints
            
         Orients joints on a target skeleton. 
- 
        
            
        
        
            
                Orientation along Curve
            
         Computes orientations (frames) along curves. 
- 
        
            
        
        
            
                Otis Muscle and Tissue Configure
            
         Creates Muscle & Tissue constraints compatible the Otis Solver SOP. 
- 
        
            
        
        
            
                Otis Solver
            
         Summary. 
- 
        
            
        
        
            
                Output
            
         Marks the output of a sub-network. 
- 
        
            
        
        
            
                Pack
            
         Packs geometry into an embedded primitive. 
- 
        
            
        
        
            
                Pack Folder
            
         Packs inputs into a folder structure. 
- 
        
            
        
        
            
                Pack Inject
            
         Replaces the contents of Packed Primitives in-place. 
- 
        
            
        
        
            
                Pack Points
            
         Packs points into a tiled grid of packed primitives. 
- 
        
        
            
                Packed Disk Properties
            
         Change Properties of Packed Disk Primitives. 
- 
        
            
        
        
            
                Packed Folder Copy
            
         Copies or renames packed folders. 
- 
        
            
        
        
            
                Packed Folder Split
            
         Extracts contents from a packed folder structure. 
- 
        
            
        
        
            
                Packed Properties
            
         Change Properties of Packed Primitives. 
- 
        
            
        
        
            
                Paint Color Volume
            
         Creates a color volume based on drawn curve 
- 
        
            
        
        
            
                Paint Fog Volume
            
         Creates a fog volume based on drawn curve 
- 
        
            
        
        
            
                Paint SDF Volume
            
         Creates an SDF volume based on drawn curve 
- 
        
            
        
        
            
                Parent Joints
            
         Parent Joints on a target skeleton. 
- 
        
            
        
        
            
                Particle Fluid Surface
            
         Generates a surface around the particles from a particle fluid simulation. 
- 
        
            
        
        
            
                Particle Fluid Tank
            
         Creates a set of regular points filling a tank. 
- 
        
            
        
        
            
                Particle Trail
            
         Generates trails from the incoming particles that can be used to render sparks, fireworks, and rain. 
- 
        
            
        
        
            
                Path Deform
            
         Deforms geometry using the shape of a curve. 
- 
        
            
        
        
            
                Peak
            
         Moves primitives, points, edges or breakpoints along their normals. 
- 
        
            
        
        
            
                Pendulum Motion
            
         Inserts periods of pendulum motion into the middle of character animations. 
- 
        
            
        
        
            
                Planar Inflate
            
         Inflates a polygon into a triangle mesh. 
- 
        
            
        
        
            
                Planar Patch
            
         Creates a planar polygonal patch. 
- 
        
            
        
        
            
                Planar Patch from Curves
            
         Fills in a 2d curve network with triangles. 
- 
        
            
        
        
            
                Planar Pleat
            
         Deforms flat geometry into a pleat. 
- 
        
            
        
        
            
                Planar Tiles
            
         Generates rectangular tiles for texture patterns. 
- 
        
            
        
        
            
                Platonic Solids
            
         Creates platonic solids of different types. 
- 
        
            
        
        
            
                Point Capture
            
         Generates connectivity aware capture weights for use with Point Deform. 
- 
        
            
        
        
            
                Point Cloud Iso
            
         Constructs an iso surface from its input points. 
- 
        
            
        
        
            
                Point Cloud Measure
            
         Measures unorganized points using the characteristics of each point’s neighborhood, and puts the results in attributes. 
- 
        
            
        
        
            
                Point Cloud Normal
            
         Computes point cloud normal vectors and gives them a consistent direction. 
- 
        
            
        
        
            
                Point Cloud Reduce
            
         Reduces a point cloud using a point grid. 
- 
        
            
        
        
            
                Point Cloud Surface
            
         Constructs a surface from a point cloud. 
- 
        
            
        
        
            
                Point Deform
            
         Deforms geometry according to an arbitrary connected point mesh. 
- 
        
            
        
        
            
                Point Generate
            
         Creates new points, optionally based on point positions in the input geometry. 
- 
        
            
        
        
            
                Point Jitter
            
         Jitters points in random directions. 
- 
        
            
        
        
            
                Point Relax
            
         Moves points with overlapping radii away from each other, optionally on a surface. 
- 
        
            
        
        
            
                Point Replicate
            
         Generates a cloud of points around the input points. 
- 
        
            
        
        
            
                Point Split
            
         Splits points shared by multiple vertices, optionally only if the vertices
differ in attribute values. 
- 
        
            
        
        
            
                Point Velocity
            
          Computes and manipulates velocities for points of a geometry.  
- 
        
            
        
        
            
                Point Weld
            
         Merges points interactively. 
- 
        
            
        
        
            
                Points from Volume
            
         Creates set of regular points filling a volume. 
- 
        
            
        
        
            
                Poly Bridge
            
         Creates flat or tube-shaped polygon surfaces between source and destination edge loops, with controls for the shape of the bridge. 
- 
        
            
        
        
            
                Poly Expand 2D
            
         Creates offset polygonal geometry for planar polygonal graphs. 
- 
        
            
        
        
            
                Poly Extrude
            
         Extrudes polygonal faces and edges. 
- 
        
            
        
        
            
                PolyBevel
            
         Creates straight, rounded, or custom fillets along edges and corners. 
- 
        
            
        
        
            
                PolyCut
            
         Breaks curves where an attribute crosses a threshold. 
- 
        
            
        
        
            
                PolyDoctor
            
         Helps repair invalid polygonal geometry, such as for cloth simulation. 
- 
        
            
        
        
            
                PolyFill
            
         Fills holes with polygonal patches. 
- 
        
            
        
        
            
                PolyFrame
            
         Creates coordinate frame attributes for points and vertices. 
- 
        
            
        
        
            
                PolyHinge
            
         Extrudes polygonal faces around a pivot line. 
- 
        
            
        
        
            
                PolyLoft
            
         Creates new polygons using existing points. 
- 
        
            
        
        
            
                PolyPatch
            
         Creates a smooth polygonal patch from primitives. 
- 
        
            
        
        
            
                PolyPath
            
         Cleans up topology of polygon curves. 
- 
        
            
        
        
            
                PolyReduce
            
         Reduces the number of polygons in a model while retaining its shape. This node preserves features, attributes, textures, and quads during reduction. 
- 
        
            
        
        
            
                PolySoup
            
         Combines polygons into a single primitive that can be more efficient for many polygons 
- 
        
            
        
        
            
                PolySpline
            
         The PolySpline SOP fits a spline curve to a polygon or hull and
outputs a polygonal approximation of that spline. 
- 
        
            
        
        
            
                PolySplit
            
         Divides an existing polygon into multiple new polygons. 
- 
        
            
        
        
            
                PolyWire
            
         Constructs polygonal tubes around polylines, creating
renderable geometry with smooth bends and intersections. 
- 
        
            
        
        
            
                Pose Difference
            
         Compute the difference between point transforms on two SOP skeletons. 
- 
        
            
        
        
            
                Pose Scope
            
         Assigns channel paths and/or pickscripts to geometry. 
- 
        
            
        
        
            
                Pose-Space Deform
            
         (Deprecated) Interpolates between a set of pose-shapes based on the value of a set of drivers. 
- 
        
            
        
        
            
                Pose-Space Deform Combine
            
         (Deprecated) Combine result of Pose-Space Deform with rest geometry. 
- 
        
            
        
        
            
                Pose-Space Edit
            
         (Deprecated) Packs geometry edits for pose-space deformation. 
- 
        
            
        
        
            
                Pose-Space Edit Configure
            
         (Deprecated) Creates common attributes used by the Pose-Space Edit SOP. 
- 
        
            
        
        
            
                Primitive Properties
            
         Edits primitive, primitive attributes, and profile curves. 
- 
        
            
        
        
            
                Principal Component Analysis
            
         Computes the principle components of volume or point data. 
- 
        
            
        
        
            
                Projectile Motion
            
         Inserts periods of projectile motion into the middle of character animations. 
- 
        
            
        
        
            
                Proximity
            
         Finds the nearest points to one or more target points. 
- 
        
            
        
        
            
                Pyro Bake Volume
            
         Helps develop the volume look both for viewport display and rendering after the pyro solve. 
- 
        
            
        
        
            
                Pyro Burst Source
            
         Creates points suitable for sourcing into pyro simulations to create explosions, muzzle flashes, shockwaves, and detonation rings. 
- 
        
            
        
        
            
                Pyro Post-Process
            
         Applies common post-processing effects to the results of Pyro solves. 
- 
        
            
        
        
            
                Pyro Scatter from Burst
            
         Generates a cloud of points around the input points suitable for pyro trails and particle simulations. 
- 
        
            
        
        
            
                Pyro Solver
            
         Runs a dynamic Pyro simulation. 
- 
        
            
        
        
            
                Pyro Source
            
          Creates points for sourcing pyro and smoke simulations.  
- 
        
            
        
        
            
                Pyro Source Instance
            
          Creates source instance points from spawn points for sourcing pyro
simulations with packed sets.  
- 
        
            
        
        
            
                Pyro Source Pack
            
          Creates a packed source set from the input volumes.  
- 
        
            
        
        
            
                Pyro Source Spread
            
         Pyro Source Spread solves for the spreading of flame across a point cloud. 
- 
        
            
        
        
            
                Pyro Spawn Sources
            
          Creates spawn points for sourcing pyro simulations with packed sets.  
- 
        
            
        
        
            
                Pyro Thruster Exhaust
            
         Creates volumes and particles to simulate thruster exhausts without the need of simulation. 
- 
        
            
        
        
            
                Pyro Trail Path
            
         Generates curves to use as trails for the Pyro Trail Source node. 
- 
        
            
        
        
            
                Pyro Trail Source
            
         Creates points suitable for sourcing into pyro simulations to create trails for explosions. 
- 
        
            
        
        
            
                Python
            
         Runs a Python snippet to modify the incoming geometry. 
- 
        
            
        
        
            
                Python Snippet
            
         Runs a snippet of Python on geometry. 
- 
        
            
        
        
            
                Quad Remesh
            
         Converts an arbitrary mesh into structured quadrilaterals. 
- 
        
            
        
        
            
                RBD Bullet Solver
            
         Runs a dynamic Bullet simulation. 
- 
        
            
        
        
            
                RBD Car Deform
            
         Add Post-Sim Deformations to RBD Cars. 
- 
        
            
        
        
            
                RBD Car Follow Path
            
         Animate a RBD Car Rig along a path. 
- 
        
            
        
        
            
                RBD Car Fracture
            
         Fracture a RBD Car Rig. 
- 
        
            
        
        
            
                RBD Car Rig
            
         Builds a drivable RBD Car Rig. 
- 
        
            
        
        
            
                RBD Car Transform
            
         Transform a fractured car. 
- 
        
            
        
        
            
                RBD Cluster
            
         Combines fractured pieces or constraints into larger clusters. 
- 
        
            
        
        
            
                RBD Cone Twist Constraint Properties
            
         Creates attributes describing rigid body cone twist constraints. 
- 
        
            
        
        
            
                RBD Configure
            
         Packs and creates attributes describing rigid body objects. 
- 
        
            
        
        
            
                RBD Connected Faces
            
         Stores the primitive number and distance to the opposite face on the inside faces of fractured geometry. 
- 
        
            
        
        
            
                RBD Constraint Properties
            
         Creates attributes describing rigid body constraints. 
- 
        
            
        
        
            
                RBD Constraints From Curves
            
         Creates rigid body constraint geometry from curves drawn in the viewport. 
- 
        
            
        
        
            
                RBD Constraints From Lines
            
         Creates rigid body constraint geometry from interactively drawn lines in the viewport. 
- 
        
            
        
        
            
                RBD Constraints From Rules
            
         Creates rigid body constraint geometry from a set of rules and conditions. 
- 
        
            
        
        
            
                RBD Convert Constraints
            
         Converts existing constraint prims into constraints with different anchor positions. 
- 
        
            
        
        
            
                RBD Deform Pieces
            
         Deforms geometry with simulated proxy geometry. 
- 
        
            
        
        
            
                RBD Deforming to Animated
            
         Converts deforming geometry to animated static packed objects. 
- 
        
            
        
        
            
                RBD Disconnected Faces
            
         Detects when connected faces have become separated. 
- 
        
            
        
        
            
                RBD Exploded View
            
         Visualize RBD fractured geometry merged with the proxy geometry, pushed out from the center to create an exploded view. 
- 
        
            
        
        
            
                RBD Find Instances
            
         Find instances of the same geometry pieces and replace them with packed geometry instances. 
- 
        
            
        
        
            
                RBD Group Constraints
            
         Creates constraint groups from anchored RBD pieces groups. 
- 
        
            
        
        
            
                RBD Guide Setup
            
         Sets attributes on packed fragments for the RBD Guide DOP. 
- 
        
            
        
        
            
                RBD I/O
            
         Packs RBD fractured geometry, saves them to disk, and loads them back again. 
- 
        
            
        
        
            
                RBD Interior Detail
            
         Creates additional detail on the interior surfaces of fractured geometry. 
- 
        
            
        
        
            
                RBD Match Transforms
            
         Given an untransformed reference, extracts the transforms for each piece per name, from either Geometry or Proxy Geometry, and applies them to the geometry with the corresponding name attribute. 
- 
        
            
        
        
            
                RBD Material Fracture
            
         Fractures the input geometry based on a material type. 
- 
        
            
        
        
            
                RBD Pack
            
         Packs RBD geometry, constraints, and proxy geometry into a single geometry. 
- 
        
            
        
        
            
                RBD Paint
            
         Paints values onto geometry or constraints using strokes. 
- 
        
        
            
                RBD Transform
            
         The RBD Transform operator performs a Transform operation on all 3 source geometries (Geometry, Constraint Geometry and Proxy Geometry) at once. 
- 
        
            
        
        
            
                RBD Unpack
            
         Unpacks an RBD setup into three outputs. 
- 
        
            
        
        
            
                RMan Shader
            
         Attaches RenderMan shaders to groups of faces. 
- 
        
            
        
        
            
                ROP FBX Animation Output
            
         Export animation from geometry-based skeleton to an FBX file. 
- 
        
            
        
        
            
                ROP FBX Character Output
            
         Export a skinned character with geometry-based skeleton to an FBX file. 
- 
        
            
        
        
            
                ROP GLTF Character Output
            
         Export a skinned character with a geometry-based skeleton to a glTF or glb (binary) file. 
- 
        
            
        
        
            
                ROP Geometry Output
            
         
- 
        
            
        
        
            
                ROP Geometry Raw Output
            
         
- 
        
            
        
        
            
                Ragdoll Collision Shapes
            
         Creates collision shapes for a KineFX skeleton to be used in a ragdoll RBD simulation. 
- 
        
            
        
        
            
                Ragdoll Solver
            
         Runs a ragdoll RBD simulation on the target skeleton. 
- 
        
            
        
        
            
                Rails
            
         Generates surfaces by stretching cross-sections between
two guide rails. 
- 
        
            
        
        
            
                Raw Import
            
         Imports raw binary files as point, detail, or volumes. 
- 
        
            
        
        
            
                Ray
            
         Projects one surface onto another. 
- 
        
            
        
        
            
                Recipe Builder
            
         Creates a subnetwork with spare parameters to use as a container for recipe creation. 
- 
        
            
        
        
            
                Refine
            
         Increases the number of points/CVs in a curve or surface
without changing its shape. 
- 
        
            
        
        
            
                Reguide
            
         Scatters new guides, interpolating the properties of existing guides. 
- 
        
            
        
        
            
                Remesh
            
         Recreates the shape of the input surface using high-quality (nearly equilateral) triangles. 
- 
        
            
        
        
            
                Remesh Bubbles
            
         Generates foam bubble like structure onto a point cloud. 
- 
        
            
        
        
            
                Remesh to Camera
            
         Subdivide input geometry to generate polygons smaller than a camera measurement. 
- 
        
            
        
        
            
                Remesh to Grid
            
         Rebuilds polygonal topology to straighten edges, close small holes, and remove interior geometry. 
- 
        
            
        
        
            
                Repack
            
         Repacks geometry as an embedded primitive. 
- 
        
            
        
        
            
                Resample
            
         Resamples one or more curves or surfaces into even length segments. 
- 
        
            
        
        
            
                Rest Position
            
         Creates rest attributes on the geometry so procedural
textures stay put on the surface as it deforms. 
- 
        
            
        
        
            
                Retime
            
         Retimes the time-dependent input geometry. 
- 
        
            
        
        
            
                Reverse
            
         Reverses or cycles the vertex order of faces. 
- 
        
            
        
        
            
                Reverse Foot
            
         Creates a reverse foot set up for the given input skeleton. 
- 
        
            
        
        
            
                Revolve
            
         Revolves a curve around a center axis to sweep out a surface. 
- 
        
        
            
                Rewire Vertices
            
         Rewires vertices to different points specified by an attribute. 
- 
        
            
        
        
            
                Rig Attribute VOP
            
         Runs a VOP network to modify geometry attributes on a KineFX rig. 
- 
        
            
        
        
            
                Rig Attribute Wrangle
            
         Runs a VEX snippet to modify transform attribute values on a KineFX rig. 
- 
        
            
        
        
            
                Rig Copy Transforms
            
         Attach the joints of a skeleton SOP to another, posed skeleton. 
- 
        
            
        
        
            
                Rig Doctor
            
         Optimizes and runs checks on a SOP skeleton. 
- 
        
            
        
        
            
                Rig Match Pose
            
         Conforms the rest poses of two skeletons in preparation for retargeting. 
- 
        
            
        
        
            
                Rig Mirror Pose
            
         Mirrors a SOP skeleton’s pose. 
- 
        
            
        
        
            
                Rig Pose
            
         Poses and animates a SOP rig or skeleton. 
- 
        
            
        
        
            
                Rig Python
            
         Runs a Python snippet to modify the incoming rig geometry. 
- 
        
            
        
        
            
                Rig Stash Pose
            
         Stores a static pose on a skeleton as a matrix point attribute. 
- 
        
            
        
        
            
                Ripple
            
         Generates ripples by displacing points along the up direction
specified. 
- 
        
            
        
        
            
                Ripple Solver
            
         Runs ripple simulations on geometry surfaces. 
- 
        
            
        
        
            
                Room Map Frame
            
         Setup geometry for usage with Karma Room Map 
- 
        
            
        
        
            
                Scatter
            
         Scatters new points randomly across a surface or through a volume. 
- 
        
            
        
        
            
                Scatter and Align
            
         Scatters points across a surface with randomized scale and orientation attributes for use with Copy to Points. 
- 
        
            
        
        
            
                Scatter in Texture Mask
            
         Scatters points on a mesh, with density controlled by a texture. 
- 
        
            
        
        
            
                Scene Character Export
            
         Export animation from a geometry-based character to the Scene (OBJ) context. 
- 
        
            
        
        
            
                Scene Character Import
            
         Creates a geometry-based character with animation from the Scene (OBJ) context. 
- 
        
            
        
        
            
                Script
            
         Runs scripts when cooked. 
- 
        
            
        
        
            
                Sculpt
            
         Interactively reshape a surface using brushes that push, pull, flatten, smooth, or deform the mesh similarly to sculpting a clay model.  
- 
        
            
        
        
            
                Secondary Motion
            
         Adds secondary motion effects to a static or animated input KineFX joint, skeleton, or character. 
- 
        
            
        
        
            
                Separate Pieces
            
         Separates geometry pieces based on a shared attribute. 
- 
        
            
        
        
            
                Sequence Blend
            
         Morphs though a sequence of 3D shapes, interpolating geometry and attributes. 
- 
        
            
        
        
            
                Set T-Pose
            
         Stores the rest position for the input bone, muscle, or tissue geometry. 
- 
        
            
        
        
            
                Shallow Water Solver
            
          Runs shallow water simulations on height fields.  
- 
        
            
        
        
            
                Shape Diff
            
         Computes the post-deform or pre-deform difference of two geometries with similar topologies. 
- 
        
            
        
        
            
                Shot Sculpt
            
         Interactive tool for creating and managing time-based deformations. 
- 
        
            
        
        
            
                Shrinkwrap
            
         Computes the convex hull of the input geometry and moves its polygons inwards along their normals. 
- 
        
            
        
        
            
                Skeleton
            
         Interactively creates and edits geometry-based skeletons. 
- 
        
            
        
        
            
                Skeleton Blend
            
         Blends the poses of multiple skeletons. 
- 
        
            
        
        
            
                Skeleton Mirror
            
         Modifies an input skeleton by duplicating joints across a mirror plane. 
- 
        
            
        
        
            
                Skin
            
         Builds a skin surface between any number of shape curves. 
- 
        
            
        
        
            
                Skin Deform
            
         Performs quasi-static deformation of skin geometry based on muscle and bone inputs. 
- 
        
            
        
        
            
                Skin Properties
            
         Creates and modifies skin attributes in preparation for the skin solver. 
- 
        
            
        
        
            
                Skin Solidify
            
         Converts surface geometry to a solid (tetrahedrons) and prepares the output geometry for solving with a skin solver. 
- 
        
            
        
        
            
                Skin Solver Vellum
            
         Computes the dynamics simulation for the skin pass using Vellum. 
- 
        
            
        
        
            
                Sky Box
            
         Creates a volume filled with volumetric clouds. 
- 
        
            
        
        
            
                Sky Field
            
         Generates an initial Sky Field volume to use with sky tools. 
- 
        
            
        
        
            
                Sky Field Noise
            
         Modifies a Sky Field using 2D cloud noise. 
- 
        
            
        
        
            
                Sky Field Pattern
            
         Modifies a Sky Field using a 2D cloud pattern. 
- 
        
            
        
        
            
                Sky Field from Map
            
         Modifies a Sky Field using an image saved on your disk. 
- 
        
            
        
        
            
                Smooth
            
         Smooths out (or relaxes) polygons, meshes and curves without increasing the number of points. 
- 
        
            
        
        
            
                Smooth Motion
            
         Smooths out unwanted noise in the animated input points or the KineFX joint, skeleton, or MotionClip. 
- 
        
            
        
        
            
                Soft Peak
            
         Moves the selected point along its normal or a custom normalized point attribute, 
with smooth rolloff to surrounding points. 
- 
        
            
        
        
            
                Soft Transform
            
         Moves the selected point, with smooth rolloff to surrounding points. 
- 
        
            
        
        
            
                Solid Fracture
            
         Creates a partition of a tetrahedral mesh that can be used for finite-element fracturing. 
- 
        
            
        
        
            
                Solver
            
         Allows running a SOP network iteratively over some input geometry, with the output of the network from the previous frame serving as the input for the network at the current frame. 
- 
        
            
        
        
            
                Sort
            
         Reorders points and primitives in different ways, including randomly. 
- 
        
            
        
        
            
                Sphere
            
         Creates a sphere or ovoid surface. 
- 
        
            
        
        
            
                Spiral
            
         Creates spirals and helices. 
- 
        
            
        
        
            
                Spline Align
            
         Aligns a group of primitives to each other or to an auxiliary input. 
- 
        
            
        
        
            
                Spline Basis
            
         Provides operations for moving knots within the parametric space
of a NURBS curve or surface. 
- 
        
            
        
        
            
                Spline Cap
            
         Closes open areas with flat or rounded coverings. 
- 
        
            
        
        
            
                Spline Clay
            
         Lets you deform NURBS faces and NURBS surfaces by pulling points that lie
directly on them. 
- 
        
            
        
        
            
                Spline Creep
            
         Deforms and animates a piece of geometry across a surface. 
- 
        
            
        
        
            
                Spline Curve Clay
            
         Deforms a spline surface by reshaping a curve on the surface. 
- 
        
            
        
        
            
                Spline Fillet
            
         Creates smooth bridging geometry between two curves or surfaces. 
- 
        
            
        
        
            
                Spline Fit
            
         Fits a spline curve to points, or a spline surface to a mesh of points. 
- 
        
            
        
        
            
                Spline Profile
            
         Extracts or manipulates profile curves. 
- 
        
            
        
        
            
                Spline Project
            
         Creates profile curves on surfaces. 
- 
        
            
        
        
            
                Spline Round
            
         Generates round fillets of a specified radius between two surfaces. 
- 
        
            
        
        
            
                Spline Surfsect
            
         Trims or creates profile curves along the intersection lines
between NURBS or bezier surfaces. 
- 
        
            
        
        
            
                Spline Trim
            
         Trims away parts of a spline surface defined by a profile curve
or untrims previous trims. 
- 
        
            
        
        
            
                Split
            
         Splits primitives or points into two streams. 
- 
        
            
        
        
            
                Split by Point Attribute
            
         Splits geometry along edges where a point attribute changes. 
- 
        
            
        
        
            
                Spray Paint
            
         Spray paints random points onto a surface. 
- 
        
            
        
        
            
                Sprite
            
         A SOP node that sets the sprite display for points. 
- 
        
            
        
        
            
                Stabilize Joint
            
         Removes jitter from the input animation and handles geometry snapping of joints. 
- 
        
            
        
        
            
                Starburst
            
         Insets points on polygonal faces. 
- 
        
            
        
        
            
                Stash
            
         Caches the input geometry in the node on command, and then uses it as the node’s output. 
- 
        
            
        
        
            
                Stitch
            
         Stretches two curves or surfaces to cover a smooth area. 
- 
        
            
        
        
            
                Stroke
            
         Low level tool for building interactive assets. 
- 
        
            
        
        
            
                Subdivide
            
         Subdivides polygons into smoother, higher-resolution polygons. 
- 
        
            
        
        
            
                Subnetwork
            
         The Subnet op is essentially a way of creating a macro to represent a collection of ops as a single op in the Network Editor. 
- 
        
            
        
        
            
                Super Quad
            
         Generates an isoquadric surface. 
- 
        
            
        
        
            
                Surface Deform
            
         Deforms points using a polygon surface. 
- 
        
            
        
        
            
                Sweep
            
         Creates a surface by sweeping a cross section curve along a spine curve. 
- 
        
            
        
        
            
                Switch
            
         Switches between network branches based on an expression or keyframe animation. 
- 
        
            
        
        
            
                Switch-If
            
         Switches between two network branches based on an expression or geometry test. 
- 
        
            
        
        
            
                TOP Geometry
            
         Sends input geometry to a TOP subnet and retrieves the output geometry. 
- 
        
            
        
        
            
                TOP Network
            
         The TOP Network operator contains SOP nodes for running tasks. 
- 
        
            
        
        
            
                Table Import
            
         Reads a CSV file creating point per row. 
- 
        
            
        
        
            
                Tangent Field
            
         Creates a smooth tangent (multi-) vector field on a polygonal surface. 
- 
        
            
        
        
            
                Test Geometry: Capybara
            
         Creates a capybara, which can be used as test geometry. 
- 
        
            
        
        
            
                Test Geometry: Crag
            
         Creates a rock creature, which can be used as test geometry. 
- 
        
            
        
        
            
                Test Geometry: Electra
            
         Creates Electra, the test KineFX character. 
- 
        
            
        
        
            
                Test Geometry: Otto
            
         Creates Otto, a production quality test character. 
- 
        
            
        
        
            
                Test Geometry: Pig Head
            
         Creates a pig head, which can be used as test geometry.. 
- 
        
            
        
        
            
                Test Geometry: Rubber Toy
            
         Creates a rubber toy, which can be used as test geometry. 
- 
        
            
        
        
            
                Test Geometry: Shader Ball
            
         Creates a shader ball, which can be used to test shaders. 
- 
        
            
        
        
            
                Test Geometry: Squab
            
         Creates a squab, which can be used as test geometry. 
- 
        
            
        
        
            
                Test Geometry: Template Body
            
         Creates a template body, which can be used as test geometry. 
- 
        
            
        
        
            
                Test Geometry: Template Head
            
         Creates a template head, which can be used as test geometry. 
- 
        
            
        
        
            
                Test Geometry: Tommy
            
         Creates a soldier, which can be used as test geometry. 
- 
        
            
        
        
            
                Test Simulation: Crowd Transition
            
         Provides a simple crowd simulation for testing transitions between animation clips. 
- 
        
            
        
        
            
                Test Simulation: Ragdoll
            
         Provides a simple Bullet simulation for testing the behavior of a ragdoll. 
- 
        
            
        
        
            
                Tet Conform
            
         Creates a tetrahedral mesh that conforms to a connected mesh as much as possible. 
- 
        
            
        
        
            
                Tet Embed
            
         Creates a simple tetrahedral mesh that covers a connected mesh. 
- 
        
        
            
                Tet Partition
            
         Partitions a given tetrahedron mesh into groups of tets isolated by a given polygon mesh 
- 
        
            
        
        
            
                Texture Feature
            
         Uses computer vision to identify feature points in an image. 
- 
        
        
            
                Texture Mask Paint
            
         Paints a mask into a texture map. 
- 
        
            
        
        
            
                Texture Optical Flow
            
         An operator that uses computer vision to track movement between two textures embedded as two-dimensional volumes. 
- 
        
            
        
        
            
                TimeShift
            
         Cooks its input at a different time. 
- 
        
            
        
        
            
                Tissue Properties Otis
            
         Creates and modifies tissue attributes in preparation for the tissue solver. 
- 
        
            
        
        
            
                Tissue Properties Vellum
            
         Creates and modifies tissue attributes in preparation for the Vellum tissue solver. 
- 
        
            
        
        
            
                Tissue Solidify Otis
            
         Solidifies an input surface or shell into a volumetric tissue structure composed of tetrahedra, ready for simulation with Otis Solver SOP. 
- 
        
            
        
        
            
                Tissue Solidify Vellum
            
         Converts surface geometry to a layered solid (tetrahedrons) and prepares the output geometry for solving with the Vellum tissue solver. 
- 
        
            
        
        
            
                Tissue Solver Vellum
            
         Computes the dynamics simulation for the Tissue pass using Vellum. 
- 
        
        
            
                Toon Shader Attributes
            
         Sets attributes used by the Toon Color Shader and Toon Outline Shader. 
- 
        
            
        
        
            
                Topo Flow
            
         Deforms a surface to match the size, shape, and texture of a different surface. 
- 
        
            
        
        
            
                Topo Flow Sample
            
         An operator that uses computer vision to identify distinct feature points in 
a given image file. 
- 
        
            
        
        
            
                Topo Landmark
            
         A state interface to establish correspondence from points on one surface 
to points on another surface. 
- 
        
            
        
        
            
                Topo Slide by Curve References
            
         Slides geometry across a surface using pairs of reference curves. 
- 
        
            
        
        
            
                Topo Transfer
            
         Non-rigidly deforms a surface to match the size and shape of a different surface. 
- 
        
            
        
        
            
                TopoBuild
            
         Lets you interactively draw a reduced quad mesh automatically snapped to existing geometry. 
- 
        
            
        
        
            
                Torus
            
         Creates a torus (doughnut) shaped surface. 
- 
        
            
        
        
            
                Trace
            
         Traces curves from an image file or heightfield. 
- 
        
            
        
        
            
                Trail
            
         Creates trails behind points. 
- 
        
            
        
        
            
                Transform
            
         The Transform operation transforms the source geometry in object space using a transformation matrix. 
- 
        
            
        
        
            
                Transform Axis
            
         Transforms the input geometry relative to a specific axis. 
- 
        
            
        
        
            
                Transform By Attribute
            
         Transforms the input geometry by a point attribute. 
- 
        
            
        
        
            
                Transform Pieces
            
         Transforms input geometry according to transformation attributes on template geometry. 
- 
        
            
        
        
            
                Tri Bezier
            
         Creates a triangular Bezier surface. 
- 
        
            
        
        
            
                TriDivide
            
         Refines triangular meshes using various metrics. 
- 
        
            
        
        
            
                Triangulate 2D
            
         Connects points to form well-shaped triangles. 
- 
        
            
        
        
            
                Tube
            
         Creates open or closed tubes, cones, or pyramids. 
- 
        
            
        
        
            
                USD Animation Import
            
         Imports a skeleton and animation from a UsdSkel character. 
- 
        
            
        
        
            
                USD Character Import
            
         Imports the rest geometry, skeleton, and animation from a UsdSkel character. 
- 
        
            
        
        
            
                USD Configure Import
            
         
- 
        
            
        
        
            
                USD Configure Prims from Points
            
         
- 
        
            
        
        
            
                USD File Export
            
         
- 
        
            
        
        
            
                USD File Import
            
         
- 
        
            
        
        
            
                USD Skin Import
            
         Imports skinned geometry from a UsdSkel character. 
- 
        
            
        
        
            
                UV Auto Seam
            
         Generates an edge group representing suggested seams for flattening a polygon model in UV space. 
- 
        
            
        
        
            
                UV Brush
            
         Adjusts texture coordinates in the UV viewport by painting. 
- 
        
            
        
        
            
                UV Edit
            
         Lets you interactively move UVs in the texture view. 
- 
        
            
        
        
            
                UV Flatten
            
         Creates flattened pieces in texture space from 3D geometry. 
- 
        
            
        
        
            
                UV Flatten from Points
            
         Creates UV islands from points that measure distance and direction outward from the sources. 
- 
        
            
        
        
            
                UV Fuse
            
         Merges UVs. 
- 
        
            
        
        
            
                UV Layout
            
         Packs UV islands efficiently into a limited area. 
- 
        
            
        
        
            
                UV Pelt
            
         Relaxes UVs by pulling them out toward the edges of the texture area. 
- 
        
            
        
        
            
                UV Project
            
         Assigns UVs by projecting them onto the surface from
a set direction. 
- 
        
            
        
        
            
                UV Quick Shade
            
         Applies an image file as a textured shader to a surface. 
- 
        
            
        
        
            
                UV Texture
            
         Assigns texture UV coordinates to geometry
for use in texture and bump mapping. 
- 
        
            
        
        
            
                UV Transform
            
         Transforms UV texture coordinates on the source geometry. 
- 
        
            
        
        
            
                UV Unwrap
            
         Separates UVs into reasonably flat, non-overlapping groups. 
- 
        
            
        
        
            
                Unix
            
         Processes geometry using an external program. 
- 
        
            
        
        
            
                Unpack
            
         Unpacks packed primitives. 
- 
        
            
        
        
            
                Unpack Folder
            
         Extracts contents from a packed folder structure. 
- 
        
            
        
        
            
                Unpack Points
            
         Unpacks points from packed primitives. 
- 
        
            
        
        
            
                Unpack USD
            
         Converts packed USD primitives into normal Houdini geometry. 
- 
        
            
        
        
            
                Unpaste
            
         The Unpaste op removes one or more pasted surfaces from a paste
hierarchy, causing the hierarchy to update. 
- 
        
            
        
        
            
                Unsubdivide
            
         Reverses mesh modifications performed by the Catmull-Clark algorithm. 
- 
        
            
        
        
            
                VDB
            
         Creates one or more empty/uniform VDB volume primitives. 
- 
        
            
        
        
            
                VDB Activate
            
         Activates voxel regions of a VDB for further processing. 
- 
        
            
        
        
            
                VDB Activate SDF
            
         Expand or contract signed distance fields stored on VDB volume primitives. 
- 
        
            
        
        
            
                VDB Advect
            
         Moves VDBs in the input geometry along a VDB velocity field. 
- 
        
            
        
        
            
                VDB Advect Points
            
         Moves points in the input geometry along a VDB velocity field. 
- 
        
            
        
        
            
                VDB Analysis
            
         Computes an analytic property of a VDB volumes, such as gradient or curvature. 
- 
        
            
        
        
            
                VDB Clip
            
         Clips VDB volume primitives using a bounding box or another VDB as a mask. 
- 
        
            
        
        
            
                VDB Collider
            
         Defines VDB colliders to bounce or kill dynamic objects. 
- 
        
            
        
        
            
                VDB Combine
            
         Combines the values of two VDB volumes in various ways. 
- 
        
            
        
        
            
                VDB Convex Clip SDF
            
         Clips an SDF VDB by a convex hull. 
- 
        
            
        
        
            
                VDB Diagnostics
            
         Tests VDBs for Bad Values and Repairs. 
- 
        
            
        
        
            
                VDB Extrapolate
            
         Extrapolate a VDB signed distance field. 
- 
        
            
        
        
            
                VDB Fracture
            
         Cuts level set VDB volume primitives into multiple pieces. 
- 
        
            
        
        
            
                VDB LOD
            
         Build an LOD Pyramid from a VDB. 
- 
        
            
        
        
            
                VDB Merge
            
         Combines many VDB volumes in various ways. 
- 
        
            
        
        
            
                VDB Morph SDF
            
         Blends between source and target SDF VDBs. 
- 
        
            
        
        
            
                VDB Occlusion Mask
            
         Create a mask of the voxels in shadow from a camera for VDB primitives. 
- 
        
            
        
        
            
                VDB Points Delete
            
         Deletes points inside of VDB Points primitives. 
- 
        
            
        
        
            
                VDB Points Group
            
         Manipulates the Internal Groups of a VDB Points Primitive. 
- 
        
            
        
        
            
                VDB Potential Flow
            
         Computes the steady-state air flow around VDB obstacles. 
- 
        
            
        
        
            
                VDB Project Non-Divergent
            
         Removes divergence from a Vector VDB. 
- 
        
            
        
        
            
                VDB Rasterize Frustum
            
         Rasterize points into density and attribute volumes. 
- 
        
            
        
        
            
                VDB Renormalize SDF
            
         Fixes signed distance fields stored in VDB volume primitives. 
- 
        
            
        
        
            
                VDB Resample
            
         Re-samples a VDB volume primitive into a new orientation and/or voxel size. 
- 
        
            
        
        
            
                VDB Reshape SDF
            
         Reshapes signed distance fields in VDB volume primitives. 
- 
        
            
        
        
            
                VDB Segment by Connectivity
            
         Splits SDF VDBs into connected components. 
- 
        
            
        
        
            
                VDB Smooth
            
         Smooths out the values in a VDB volume primitive. 
- 
        
            
        
        
            
                VDB Smooth SDF
            
         Smooths out SDF values in a VDB volume primitive. 
- 
        
            
        
        
            
                VDB Topology to SDF
            
         Creates an SDF VDB based on the active set of another VDB. 
- 
        
            
        
        
            
                VDB Vector Split
            
         Splits a vector VDB primitive into three scalar VDB primitives. 
- 
        
            
        
        
            
                VDB Vector from Scalar
            
         Merges three scalar VDB into one vector VDB. 
- 
        
            
        
        
            
                VDB Visualize Tree
            
         Replaces a VDB volume with geometry that visualizes its structure. 
- 
        
            
        
        
            
                VDB from Particle Fluid
            
         Generates a signed distance field (SDF) VDB volume representing the surface of a set of particles from a particle fluid simulation. 
- 
        
            
        
        
            
                VDB from Particles
            
         Converts point clouds and/or point attributes into VDB volume primitives. 
- 
        
            
        
        
            
                VDB from Polygons
            
         Converts polygonal surfaces and/or surface attributes into VDB volume primitives. 
- 
        
            
        
        
            
                VDB to Spheres
            
         Fills a VDB volume with adaptively-sized spheres. 
- 
        
            
        
        
            
                Vellum Attach Constraints
            
         Edit or create new vellum attach to geometry and stitch constraints, interactively. 
- 
        
            
        
        
            
                Vellum Brush
            
         Interactive brushing of Vellum geometry, grains, and fluids in the viewport. 
- 
        
            
        
        
            
                Vellum Configure Grain
            
         Configures geometry for Vellum Grain constraints. 
- 
        
            
        
        
            
                Vellum Configure Muscles
            
         Configures muscle geometry attributes and constraints for Vellum simulations. 
- 
        
            
        
        
            
                Vellum Configure Tissue
            
         Configures tissue geometry attributes and constraints for Vellum simulations. 
- 
        
            
        
        
            
                Vellum Constraint Properties
            
         Modifies common Vellum Constraint properties. 
- 
        
            
        
        
            
                Vellum Constraints
            
         Configure constraints on geometry for the Vellum solvers. 
- 
        
            
        
        
            
                Vellum Drape
            
         Vellum solver setup to pre-roll fabric to drape over characters. 
- 
        
            
        
        
            
                Vellum I/O
            
         Packs Vellum simulations, saves them to disk, and loads them back again. 
- 
        
            
        
        
            
                Vellum Pack
            
         Packs Vellum geometry and constraints into a single geometry. 
- 
        
            
        
        
            
                Vellum Post-Process
            
         Applies common post-processing effects to the result of Vellum solves. 
- 
        
            
        
        
            
                Vellum Reference Frame
            
         Ties Vellum points to a reference frame defined by moving geometry. 
- 
        
            
        
        
            
                Vellum Rest Blend
            
         Blends the current rest values of constraints with a rest state calculated from external geometry. 
- 
        
            
        
        
            
                Vellum Solver
            
         Runs a dynamic Vellum simulation. 
- 
        
            
        
        
            
                Vellum Transform Pieces
            
         Transforms geometry using the rest and solved data from Vellum Shape Match constraints. 
- 
        
            
        
        
            
                Vellum Unpack
            
         Unpacks a Vellum simulation into two outputs. 
- 
        
        
            
                Verify BSDF
            
         Verify that a bsdf conforms to the required interface. 
- 
        
            
        
        
            
                Visibility
            
         Shows/hides primitives in the 3D viewer and UV editor. 
- 
        
            
        
        
            
                Visualize Properties
            
         Lets you adjust display options and attach visualizers to geometry. 
- 
        
            
        
        
            
                Visualize Rig
            
         Visualizes the transformations and parenting of a SOP skeleton. 
- 
        
            
        
        
            
                Volume
            
         Creates a volume primitive. 
- 
        
            
        
        
            
                Volume Adjust Fog
            
         Modifies values on the incoming Volume and VDB primitives. 
- 
        
            
        
        
            
                Volume Ambient Occlusion
            
         A node that generates the ambient occlusion field of the provided density field. 
- 
        
            
        
        
            
                Volume Analysis
            
         Computes analytic properties of volumes. 
- 
        
            
        
        
            
                Volume Arrival Time
            
         Computes a speed-defined travel time from source points to voxels. 
- 
        
            
        
        
            
                Volume Blur
            
         Blurs the voxels of a volume. 
- 
        
            
        
        
            
                Volume Bound
            
         Bounds voxel data. 
- 
        
            
        
        
            
                Volume Break
            
         Cuts polygonal objects using a signed distance field volume. 
- 
        
            
        
        
            
                Volume Combine
            
         Combines multiple volumes or VDBs within one geometry into a new volume or VDB. 
- 
        
            
        
        
            
                Volume Compress
            
         Re-compresses Volume Primitives. 
- 
        
            
        
        
            
                Volume Convolve 3×3×3
            
         Convolves a volume by a 3×3×3 kernel. 
- 
        
            
        
        
            
                Volume Deform
            
         Deform a volume using lattice points. 
- 
        
            
        
        
            
                Volume FFT
            
         Compute the Fast Fourier Transform of volumes. 
- 
        
            
        
        
            
                Volume Feather
            
         Feathers the edges of volumes. 
- 
        
            
        
        
            
                Volume Merge
            
         Flattens many volumes into one volume. 
- 
        
            
        
        
            
                Volume Mix
            
         Combines the scalar fields of volume primitives. 
- 
        
            
        
        
            
                Volume Noise Fog
            
         Adds or generates noise in volume/VDB primitives. 
- 
        
            
        
        
            
                Volume Noise SDF
            
         Adds or generates noise and displaces an SDF. 
- 
        
            
        
        
            
                Volume Noise Vector
            
         Adds or generates noise in a Vector volume/VDB. 
- 
        
            
        
        
            
                Volume Normalize Weights
            
         Ensure a set of volumes add up to one. 
- 
        
            
        
        
            
                Volume Optical Flow
            
         Translates the motion between two image volumes into displacement vectors. 
- 
        
            
        
        
            
                Volume Patch
            
         Fill in a region of a volume with features from another volume. 
- 
        
            
        
        
            
                Volume Ramp
            
         Remaps a volume according to a ramp. 
- 
        
            
        
        
            
                Volume Rasterize
            
         Rasterizes into a volume. 
- 
        
            
        
        
            
                Volume Rasterize Attributes
            
         Samples point attributes into VDBs. 
- 
        
            
        
        
            
                Volume Rasterize Curve
            
         Converts a curve into a volume. 
- 
        
            
        
        
            
                Volume Rasterize Hair
            
         Converts fur or hair to a volume for rendering. 
- 
        
            
        
        
            
                Volume Rasterize Lattice
            
         Deform a volume using lattice points. 
- 
        
            
        
        
            
                Volume Rasterize Particles
            
         Converts a point cloud into a volume. 
- 
        
            
        
        
            
                Volume Rasterize Points
            
         Converts a point cloud into a volume. 
- 
        
            
        
        
            
                Volume Reduce
            
         Reduces the values of a volume into a single number. 
- 
        
            
        
        
            
                Volume Resample
            
         Resamples the voxels of a volume to a new resolution. 
- 
        
            
        
        
            
                Volume Resize
            
         Resizes the bounds of a volume without changing voxels. 
- 
        
            
        
        
            
                Volume SDF
            
         Builds a Signed Distance Field from an isocontour of a volume. 
- 
        
            
        
        
            
                Volume Slice
            
         Extracts 2d slices from volumes. 
- 
        
            
        
        
            
                Volume Splice
            
         Splices overlapping volume primitives together. 
- 
        
            
        
        
            
                Volume Stamp
            
         Stamps volumes instanced on points into a single target volume. 
- 
        
            
        
        
            
                Volume Surface
            
         Adaptively surfaces a volume hierarchy with a regular triangle mesh. 
- 
        
            
        
        
            
                Volume Trail
            
         Computes a trail of points through a velocity volume. 
- 
        
            
        
        
            
                Volume VOP
            
         Runs CVEX on a set of volume primitives. 
- 
        
            
        
        
            
                Volume Vector Join
            
         Merges multiple scalar Volumes into a vector Volume.. 
- 
        
            
        
        
            
                Volume Vector Split
            
         Splits a vector Volume primitive into scalar Volume primitives. 
- 
        
            
        
        
            
                Volume Velocity
            
         Computes a velocity volume. 
- 
        
        
            
                Volume Velocity from Curves
            
         Generates a volume velocity field using curve tangents. 
- 
        
        
            
                Volume Velocity from Surface
            
         Generates a velocity field within a surface geometry. 
- 
        
            
        
        
            
                Volume Visualization
            
         Adjusts attributes for multi-volume visualization. 
- 
        
            
        
        
            
                Volume Wrangle
            
         Runs a VEX snippet to modify voxel values in a volume. 
- 
        
            
        
        
            
                Volume from Attribute
            
         Sets the voxels of a volume from point attributes. 
- 
        
            
        
        
            
                Voronoi Adjacency
            
         Create a line segment between points with adjacent Voronoi cells 
- 
        
            
        
        
            
                Voronoi Fracture
            
         Fractures the input geometry by performing a Voronoi decomposition of space around the input cell points 
- 
        
            
        
        
            
                Voronoi Fracture Points
            
         Given an object and points of impact on the object, this SOP
generates a set of points that can be used as input to the Voronoi
Fracture SOP to simulate fracturing the
object from those impacts. 
- 
        
            
        
        
            
                Voronoi Split
            
         Cuts the geometry into small pieces according to a set of cuts
defined by polylines. 
- 
        
            
        
        
            
                Vortex Force Attributes
            
         Creates the point attributes needed to create a Vortex Force DOP. 
- 
        
            
        
        
            
                Weight Array Biharmonic
            
         Fills in index and weight array pairs for points on a mesh using biharmonic
functions. 
- 
        
            
        
        
            
                Weight Array Interpolate
            
         Evaluates weight arrays specified on points on a mesh at a given point within a primitive. 
- 
        
            
        
        
            
                Whitewater Post-Process
            
         Prepares the whitewater simulation for rendering. 
- 
        
            
        
        
            
                Whitewater Solver
            
         Sets and configures a Whitewater simulation inside a SOP network. 
- 
        
            
        
        
            
                Whitewater Source
            
          Generates the emission field for whitewater simulations.  
- 
        
            
        
        
            
                Winding Number
            
         Computes generalized winding number of surface at query points. 
- 
        
            
        
        
            
                Wire Blend
            
         Morphs between curve shapes while maintaining curve length. 
- 
        
            
        
        
            
                Wire Capture
            
         Captures surfaces to a wire,
allowing you to edit the wire to deform the surface. 
- 
        
            
        
        
            
                Wire Deform
            
         Deforms geometry captured to a curve via the Wire Capture node. 
- 
        
            
        
        
            
                Wire Transfer
            
         Transfers the shape of one curve to another. 
- 
        
            
        
        
            
                Wireframe
            
         Constructs polygonal tubes around polylines, creating renderable geometry. 
- 
        
            
        
        
            
                Wrinkle Deformer
            
         Deforms geometry to simulate surface wrinkles. 
- 
        
        
            
                _executionprovider_common
            
         
- 
        
        
            
                _mkl_note
            
         
- 
        
        
            
                _ml_attributeserialization_common
            
         
- 
        
        
            
                _ml_example_batch
            
         
- 
        
        
            
                _ml_generate_common
            
         
- 
        
        
            
                _ml_poseserialization_common
            
         
- 
        
        
            
                _ml_regression_kernel
            
         
- 
        
        
            
                _serial_common
            
         
- 
        
            
        
        
            
                glTF
            
         
- 
        
            
        
        
            
                glTF ROP output driver
            
         
- 
        
            
        
        
            
                rop_ml_exampleraw