# Point geometry node

Manually adds or edits point attributes.

In Houdini, each geometry primitive has a list of points (numbered from 0). Each point has attributes such as XYZ location, color, alpha, texture UV, weight, and normal direction.

(Polygons, NURBS, and primitives also have a list of vertices, which reference points by their position in the point list. These points are shared between multiple polygons/NURBS/primitives.)

The Point SOP lets you edit the attributes of points, including their position. For example, you can change the distance of a point from the center of the object’s bounding box (using the local variables `\$BBX`, `\$BBY`, and `\$BBZ`), change the color of a point (`\$CR, \$CG, \$CB`), or change the normal of a point (`\$NX, \$NY, \$NZ`).

This is an extremely general and powerful operator. You can use it for an almost infinite variety of purposes, including deforming a surface (by changing point positions), creating interesting color effects (by changing point colors), and altering the initial trajectories of emitted particles (by changing the point normals).

It is important to note that the expressions in this operator are evaluated for each point. The `\$PT` local variable contains the point number of the point currently being processed.

## Tips

• When writing expressions for editing points, you may find the point and pointavg functions useful.

• To see the point numbers of points in the viewer, turn on the Point numbers icon in the display options window (Viewport Menu ▸ Display ▸ Display Options, or press D) or in the display toolbar on the right side of the viewer.

• To flip normals, turn on Add normals and enter `-\$NX -\$NY -\$NZ`.

• While this operator edits the attributes of points, the Primitive SOP edits attributes of entire primitives.

• The local variables in the Point SOP are relative to the point. You can use the prefixes "det", "prim", or "vtx" to use detail, primitive, or vertex variables. For example, `\$primTX, \$primTY, \$primTZ` is the barycenter of the first primitive the point belongs to.

## Parameters

Match By Attribute

When there are two inputs the standard behavior is to match according to point number. However, if the inputs are particle systems, this might not match properly as one wants to match the same particle even if particles are deleted or created. Match By Attribute will have \$TX2 refer to the point on the second input whose attribute matches the attribute of the currently evaluated point.

If more than one point on the second input matches, the point with the greatest point number will be used.

Attribute To Match

Which attribute to use for matching. This attribute must be present on both inputs of the Point SOP. Equality will be determined by treating it as an integer.

## Standard

Position

XYZ position.

Weight

Spline weight of the point.

Color

Diffuse color (RGB).

Alpha

Transparency value.

Normal

Normal vector. If you just want to compute normals, please use the Normal node instead.

Texture

Texture coordinates.

## Particle

Mass

Point mass.

Drag

Drag coefficient.

Tension

Spring tension for connected edge.

Spring K

Spring constant per point.

Velocity

Velocity vector.

Up Vector

Up vector attribute.

Scale

Particle size multiplier.

Instance

Geometry to instance on particle.

## Force

Force Scale

Multiplier for total force.

Force directed toward attractor.

Normal Force

Directed along normal direction.

Edge Force

Directed along edge direction.

Dir. Force

Arbitrary directional force.

## Custom

Number of Attributes

The number of attributes available to be set. Clicking the `+` button adds an attribute, clicking the `-` button removes an attribute, and clicking the `Clear` button removes all attributes.

Apply Attribute #

Whether to set this attribute.

It controls how attributes are modified. However, if the attribute does not exist, it will not be created.

Name #

Name of attribute, for example `Cd`.

Scalar Value

Value (for scalar attributes).

String Value

Value (for string attributes).

## Locals

PT

Point number.

NPT

Total number of points.

CEX, CEY, CEZ

Centroid of the input geometry.

TX, TY, TZ

Point position.

WEIGHT

Point spline weight.

BBX, BBY, BBZ

Position of point within bounding box, ranges `[0-1]`.

NX, NY, NZ

Point normal directions.

MAPU, MAPV, MAPW

Point texture coordinates.

CR, CG, CB

Diffuse point color.

CA

Point alpha value.

MASS, DRAG

Point mass and drag.

TENSION, SPRINGK

Spring tension of an edge, and elasticity of a point.

AGE

Number of seconds a particle has been alive.

LIFE

Particle age divided by life expectancy (0 to 1).

DIST

Distance to intersection from the Ray operation.

VX, VY, VZ

Point velocity values.

UPX, UPY, UPZ

Point up vector values.

ID

Particle ID.

PSCALE

Particle Scale

PTn, NPTn

Append n for the second source.

## Examples

AimPointNormals Example for Point geometry node

This is an example of how to use the Point SOP to orient point normals along a path. This allows for control over the orientation of geometry when copied onto points.

Points are extracted along a spiral on a per frame basis using an expression in the Carve SOP. A cone is copied to these points sequentially and results in an animation along the path.

CrossProduct Example for Point geometry node

This is an example of how to calculate a cross product by using the Point SOP. The cross product is defined as the vector perpendicular to two input vectors.

To visualize this demonstration, please explore the SOP network and turn on Point Normals in the display.

PointBorrowing Example for Point geometry node

This example of the Point SOP demonstrates the capacity of the Point SOP to alter geometry based on another input.

A sphere is created and then the points are randomly transformed. Then, by using both inputs of the Point SOP, the original sphere is brought back to average out its altered form. A simple math expression averages the positions of the two spheres, point by point.

PointExamples Example for Point geometry node

The Point SOP is quite a versatile operator. This example shows how the Point SOP may be used to control point weight, color, normals, and UV attributes.

Furthermore, it is possible to create various relationships among the point attributes through the Point SOP.

PointNormals Example for Point geometry node

This is a demonstration of how the Point SOP can be used to add Normals to geometry.

It also shows how the Point Normals affect the orientation of copied geometry and the appearance of shaders.

PointOffsetSurface Example for Point geometry node

Using the Point SOP, a simple displacement is created and applied to a portion of a spherical surface.

Using the normals of a point, which is basically a vector, and adding that number to the position of the point, the point is displaced in that given direction. With a Merge and Skin SOP the displaced surface is then connected back to the original.

PointSpiral Example for Point geometry node

This example file uses the Point SOP to turn a regular line into a spiral.

There are two different approaches used in this example. The first uses the point numbers of the line to define the expression calculations. The second uses the position of the points in the line’s bounding box for the expression.

PointTerrainErode Example for Point geometry node

The Point Terrain Erode file displays a mountainous landscape, created by the Fractal SOP. The landscape is swiftly worn away by the Point SOP.

With just a spare channel, erode, and a simple clamp() expression, the Point SOP can control the whole land.

PythonExpressionSopDeformer Example for Point geometry node

This example shows how to use a simple python expression inside a SOP node to deform a grid. The expression imports a python math library and uses noise to deform the points of a grid.

The following examples include this node.

BlendPoseBasic Example for BlendPose channel node

This is a simple example of using the BlendPose CHOP to deform some geometry using random tracker point positions.

CopyStamping Example for Copy channel node

This example demonstrates how to use the CopyStamp feature of the Copy CHOP. Custom variables are created within the Copy CHOP and used to modify the geometry.

In the file, geometry is imported into CHOPS. The Alpha attribute is scoped and manipulated using the Copy Stamping technique.

The new Alpha data is then brought back to the SOP level, and applied to the geometry’s Position.

AnchorPins Example for Constraint Network dynamics node

This example demonstrates how different anchor positions can affect pin constraints.

FromRBD Example for Field Force dynamics node

This example demonstrates how to use another active RBD Object as the source for the Field Force DOP. Two balls bounce inside a cube, one of the balls is set to repel the other according to force values stored on its geometry.

SimpleField Example for Field Force dynamics node

This example demonstrates the use of the Field Force DOP. A group of RBD Objects are passed through a field which at first pulls the together, and then pulls them apart as they advance through the field.

fieldforce Example for Field Force dynamics node

This example demonstrates the use of the Field Force DOP. It shows how to use a particle system to blow around smoke.

DensityViscosity Example for FLIP Solver dynamics node

This example demonstrates two fluids with different densities and viscosities interacting with a solid object.

FlipColorMix Example for FLIP Solver dynamics node

This example demonstrates the use of the Flip Solver to mix the colors of a red fluid with a blue fluid to form a purple fluid.

SpinningFlipCollision Example for FLIP Solver dynamics node

This scene shows how to create FLIP fluids based on the velocity of geometry by generating new particles from points scattered on the original geometry based on the velocity vectors. It also shows how to set up the original geometry to act as a collision object for the fluid.

TimelessGas Example for Gas Particle to Field dynamics node

This example demonstrates the use of gasParticleToField in Timeless mode.

A Uniform Force is applied to a number of RBD Objects to demonstrate how the Mask Field can be used to define a region where the force will be applied.

SimpleMultiple Example for Multiple Solver dynamics node

This examples demonstrates how to use a Multiple Solver. In this example, the motion of an object is controlled by an RBD Solver while the geometry is modified by a SOP Solver.

FluidGlass Example for Particle Fluid Solver dynamics node

This example demonstrates how to get a smooth fluid stream to pour into a glass.

PopFlow Example for Particle Fluid Solver dynamics node

This example demonstrates how to integrate a POP network with a particle fluid simulation, granting one the Total Artistic Control of POPs with the fluid dynamics of the particle fluid simulator.

StackedBricks Example for RBD Fractured Object dynamics node

This example shows how to create a large number of RBD objects from a single SOP. It also shows how a velocity point attribute can be used to set the initial motion for the objects.

This example shows how to grab animated key frame data from an RBD Glue object and blend it into a simulation of a cube fragmenting into multiple pieces on impact.

This example shows how one can control the break up of any glued object through the use of the RBD State node.

A torus, composed of spheres, is glued together. An additional sweep plane is defined. Any sphere which ends up on the wrong side of the sweep plane is broken off the torus and left to bounce on its own. This lets the break up of the torus to be controlled over many frames.

popswithrbdcollision Example for RBD Point Object dynamics node

Shows an RBD Simulation being attatched to a POP simulation to provide RBD style collisions to POPs.

InheritVelocity Example for RBD State dynamics node

This example demonstrates the use of the RBD State node to inherit velocity from movement and collision with other objects in a glued RBD fracture simulation.

SumImpacts Example for Script Solver dynamics node

This example uses the Script Solver and SOP Solver to change the color of RBD objects based on the total impact energy applied to the object at each timestep.

VisualizeImpacts Example for SOP Solver dynamics node

An example that shows how you can visualize impact data in an RBD simulation by using a SOP Solver to add custom guide geometry to the RBD Objects.

This example has three toruses falling on a grid with green lines showing the position and magnitude of impacts. The force visualization is added as ancillary geometry data to the actual toruses, so the RBD Solver is entirely unaware of the effect. The SOP Solver could also be used as an independent SOP network to extract impact visualization from an RBD Object.

SimpleVortex Example for Vortex Force dynamics node

This example uses a few balls to visualize the force generated by a Vortex Force DOP.

AnimatedSkin Example for Wire Glue Constraint dynamics node

This example shows how the Wire Glue Constraint DOP can constrain a wire object to animated geometry.

BendingTree Example for Wire Solver dynamics node

This example shows how to use the Wire Solver to simulate a flexible tree built with the LSystem SOP.

BreakWire Example for Wire Solver dynamics node

This example demonstrates how to break wire constraints on a per point basis. The wire solver is set up to constrain certain points if it finds an attribute named 'pintoanimation'.

CurveAdvection Example for Wire Solver dynamics node

This example demonstrates how to advect curves based on a pyro simulation. An Attribute Wrangle SOP is used to sample the velocity from the volume and apply it to a wire object.

Down Hill Lava Flow Example for Material shader node

In this file we create a downhill lava flow with crust gathering and hardening at the base of the slope. All of the animation is achieved through the shader itself, and all of the geometry is completely static.

FirePit Example for Material shader node

Flames are grids so that UV textures can easily be applied, they are then warped around a metaball using a magnet SOP. The flames are then assigned to either a yellow or blue Flames texture. The Flames' opacity mask wrap is set to Decal to prevent the texture from repeating and showing a single pixel ring at the top of the flame geometry. I'm also using a mask file named `flameOpacMap.jpg` to enhance the flames' shape at the top. The noise offset has been animated over `\$T` with an greater emphasis on the Y axis so that the flames look like they are rising. This is the same reason the Noise jitter is larger for the Y axis as well.

The coals are spheres that have been copy stamped onto a deformed grid. Using Attribute Create surface nodes I am able to override and copy stamp the lava texture’s parameters at the SOP level so that local variables, such as `\$BBY`, can be used to animate the texture. This way the texture’s crust and its crust values can be used only to form the tops of the coals. This reserves the lava aspect of the texture to be used on the bottoms of the coals. The lava intensity (`Kd` attribute) is then stamped and animated to create the look of embers on the bottom of coals glowing.

NormalsAttribTransfer Example for Attribute Transfer geometry node

The AttribTransfer SOP may be used to transfer various point attributes from a source geometry to a target. In this case, the normal attributes, `N[3]`, of one grid are transferred to another grid.

TransferColor Example for Attribute Transfer geometry node

The Attribute Transfer SOP can be used to transfer color attributes from one geometry to another. The effective field of transfer can be controlled through the various parameters in the Attribute Transfer SOP.

AttributeRename Example for Attribute Rename geometry node

This is an example of how the Attribute SOP is used to delete and rename attributes within Houdini. Attributes may also be renamed for proper RIB outputs for Renderman.

BlendColors Example for Blend Shapes geometry node

This network utilizes the Blendshapes SOP to morph one geometry’s colors into another’s color.

Two input blend shapes act as inputs for the Blendshapes SOP.

The Blendshapes SOP interpolates all designated attributes, in this case "Cd" between the various inputs.

Play the animation to see the effect.

CarveExtractCurve Example for Carve geometry node

This network is a demonstration of how the Carve SOP can be used to extract various elements of the surface geometry.

Depending on the type of geometry, the Carve SOP may be used to extract points from polygonal objects or curves from NURBS surfaces.

Furthermore, the Carve SOP uses the surface U and V information to extract the various elements, and by animating the U and V values we can create various effects as the points and curves move on the geometry surface.

CopyAttributes Example for Copy Stamp geometry node

The Copy SOP can be used for more than copying geometry. In this example, the Copy SOP is used to transfer color attributes from the template geometry (or point) to the copied geometry.

A polygonal sphere with color infomation is used as the source geometry. A point with a color attribute (Cd) is extracted from the sphere and used as a template by the Copy SOP. Then the Copy SOP transfers the color infomation to a copied polygonal circle.

CopyTemplateAttribs Example for Copy Stamp geometry node

The Copy SOP is used to transfer specific attributes from a template to copied primitives. In this example, a sphere is use as a template with color attributes added to the sphere points. A Particle SOP is then used to birth particles from the sphere points.

Next, a Copy SOP does two things:

• It copies geometry to the particles.

• It transfers the color attribute from the source sphere points to the geometry whose position is based on the particles.

Play the animation to see the effects.

CreepWeave Example for Creep geometry node

This example shows how you can take a geometry and creep it over an animated surface.

A file, fabric.bgeo, which looks like woven fabric, has been brought in using the File SOP. A NURBS grid has been animated to look like a piece of waving fabric using sine and noise functions.

The fabric.bgeo is crept over the animated NURBS grid, using a Creep SOP, and the result is an animated piece of woven fabric.

DeleteDemo Example for Delete geometry node

This example demonstrates how the Delete SOP is used to remove specified geometry from a scene.

Geometry may be deleted by Point or Primitive Numbers, by Group, or by position within a Bounding Box.

LowHigh Example for Dop Import geometry node

This example shows how to create a low res - high res set up to support RBD objects. The two main methods are to reference copy the DOP Import SOP and feed in the high res geometry or to use point instancing with an Instance Object.

EdgeCuspStairs Example for Edge Cusp geometry node

The Edge Cusp SOP is a quick way to create distinct edges on a model during render time. Edge Cusp creates the edges by uniquing shared edge points and recomputing point normals.

FitSurfaces Example for Fit geometry node

This contains examples of fitting a Polygon Mesh to a NURBS surface through the use of the Fit SOP. There are two methods of fitting:

• Approximation, which generates primitives that roughly follow the path of the data points.

• Interpolation, which generates primitives that touch all the data points.

BubblyFont Example for Font geometry node

The Font SOP is used to create 3D text geometry in the scene.

The geometry may be set to Polygon, Bezier, or a combination of the two.

With the combination, Bezier will be used for letters containing curves, and Polygon will be used for those with only straight edges.

Fonts other than those loaded by default may be loaded in the Font parameter.

FontBasic Example for Font geometry node

This example demonstrates some of the parameters available for formatting text using the Font SOP.

ForceBasic Example for Force geometry node

This example file uses the Force SOP in conjunction with Metaball SOPs and Particle SOPs to create dynamic animations.

Using the Radial Force Parameter of the Force SOP, particles are puffed in and out. Then, using the Directional Force Parameter, a rotating vortex is created as a metaball spins around an axis.

Press play to view the animation.

This example shows how to use the foreach sop to intersect one object with each part of another object and merge the results together.

FractalGeoTypes Example for Fractal geometry node

This example demonstrates using the Fractal SOP to deform geometry to get a random, jagged subdivision surface. This is a useful tool in creating things such as bumpy terrains, landscapes, rocks, or debris.

The Fractal SOP is applied to each geometry type to show how the displacement changes based on the geometry type.

HoleBasic Example for Hole geometry node

This file demonstrates the Hole SOP.

There are four examples given of the Hole SOP, how to add holes to a surface, or remove them.

BasicJoin Example for Join geometry node

This example demonstrates how the Join SOP can connect multiple pieces of geometry by faces and surfaces.

The Join SOP will combine the individual pieces of geometry into a single primitive that will inherit attributes.

Nurbs, Bezier, or Mesh surfaces should be used with the Join SOP.

Do not use Polygons as it will not work with the Join SOP.

MagnetDistortion Example for Magnet geometry node

This example demonstrates some of the various ways to use the Magnet SOP.

It can be used to affect point position, point color, point normals, and velocity.

MergeAttributes Example for Merge geometry node

The Merge SOP applies all incoming attributes to all input geometry. Each input geometry may have its own set of attributes.

Three spheres are wired into a Merge SOP. The first has no attributes applied. The second has a color attribute (`Cd[3]`) applied by a Point SOP. The third has a normal attribute (`N[3]`) applied by another Point SOP.

The Merge SOP does NOT know how to build attributes, but can apply them. As a result, all applied attribute values are set to zero.

This is why the first two spheres display and render black. They have normal attributes applied, but their values are set to zero.

In addition, the first and last spheres have a color attribute applied, but their values are set to zero.

It is better to set attributes explicitly, instead of relying on the Merge SOP to do so.

BlendMetaballs Example for Metaball geometry node

This is a basic example of how metaballs interact as force fields with a density threshold and falloff. Metaballs can be created in Houdini through the Metaball SOP

The Point SOP is used to provide a visual representation of how metaballs interact when their respective fields blend into one another in an additive fashion.

PaintAttributes Example for Paint geometry node

This example demonstrates how to use the Paint SOP to paint an attribute onto geometry, and then use the attribute to modify the geometry.

FlutteringLeaves Example for Particle geometry node

This example demonstrates how to create a fluttering leaf simulation by using the Particle SOP.

It also demonstrates how to use the Point SOP to modify point normals, affecting the velocity and direction of particles. Since particles are actually points in space, the Point SOP is a powerful way to control particle attributes.

Press play to watch the simulation.

PScale Example for Particle geometry node

This example shows the ability of the Particle SOP to define a default Size for any given birthed particle.

A simple Grid can be used to create a dynamic solution of particles streaming off as if blown by the wind. As these particles leave the grid, their size slowly diminishes, as the particle continues to die.

ParticleDisturbance Example for Particle geometry node

The given example file takes a grid, and using the Particle SOP in combination with the Metaball and Force SOPs, creates a dynamic animation.

A metaball ship jets through space driving particles out of its path along the wake of the ship. With the help of the Force SOP, the metaballs are given the properties necessary to make this reaction possible.

Play the animation to see the full effect.

ParticleExamples Example for Particle geometry node

This example contains five demonstrations of some of the various uses of the Particle SOP.

• Creep particles along a surface using a the Creep SOP.

• Group birth particles from a group of points on a surface.

• Bounce particles.

• Split particles on contact.

• Collide particles off a collision object.

• Birth particles from a moving object.

• Use a metaball to exert force on a particle.

ParticleFountain Example for Particle geometry node

This is an example of creating a fountain from several Particle SOPs and basic modeling.

It demonstrates how to create normal offsets, velocity variances, and collision behaviors to control the motion and look of the particles.

ParticlePusher Example for Particle geometry node

This example uses a Metaball SOP and a Force SOP to push particles side to side as they pass through a particle stream generated by a Particle SOP.

Particles are birthed in the air off of a sphere, while a metaball passes back and forth through, pushing the particles from its path.

Play the animation to see the full effect.

ParticleTube Example for Particle geometry node

The Particle SOP enables the creation of particles at the SOP level and allows those particles to directly interact with geometry. Furthermore, these particles are in turn treated as point geometry.

In this example, particles are both crept along and collided with a collision tube object. It is possible to also manipulate and control particles in SOPs through the adjustment of point normals (including those of the particles).

PartitionBall Example for Partition geometry node

This example demonstrates how to break geometry in a DOPs simulation using the Partition SOP to determine the DOP Objects.

AimPointNormals Example for Point geometry node

This is an example of how to use the Point SOP to orient point normals along a path. This allows for control over the orientation of geometry when copied onto points.

Points are extracted along a spiral on a per frame basis using an expression in the Carve SOP. A cone is copied to these points sequentially and results in an animation along the path.

CrossProduct Example for Point geometry node

This is an example of how to calculate a cross product by using the Point SOP. The cross product is defined as the vector perpendicular to two input vectors.

To visualize this demonstration, please explore the SOP network and turn on Point Normals in the display.

PointBorrowing Example for Point geometry node

This example of the Point SOP demonstrates the capacity of the Point SOP to alter geometry based on another input.

A sphere is created and then the points are randomly transformed. Then, by using both inputs of the Point SOP, the original sphere is brought back to average out its altered form. A simple math expression averages the positions of the two spheres, point by point.

PointExamples Example for Point geometry node

The Point SOP is quite a versatile operator. This example shows how the Point SOP may be used to control point weight, color, normals, and UV attributes.

Furthermore, it is possible to create various relationships among the point attributes through the Point SOP.

PointNormals Example for Point geometry node

This is a demonstration of how the Point SOP can be used to add Normals to geometry.

It also shows how the Point Normals affect the orientation of copied geometry and the appearance of shaders.

PointOffsetSurface Example for Point geometry node

Using the Point SOP, a simple displacement is created and applied to a portion of a spherical surface.

Using the normals of a point, which is basically a vector, and adding that number to the position of the point, the point is displaced in that given direction. With a Merge and Skin SOP the displaced surface is then connected back to the original.

PointSpiral Example for Point geometry node

This example file uses the Point SOP to turn a regular line into a spiral.

There are two different approaches used in this example. The first uses the point numbers of the line to define the expression calculations. The second uses the position of the points in the line’s bounding box for the expression.

PointTerrainErode Example for Point geometry node

The Point Terrain Erode file displays a mountainous landscape, created by the Fractal SOP. The landscape is swiftly worn away by the Point SOP.

With just a spare channel, erode, and a simple clamp() expression, the Point SOP can control the whole land.

PythonExpressionSopDeformer Example for Point geometry node

This example shows how to use a simple python expression inside a SOP node to deform a grid. The expression imports a python math library and uses noise to deform the points of a grid.

TwistyCube Example for Point Cloud Iso geometry node

This example demonstrates how to construct a polygonal surface from a point cloud using the Point Cloud Iso Surface SOP.

This example demonstrates the various options for joining polygons using the PolyKnit SOP. The PolyKnit SOP is useful for filling in holes, gaps, or to re-define edges on polygonal geometry.

PolyKnit can be used to manually knit joining polygons between existing polygons. Polygons are created by specifying a list of input points from which to "knit" the new polygons.

PolyKnit will yield different results, depending on the pattern by which the points are selected or listed. Please see the Helpcard documentation for more information on how the PolyKnit SOP builds new polygons.

PolyPatchDNA Example for PolyPatch geometry node

This example demonstrates the use of the PolyPatch SOP to procedurally model complex forms.

Here, a DNA model is created.

PolyStitchBasicSmooth Example for PolyStitch geometry node

This example demonstrates how the Polystitch SOP can stitch together or refine seams between polygonal surfaces with incongruent U and V divisions. This is useful for smoothing and eliminating cracks at seams.

PolywireModel Example for PolyWire geometry node

This example demonstrates how the Polywire SOP builds polygonal geometry based on a polygonal frame, and how the parameters can be customized with local variables.

BasicRail Example for Rails geometry node

In this example simple curves are taken by the Rail SOP to create a surface based upon the path they describe.

With only simple changes to the SOP’s parameters different surfaces can be created. In the end the curves are gone, but their surface remains.

RayWrap Example for Ray geometry node

The Ray SOP projects one object over the surface contours of another.

It does so by calculating the collisions of the projected object’s normals with the surface geometry of the collided object.

In this example, a Grid is wrapped over the surface of a deformed Sphere using the Ray SOP.

A Facet SOP is used to correct the normals of the wrapped Grid after it is deformed over the surface.

WigglyWorm Example for Sweep geometry node

This network demonstrates how the Sweep SOP can be used to construct geometry that is easily deformable. The Sweep SOP requires a backbone and cross section geometry.

Through a sin() function an expression is created to animate the backbone for a slithering effect. Then the circles are copied at every point on the backbone to create the skeleton of the worm. Finally, a simple skin operation completes the worm body.

VertexTexture Example for Vertex Split geometry node

This example uses the Vertex Split SOP to add sufficient points for copying vertex texture coordinates to point positions.

volumefeather Example for Volume Feather geometry node

This example shows how to use the Volume Feather SOP to smooth sharp volumes either in a purely outwards or purely inwards direction.

barycenter Example for Volume Reduce geometry node

This example shows how to use the Volume Reduce SOP to compute the barycenter of a 3d object.

Wireblend Example for Wire Blend geometry node

The Wire Blend SOP is used to blend curves from input geometry. In this case, three input morph targets are used by the Wire Blend SOP with the Differencing and option checked. The blend values of the input morphs are keyframed for specific effects. Play the animation to see the results.

ModulusTransform Example for Transform geometry node

Create a cyclical animation using the Transform SOP, the Group SOP, and the modulus operation.

CrinkleSphere Example for Inline Code VOP node

This example demonstrates the use of an Inline Code node that allows you to write VEX code that is put directly into your shader or operator definition.

# Geometry nodes

• Removes elements while trying to maintain the overall appearance.

• Creates Points or Polygons, or adds points/polys to an input.

• Creates agent primitives.

• Adds new clips to agent primitives.

• Adds new clips to agent primitives.

• Defines how agents' animation clips should be played back.

• Creates geometry describing possible transitions between animation clips.

• Creates a new agent layer that is suitable for collision detection.

• Creates point attributes that specify the rotation limits of an agent’s joints.

• Builds a constraint network to hold an agent’s limbs together.

• Writes agent definition files to disk.

• Edits properties of agent primitives.

• Adds a new layer to agent primitives.

• Adjusts the head of an agent to look at a specific object or position.

• Adjusts the head of an agent to look at a specific object or position.

• Adds various common point attributes to agents for use by other crowd nodes.

• Adds various common point attributes to agents for use by other crowd nodes.

• Provides simple proxy geometry for an agent.

• Creates parent-child relationships between agents.

• Adapts agents' legs to conform to terrain and prevent the feet from sliding.

• Adds new transform groups to agent primitives.

• Extracts geometry from agent primitives.

• Extracts geometry from agent primitives for a Vellum simulation.

• Loads the geometry from an Alembic scene archive (.abc) file into a geometry network.

• Creates a geometry group for Alembic primitives.

• Modifies intrinsic properties of Alembic primitives.

• Aligns a group of primitives to each other or to an auxiliary input.

• Cleans up a series of break operations and creates the resulting pieces.

• Blurs out (or "relaxes") points in a mesh or a point cloud.

• Changes the size/precision Houdini uses to store an attribute.

• Composites vertex, point, primitive, and/or detail attributes between two or more selections.

• Copies attributes between groups of vertices, points, or primitives.

• Adds or edits user defined attributes.

• Deletes point and primitive attributes.

• Allows simple VEX expressions to modify attributes.

• Fades a point attribute in and out over time.

• Interpolates attributes within primitives or based on explicit weights.

• Copies and flips attributes from one side of a plane to another.

• Adds noise to attributes of the incoming geometry.

• Promotes or demotes attributes from one geometry level to another.

• Generates random attribute values of various distributions.

• Renames or deletes point and primitive attributes.

• Modifies point attributes based on differences between two models.

• Edits string attribute values.

• Copies, moves, or swaps the contents of attributes.

• Transfers vertex, point, primitive, and/or detail attributes between two models.

• Transfers attributes between two geometries based on UV proximity.

• Runs a VOP network to modify geometry attributes.

• Runs a VEX snippet to modify attribute values.

• Samples texture map information to a point attribute.

• Copies information from a volume onto the point attributes of another piece of geometry, with optional remapping.

• Converts primitives for ODE and Bullet solvers.

• Computes lighting values within volume primitives

• Provides operations for moving knots within the parametric space of a NURBS curve or surface.

• Applies deformations such as bend, taper, squash/stretch, and twist.

• Deletes primitives, points, edges or breakpoints.

• Computes a 3D metamorphosis between shapes with the same topology.

• Computes a 3D metamorphosis between shapes with the same topology.

• The start of a looping block.

• The start of a compile block.

• The end/output of a looping block.

• The end/output of a compile block.

• Supports Bone Deform by assigning capture weights to bones.

• Supports Deform by assigning capture weights to points based on biharmonic functions on tetrahedral meshes.

• Supports Bone Capture Biharmonic by creating lines from bones with suitable attributes.

• Supports Bone Deform by assigning capture weights to points based on distance to bones.

• Uses capture attributes created from bones to deform geometry according to their movement.

• Creates default geometry for Bone objects.

• Combines two polygonal objects with boolean operators, or finds the intersection lines between two polygonal objects.

• Fractures the input geometry using cutting surfaces.

• Creates an axis-aligned bounding box or sphere for the input geometry.

• Creates a cube or six-sided rectangular box.

• Breaks the input geometry using the specified cutting shape.

• Deforms the points in the first input using one or more magnets from the second input.

• Records and caches its input geometry for faster playback.

• Closes open areas with flat or rounded coverings.

• Converts array attributes into a single index-pair capture attribute.

• Converts a single index-pair capture attribute into per-point and detail array attributes.

• Adjusts capture regions and capture weights.

• Lets you paint capture attributes directly onto geometry.

• Copies capture attributes from one half of a symmetric model to the other.

• Overrides the capture weights on individual points.

• Supports Capture and Deform operation by creating a volume within which points are captured to a bone.

• Slices, cuts or extracts points or cross-sections from a primitive.

• Reads sample data from a chop and converts it into point positions and point attributes.

• Creates open or closed arcs, circles and ellipses.

• Lets you deform NURBS faces and NURBS surfaces by pulling points that lie directly on them.

• Helps clean up dirty models.

• Removes or groups geometry on one side of a plane, or creases geometry along a plane.

• Captures low-res simulated cloth.

• Deforms geometry captured by the Cloth Capture SOP.

• Creates a volume representation of source geometry.

• Fills a volume with a diffuse light.

• Applies a cloud like noise to a Fog volume.

• Low-level machinery to cluster points based on their positions (or any vector attribute).

• Higher-level node to cluster points based on their positions (or any vector attribute).

• Creates geometry and VDB volumes for use with DOPs collisions.

• Adds color attributes to geometry.

• Adjust surface point normals by painting.

• Creates lines between nearby pieces.

• Creates an attribute with a unique value for each set of connected primitives or points.

• Creates simple geometry for use as control shapes.

• Converts geometry from one geometry type to another.

• Converts a 2D height field to a 3D VDB volume, polygon surface, or polygon soup surface.

• Converts the input geometry into line segments.

• Polygonizes metaball geometry.

• Generates the oriented surface of a tetrahedron mesh.

• Converts sparse volumes.

• Converts a Point Cloud into a VDB Points Primitive, or vice versa.

• Converts the iso-surface of a volume into a polygonal surface.

• Decomposes the input geometry into approximate convex segments.

• Creates multiple copies of the input geometry, or copies the geometry onto the points of the second input.

• Copies geometry and applies transformations to the copies.

• Copies the geometry in the first input onto the points of the second input.

• Manually adds or removes a creaseweight attribute to/from polygon edges, for use with the Subdivide SOP.

• Deforms and animates a piece of geometry across a surface.

• Populates a crowd of agent primitives.

• Creates crowd agents to be used with the crowd solver.

• Creates polygonal, NURBS, or Bezier curves.

• Deforms a spline surface by reshaping a curve on the surface.

• Finds the intersections (or points of minimum distance) between two or more curves or faces.

• Imports fields from DOP simulations, saves them to disk, and loads them back again.

• Imports scalar and vector fields from a DOP simulation.

• Imports option and record data from DOP simulations into points with point attributes.

• Generates point emission sources for debris from separating fractured rigid body objects.

• Runs a VEX snippet to deform geometry.

• Deletes input geometry by group, entity number, bounding volume, primitive/point/edge normals, and/or degeneracy.

• Smooths out (or "relaxes") point deformations.

• Attempts to prevent collisions when deforming geometry.

• Deletes edges from the input polygonal geometry merging polygons with shared edges.

• Deletes points, primitives, and edges from the input geometry and repairs any holes left behind.

• Divides, smooths, and triangulates polygons.

• Imports and transforms geometry based on information extracted from a DOP simulation.

• Creates a curve based on user input in the viewport.

• Culls the input geometry according to the specifications of the For Each SOP.

• Collapses edges and faces to their centerpoints.

• Sharpens edges by uniquing their points and recomputing point normals.

• Inserts points on the edges of polygons and optionally connects them.

• Flips the direction of polygon edges.

• Cuts geometry along edges using guiding curves.

• Copies and optionally modifies attribute values along edges networks and curves.

• Edits points, edges, or faces interactively.

• Closes, opens, or clamps end points.

• Sets an attribute on selected points or primitives to sequential numbers.

• Generates a message, warning, or error, which can show up on a parent asset.

• Pushes geometry out from the center to create an exploded view.

• Computes the centroid of each piece of the geometry.

• Computes the best-fit transform between two pieces of geometry.

• Extrudes geometry along a normal.

• Extrudes surface geometry into a volume.

• Creates a surface or density VDB for sourcing FLIP simulations.

• Controls the smoothness of faceting of a surface.

• Adds smooth distance attributes to geometry.

• Evolves polygonal curves as vortex filaments.

• Reads, writes, or caches geometry on disk.

• Writes and reads geometry sequences to disk.

• Reads and collates data from disk.

• Creates smooth bridging geometry between two curves or surfaces.

• Finds the shortest paths from start points to end points, following the edges of a surface.

• Fits a spline curve to points, or a spline surface to a mesh of points.

• Compresses the output of fluid simulations to decrease size on disk

• Creates 3D text from Type 1, TrueType and OpenType fonts.

• Uses a metaball to attract or repel points or springs.

• Creates jagged mountain-like divisions of the input geometry.

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

• Merges or splits (uniques) points.

• Adds strength to a glue constraint network according to cluster values.

• Generates particles to be used as sources in a particle-based grain simulation.

• Assigns a unique integer attribute to non-touching components.

• Creates planar geometry.

• Blends the guides and skin of two grooms.

• Fetches groom data from grooming objects.

• Packs the components of a groom into a set of named Packed Primitives for the purpose of writing it to disk.

• Switches between all components of two groom streams.

• Unpacks the components of a groom from a packed groom.

• Generates groups of points, primitives, edges, or vertices according to various criteria.

• Combines point groups, primitive groups, or edge groups according to boolean operations.

• Copies groups between two pieces of geometry, based on point/primitive numbers.

• Deletes groups of points, primitives, edges, or vertices according to patterns.

• Runs VEX expressions to modify group membership.

• Sets group membership interactively by painting.

• Converts point, primitive, edge, or vertex groups into point, primitive, edge, or vertex groups.

• Groups points and primitives by ranges.

• Renames groups according to patterns.

• Transfers groups between two pieces of geometry, based on proximity.

• Advects guide points through a velocity volume.

• Resolves collisions of guide curves with VDB signed distance fields.

• Deforms geometry with an animated skin and optionally guide curves.

• Allows intuitive manipulation of guide curves in the viewport.

• Creates standard primitive groups used by grooming tools.

• Quickly give hair guides some initial direction.

• Creates masking attributes for other grooming operations.

• Creates and prepares parting lines for use with hair generation.

• Looks up skin geometry attributes under the root point of guide curves.

• Constructs a coherent tangent space along a curve.

• Transfer hair guides between geometries.

• Converts dense hair curves to a polygon card, keeping the style and shape of the groom.

• Clumps guide curves together.

• Generates hair on a surface or from points.

• Generates a velocity field based on stroke primitives.

• Generates an initial heightfield volume for use with terrain tools.

• Blurs a terrain height field or mask.

• Limits height values to a certain minimum and/or maximum.

• Creates a copy of a height field or mask.

• Extracts a square of a certain width/length from a larger height volume, or resizes/moves the boundaries of the height field.

• Displaces a height field by another field.

• Advects the input volume through a noise pattern to break up hard edges and add variety.

• Lets you draw shapes to create a mask for height field tools.

• Calculates thermal and hydraulic erosion over time (frames) to create more realistic terrain.

• Calculates thermal and hydraulic erosion over time (frames) to create more realistic terrain.

• Simulates the erosion from one heightfield sliding over another for a short time.

• Distributes water along a heightfield. Offers controls for adjusting the intensity, variability, and location of rainfall.

• Calculates the effect of thermal erosion on terrain for a short time.

• Imports a 2D image map from a file or compositing node into a height field or mask.

• Generates flow and flow direction layers according to the input height layer.

• Copies another layer over the mask layer, and optionally flattens the height field.

• Composites together two height fields.

• Sets all values in a heightfield layer to a fixed value.

• Sets the border voxel policy on a height field volume.

• Creates a mask based on different features of the height layer.

• Creates a mask based some other geometry.

• Creates a mask where the input terrain is hollow/depressed, for example riverbeds and valleys.

• Adds vertical noise to a height field, creating peaks and valleys.

• Exports height and/or mask layers to disk as an image.

• Lets you paint values into a height or mask field using strokes.

• Patches features from one heightfield to another.

• Adds displacement in the form of a ramps, steps, stripes, Voronoi cells, or other patterns.

• Projects 3D geometry into a height field.

• Applies a material that lets you plug in textures for different layers.

• Remaps the values in a height field or mask layer.

• Changes the resolution of a height field.

• Scatters points across the surface of a height field.

• Scatters points across the surface of a height field.

• Simulates loose material sliding down inclines and piling at the bottom.

• Creates stepped plains from slopes in the terrain.

• Stitches height field tiles back together.

• Splits a height field volume into rows and columns.

• Height field specific scales and offsets.

• Visualizes elevations using a custom ramp material, and mask layers using tint colors.

• Makes holes in surfaces.

• Deforms the points in the first input to make room for the inflation tool.

• Instances Geometry on Points.

• Creates points with attributes at intersections between a triangle and/or curve mesh with itself, or with an optional second set of triangles and/or curves.

• Composes triangle surfaces and curves together into a single connected mesh.

• Processes its inputs using the operation of a referenced compiled block.

• Builds an offset surface from geometry.

• Generates an isometric surface from an implicit function.

• The Join op connects a sequence of faces or surfaces into a single primitive that inherits their attributes.

• Divides, deletes, or groups geometry based on an interactively drawn line.

• Creates fractal geometry from the recursive application of simple rules.

• Deforms geometry based on how you reshape control geometry.

• Reads a lidar file and imports a point cloud from its data.

• Creates polygon or NURBS lines from a position, direction, and distance.

• Animates points using an MDD file.

• Deforms geometry by using another piece of geometry to attract or repel points.

• Aligns the input geometry to a specific axis.

• Resizes and recenters the geometry according to reference geometry.

• Reorders the primitive and point numbers of the input geometry to match some reference geometry.

• Assigns one or more materials to geometry.

• Measures volume, area, and perimeter of polygons and puts the results in attributes.

• Merges geometry from its inputs.

• Defines groupings of metaballs so that separate groupings are treated as separate surfaces when merged.

• Creates metaballs and meta-superquadric surfaces.

• Duplicates and mirrors geometry across a mirror plane.

• Displaces points along their normals based on fractal noise.

• Displaces points along their normals based on fractal noise.

• Supports Muscle Deform by assigning capture weights to points based on distance away from given primitives

• Deforms a surface mesh representing skin to envelop or drape over geometry representing muscles

• Creates a "naming" attribute on points or primitives allowing you to refer to them easily, similar to groups.

• Computes surface normal attribute.

• Does nothing.

• Merges geometry from multiple sources and allows you to define the manner in which they are grouped together and transformed.

• Assists the creation of a Muscle or Muscle Rig by allowing you to draw a stroke on a projection surface.

• Deforms input geometry based on ocean "spectrum" volumes.

• Deforms input geometry based on ocean "spectrum" volumes.

• Generates particle-based foam

• Generates particles and volumes from ocean "spectrum" volumes for use in simulations

• Generates particles and volumes from ocean "spectrum" volumes for use in simulations

• Generates volumes containing information for simulating ocean waves.

• Instances individual waveforms onto input points and generated points.

• Executes an OpenCL kernel on geometry.

• Marks the output of a sub-network.

• Packs geometry into an embedded primitive.

• Packs points into a tiled grid of packed primitives.

• Editing Packed Disk Primitives.

• Editing Packed Primitives.

• Lets you paint color or other attributes on geometry.

• Creates a color volume based on drawn curve

• Creates a fog volume based on drawn curve

• Creates an SDF volume based on drawn curve

• Creates simple particle simulations without requiring an entire particle network.

• Generates a surface around the particles from a particle fluid simulation.

• Creates a set of regular points filling a tank.

• Places points and primitives into groups based on a user-supplied rule.

• Moves primitives, points, edges or breakpoints along their normals.

• Creates a planar polygonal patch.

• Fills in a 2d curve network with triangles.

• Deforms flat geometry into a pleat.

• Creates platonic solids of different types.

• Manually adds or edits point attributes.

• Constructs an iso surface from its input points.

• Deforms geometry on an arbitrary connected point mesh.

• Creates new points, optionally based on point positions in the input geometry.

• Jitters points in random directions.

• Moves points with overlapping radii away from each other, optionally on a surface.

• Generates a cloud of points around the input points.

• Computes and manipulates velocities for points of a geometry.

• Creates set of regular points filling a volume.

• Creates flat or tube-shaped polygon surfaces between source and destination edge loops, with controls for the shape of the bridge.

• Creates offset polygonal geometry for planar polygonal graphs.

• Extrudes polygonal faces and edges.

• Creates straight, rounded, or custom fillets along edges and corners.

• Bevels points and edges.

• Breaks curves where an attribute crosses a threshold.

• Helps repair invalid polygonal geometry, such as for cloth simulation.

• Extrudes polygonal faces and edges.

• Fills holes with polygonal patches.

• Creates coordinate frame attributes for points and vertices.

• Creates new polygons using existing points.

• Creates a smooth polygonal patch from primitives.

• Cleans up topology of polygon curves.

• Reduces the number of polygons in a model while retaining its shape. This node preserves features, attributes, textures, and quads during reduction.

• Combines polygons into a single primitive that can be more efficient for many polygons

• The PolySpline SOP fits a spline curve to a polygon or hull and outputs a polygonal approximation of that spline.

• Divides an existing polygon into multiple new polygons.

• Divides an existing polygon into multiple new polygons.

• Stitches polygonal surfaces together, attempting to remove cracks.

• Constructs polygonal tubes around polylines, creating renderable geometry with smooth bends and intersections.

• Interpolates between a set of pose-shapes based on the value of a set of drivers.

• Combine result of Pose-Space Deform with rest geometry.

• Packs geometry edits for pose-space deformation.

• Creates common attributes used by the Pose-Space Edit SOP.

• Edits primitive, primitive attributes, and profile curves.

• Takes a primitive attribute and splits any points whose primitives differ by more than a specified tolerance at that attribute.

• Extracts or manipulates profile curves.

• Creates profile curves on surfaces.

• Creates points for sourcing pyro and smoke simulations.

• Runs a Python snippet to modify the incoming geometry.

• Combines fractured pieces or constraints into larger clusters.

• Creates attributes describing rigid body constraints.

• Creates additional detail on the interior surfaces of fractured geometry.

• Fractures the input geometry based on a material type.

• Packs RBD geometry, constraints, and proxy geometry into a single geometry.

• Paints values onto geometry or constraints using strokes.

• Unpacks an RBD setup into three outputs.

• Attaches RenderMan shaders to groups of faces.

• Generates surfaces by stretching cross-sections between two guide rails.

• Projects one surface onto another.

• Increases the number of points/CVs in a curve or surface without changing its shape.

• Scatters new guides, interpolating the properties of existing guides.

• Recreates the shape of the input surface using "high-quality" (nearly equilateral) triangles.

• Repacks geometry as an embedded primitive.

• Resamples one or more curves or surfaces into even length segments.

• Sets the alignment of solid textures to the geometry so the texture stays put on the surface as it deforms.

• Retimes the time-dependent input geometry.

• Reverses or cycles the vertex order of faces.

• Revolves a curve around a center axis to sweep out a surface.

• Rewires vertices to different points specified by an attribute.

• Generates ripples by displacing points along the up direction specified.

• Scatters new points randomly across a surface or through a volume.

• Runs scripts when cooked.

• Lets you interactively reshape a surface by brushing.

• Morphs though a sequence of 3D shapes, interpolating geometry and attributes.

• Sequence Blend lets you do 3D Metamorphosis between shapes and Interpolate point position, colors…

• Computes the post-deform or pre-deform difference of two geometries with similar topologies.

• Computes the convex hull of the input geometry and moves its polygons inwards along their normals.

• Takes the convex hull of input geometry and moves its polygons inwards along their normals.

• Builds a skin surface between any number of shape curves.

• Creates a sky filled with volumentric clouds

• Smooths out (or "relaxes") polygons, meshes and curves without increasing the number of points.

• Smooths out (or "relaxes") polygons, meshes and curves without increasing the number of points.

• Moves the selected point along its normal, with smooth rolloff to surrounding points.

• Moves the selected point, with smooth rolloff to surrounding points.

• Creates a tetrahedral mesh that conforms to a connected mesh as much as possible.

• Creates a simple tetrahedral mesh that covers a connected mesh.

• Creates a partition of a tetrahedral mesh that can be used for finite-element fracturing.

• 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.

• Reorders points and primitives in different ways, including randomly.

• Creates a sphere or ovoid surface.

• Splits primitives or points into two streams.

• Spray paints random points onto a surface.

• Simulates the behavior of points as if the edges connecting them were springs.

• A SOP node that sets the sprite display for points.

• Insets points on polygonal faces.

• Caches the input geometry in the node on command, and then uses it as the node’s output.

• Stretches two curves or surfaces to cover a smooth area.

• Low level tool for building interactive assets.

• Simplifies the building of tools that incrementally modify geometry based on strokes.

• Subdivides polygons into smoother, higher-resolution polygons.

• 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.

• Trims or creates profile curves along the intersection lines between NURBS or bezier surfaces.

• Creates a surface by sweeping cross-sections along a backbone curve.

• Switches between network branches based on an expression or keyframe animation.

• Reads a CSV file creating point per row.

• Creates a rock creature, which can be used as test geometry.

• Creates a pig head, which can be used as test geometry..

• Creates a rubber toy, which can be used as test geometry.

• Creates a shader ball, which can be used to test shaders.

• Creates a squab, which can be used as test geometry.

• Creates a soldier, which can be used as test geometry.

• Provides a simple crowd simulation for testing transitions between animation clips.

• Provides a simple Bullet simulation for testing the behavior of a ragdoll.

• Partitions a given tetrahedron mesh into groups of tets isolated by a given polygon mesh

• Performs variations of a Delaunay Tetrahedralization.

• Cooks the input at a different time.

• Sets attributes used by the Toon Color Shader and Toon Outline Shader.

• Lets you interactively draw a reduced quad mesh automatically snapped to existing geometry.

• Creates a torus (doughnut) shaped surface.

• Traces curves from an image file.

• Creates trails behind points.

• The Transform operation transforms the source geometry in "object space" using a transformation matrix.

• Transforms the input geometry relative to a specific axis.

• Transforms the input geometry by a point attribute.

• Transforms input geometry according to transformation attributes on template geometry.

• Creates a triangular Bezier surface.

• Refines triangular meshes using various metrics.

• Connects points to form well-shaped triangles.

• Trims away parts of a spline surface defined by a profile curve or untrims previous trims.

• Creates open or closed tubes, cones, or pyramids.

• Generates an edge group representing suggested seams for flattening a polygon model in UV space.

• Adjusts texture coordinates in the UV viewport by painting.

• Lets you interactively move UVs in the texture view.

• Creates flattened pieces in texture space from 3D geometry.

• Creates flattened pieces in texture space from 3D geometry.

• Merges UVs.

• Packs UV islands efficiently into a limited area.

• Relaxes UVs by pulling them out toward the edges of the texture area.

• Assigns UVs by projecting them onto the surface from a set direction.

• Applies an image file as a textured shader to a surface.

• Assigns texture UV coordinates to geometry for use in texture and bump mapping.

• Transforms UV texture coordinates on the source geometry.

• Transforms UV texture coordinates on the source geometry.

• Separates UVs into reasonably flat, non-overlapping groups.

• Processes geometry using an external program.

• Unpacks packed primitives.

• Unpacks points from packed primitives.

• Creates one or more empty/uniform VDB volume primitives.

• Activates voxel regions of a VDB for further processing.

• Expand or contract signed distance fields stored on VDB volume primitives.

• Moves VDBs in the input geometry along a VDB velocity field.

• Moves points in the input geometry along a VDB velocity field.

• Computes an analytic property of a VDB volumes, such as gradient or curvature.

• Clips VDB volume primitives using a bounding box or another VDB as a mask.

• Combines the values of two aligned VDB volumes in various ways.

• Tests VDBs for Bad Values and Repairs.

• Cuts level set VDB volume primitives into multiple pieces.

• Build an LOD Pyramid from a VDB.

• Blends between source and target SDF VDBs.

• Create a mask of the voxels in shadow from a camera for VDB primitives.

• Manipulates the Internal Groups of a VDB Points Primitive.

• Removes divergence from a Vector VDB.

• Fixes signed distance fields stored in VDB volume primitives.

• Re-samples a VDB volume primitive into a new orientation and/or voxel size.

• Reshapes signed distance fields in VDB volume primitives.

• Splits SDF VDBs into connected components.

• Smooths out the values in a VDB volume primitive.

• Smooths out SDF values in a VDB volume primitive.

• Creates an SDF VDB based on the active set of another VDB.

• Merges three scalar VDB into one vector VDB.

• Splits a vector VDB primitive into three scalar VDB primitives.

• Replaces a VDB volume with geometry that visualizes its structure.

• Generates a signed distance field (SDF) VDB volume representing the surface of a set of particles from a particle fluid simulation.

• Converts point clouds and/or point attributes into VDB volume primitives.

• Converts polygonal surfaces and/or surface attributes into VDB volume primitives.

• Fills a VDB volume with adaptively-sized spheres.

• Configures geometry for Vellum Grain constraints.

• Configure constraints on geometry for the Vellum solvers.

• Vellum solver setup to pre-roll fabric to drape over characters.

• Packs Vellum simulations, saves them to disk, and loads them back again.

• Packs Vellum geometry and constraints into a single geometry.

• Applies common post-processing effects to the result of Vellum solves.

• Blends the current rest values of constraints with a rest state calculated from external geometry.

• Runs a dynamic Vellum simulation.

• Unpacks a Vellum simulation into two outputs.

• Verify that a bsdf conforms to the required interface.

• Manually adds or edits attributes on vertices (rather than on points).

• Takes a vertex attribute and splits any point whose vertices differ by more than a specified tolerance at that attribute.

• Shows/hides primitives in the 3D viewer and UV editor.

• Lets you attach visualizations to different nodes in a geometry network.

• Creates a volume primitive.

• Computes analytic properties of volumes.

• Computes a speed-defined travel time from source points to voxels.

• Blurs the voxels of a volume.

• Bounds voxel data.

• Cuts polygonal objects using a signed distance field volume.

• Re-compresses Volume Primitives.

• Convolves a volume by a 3×3×3 kernel.

• Compute the Fast Fourier Transform of volumes.

• Feathers the edges of volumes.

• Flattens many volumes into one volume.

• Combines the scalar fields of volume primitives.

• Translates the motion between two "image" volumes into displacement vectors.

• Fill in a region of a volume with features from another volume.

• Remaps a volume according to a ramp.

• Rasterizes into a volume.

• Samples point attributes into VDBs.

• Converts a curve into a volume.

• Converts fur or hair to a volume for rendering.

• Converts a point cloud into a volume.

• Converts a point cloud into a volume.

• Reduces the values of a volume into a single number.

• Resamples the voxels of a volume to a new resolution.

• Resizes the bounds of a volume without changing voxels.

• Builds a Signed Distance Field from an isocontour of a volume.

• Extracts 2d slices from volumes.

• Splices overlapping volume primitives together.

• Stamps volumes instanced on points into a single target volume.

• Adaptively surfaces a volume hierarchy with a regular triangle mesh.

• Computes a trail of points through a velocity volume.

• Runs CVEX on a set of volume primitives.

• Computes a velocity volume.

• Generates a volume velocity field using curve tangents.

• Generates a velocity field within a surface geometry.

• Adjusts attributes for multi-volume visualization.

• Runs a VEX snippet to modify voxel values in a volume.

• Sets the voxels of a volume from point attributes.

• Fractures the input geometry by performing a Voronoi decomposition of space around the input cell points

• Fractures the input geometry by performing a Voronoi decomposition of space around the input cell 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.

• Cuts the geometry into small pieces according to a set of cuts defined by polylines.

• Creates the point attributes needed to create a Vortex Force DOP.

• Generates volumes to be used as sources in a whitewater simulation.

• Generates emission particles and volumes to be used as sources in a Whitewater simulation.

• Computes generalized winding number of surface at query points.

• Morphs between curve shapes while maintaining curve length.

• Captures surfaces to a wire, allowing you to edit the wire to deform the surface.

• Deforms geometry captured to a curve via the Wire Capture node.

• Transfers the shape of one curve to another.

• Constructs polygonal tubes around polylines, creating renderable geometry.

• Assigns channel paths and/or pickscripts to geometry.