- 
        
            
        
        
            
                Auto Stereogram
            
         Generates an image with a 3D illusion. 
- 
        
            
        
        
            
                Bake Geometry Textures
            
         Generates textures by baking between a low-resolution and high-resolution mesh at interactive speeds. 
- 
        
            
        
        
            
                Bend
            
         Curves images using handles or a captured region. 
- 
        
            
        
        
            
                Blend
            
         Blends two layers together. 
- 
        
            
        
        
            
                Block Begin
            
         Start of a block, containing its inputs. 
- 
        
            
        
        
            
                Block End
            
         End of a block, declaring its outputs. 
- 
        
            
        
        
            
                Block to Geometry
            
         Compiles a block and produces its geometry representation. 
- 
        
            
        
        
            
                Blur
            
         Applies a blur to a layer. 
- 
        
            
        
        
            
                Bokeh
            
         Creates a Bokeh effect by expanding each pixel by an aperture shape. 
- 
        
            
        
        
            
                Bounding Rectangle
            
         Finds the bounding rectangle of a mask. 
- 
        
            
        
        
            
                Bright
            
         Brightens a layer. 
- 
        
            
        
        
            
                Bubble Noise
            
         Generates bubble noise. 
- 
        
            
        
        
            
                Cable Filter
            
         Removes empty wires from a cable. 
- 
        
            
        
        
            
                Cable Merge
            
         Combines two cables into one cable. 
- 
        
            
        
        
            
                Cable Pack
            
         Combines input layers into a cable. 
- 
        
            
        
        
            
                Cable Rename
            
         Renames a cable’s wires based on filters. 
- 
        
            
        
        
            
                Cable Sort
            
         Sorts a cable’s wires by name. 
- 
        
            
        
        
            
                Cable Split
            
         Splits a cable based on filtering parameters. 
- 
        
            
        
        
            
                Cable Switch
            
         Selects an input cable. 
- 
        
            
        
        
            
                Cable Unpack
            
         Extracts individual wires from a cable. 
- 
        
            
        
        
            
                Cache
            
         Caches the input layers for faster playback. 
- 
        
            
        
        
            
                Camera Import
            
         Creates a layer in a camera’s space. 
- 
        
            
        
        
            
                Camera Properties
            
         Adjusts the camera properties of a layer. 
- 
        
            
        
        
            
                Channel Extract
            
         Extracts a channel from a layer. 
- 
        
            
        
        
            
                Channel Join
            
         Combines multiple Mono layers into one multichannel layer. 
- 
        
            
        
        
            
                Channel Split
            
         Divides a layer’s channels into Mono layers. 
- 
        
            
        
        
            
                Channel Swap
            
         Swaps channels within a multichannel layer. 
- 
        
            
        
        
            
                Checkerboard
            
         Creates an alternating checker pattern. 
- 
        
            
        
        
            
                Chladni Cymatic Patterns
            
         Generates interference patterns that represent various vibration modes. 
- 
        
            
        
        
            
                Chroma Key
            
         Keys an input based on hue, saturation, and luminance ranges. 
- 
        
            
        
        
            
                Chromatic Aberration
            
         Adds chromatic aberration to your image. 
- 
        
            
        
        
            
                Clamp
            
         Clamps an input layer. 
- 
        
            
        
        
            
                Cloud Noise 3D
            
         Generates a billowy cloud noise. 
- 
        
            
        
        
            
                Color Correct
            
         Adjusts colors in the image. 
- 
        
            
        
        
            
                Combine Layers
            
         Combines all input layers. 
- 
        
            
        
        
            
                Combine Normals
            
         Blends two normal maps together. 
- 
        
            
        
        
            
                Compare
            
         Creates a mask by comparing two layers. 
- 
        
            
        
        
            
                Constant
            
         Initializes pixels to constant values. 
- 
        
            
        
        
            
                Contact Sheet
            
         Arranges input layers into a contact sheet. 
- 
        
            
        
        
            
                Contrast
            
         Applies contrast to a layer. 
- 
        
            
        
        
            
                Convert Depth
            
         Converts depth layers between height, depth, and distance. 
- 
        
            
        
        
            
                Convert Normal
            
         Converts normal layers between signed and offset. 
- 
        
            
        
        
            
                Convolve 3×3
            
         Convolves a layer by a 3×3 kernel. 
- 
        
            
        
        
            
                Copy and Transform
            
         Copies stamps and applies transformations to the copies. 
- 
        
            
        
        
            
                Corner Pin
            
         Pins a layer’s corners in a reference layer. 
- 
        
            
        
        
            
                Crop
            
         Crops a layer to a new size. 
- 
        
            
        
        
            
                Cross Product
            
         Performs a cross product of two RGB layers. 
- 
        
            
        
        
            
                Cryptomatte
            
         Builds a matte from cryptomatte layers. 
- 
        
            
        
        
            
                Cryptomatte Decode
            
         Decodes a cyrptomatte into coverage and ID. 
- 
        
            
        
        
            
                Cryptomatte Encode
            
         Encodes a coverage and object hash into a cryptomatte layer. 
- 
        
            
        
        
            
                Crystal Noise
            
         Generates a sharp and angular Worley noise type. 
- 
        
            
        
        
            
                Crystal Noise 3D
            
         Generates a sharp and angular Worley noise type from 3D locations. 
- 
        
            
        
        
            
                Curvature
            
         Computes the curvature of a layer. 
- 
        
            
        
        
            
                Curve 3D
            
         Lets you interactively draw Bézier curves using tools similar to 2D illustration programs, as well as polylines and NURBS. 
- 
        
            
        
        
            
                Defocus
            
         Defocuses an input layer. 
- 
        
            
        
        
            
                Denoise AI
            
         Denoises an input layer. 
- 
        
            
        
        
            
                Denoise TVD
            
         Removes white noise from an image. 
- 
        
            
        
        
            
                Derivative
            
         Computes the derivative of the source layer along the x- and y-axis. 
- 
        
            
        
        
            
                Dilate Erode
            
         Dilates or erodes a layer. 
- 
        
            
        
        
            
                Distort
            
         Distorts an input layer. 
- 
        
            
        
        
            
                Dot Product
            
         Performs dot product between two layers. 
- 
        
            
        
        
            
                Edge Detect
            
         Detects edges in the input image. 
- 
        
            
        
        
            
                Edge Detect by Contour
            
         Detects varying-width silhouette lines. 
- 
        
            
        
        
            
                Edge Detect by Depth
            
         Detects varying-width self-occluding silhouettes. 
- 
        
            
        
        
            
                Edge Detect by Normal
            
         Detects varying-width crease-lines. 
- 
        
            
        
        
            
                Eikonal
            
         Computes distances by solving the Eikonal equation. 
- 
        
            
        
        
            
                Equalize
            
         Equalizes colors by stretching or shifting their range. 
- 
        
            
        
        
            
                Error
            
         Generates a message, warning, or error. 
- 
        
            
        
        
            
                Extrapolate Boundaries
            
         Fills empty areas of an image using colors at the edges of non-empty areas. 
- 
        
            
        
        
            
                Feather
            
         Smooths out sharp changes in contrast. 
- 
        
            
        
        
            
                Fetch
            
         Brings a COP node’s outputs into the current network. 
- 
        
            
        
        
            
                File
            
         Loads an image or video from disk. 
- 
        
            
        
        
            
                Fill
            
         Fills a layer with a constant value. 
- 
        
            
        
        
            
                Fill Connected
            
         Flood fills the connected regions of a layer. 
- 
        
            
        
        
            
                Flip
            
         Flips a layer horizontally, vertically, or diagonally. 
- 
        
            
        
        
            
                Flow Block Begin
            
         Start of a Flow simulation block. 
- 
        
            
        
        
            
                Flow Block End
            
         End of a Flow simulation block. 
- 
        
            
        
        
            
                Flow Project Non-Divergent Multigrid
            
         Removes divergent components from a 2-dimensional vector field. 
- 
        
            
        
        
            
                Font
            
         Rasterizes text onto a layer from Type 1, TrueType, and OpenType fonts. 
- 
        
            
        
        
            
                Fractal Noise
            
         Generates fractal noise. 
- 
        
            
        
        
            
                Fractal Noise 3D
            
         Generates fractal noise from 3D locations. 
- 
        
            
        
        
            
                Function
            
         Applies a mathematical function to a layer. 
- 
        
            
        
        
            
                Gamma
            
         Applies gamma correction to a layer. 
- 
        
            
        
        
            
                Geometry to Layer
            
         Converts a volume into a layer. 
- 
        
            
        
        
            
                Glow
            
         Adds glow to an image based on its luminance. 
- 
        
            
        
        
            
                Grunge Aurora
            
         Generates a pattern resembling an aurora display. 
- 
        
            
        
        
            
                Grunge Birch Bark
            
         Generates a pattern resembling the bark of a birch tree. 
- 
        
            
        
        
            
                Grunge Layered Noise
            
         Generates a higher-level noise pattern by layering simple noises. 
- 
        
            
        
        
            
                Grunge Pine Bark
            
         Generates a pattern resembling the bark of a pine tree. 
- 
        
            
        
        
            
                Grunge Rust
            
         Generates a pattern resembling rust on a surface. 
- 
        
            
        
        
            
                HSV Adjust
            
         Converts between RGB and HSV color spaces, or modifies HSV. 
- 
        
            
        
        
            
                Heat Distort
            
         Distorts the input layer to simulate heat around fire and other mirage effects. 
- 
        
            
        
        
            
                Heat Distort by Layer
            
         Distorts the input layer using another layer to simulate heat around fire and other mirage effects. 
- 
        
            
        
        
            
                Height to Ambient Occlusion
            
         Imagines a sphere for each pixel and determines how occluded that sphere is based on its surroundings. 
- 
        
            
        
        
            
                Height to Normal
            
         Converts a height layer to a normal layer. 
- 
        
            
        
        
            
                Height to Shadow
            
         Creates shadows using a virtual light source. 
- 
        
            
        
        
            
                HeightField Visualize
            
         Visualizes layers as colored heightfields. 
- 
        
            
        
        
            
                Hex Tile
            
         Randomly tiles texture. 
- 
        
            
        
        
            
                Histogram
            
         Builds a histogram from a layer. 
- 
        
            
        
        
            
                Hyperbolic Tile
            
         Generates hyperbolic polygon tiles for texture patterns. 
- 
        
            
        
        
            
                ID to Mask
            
         Creates a mask from an ID layer based on filtering parameters. 
- 
        
            
        
        
            
                ID to Mono
            
         Converts an ID layer into a mono layer. 
- 
        
            
        
        
            
                ID to RGB
            
         Converts an ID layer into an RGB layer. 
- 
        
            
        
        
            
                ID to SDF
            
         Computes a Signed Distance Field from changes in ID values. 
- 
        
            
        
        
            
                Illegal Pixel
            
         Detects and then fixes or highlights illegal pixels in images. 
- 
        
            
        
        
            
                Input
            
         Fetches the input to a subnetwork. 
- 
        
            
        
        
            
                Integrate Volume
            
         Integrates a VDB along camera rays. 
- 
        
            
        
        
            
                Invert
            
         Inverts a layer. 
- 
        
            
        
        
            
                Invoke Block
            
         Runs a block using inputs plugged into this node. 
- 
        
            
        
        
            
                Invoke Geometry
            
         Runs a program saved into geometry using inputs plugged into this node. 
- 
        
            
        
        
            
                Julia Fractal
            
         Computes the Julia set to create a fractal. 
- 
        
            
        
        
            
                Kuwahara Filter
            
         Applies the Kuwahara filter, which creates painterly effects. 
- 
        
            
        
        
            
                Lattice Deform
            
         Applies grid-based deformation to a layer. 
- 
        
            
        
        
            
                Layer
            
         Generates a layer. 
- 
        
            
        
        
            
                Layer Attribute Create
            
         Adds or edits user-defined metadata on a layer. 
- 
        
            
        
        
            
                Layer Attribute Delete
            
         Removes user-defined metadata from a layer. 
- 
        
            
        
        
            
                Layer Properties
            
         Edits basic layer metadata. 
- 
        
            
        
        
            
                Layer from Curves
            
         Render Curves into a Layer. 
- 
        
            
        
        
            
                Layer from VDB
            
         Sets a layer’s values from a VDB. 
- 
        
            
        
        
            
                Layer to Geometry
            
         Converts a layer into a 2D volume. 
- 
        
            
        
        
            
                Layer to Points
            
         Creates points based on a layer. 
- 
        
            
        
        
            
                Layer to VDB Leaf Points
            
         Creates a point for each leaf of a VDB that would be in an envelope. 
- 
        
            
        
        
            
                Lens Distort
            
         Adds radial and tangential distortion to a layer based on OpenCV coefficients. 
- 
        
            
        
        
            
                Light
            
         Lights a layer given a light direction and normals. 
- 
        
            
        
        
            
                Live Video
            
         Captures images from a live video source. 
- 
        
            
        
        
            
                Mask from Curves
            
         Creates a mask from 2D curves. 
- 
        
            
        
        
            
                Match Camera
            
         Transforms a layer to match a reference camera. 
- 
        
            
        
        
            
                Match UDIM
            
         Reframes pixels of a layer to match a particular UDIM tile. 
- 
        
            
        
        
            
                Median
            
         Applies a median filter to an image. 
- 
        
            
        
        
            
                Mirror
            
         Mirrors an image based on an arbitrary number of planes. 
- 
        
            
        
        
            
                Mono
            
         Converts a layer to mono. 
- 
        
            
        
        
            
                Mono to ID
            
         Converts a mono layer into an ID layer. 
- 
        
            
        
        
            
                Mono to RGB
            
         Converts a mono layer into an RGB layer. 
- 
        
            
        
        
            
                Mono to RGBA
            
         Converts a mono layer into an RGBA layer. 
- 
        
            
        
        
            
                Mono to SDF
            
         Computes a signed distance field from an iso-level of a mono layer. 
- 
        
            
        
        
            
                Null
            
         Passes inputs to the outputs. 
- 
        
            
        
        
            
                OCIO Transform
            
         Converts color spaces using OCIO transforms. 
- 
        
            
        
        
            
                ONNX Inference
            
         Applies inference from an ONNX Machine Learning model. 
- 
        
            
        
        
            
                OpenCL
            
         Executes an OpenCL kernel on layers, attributes, volumes, and VDBs. 
- 
        
            
        
        
            
                Output
            
         Collects the outputs of a subnetwork. 
- 
        
            
        
        
            
                Phasor Noise
            
         Generates phasor noise, which resembles a wave pattern. 
- 
        
            
        
        
            
                Pixelate
            
         Increases the size of pixels to pixelate an input layer. 
- 
        
            
        
        
            
                Polar to UV
            
         Converts polar coordinate pixels to Cartesian pixels. 
- 
        
            
        
        
            
                Position Map
            
         Generates a position map. 
- 
        
            
        
        
            
                Position Sample
            
         Samples an input texture by position. 
- 
        
            
        
        
            
                Prefix Sum
            
         Computes the prefix sum of a layer. 
- 
        
            
        
        
            
                Premultiply
            
         Premultiplies or un-premultiplies an RGBA layer. 
- 
        
            
        
        
            
                Preview Material
            
         Applies the preview material to geometry. 
- 
        
            
        
        
            
                Project on Layer
            
         Projects a layer onto a target layer. 
- 
        
            
        
        
            
                Pyro Activate
            
         Changes the activation of VDBs in a Pyro simulation. 
- 
        
            
        
        
            
                Pyro Advect
            
         Advects VDBs by Velocity. 
- 
        
            
        
        
            
                Pyro Advect by Map
            
         Advects a VDB by a flow map. 
- 
        
            
        
        
            
                Pyro Axis Force
            
         Applies a force around an axis to a velocity VDB. 
- 
        
            
        
        
            
                Pyro Block Begin
            
         Start of a Pyro simulation block. 
- 
        
            
        
        
            
                Pyro Block End
            
         End of a Pyro simulation block. 
- 
        
            
        
        
            
                Pyro Build Advection Map
            
         Constructs a flow map from a velocity VDB. 
- 
        
            
        
        
            
                Pyro Buoyancy
            
         Applies a Buoyancy force. 
- 
        
            
        
        
            
                Pyro Configure
            
         Configures a Pyro simulation. 
- 
        
            
        
        
            
                Pyro Dissipate
            
         Dissipates a VDB’s values over time. 
- 
        
            
        
        
            
                Pyro Disturbance
            
         Applies disturbance to a velocity VDB to break up still air. 
- 
        
            
        
        
            
                Pyro Light Ambient
            
         Builds a light field of ambient illumination of a VDB. 
- 
        
            
        
        
            
                Pyro Light Scatter
            
         Builds a light field of internal glow of a VDB. 
- 
        
            
        
        
            
                Pyro Light from Points
            
         Builds a light field of points lighting a VDB. 
- 
        
            
        
        
            
                Pyro Packed MipMap
            
         Builds an in-place MipMap of a VDB. 
- 
        
            
        
        
            
                Pyro Project Non-Divergent Electro Static
            
         Removes divergence from a velocity VDB. 
- 
        
            
        
        
            
                Pyro Source from Layer
            
         Sources from a layer’s envelope into a VDB. 
- 
        
            
        
        
            
                Pyro Source from Points
            
         Sources points into a VDB. 
- 
        
            
        
        
            
                Pyro Turbulence
            
         Apply turbulence to a velocity VDB. 
- 
        
            
        
        
            
                Pyro Uniform Force
            
         Applies a uniform force. 
- 
        
            
        
        
            
                Python Snippet
            
         Runs a snippet of Python on layers. 
- 
        
            
        
        
            
                Quantize
            
         Quantizes input data into discrete steps. 
- 
        
            
        
        
            
                RGB to RGBA
            
         Converts RGB layers to RGBA. 
- 
        
            
        
        
            
                RGB to UV
            
         Splits an RGB layer into UV and mono layers. 
- 
        
            
        
        
            
                RGBA to RGB
            
         Converts RGBA layers to RGB. 
- 
        
            
        
        
            
                RGBA to UV
            
         Splits an RGBA layer into two UV layers. 
- 
        
            
        
        
            
                ROP Image
            
         Writes the output of a COP network to disk. 
- 
        
            
        
        
            
                Ramp
            
         Generates linear and radial ramps. 
- 
        
            
        
        
            
                Random Mono
            
         Creates a mono layer with random values. 
- 
        
            
        
        
            
                Random RGB
            
         Creates an RGB layer with random colors. 
- 
        
            
        
        
            
                Rasterize Curves
            
         Rasterizes curves onto a layer. 
- 
        
            
        
        
            
                Rasterize Geometry
            
         Rasterizes geometry onto a layer. 
- 
        
            
        
        
            
                Rasterize Layer
            
         Rasterizes a layer onto another layer’s camera. 
- 
        
            
        
        
            
                Rasterize Setup
            
         Prepares geometry for the Rasterize Geometry COP. 
- 
        
            
        
        
            
                Rasterize Volume
            
         Renders a volume viewed through a camera. 
- 
        
            
        
        
            
                Ray Trace
            
         Performs ray tracing on an input mesh based on an origins and directions map. 
- 
        
            
        
        
            
                Reaction-Diffusion Block Begin
            
         Start of a Reaction-Diffusion simulation block. 
- 
        
            
        
        
            
                Reaction-Diffusion Block End
            
         Creates unique patterns by solving the reaction and diffusion of multiple chemicals as described by its inputs and parameters. 
- 
        
            
        
        
            
                Remap
            
         Remaps a layer. 
- 
        
            
        
        
            
                Resample
            
         Performs image scaling by changing the width, height, and pixel sizes. 
- 
        
            
        
        
            
                SDF Adjust
            
         Modifies the values for a Mono SDF layer. 
- 
        
            
        
        
            
                SDF Blend
            
         Combines two Mono SDF layers. 
- 
        
            
        
        
            
                SDF Shape
            
         Builds a 2D signed distance field of a selected shape. 
- 
        
            
        
        
            
                SDF to Mono
            
         Converts an SDF field to a Mono image layer. 
- 
        
            
        
        
            
                SDF to RGB
            
         Converts an SDF field to an RGB color layer. 
- 
        
            
        
        
            
                SOP Import
            
         Imports SOP geometry into Copernicus. 
- 
        
            
        
        
            
                SOP Invoke
            
         Invokes a compiled SOP block on the inputs. 
- 
        
            
        
        
            
                SOP Invoke Graph
            
         Invokes a geometry SOP graph on the inputs. 
- 
        
            
        
        
            
                Scatter Shapes
            
         Scatters input stamps across the image using randomization controls. 
- 
        
            
        
        
            
                Scatter on Curves
            
         Scatters input stamps along an input curve using randomization controls. 
- 
        
            
        
        
            
                Segment by Connectivity
            
         Segment a layer into connected components. 
- 
        
            
        
        
            
                Segment by Value
            
         Segment a mono layer into bands of similar value. 
- 
        
            
        
        
            
                Sequence Blend
            
         Blends multiple image inputs by a blend factor. 
- 
        
            
        
        
            
                Sharpen
            
         Sharpens an input layer to increase the definition of its edges. 
- 
        
            
        
        
            
                Slap Comp Import
            
         Import live layers from the Solaris Viewport. 
- 
        
            
        
        
            
                Slope Direction
            
         Converts a height layer into a direction layer. 
- 
        
            
        
        
            
                Smooth Fill
            
         Smoothly fills a region of a layer. 
- 
        
            
        
        
            
                Solve Poisson Multigrid
            
         Solves Poisson’s equation in a rectangular region using geometric multigrid. 
- 
        
            
        
        
            
                Space Transform
            
         Transforms positions and UV values between spaces. 
- 
        
            
        
        
            
                Stamp Points
            
         Stamps layers from point positions. 
- 
        
            
        
        
            
                Stash
            
         Stashes the input of the node on command and uses it as the node’s output. 
- 
        
            
        
        
            
                Statistics
            
         Outputs the average, minimum and maximum values of the input layer 
- 
        
            
        
        
            
                Statistics by ID
            
         Compute statistics for each ID island. 
- 
        
            
        
        
            
                Streak Blur
            
         Streaks an image, adding a motion blur effect. 
- 
        
            
        
        
            
                Subnetwork
            
         Used to organize a collection of COPs into one node. 
- 
        
            
        
        
            
                Surface Dither
            
         Applies a halftone dithering pattern relative to UVs. 
- 
        
            
        
        
            
                Swirl
            
         Twists an image layer into a spiral shape. 
- 
        
            
        
        
            
                Switch
            
         Selects an input layer. 
- 
        
            
        
        
            
                Switch If Wired
            
         Selects an input based on what is connected. 
- 
        
            
        
        
            
                Switch by Type
            
         Selects an output layer by the type of the inputs. 
- 
        
            
        
        
            
                Tile Pattern
            
         Generates rectangular tiles for texture patterns. 
- 
        
            
        
        
            
                Tone Map
            
         Applies a filmic tone mapping curve to compress a high dynamic range input into a displayable range. 
- 
        
            
        
        
            
                Transform 2D
            
         Transforms a layer in 2D. 
- 
        
            
        
        
            
                Transform 3D
            
         Transforms a layer in 3D. 
- 
        
            
        
        
            
                Triplanar
            
         Generates a texture by projecting X, Y, and Z textures onto the position layer. 
- 
        
            
        
        
            
                Triplanar Hex Tile
            
         Seamless texturing and normal mapping of triplanar projections without visible repetitions. 
- 
        
            
        
        
            
                Triplanar UV
            
         Generates UVs in three orthogonal projections. 
- 
        
            
        
        
            
                Two Way Switch If Wired
            
         Selects between two inputs based on if you wire in another input. 
- 
        
            
        
        
            
                UV Map
            
         Generates a UV Map. 
- 
        
            
        
        
            
                UV Map by ID
            
         Creates a UV Map for each connected ID island. 
- 
        
            
        
        
            
                UV Sample
            
         Samples an input layer using a UV layer. 
- 
        
            
        
        
            
                UV Transform
            
         Transforms the values of a UV layer in 2d space. 
- 
        
            
        
        
            
                UV to Polar
            
         Converts Cartesian coordinate pixels to polar coordinate pixels. 
- 
        
            
        
        
            
                UV to RGB
            
         Joins a UV and mono layer into an RGB layer. 
- 
        
            
        
        
            
                UV to RGBA
            
         Joins two UV layers into an RGBA layer. 
- 
        
            
        
        
            
                VDB Activate from Points
            
         Activates leaves on a VDB according to a point cloud. 
- 
        
            
        
        
            
                VDB Leaf Points
            
         Creates a point for each active leaf in a VDB. 
- 
        
            
        
        
            
                VDB Position Map
            
         Stores in each voxel that voxel’s position. 
- 
        
            
        
        
            
                VDB Reshape
            
         Rebuilds a VDB to match another VDB’s topology. 
- 
        
            
        
        
            
                VDB Visualize
            
         Creates multi-volume visualization. 
- 
        
            
        
        
            
                VDB Visualize Slice
            
         Extracts a slice from a VDB as Geometry for visualization. 
- 
        
            
        
        
            
                VDB Visualize Tree
            
         Builds a geometry visualizing the topology of a VDB. 
- 
        
            
        
        
            
                VDB Visualize Velocity
            
         Traces streamers through a velocity VDB. 
- 
        
            
        
        
            
                VDB from Layer
            
         Sets VDB values from the closest values in a layer. 
- 
        
            
        
        
            
                Vector Transform
            
         Transforms values of an RGB layer in 3d space. 
- 
        
            
        
        
            
                Vector Transform 2D
            
         Transforms the values of a UV layer in 2D space. 
- 
        
            
        
        
            
                Vignette
            
         Darkens the corners of an input layer. 
- 
        
            
        
        
            
                Wipe
            
         Performs a wipe transition between two images. 
- 
        
            
        
        
            
                Worley Noise
            
         Generates Worley noise. 
- 
        
            
        
        
            
                Worley Noise 3D
            
         Generates Worley noise from 3D locations. 
- 
        
            
        
        
            
                Wrangle
            
         Runs a VEX snippet to modify layer values. 
- 
        
            
        
        
            
                Z Composite
            
         Composites two layers by depth.