Houdini 16.5 Nodes Object nodes

Geometry object node

Container for the geometry operators (SOPs) that define a modeled object.

On this page

The Geo object represents a high-level modeled object, such as a character or a prop. It contains geometry operators that define its shape.

Parameters

Transform

Transform Order

The left menu chooses the order in which transforms are applied (for example, scale, then rotate, then translate). This can change the position and orientation of the object, in the same way that going a block and turning east takes you to a different place than turning east and then going a block.

The right menu chooses the order in which to rotate around the X, Y, and Z axes. Certain orders can make character joint transforms easier to use, depending on the character.

Translate

Translation along XYZ axes.

Rotate

Degrees rotation about XYZ axes.

Scale

Non-uniform scaling about XYZ axes.

Pivot

Local origin of the object. See also setting the pivot point .

Uniform Scale

Scale the object uniformly along all three axes.

Modify Pre-Transform

This menu contains options for manipulating the pre-transform values. The pre-transform is an internal transform that is applied prior to the regular transform parameters. This allows you to change the frame of reference for the translate, rotate, scale parameter values below without changing the overall transform.

Clean Transform

This reverts the translate, rotate, scale parameters to their default values while maintaining the same overall transform.

Clean Translates

This sets the translate parameter to (0, 0, 0) while maintaining the same overall transform.

Clean Rotates

This sets the rotate parameter to (0, 0, 0) while maintaining the same overall transform.

Clean Scales

This sets the scale parameter to (1, 1, 1) while maintaining the same overall transform.

Extract Pre-transform

This removes the pre-transform by setting the translate, rotate, and scale parameters in order to maintain the same overall transform. Note that if there were shears in the pre-transform, it can not be completely removed.

Reset Pre-transform

This completely removes the pre-transform without changing any parameters. This will change the overall transform of the object if there are any non-default values in the translate, rotate, and scale parameters.

Keep Position When Parenting

When the object is re-parented, maintain its current world position by changing the object’s transform parameters.

Child Compensation

When the object is being transformed, maintain the current world transforms of its children by changing their transform parameters.

Enable Constraints

Enable Constraints Network on the object.

Constraints

Path to a CHOP Constraints Network. See also creating constraints.

Tip

You can you use the Constraints drop down button to activate one of the Constraints Shelf Tool. If you do so, the first pick session is filled automatically by nodes selected in the parameter panel.

Note

Lookat and Follow Path parameters on object nodes are deprecated in favor of Look At and Follow Path constraints. The parameters are only hidden for now and you can set their visibitily if you do edit the node’s parameter interface.

Render

Material

Path to the Material node.

Display

Whether or not this object is displayed in the viewport and rendered. Turn on the checkbox to have Houdini use this parameter, then set the value to 0 to hide the object in the viewport and not render it, or 1 to show and render the object. If the checkbox is off, Houdini ignores the value.

Phantom

When true, the object will not be rendered by primary rays. Only secondary rays will hit the object.

(See the Render Visibility property).

Renderable

If this option is turned off, then the instance will not be rendered. The object’s properties can still be queried from within VEX, but no geometry will be rendered. This is roughly equivalent to turning the object into a transform space object.

See Render Visibility (vm_rendervisibility property).

Display As

How to display your geometry in the viewport.

Polygons as subdivision (Mantra)

Render polygons as a subdivision surface. The creaseweight attribute is used to perform linear creasing. This attribute may appear on points, vertices or primitives.

When rendering using OpenSubdiv, in addition to the creaseweight, cornerwieght attributes and the subdivision_hole group, additional attributes are scanned to control the behaviour of refinement. These override any other settings:

  • int osd_scheme, string osd_scheme: Specifies the scheme for OSD subdivision (0 or "catmull-clark"; 1 or "loop"; 2 or "bilinear"). Note that for Loop subdivision, the geometry can only contain triangles.

  • int osd_vtxboundaryinterpolation: The Vertex Boundary Interpolation method (see vm_osd_vtxinterp for further details)

  • int osd_fvarlinearinterpolation: The Face-Varying Linear Interpolation method (see vm_osd_fvarinterp for further details)

  • int osd_creasingmethod: Specify the creasing method, 0 for Catmull-Clark, 1 for Chaikin

  • int osd_trianglesubdiv: Specifies the triangle weighting algorithm, 0 for Catmull-Clark weights, 1 for "smooth triangle" weights.

Shading

Categories

The space or comma separated list of categories to which this object belongs.

Currently not supported for per-primitive material assignment (material SOP).

Reflection mask

A list of patterns. Objects matching these patterns will reflect in this object. You can use wildcards (for example, key_*) and bundle references to specify objects.

You can also use the link editor pane to edit the relationships between lights and objects using a graphical interface.

The object:reflectmask property in Mantra is a computed property containing the results of combining reflection categories and reflection masks.

Refraction mask

A list of patterns. Objects matching these patterns will be visible in refraction rays. You can use wildcards (for example, key_*) and bundle references to specify objects.

You can also use the link editor pane to edit the relationships between lights and objects using a graphical interface.

The object:refractmask property in Mantra is a computed property containing the results of combining reflection categories and reflection masks.

Light mask

A list of patterns. Lights matching these patterns will illuminate this object. You can use wildcards (for example, key_*) and bundle references to specify lights.

You can also use the link editor pane to edit the relationships between lights and objects using a graphical interface.

The object:lightmask property in Mantra is a computed property containing the results of combining light categories and light masks.

Volume filter

Some volume primitives (Geometry Volumes, Image3D) can use a filter during evaluation of volume channels. This specifies the filter. The default box filter is fast to evaluate and produces sharp renders for most smooth fluid simulations. If your voxel data contains aliasing (stairstepping along edges), you may need to use a larger filter width or smoother filter to produce acceptable results. For aliased volume data, gauss is a good filter with a filter width of 1.5.

  • point

  • box

  • gauss

  • bartlett

  • blackman

  • catrom

  • hanning

  • mitchell

Volume filter width

This specifies the filter width for the object:filter property. The filter width is specified in number of voxels. Larger filter widths take longer to render and produce blurrier renders, but may be necessary to combat aliasing in some kinds of voxel data.

Matte shading

When enabled, the object’s surface shader will be replaced with a matte shader for primary rays. The default matte shader causes the object to render as fully opaque but with an alpha of 0 - effectively cutting a hole in the image where the object would have appeared. This setting is useful when manually splitting an image into passes, so that the background elements can be rendered separately from a foreground object. The default matte shader is the "Matte" VEX shader, though it is possible to set a different matte shader by adding the vm_matteshader render property and assigning another shader. Secondary rays will still use the object’s assigned surface shader, allowing it to appear in reflections and indirect lighting even though it will not render directly.

For correct matte shading of volumes:

  1. Add the vm_matteshader property to the object.

  2. Create a Volume Matte shader.

  3. Set the density on this shader to match the density on the geometry shader.

  4. Assign this shader to vm_matteshader.

Then when the Matte Shading toggle is enabled, it will use your custom volume matte shader rather than the default (which just sets the density to 1). If you want fully opaque matte, you can use the matte shader rather than volume matte.

Raytrace shading

Shade every sample rather than shading micropolygon vertices. This setting enables the raytrace rendering on a per-object basis.

When micro-polygon rendering, shading normally occurs at micro-polygon vertices at the beginning of the frame. To determine the color of a sample, the corner vertices are interpolated. Turning on object:rayshade will cause the ray-tracing shading algorithm to be invoked. This will cause each sample to be shaded independently. This means that the shading cost may be significantly increased. However, each sample will be shaded at the correct time, and location.

Currently not supported for per-primitive material assignment (material SOP).

Sampling

Geometry velocity blur

If enabled, this object’s rendered motion blur will be based upon the vector attribute named v in the geometry. The units of the attribute are in (1 unit/second).

Velocity motion blur should be used if it contains changing point counts since it cannot be rendered correctly with deformation motion blur. For example, a particle system with changing particle counts should use this option.

You can use Velocity blur on these types of objects as long as they have valid v attributes. Particles automatically have the "v" attribute so if you are rendering particles, simply enable this parameter.

Dicing

Shading quality

This parameter controls the geometric subdivision resolution for all rendering engines and additionally controls the shading resolution for micropolygon rendering. With all other parameters at their defaults, a value of 1 means that approximately 1 micropolygon will be created per pixel. A higher value will generate smaller micropolygons meaning that more shading will occur - but the quality will be higher.

In ray tracing engines, shading quality only affects the geometric subdivision quality for smooth surfaces (NURBS, render as subdivision) and for displacements - without changing the amount of surface shading. When using ray tracing, pixel samples and ray sampling parameters must be used to improve surface shading quality.

The effect of changing the shading quality is to increase or decrease the amount of shading by a factor of vm_shadingquality squared - so a shading quality of 2 will perform 4 times as much shading and a shading quality of 0.5 will perform 1/4 times as much shading.

Dicing flatness

This property controls the tesselation levels for nearly flat primitives. By increasing the value, more primitives will be considered flat and will be sub-divided less. Turn this option down for more accurate (less optimized) nearly-flat surfaces.

Ray predicing

This property will cause this object to generate all displaced and subdivided geometry before the render begins. Ray tracing can be significantly faster when this setting is enabled at the cost of potentially huge memory requirements.

Disable Predicing

Geometry is diced when it is hit by a ray.

Full Predicing

Generate and store all diced geometry at once.

Precompute Bounds

Generate all diced geometry just to compute accurate bounding boxes. This setting will discard the diced geometry as soon as the box has been computed, so it is very memory efficient. This can be useful to improve efficiency when using displacements with a large displacement bound without incurring the memory cost of full predicing.

When ray-tracing, if all polygons on the model are visible (either to primary or secondary rays) it can be more efficient to pre-dice all the geometry in that model rather than caching portions of the geometry and re-generating the geometry on the fly. This is especially true when global illumination is being computed (since there is less coherency among rays).

Currently not supported for per-primitive material assignment (material SOP).

Shade curves as surfaces

When rendering a curve, turns the curve into a surface and dices the surface, running the surface shader on multiple points across the surface. This may be useful when the curves become curved surfaces, but is less efficient. The default is to simply run the shader on the points of the curve and duplicate those shaded points across the created surface.

Geometry

Backface removal (Mantra)

If enabled, geometry that are facing away from the camera are not rendered.

Procedural shader

Geometry SHOP used by the renderer to generate render geometry for this object.

Force procedural geometry output

Enables output of geometry when a procedural shader is assigned. If you know that the procedural you have assigned does not rely on geometry being present for the procedural to operate correctly, you can disable this toggle.

Polygons as subdivision (Mantra)

Render polygons as a subdivision surface. The creaseweight attribute is used to perform linear creasing. This attribute may appear on points, vertices or primitives.

When rendering using OpenSubdiv, in addition to the creaseweight, cornerwieght attributes and the subdivision_hole group, additional attributes are scanned to control the behaviour of refinement. These override any other settings:

  • int osd_scheme, string osd_scheme: Specifies the scheme for OSD subdivision (0 or "catmull-clark"; 1 or "loop"; 2 or "bilinear"). Note that for Loop subdivision, the geometry can only contain triangles.

  • int osd_vtxboundaryinterpolation: The Vertex Boundary Interpolation method (see vm_osd_vtxinterp for further details)

  • int osd_fvarlinearinterpolation: The Face-Varying Linear Interpolation method (see vm_osd_fvarinterp for further details)

  • int osd_creasingmethod: Specify the creasing method, 0 for Catmull-Clark, 1 for Chaikin

  • int osd_trianglesubdiv: Specifies the triangle weighting algorithm, 0 for Catmull-Clark weights, 1 for "smooth triangle" weights.

Render as points (Mantra)

Controls how points from geometry are rendered. At the default settings, No Point Rendering, only points from particle systems are rendered. Setting this value to Render Only Points, will render the geometry using only the point attributes, ignoring all vertex and primitive information. Render Unconnected Points works in a similar way, but only for points not used by any of the geometry’s primitives.

Two attributes control the point primitives if they exist.

orient

A vector which determines the normal of the point geometry. If the attribute doesn’t exist, points are oriented to face the incoming ray (the VEX I variable).

width

Determines the 3D size of the points (defaults to 0.05).

Use N for point rendering

Mantra will initialize the N global from the N attribute when rendering point primitives. When disabled (the default), point normals will be initialized to face the camera.

Metaballs as volume

Render metaballs as volumes as opposed to surfaces. The volume quality for metaballs will be set based on the average size of all metaballs in the geometry, so increasing or decreasing the metaball size will automatically adjust the render quality to match.

Coving

Whether Mantra will try to prevent cracks.

Coving is the process of filling cracks in diced geometry at render time, where different levels of dicing side-by-side create gaps at T-junctions.

The default setting, Coving for displacement/sub-d, only does coving for surfaces with a displacement shader and subdivision surfaces, where the displacement of points can potentially create large cracks. This is sufficient for more rendering, however you may want to use Coving for all primitives if you are using a very low shading rate or see cracks in the alpha of the rendered image.

Do not use Disable coving. It has no performance benefit, and may actually harm performance since Houdini has to render any geometry visible through the crack.

0

No coving.

1

Only displaced surfaces and sub-division surfaces will be coved.

2

All primitives will be coved.

Material Override

Controls how material overrides are evaluated and output to the IFD.

When set to Evaluate Once, any parameter on the material, that uses channels or expressions, will be evaluated only once for the entire detail. This results in significantly faster IFD generation, due to the material parameter assignment being handled entirely by Mantra, rather than Houdini. Setting the parameter value to Evaluate for Each Primitive/Point will evaluate those parameters for each primitive and/or point. It’s also possible to skip material overrides entirely by setting the parameter value to Disabled.

Automatically Compute Normals (Old)

Whether mantra should compute the N attribute automatically. If the N attribute exists, the value will remain unchanged. However, if no N attribute exists, it will be created. This allows polygon geometry which doesn’t have the N attribute already computed to be smooth shaded.

Not supported for per-primitive material assignment (material SOP).

Ignore geometry attribute shaders

When geometry has shaders defined on a per-primitive basis, this parameter will override these shaders and use only the object’s shader. This is useful when performing matte shading on objects.

Not supported for per-primitive material assignment (material SOP).

Misc

Set Wireframe Color

Use the specified wireframe color

Wireframe Color

The display color of the object

Viewport Selecting Enabled

Object is capable of being picked in the viewport.

Select Script

Script to run when the object is picked in the viewport. See select scripts .

Cache Object Transform

Caches object transforms once Houdini calculates them. This is especially useful for objects whose world space position is expensive to calculate (such as Sticky objects), and objects at the end of long parenting chains (such as Bones). This option is turned on by default for Sticky and Bone objects.

See the OBJ Caching section of the Houdini Preferences window for how to control the size of the object transform cache.

Shade Open Curves In Viewport

Any open curves contained in this object will be lit when the viewport is set to do so.

Turning this on will also use a GLSL shader better suited to hair if the whitehair or guardhair attributes are found in the geometry.

Curves with the width attribute will also be rendered as thick ribbons with varying width in shaded modes.

Onion Skinning

Draw this geometry with multiple skins, at different frames in the future and/or past. The number of skins before and after the current frame, the frame increment between them, their opacity and color tinting can be configured in the 3D Display Options.

Off

Turn off onion skinning.

Transform only

Only show the effects of the object transform. This will not recook the actual geometry if it is changing over time, making it faster than Deformation.

Deformation

Show the skins with both object transforms and geometry deformation. This will cause cooking of geometry at the SOP level, if animated.

Locals

IPT

This is typically -1. However, if the object is performing point instancing, then this variable will be set to the point number of the template geometry. For the IPT variable to be active, the Point Instancing parameter must be turned on in this object.

Note

This variable is deprecated. Use the instancepoint expression function instead.

Examples

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.

ChannelBasic Example for Channel channel node

This is a simple example of using the Channel CHOP along with a Noise CHOP to add some variety to keyframed animation that can still be easily tweaked as keyframe animation. Notice that the object can be manipulated as usual in the viewport transparently. The values will be modified in the Channel CHOP.

LookAtTargetAndOffset Example for Constraint Lookat channel node

The first example shows a LookAt constraint with a global Y axis up vector. The second example shows a LookAt constraint with its up vector driven by an object. The third example shows a LookAt constraint applied with Keep Position turned on. The CHOP Offset node, after the constraint, makes the object keep its orientation when the constraint is applied. You can use the LookAt Shelf Tool to recreate the examples.

CopyAnimation Example for Copy channel node

This file demonstrates how the Copy CHOP can be used to copy channels and apply them to geometry.

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.

CountImpacts Example for Count channel node

This example demonstrates how to count impacts from a DOPs simulation using the Count CHOP. Then, using the values from the Count CHOP, we generate copies of a teapot.

DelayPosition Example for Delay channel node

This example demonstrates how to take the position of an object, and delay the animation using the Delay CHOP.

DynamicPops Example for Dynamics channel node

This example demonstrates using the Dynamics CHOP to birth particles where an impact occurs, as well as controlling the birth rate based in impulse.

ExtractTransforms Example for Dynamics channel node

This example demonstrates the use of the Dynamics CHOP to pull transformation information out of a DOP simulation and apply it to Objects.

Export Example for Export channel node

This is an example of the Export CHOP. The Export CHOP is a convenient tool for exporting channels. It allows you to match a CHOP’s channels with different destination channels, without needing to rename the channels. This demonstrates a method to export channels from CHOPs to the ty parameter of a model.

ExpressionLine Example for Expression channel node

This example demonstrates how to use an expression in an Expression CHOP.

Geometry Example for Geometry channel node

This is an example of how the Geometry CHOP can fetch data from a SOP and turn that data into channels.

In this case, the Geometry CHOP pulls in the position of every point in a Superquad SOP and creates channels from that data.

GeometryMethods Example for Geometry channel node

This example demonstrates using the different methods of the Geometry CHOP - Animated and Static.

Lookup Example for Lookup channel node

This example demonstrates how to use the Lookup CHOP to play animation based on an event, or trigger.

Keyboard Example for MIDI Out channel node

This example demonstrates how to write MIDI data using the MIDI Out CHOP, and read it in using the MIDI In CHOP. The MIDI that is written out is based on geometry, and the MIDI that is read in is controlling other geometry.

NoiseTransform Example for Noise channel node

This example demonstrates using the Noise CHOP to generate animation and apply it to geometry.

ObjectBasic Example for Object channel node

This file demonstrates the Object CHOP.

The CHOP is used to bring in the channel information from a Object.

This data can then be manipulated within CHOPs and exported back into the Object, or even a different Operator.

AnimationSequence Example for Sequence channel node

This example demonstrates how to take the animation from three separate objects, and sequence their animation into one animation on a fourth object.

AverageSpeed Example for Vector channel node

This example shows you how to calculate the average speed for each particle over a given time interval using CHOP nodes such as Vector, Trim, and Math.

WarpSpeed Example for Warp channel node

This example demonstrates how to retime a particle simulation using the Warp CHOP.

WaveGrid Example for Wave channel node

This example demonstrates how to warp geometry using a Wave CHOP.

GeometryMattes Example for Geometry compositing node

Using the Geometry COP to make solid mattes out of SOP geometry.

ClipLayerTrigger Example for Agent Clip Layer dynamics node

This example demonstrates how to use the Agent Clip Layer DOP to apply a clip to the upper body of an agent. The clip is activated when the agent is inside a bounding box.

ApplyRelationship Example for Apply Relationship dynamics node

This example shows how you can use the Apply Relationship DOP to add pin constraints to wire objects.

BridgeCollapse Example for Apply Relationship dynamics node

This example shows how to use the Apply Relationship DOP to propagate constraints automatically and create an RBD simulation of a collapsing bridge.

ConstrainedTeapots Example for Apply Relationship dynamics node

This example demonstrates how the Apply Relationship DOP can be used to create multiple constraints with the RBD Pin Constraint node.

MutualConstraints Example for Apply Relationship dynamics node

This example demonstrates how to build mutual constraints between two DOP objects using the Apply Relationship node.

SimpleBlend Example for Blend Solver dynamics node

This example demonstrates how to use the Blend Solver. In this case the Blend Solver is used to blend between an RBD solution and a keyframed solution.

BuoyancyForce Example for Buoyancy Force dynamics node

This example shows how to extract a surface field from another object to use as a buoyancy force source.

AnimatedClothPatch Example for Cloth Object dynamics node

This example shows how a piece of cloth that is pinned on four corners. These corners are constrained to the animated geometry.

BendCloth Example for Cloth Object dynamics node

This cloth example demonstrates how the stiffness of your cloth object can be defined by using the strong or weak bend parameters.

BendDamping Example for Cloth Object dynamics node

This cloth example demonstrates the use of the Damping parameter to control how quickly a cloth object will come to its rest position.

BlanketBall Example for Cloth Object dynamics node

This cloth example shows you how to simulate a ball bouncing on a blanket pinned at all four corners.

ClothAttachedDynamic Example for Cloth Object dynamics node

This example shows a piece of cloth attached to a dynamics point on a rigid object.

ClothFriction Example for Cloth Object dynamics node

This cloth example demonstrates the Friction parameter on the Physical properties of a cloth object.

ClothUv Example for Cloth Object dynamics node

This is an example that shows how you can specify the warped and weft directions on a triangulated cloth planel using uv coordinates.

Because the uv directions are aligned with the xy directions of the grid, the result looks nearly identical to a quad grid, even though the mesh is triangulated.

The little blue and yellow lines visualize the directions of the cloth fabric. This is enabled in the Visualization tab of both cloth objects.

DragCloth Example for Cloth Object dynamics node

This example shows how adding Normal and Tanget Drag to a cloth object can influence its behaviour.

MultipleSphereClothCollisions Example for Cloth Object dynamics node

This example shows a pieces of cloth with different properties colliding with spheres. By adjusting the stiffness, bend, and surfacemassdensity values, we can give the cloth a variety of different behaviours.

PanelledClothPrism Example for Cloth Object dynamics node

This example demonstraits a paneling workflow to create a open-ended rectangular prism which keeps its shape.

PanelledClothRuffles Example for Cloth Object dynamics node

This example demonstraits a paneling workflow and use of the seamangle primitive attribute to create a cloth ruffle attached to a static object.

AnchorPins Example for Constraint Network dynamics node

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

AngularMotorDenting Example for Constraint Network dynamics node

This example demonstrates how angular motors can be used with pin constraints to create a denting effect.

BreakingSprings Example for Constraint Network dynamics node

This example shows how to use a SOP Solver to break spring constraints in a constraint network that have stretched too far.

Chains Example for Constraint Network dynamics node

This example shows how to create a chain of objects that are connected together by pin constraints.

ControlledGlueBreaking Example for Constraint Network dynamics node

This example shows how to gradually remove glue bonds from a constraint network and control the crumbling of a building.

GlueConstraintNetwork Example for Constraint Network dynamics node

This example shows how to create a constraint network to glue together adjacent pieces of a fractured object. It also shows how primitive attributes such as 'strength' can be used to modify properties of individual constraints in the network.

Hinges Example for Constraint Network dynamics node

This example demonstrates how to use pin constraints to create hinges between objects.

PointAnchors Example for Constraint Network dynamics node

This example shows how to create a basic constraint network with point anchors.

SpringToGlue Example for Constraint Network dynamics node

This example shows how to create spring constraints between nearby objects, and then change those constraints to glue constraints during the simulation.

AutoFracturing Example for Copy Objects dynamics node

This example shows how to use the Copy Object DOP, in conjunction with a Multi Solver, to automatically break an RBD object in half whenever it impacts another object.

CrowdHeightField Example for Crowd Solver dynamics node

This example demonstrates using heightfields for terrain adaptation in the crowd solver, and for collisions against ragdolls in the Bullet solver.

FollowTerrain Example for Crowd Solver dynamics node

This example demonstrates how to set up a crowd simulation where agents are oriented to follow the terrain normal.

FootLocking Example for Crowd Solver dynamics node

This example demonstrates how to set up foot locking for an agent.

PartialRagdolls Example for Crowd Solver dynamics node

This example demonstrates how to set up a partial ragdoll, where a subset of the agent’s joints are simulated as active objects by the Bullet solver and the remaining joints are animated.

PinnedRagdolls Example for Crowd Solver dynamics node

This example demonstrates how to set up constraints to attach a ragdoll to an external object, and how to use motors to drive an active ragdoll with an animation clip.

Formation Crowd Example Example for Crowd Solver dynamics node

Crowd example showing a changing formation setup

The setup creates an army of agents. There are two paths created. Middle part of the army starts moving and then splits into two formations. One goes to the left, the other groups keeps marching forward and slowly changes formation to a wedge shape.

To keep the agents in formation a custom geo shape is used. It’s points are used as goals for indiviudal agents. Using blendshapes the shape can change allowing for different formation changes. Dive inside the crowdsource object to see the construction.

Note

The animation clips need to be baked out before playing the scene. This should happen automatically if example is created from Crowds shelf. Otherwise save scene file to a location of your choice and click Render on '/obj/bake_cycles' ropnet to write out the files. The default path for the files is ${HIP}/agents.

Stadium Crowd Example Example for Crowd Solver dynamics node

Crowd example showing a stadium setup

The setup creates a stadium crowd. The rotating cheer_bbox object is used as a bounding box for the agents. When they are inside it it will trigger a transition from a sitting to a cheering state. After a few seconds the cheering crowd sits back down by transitioning into a sitting state.

Note

The animation clips need to be baked out before playing the scene. This should happen automatically if example is created from Crowds shelf. Otherwise save scene file to a location of your choice and click Render on '/obj/bake_cycles' ropnet to write out the files. The default path for the files is ${HIP}/agents.

Tip

To only see a section of the crowd for quicker preview there’s a switch node in /obj/crowdsource/switch_all_subsection. When 0 it will show all agents, when set to 1 will only show a small section.

Street Crowd Example Example for Crowd Solver dynamics node

Crowd example showing a street setup with two agent groups

The setup creates two groups of agents. The yellow agents are zombies which follow a path of the street. The blue agents are living pedestrians that wander around until they come into proximity of the zombies and then they swtich into a running state.

Triggers to change agent states are setup in the crowd_sim dopnet. The zombies group uses proximity to the stoplights and the color of the light to transition into a standing state when lights are red. The living group transition into a running state when they get close to the zombie agents.

Note

The animation clips need to be baked out before playing the scene. This should happen automatically if example is created from Crowds shelf. Otherwise save scene file to a location of your choice and click Render on '/obj/bake_cycles' ropnet to write out the files. The default path for the files is ${HIP}/agents.

ClipTransitionGraph Example for Crowd Transition dynamics node

This example demonstrates how to use a clip transition graph to provide transition clips for state transitions.

FieldForceSmoke Example for Field Force dynamics node

Extracts the velocity field from a smoke simulation to use as a wind force on a POP simulation.

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.

FEMSpheres Example for finiteelementsolver dynamics node

This example demonstrates how to use the FEM Solver to deform spheres when they collide with the ground plane. The spheres have particle based animation on them prior to collision with the ground and are swapped to the FEM solver on collision.

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.

FlipColumn Example for FLIP Solver dynamics node

This example demonstrates how a mixture of fluid colours can have their colour changed by a collision with a static object.

FlipFluidWire Example for FLIP Solver dynamics node

This example demonstrates the use of the Flip Solver and the Fluid Force DOP. The Fluid Force DOP is used to apply a drag force on a wire object according to the motions of a flip fluid. The drag force is only applied at locations where fluid exists in the fluid object.

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.

VariableViscosity Example for FLIP Solver dynamics node

This example demonstrates interaction between three fluids of varying viscosity and a moving collision object.

FillGlass Example for Fluid Object dynamics node

Fills an RBD container with fluid that enters the simulation by being sourced from another RBD object.

FluidFeedback Example for Fluid Object dynamics node

This example shows a ball falling into a tank with feedback. This couples the RBD simulation with the Fluid simulation, causing the ball to float rather than sink.

PaintedGrog Example for Fluid Object dynamics node

This example creates a torus of paint which is dropped on the Grog character. The Grog character is then colored according to the paint that hits him. This also shows how to have additional color information tied to a fluid simulation.

RestartFluid Example for Fluid Object dynamics node

This example shows how to extract part of a fluid simulation and use it to start up a new fluid simulation, possibly with different resolution, location, or size.

RiverBed Example for Fluid Object dynamics node

A simple river bed has a fluid source and fluid sink set up so that liquid rushes down the river.

VariableDrag Example for Fluid Object dynamics node

This example shows how to vary the drag in a fluid simulation. It provides examples of using a specified field to be a high drag zone, of automatically applying drag only to the fluid surface, and of applying negative drag to an area to make the fluid more volatile.

HotBox Example for Gas Calculate dynamics node

This example shows how to take any object with it’s volume representation and add it to the temperature field. You can change the temperature of the object in two ways: by adjusting the volume density value or by adjusting the Gas Calculate microsolver DOP’s source’s Pre-Multiply field.

DiffuseSmoke Example for Gas Diffuse dynamics node

This example demonstrates how to diffuse the density of a smoke simulation using the Gas Diffuse DOP.

CombinedSmoke Example for Gas Embed Fluid dynamics node

In this example, two smoke volumes are merged together using a Gas Embed Fluid DOP and some feathering to help provide a smoother transition between the volumes.

EqualizeFlip Example for Gas Equalize Volume dynamics node

This example demonstrates how the Gas Equalize Volume dop can be used to preserve the volume in a fluid simulation.

EqualizeLiquid Example for Gas Equalize Volume dynamics node

This example demonstrates how the Gas Equalize Volume dop can be used to preserve the volume in a fluid simulation.

dopexample_gasnetfetchdata Example for Gas Net Fetch Data dynamics node

This example demonstrates the use of Gas Net Fetch Data to have two separate dop simulations exchange data.

TimelessGas Example for Gas Particle to Field dynamics node

This example demonstrates the use of gasParticleToField in Timeless mode.

TeapotUnderTension Example for Gas Surface Tension dynamics node

This example creates a teapot shaped blob of liquid. It then uses surface tension forces to smooth the blob into a sphere.

UpresRetime Example for Gas Up Res dynamics node

This example demonstrates how the Up Res Solver can now be used to re-time an existing simulation. The benefit of this is that one can simply change the speed without affecting the look of the sim. On the up-res solver there is a tab called Time. The Time tab offers various controls to change the simulation’s speed.

grass

This example simulates grass being pushed down by an RBD object. Fur Objects are used to represent the blades of grass and Wire Objects are used to simulate the motion. When a single Fur Object is used to represent the grass, neighbouring blades of grass will have similar motion. Additional objects with different stiffness values can be used to make the motion less uniform. When "Complex Mode" is enabled, two objects are used to represent the grass. The stiffness of each set of curves can be controlled by adjusting the "Angular Spring Constant" and "Linear Spring Constant" parameters on the corresponding Wire Objects.

GuidedWrinkling Example for Hybrid Object dynamics node

This is a setup for guided wrinkling using the hybrid object. The first sim creates a detailed mesh consisting of both tets and triangles that doesn’t have any wrinkles yet. The second sim is targeted to the animation creates by the first sim and this adds in the wrinkles.

MagnetMetaballs Example for Magnet Force dynamics node

This example demonstrates how to use the Magnet Force node on a group of metaballs to force the fragments of an object outwards at the moment of impact.

SimpleMagnets Example for Magnet Force dynamics node

This example demonstrates how the magnetforce DOP can be used with a pair of metaballs (one positive and one negative) to attract/repulse an RBD sphere.

VolumeSource Example for Particle Fluid Emitter dynamics node

This example demonstrates the use of a volume emitter to fill a container with fluid. The volume of the inside of a tank is specified as volume emission geometry, and particles are emitted randomly at points inside of this geometry for a specified number of frames. This example uses an SPH fluid.

Particle fluid buoyancy

This example demonstrates how to couple the Particle Fluid with an RBD object so they both affect each other. The result is a buoyant sphere.

FluidGlass Example for Particle Fluid Solver dynamics node

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

PressureExample Example for Particle Fluid Solver dynamics node

This is a simple example demonstrating pressure-driven flow with no viscosity. This example also demonstrates the use of a constantly emitting source of particle fluid as well as how to surface the fluid using the Particle Fluid Surface SOP.

ViscousFlow Example for Particle Fluid Solver dynamics node

This example demonstrates highly viscous fluid flow using particle-based fluids. Fluids of this form could be used to simulate slowly-flowing fluids such as lava or mud.

WorkflowExample Example for Particle Fluid Solver dynamics node

This somewhat complicated example is meant to demonstrate a simple workflow for simulating, storing, surfacing and rendering a particle fluid simulation. Three geometry nodes in the example are named Step 1, Step 2 and Step 3 according to the order in which they are to be used. They write out particle geometry to disk, read the geometry in and surface it, and read the surfaced geometry from disk, respectively. The example also has shaders and a camera built in so that it can be easily rendered.

The fluid animated in this scene models a highly-elastic gelatin-like blob of fluid.

AdvectByFilaments Example for POP Advect by Filaments dynamics node

This example demonstrates how to use POP Advect by Filaments to advect particles using the velocity field of a set of vortex filaments.

AdvectByVolume Example for POP Advect by Volumes dynamics node

This example demonstrates how to use POP Advect by Volumes to advect particles using the velocity from a smoke simulation.

ParticlesAttract Example for POP Attract dynamics node

This example demonstrates how to use the POP Attract node to get a group of particles to follow the motion of an animated sphere. POP Interact and POP Drag nodes are also used in the example to control the interaction between particles and their distance from the sphere.

ParticlesIntercept Example for POP Attract dynamics node

This example demonstrates how to use the POP Attract node to get a particle sim to intercept and follow individual particles.

PointAttraction Example for POP Attract dynamics node

This example demonstrates how to use the POP Attract node with it’s type set to Point in order to control particle attraction on a per point basis.

SphereAxisForce Example for POP Axis Force dynamics node

This example shows three different ways in which the POP Axis Force node can be used with it’s type set to sphere to control your particle simulation.

TorusAxisForce Example for POP Axis Force dynamics node

This example demonstrates how to use the POP Axis Force node to cause a group of particles to billow upwards.

ParticleCollisions Example for POP Collision Detect dynamics node

This example demonstrates the use of the POP Collision Detect node to simulate particles colliding with a rotating torus with animated deformations.

ColorVex Example for POP Color dynamics node

This example shows three different ways to use VEXpressions in your POP Color node to color your particles.

CurveForce Example for POP Curve Force dynamics node

This example demonstrates the use of the POP Curve Force node to control the flow of a particle sim AND a flip fluid sim.

FlockInPops Example for POP Flock dynamics node

This example demonstrates how to control flocks of particles by using the POP Flock node.

CurlForce Example for POP Force dynamics node

This example demonstrates how to use the POP Force node to add curl noise to your particle simulation.

BaconDrop Example for POP Grains dynamics node

This example demonstrates dropping slices of bacon onto a torus. It shows how to extract a 2d object from a texture map and how to repeatedly add the same grain-sheet object to DOPs.

KeyframedGrains Example for POP Grains dynamics node

This example demonstrates keyframing the internal grains of a solid pighead to create an animated puppet.

TargetSand Example for POP Grains dynamics node

This example demonstrates attracting grain simulations to points on the surface of a model.

VaryingGrainSize Example for POP Grains dynamics node

This example demonstrates interacting grain simulations of very different sizes.

SwarmBall Example for POP Interact dynamics node

This example demonstrates the use of the POP Interact node to control the distance between particles and create a ball shaped swarm.

LookatTarget Example for POP Lookat dynamics node

This interactive example demonstrates the use of the POP Lookat node. Hit play and move the green target handle around in the viewport. The cone particles will orient themselves towards the target as you move it around.

DragCenter Example for POP Property dynamics node

This example shows how you can use the Drag Center parameter of the POP Property node to apply an off-center drag to falling objects.

ProximateParticles Example for POP Proximity dynamics node

This example demonstrates how to use POP Proximity node to find nearby particles and set attributes based on their proximity to one another.

BillowyTurbine Example for Pyro Solver dynamics node

This example uses the Pyro Solver and a Smoke Object which emits billowy smoke up through a turbine (an RBD Object). The blades of the turbine are created procedurally using Copy, Circle, and Align SOPs.

SimpleRotationalConstraint Example for RBD Angular Spring Constraint dynamics node

This example demonstrates the use of an RBD Angular Spring Constraint.

RagdollExample Example for Cone Twist Constraint dynamics node

This sample creates a simple ragdoll using the cone twist constraint between pieces of the ragdoll.

ShatterDebris Example for RBD Fractured Object dynamics node

This example demonstrates the how the shatter, RBD Fractured Object, and Debris shelf tools can be used to create debris emanating from fractured pieces of geometry.

First, the Shatter tool (from the Model tool shelf) is used on the glass to define the fractures. Then the RBD Fracture tool is used on the glass to create RBD objects out of the fractured pieces. Then the Debris tool is used on the RBD fractured objects to create debris.

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.

BlendSolverWithRBDGlue

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.

BreakingRock

This is an example of how to use the RBD Glue Object node to create an RBD object that automatically breaks apart on collision. It also demonstrates one technique for breaking a model into pieces appropriate for this sort of simulation.

ChoreographedBreakup

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.

ChoreographedTubeBreakup

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

In this version of the choreographed breakup example, a moving plane is used to choreograph the breakup of a fractured tube. As the plane passes each piece, it is allowed to break off from the rest of the tube.

ShatterGlass

This example uses an RBD projectile to shatter a piece of glass. The glass is made up of simple trangular shards glued together.

This example also demonstrates a situation where using volume based collision detection would not work, and so the objects are treated as infinitely thin surfaces when performing collision detection.

FrictionBalls Example for RBD Object dynamics node

This example demonstrates the friction parameter on an RBD Object.

RBDInitialState Example for RBD Object dynamics node

This example demonstrates the use of the Initial State parameter of an RBD object.

ActivateObjects Example for RBD Packed Object dynamics node

This example shows how to modify the "active" point attribute of an RBD Packed Object to change objects from static to active.

AnimatedObjects Example for RBD Packed Object dynamics node

This example shows how to use animated packed primitives in an RBD Packed Object and set up a transition to active objects later in the simulation.

DeleteObjects Example for RBD Packed Object dynamics node

This example shows how to remove objects from the simulation that are inside a bounding box.

EmittingObjects Example for RBD Packed Object dynamics node

This example shows how to use a SOP Solver to create new RBD objects and add them to an existing RBD Packed Object.

SpeedLimit Example for RBD Packed Object dynamics node

This example shows how to limit the speed of specific objects in the simulation.

Chain Example for RBD Pin Constraint dynamics node

This sample creates a chain of RBD objects connected to each other using constraints.

Chainlinks Example for RBD Pin Constraint dynamics node

In this chain simulation, the individual chain links react to one another in an RBD sim.

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.

GravitySlideExample Example for Slider Constraint dynamics node

This sample creates a box which can only slide and rotate on one axis, using the Slider Constraint.

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.

ReferenceFrameForce Example for Reference Frame Force dynamics node

An RBD vase filled with water performs the water simulation in the vase’s reference frame.

RippleGrid Example for Ripple Solver dynamics node

This example demonstrates how to use the Ripple Solver and Ripple Object nodes. Bulge SOPs are used to deform a grid to create initial geometry and rest geometry for the Ripple Object which is then piped into the Ripple Solver.

ScalePieces Example for Script Solver dynamics node

This example demonstrates how to use the Script Solver node to scale fractured pieces of an RBD sim over time.

2dfluid Example for Smoke Object dynamics node

Demonstrates exporting a 2d fluid into COPs where it can be saved to disk as a sequence of image files to then be used as texture maps, displacement maps, etc.

DelayedSmokeHandoff Example for Smoke Object dynamics node

This example shows a way to turn an RBD into smoke a certain number of frames after the RBD object has hit something.

Open CL smoke Example for Smoke Object dynamics node

Demonstrates a simple Open CL accelerated smoke sim that can be used as a starting point for building optimized GPU accelerated smoke sims. See the Use OpenCL parameter on the Smoke solver.

For fastest speeds, the system needs to minimize copying to and from the video card. This example demonstrates several methods for minimizing copying.

  • Turns off DOPs caching. Caching requires copying all the fields every frame. Useful if you want to scrub and inspect random fields, not if you want maximum speed.

  • Only imports density to SOPs. This means copying only one field from the GPU to CPU each frame.

  • Saves to disk in background. This gives you the best throughput.

  • Uses a plain Smoke solver.

Displaying the simulated output in the viewport requires a GPU → CPU → GPU round trip, but this is required in general to support simulating on a card other than your display card.

RBDtoSmokeHandoff Example for Smoke Object dynamics node

This example shows a way to turn an RBD object into smoke. It uses multiple different colored smoke fields inside the same smoke object.

SourceVorticlesAndCollision Example for Smoke Object dynamics node

This example demonstrates a simple smoke system using a source, keyframed RBD collision objects, and vorticles.

rbdsmokesource Example for Smoke Object dynamics node

A ghostly tetrahedron bounces around a box, its presense shown by its continuous emission of smoke.

VolumePreservingSolid Example for Solid Object dynamics node

This solid object has a strong volume-preserving force (e.g. flesh). The effect of the volume-preserving force is clearly visible when the object hits the ground plane.

StaticBalls Example for Static Object dynamics node

This example uses static object nodes in an RBD simulation of a grid falling and bouncing off three spheres before it hits the ground.

FractureExamples Example for Voronoi Fracture Solver dynamics node

This example actually includes eight examples of ways that you can use voronoi fracturing in Houdini. In particular, it shows how you can use the Voronoi Fracture Solver and the Voronoi Fracture Configure Object nodes in your fracture simulations. Turn on the display flags for these examples one at a time to play the animation and dive down into each example to examine the setup.

SimpleVortex Example for Vortex Force dynamics node

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

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.

Pendulum Example for Wire Solver dynamics node

This example shows how to mutually affect an object at the constraint point and the object at the bob of the pendulum.

CrowdPov Example for Agent Cam object node

This example demonstrates how the agent cam can be assigned to a crowd agent to give you the point of view from someone in a crowd simulation.

PortalBox Example for Environment Light object node

This example shows how to create a portal light using window geometry. A box is modeled and then split into 2 SOPs - one representing windows and the other walls. The walls are rendered, while the windows are used to specify the portal for an environment light. Toggle on and off the portal to see the render quality difference while rendering in the Render View.

extracttransform Example for Extract Transform object node

This example shows how to parent geometry to a moving piece of geometry that is defined by a prebaked .bgeo sequence.

RainbowGeometryLight

This example highlights several features:

  • Geometry area lights

  • Attenuation ramp controls

  • Surface model specular layers

The example consists of a geometry light based on a wireframe of nurbs curves. The attenuation on the light uses colored keys, allowing for different light colors to be produced at different distances from the light. The ground plane shader uses a surface model with two specular components - one wide component and another narrower glossy component to give a multi-layered appearance.

TransparentShadows Example for Light object node

This example shows how to configure transparent shadows with deep shadow maps. The scene includes a transparent grid which casts a shadow on the scene. The renderer used is micropolygon rendering.

IndirectLightBox Example for Indirect Light object node

This example shows how to set up the indirectlight object for indirect diffuse lighting. The scene consists of a box that has been extruded several times, containing a light source and the camera. The light has been placed so that all light reaching the camera must bounce more than once inside the scene before reaching the camera. The indirectlight object is configured to generate 1000000 photons. To visualize the photon map, change the rendering mode on the light to "Direct Global Photon Map". To adjust the sampling quality, modify the pixel samples or ray samples on the mantra ROP. The rendering engine used in this example is PBR.

TubeCaustic Example for Indirect Light object node

This example shows how to set up the indirectlight object for caustic photon map generation and also how light masks and photon targets should be used. The scene consists of a reflective tube and a point and environment light. Each light has a corresponding indirectlight to generate caustics, with the light mask configured to allow the light to generate photons only from the specified light. The photon target is used to ensure that photons are only sent toward the reflective tube. The mantra ROP will produce deep raster planes for the direct_diffuse component on a per-light basis, showing the diffuse illumination from the two lights and the caustics split into separate planes.

PathPathcvWorm Example for Path object node

This example shows a use for the Path and Pathcv nodes. These Path CV’s can be rotated greater than 360. They also have an initial twist function under the controls tab. This can be useful for creating a quick spine.

StickyDonut Example for Sticky object node

In this example, a donut is stuck to an animated sticky object on the surface of a grid.

switchcamera Example for Switcher object node

In this example, we demonstrate how a switcher node can be used to switch the view between two cameras and then used by the render node to output the scene.

rop_example_bakeanimation Example for Bake Animation render node

This example shows how to setup Bake Animation ROP to tranfer animation from a rig onto another while baking object constraints.

FetchROP Example for Fetch render node

This example demonstrates the use of a Fetch ROP to make render dependency connections to ROP nodes that are in a different network. A noise COP is used to generate a texture just-in-time for a surface which is rendered by mantra.

AmbientOcclusion Example for Mantra render node

Ambient occlusion is a fast technique for producing soft, diffuse lighting in open spaces by using ray tracing. It is computed by determining how much of the hemisphere above a point is blocked by other surfaces in the scene, and producing a darker lighting value when the point is heavily occluded. This technique can be useful when you need a GI-like effect without paying the price for full global illumination.

With this particular example, an Ambient Occlusion light and some geometry is provided in the form of a Digital Asset. An Environment Light was used, and it’s parameters were promoted for easy access.

Decreasing the sample count allows you to improve render time at the expense of some additional noise in the render. The following render uses the same shader as the image above but decreases the samples from the default of 256 to 16. This value is set on the Sampling Quality under the Render Options tab of the Light.

Environment Maps

If you have a smooth environment map, it is possible to replace the global background color (white) with the value from an environment map. You can also enable the Sky Environment Map under the Sky Environment Map tab.

MotionVector Example for Mantra render node

The example demonstrates how to generate a motion vector layer for post-velocity compositing. Load the example and render 5 frames. Then in the image viewer, switch from 'C' (colour) to 'motion_vector' to see the results.

Volume Rendering - Metaballs as Volume Example for Mantra render node

Metaball geometry can be natively rendered as a volume in mantra. Metaball rendering can be enabled by checking the Metaballs as Volume parameter on the Geometry tab of a geometry object. Any point attributes on the metaballs will be interpolated to the shading position in the same manner that point attributes are interpolated for metaball surfaces.

Here is an example using randomized point color attributes:

Controlling Shadow Quality/Performance

Shadow map generation uses the Pixel Samples and Shadow Step Size parameters (in the Mantra Render Operator) to control quality and performance in exactly the same way they are used for surfaces. Since volumes often cast soft, diffuse shadows, it is often possible to use low-resolution deep shadow maps when rendering volumes, leading to much faster render times. Shadow map Resolution can be changed on the Shadow tab of a Houdini light.

Volume Rendering - File Referenced Smoke Example for Mantra render node

Volume rendering is a rendering approach that allows high-quality, integrated rendering of volumetric effects like smoke, clouds, spray, and fire.

Volume rendering is suitable for rendering many types of volumetric effects. Scenes that are particularly suited to rendering with mantra volumes include:

  • Detailed "hero" clouds, smoke, or fire

  • Fields of instanced clouds, smoke, or fire

Scenes where volume rendering may not be quite so applicable include:

  • Scenes with a single uniform fog

In this particular example, a bgeo file (1 frame only) was exported from a fluid simulation of smoke and is now referenced using the File SOP. A material using VEX Volume Cloud is assigned to this volumetric data at the top level of the Volume Object. To see this scene in shaded mode, ensure that HOUDINI_OGL_ENABLE_SHADERS is set to 1 in the environment variables.

Controlling Quality/Performance

Volume rendering uses ray marching to step through volumes. Ray marching generates shading points in the volume by uniformly stepping along rays for each pixel in the image. There are two ways to change the quality and speed of the volume ray marching:

  1. The samples parameter on the Sampling tab of the mantra ROP. More pixel samples will produce more ray marches within that pixel leading to higher quality. Using more pixel samples will also improve antialiasing and motion blur quality for the volume.

  2. The volumesteprate parameter on the Sampling tab of the mantra ROP. A larger volume step rate will produce more samples in the volume interior, improving quality and decreasing performance. A separate shadow step rate can be used for shadows.

Which parameter you should change will depend on your quality requirements for pixel antialiasing. In general, it is better to decrease the volume step size rather than increase the pixel samples because a smaller volume step size will lead to more accurate renders.

This render uses 2×2 samples and volume step rate of 1. Notice the detail in the shadows.

This render uses the same scene with 4×4 samples and a volume step rate of 0.25. The fine detail in the shadow has been lost and the volume is somewhat more transparent. The quality level is approximately the same.

Volume Rendering - From Primitives Example for Mantra render node

Volume rendering is a rendering approach that allows high-quality, integrated rendering of volumetric effects like smoke, clouds, spray, and fire.

Volume rendering is suitable for rendering many types of volumetric effects such as:

  • Detailed "hero" clouds, smoke, or fire

  • Fields of instanced clouds, smoke, or fire

It is easy to create volumes from primitives without invoking the fluid solver.

In this particular example, a primitive torus is used to render some smoke volume. Using an IsoOffset SOP produces a volume that fills the interior of the torus. Then, a material using a Volume Cloud is assigned to the volumetric data of the torus shape. Setting the Smoke Cloud Density to 5 and the Smoke Shadow Density to 10 helps create a more smoke-like look and feel.

Here is the torus rendered with tweaks to the volume step sizes (in the Mantra Render Operator), shadow map quality (under Depth Map Options of the spotlight), and volume primitive divisions (on the IsoOffset SOP). The smoke Diffuse color was adjusted too.

netbarrierpost Example for Net Barrier render node

In this example, we demonstrate how a netbarrier ROP node can be used to ensure that multiple machines stay in sync with each other.

RampReference

This example demonstrates the use of ramps and referenced ramps which are animated over time.

ShutterShape

This example demonstrates how to use the shutter shape parameter to control the opening of the shutter along time through a grayscale ramp.

rop_example_wedge Example for Wedge render node

This example shows how to setup the Wedge ROP to automatically create a bunch of variants of a network.

AtmosphereShader

This example shows how to create an atmosphere shader with volumetric shadows. The atmosphere object has a vex lit fog shader attached to it, and the spotlight has deep shadows enabled. The objects in the scene have a matte shader attached to them.

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.

Note

Most of the parameters for the lava material are overridden by point attributes created in the surface nodes.

FirePit Example for Material shader node

Note

No geometry is animated in this file. All animation is achieved by animating the textures

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.

StyleDisplacement Example for Material shader node

This is an example file showing an object made up of two quads, one with a bump map, the other with true displacement. This object is duplicated, and the second copy uses a style sheet to reverse the material assignments on the two quads.

Basic RIS Shading Example Example for RIS Shader Network shader node

In this file we create a simple geometry and assign BxDF shaders to it. The shading network consists of pattern shaders feeding into the BxDF shaders.

VolumeNoiseIso Example for Mantra: VEX Volume Procedural shader node

This example shows how to render an isosurface defined by a cvex shader using mantra’s volume rendering capabilities. A noise field is generated by a cvex shader, which is attached to the VEX Volume Procedural. The volume is shaded by finding the surface where the density crosses 0, and then shading using a simple surface shader that shows the normals.

AddItUp Example for Add geometry node

This network demonstrates the many uses of the Add SOP to build and manipulate geometry:

  • It is used to create points in space which can then be used to create polygons using designated patterns. These polygons can be open or closed. Futhermore, each point can be animated through expressions or keyframes.

  • It is used to both create points and grab points from other primitives. These points may be used in polygon creation.

  • The Add SOP may be utilized to create a polygon using points extracted from another polygonal object. A Group SOP allows for the creation of the point group that will be referenced by the Add SOP.

  • The Add SOP is used to create a polygon from a group of animated Null objects. An Object Merge SOP references the null points in SOPs which are then fed into an Add SOP for polygon generation. A Fit SOP, in turn, is used to create an interpolated spline from the referenced null points. The result is an animted spline.

  • The Add SOP is used to generate points without creating any primitives. Also, points from other objects can be extracted through the Add SOP.

  • Finally the Add SOP can additionally be used to procedurally create rows and columns.

LayerVariations Example for Agent Layer geometry node

This example demonstrates how to create several layers with different geometry variations and randomly assign those layers to agents.

AgentRelationshipBasic Example for Agent Relationship geometry node

This example demonstrates how to create a simple parent-child agent setup.

AlignTube Example for Align geometry node

This example demonstrates how the UV information on surfaces, NURBS in this example, are used by the Align SOP to orient one object to another’s surface.

UV reference parameters in the Align SOP can be animated as shown in the align_tube example.

Animating UV parameters leads to the translation and rotation of the aligned geometries along one another’s surface in various ways.

PackedFragments Example for Assemble geometry node

This example shows how you can break a sphere into packed objects for use in a rigid body simulation using the Assemble SOP.

BlendAttr Example for Attribute Composite geometry node

This example demonstrates how to blend attributes using the Attribute Composite SOP.

AttribCopyTessel Example for Attribute Copy geometry node

This is an example of how to transfer attributes from one geometry to another using the AttribCopy SOP.

A "smiley face" is painted onto a grid as a color attribute using the Paint SOP. The attribute is then transferred to another grid. Because of a discrepancy between the sizes of the grid, a tesselation occurs.

When there are differences between the sizes of the geometry, the AttribCopy SOP will repeat the pattern of the attribute in a cyclic fashion.

CurveTexturing Example for Attribute Create geometry node

The AttribCreate SOP can be used to provide various object-specific attributes by allowing both a label and a value to be given to the newly created attribute.

In this example, the AttribCreate SOP is used to control the width of a curve at rendertime. There are two versions, chosen by a Switch SOP.

  • One AttribCreate SOP gives a constant width attribute in the X axis.

  • The other uses an expression to control the thickness of the curve to create a tapering effect.

The attribute is used by Mantra at render time. To see the results, right-click on the render icon in the viewport, and choose "render_example".

FadedTorus Example for Attribute Fade geometry node

Here is an example of accumulating and fading an attribute

attribfromvolume Example for Attribute from Volume geometry node

This example demonstrates how the AttribFromVolume SOP can be used to transfer volume values onto point attributes.

AttribPromoteSphere Example for Attribute Promote geometry node

This example demonstrates how the AttribPromote SOP can be used to transfer (promote) attributes between points and primitives.

CopyUsingOrient Example for Attribute Reorient geometry node

This example demonstrates how to use the Attrib Reorient SOP to calculate rotations applied to points. These rotations are used by the Copy SOP when creating each instance.

RandomMaterial Example for Attribute String Edit geometry node

This example demonstrates how to use the Attrib String Edit SOP to modify String primitive attributes and randomize the colours on a grid on a per-primitive basis.

MountainSplash Example for Attribute Transfer geometry node

This example demonstrates how to transfer attributes from the points on one geometry to the points on another, using the AttribTransfer SOP.

A line is crept along the surface of a deformed grid. A section of the grid is painted red using the Paint SOP. Using the AttribTransfer SOP, the animated line inherits the attributes from the points on the grid.

Particles are then birthed along the line based on the color attribute (Cd). As the inherited color nears red, particles are born. The particles also use the velocity inherited by the points on the line.

Please press play to see the animation.

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.

AddPoint Example for Attribute Wrangle geometry node

This example shows you how to add a single new point using the Attribute Wrangle SOP and the addpoint() vex expression.

CentroidPoints Example for Attribute Wrangle geometry node

This example shows you how the primintrinsic method can be used to obtain the number of vertices for a primitive. The point corresponding to a vertex can be obtained by first translating a primitive-vertex offset pair to a linear vertex value then looking up the point referenced by the linear vertex value.

FluffyTorus Example for Bake Volume geometry node

This example shows how to setup the Bake Volume SOP to compute the lightfield created by the shadowing of a fog volume. It then exports the fields properly to be rendered in Mantra by a constant volume shader.

FlounderBend Example for Bend geometry node

This example demonstrates how to use the new Bend node to bend a flounder.

TorusBlast Example for Blast geometry node

This network contains a simple example of how the Blast SOP can be used to delete elements of your model.

The Blast SOP can be used to delete points, edges, polygons and breakpoints using designated patterns.

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.

PolyBlend Example for Blend Shapes geometry node

The Blendshapes SOP is used to blend shapes and/or attributes from input geometry.

In this case, three input morph targets are used by the Blendshapes SOP with the Differencing and Blend Position options checked.

The blend values of the input morphs is keyframed for specific effects. Play the animation to see the results.

NumbersOnPoints Example for Block End geometry node

This node shows how to stamp numbers onto points. It uses a for-each loop to iterate over each point, and the metadata source to get the current iteration number.

SimpleFeedback Example for Block End geometry node

This shows how to re-apply the same sequence of nodes multiple times to geometry using the for-loops.

SwissCheese Example for Block End geometry node

This node shows how to iterate over all the pieces of one geometry to consecutively subtract volumes from an original geometry.

BoundingBox Example for Bound geometry node

This example demonstrates how to create a bounding box from geometry.

BoxSpring Example for Box geometry node

The Box SOP is used for more than just creating boxes. It can also envelop existing geometry for specific purposes.

The Box SOP can either create a simple six-sided polygon box, calculate the bounding box size for geometry, or be used in conjunction with the Lattice SOP.

There are two objects within the box.hip file that are examples of this:

  • animated_bounding_box

    The animated_bounding_box object shows how you can envelope an object and surround it with a simple box, even if it is animated. This can be useful when displaying complicated geometry, in which case you would put the display flag on the box object and the render flag on the complicated geometry.

  • box_spring_lattice

    This is an example, a Lattice SOP used in conjunction with the Box SOP. The Box SOP is used to envelope some geometry, in this case a sphere. Divisions is checked to create the proper geometry by referencing the number of divisions in the Lattice SOP.

The top points of the box are grouped by a Group SOP. The Spring SOP uses these points as the Fixed Points from which to create the deformation.

Using the Box SOP in this way allows you to change the incoming geometry (the basic_sphere in this case) and have the box and lattice automatically re-size for you.

BulgeCat Example for Bulge geometry node

Create a simple cat head by using the Bulge SOP combined with metaballs and a NURBS sphere.

BulgeTube Example for Bulge geometry node

The Bulge SOP is used to deform geometry using a metaball as a magnet force.

The magnitude of the magnet force can be adusted in the Bulge SOP.

The parameters in the Metaball SOP may also be adjusted to modify the final effect of the Bulge SOP on the deforming geometry.

SlowParticles Example for Cache geometry node

This file uses the Particle SOP to create a stream of particles.

Then using the Cache SOP, the particles are slowed down. The Cache SOP has the ability to control the frame rate of an animation and read the animation slower than the global frame rate

CapCarousel Example for Cap geometry node

This example shows how to cap two designated areas of a geometry by creating groups.

Two Group SOPs are used to create two groups, group_bottom and group_middle. These groups are created using Number Enable. The Pattern number corresponds to the primitive number, which you can see by turning on primitive numbers.

Two Cap SOPs are used to cap the two groups. By capping either the First V Cap or Last V Cap, you can select which end of the group you want to cap.

CapTubeExamples Example for Cap geometry node

This example contains different variations on how to cap a tube.

There are three geometry types that are able to be capped – NURBS, mesh, and Bezier.

Each geometry type contains examples of different cap types – faceted, shared, rounded, and tangential.

For a better description of cap types, please open the help card in the Cap SOP.

VexDeform Example for Capture Attribute Unpack geometry node

This is an example of how to use the Capture Attribute Unpack SOP to turn capture attributes into something accessible to VEX. It then provides methods to smooth the capture attributes and deform them entirely in VEX.

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.

CopySpikes Example for Carve geometry node

This network contains an example of how the Carve SOP can extract 3D Isoparametric Curves from a surface, and how those curves may be used as a copy template.

The Carve SOP can be used to slice a primitive, cut it into multiple sections, or extract points or cross-sections from it.

In this example, the Extract option has been used to Extract 3D Isoparametric Curve(s). A series of disk-like shapes are created as the Carve SOP extracts curves from points around the surface with the same V Directional value.

It then uses the points along those curves as a template on which to copy sourced geometry.

DiscCarve Example for Carve geometry node

This network is a demonstration of the Carve SOP, specifically when dealing with extracting curves from a NURBs surface and animating that extraction.

The Carve SOP uses the U and V surface data to carve the geometry.

In our example we have extracted curves which can then be used as basis for other geometry to create interesting effects.

Given the Carve SOP uses a 0 to 1 value to carve either in the U or V surface direction, that value can be animated either by keyframing or through expressions.

BlobbySphere Example for Channel geometry node

This is a simple example of how to utilize the Channel SOP to bring information from CHOPs into SOPs and apply it to geometry.

We use an animated sphere and create a lag in the animation of selected areas of the sphere.

In a CHOP network, the Geometry CHOP brings in point position data of the sphere geometry and runs it through a Lag CHOP for the delaying effect. The Channel SOP then references the Lag CHOP and applies the point data back to the selected areas of the original NURBS sphere.

ChannelSOPColorExample Example for Channel geometry node

This example demonstrates using CHOPs to drive geometry color values via the Channel SOP.

ChopSoftBody Example for Channel geometry node

This is an Advanced example.

This network contains example of how the Channel SOP can be used in conjunction with a POP network to manipulate geometry at the SOP level.

First a simple particle network allows the creation and collision of particles sourced from grid geometry.

Next the positional data of the particles is evaluated through a CHOP network using a Geometry CHOP. The Geometry CHOP returns the tx, ty and tz values for every particle birthed in the POP network.

Then, a Channel SOP brings the positional data back to the geometry level and applies it to the points on the original grid surface.

CircleExamples Example for Circle geometry node

This is an example of the different geometry types and arc types a circle can have.

Geometry types include primitives, polygons, NURBS, and Beziers.

Arc types include closed circle, open arc, closed arc, and sliced arc.

The arc examples are animated, so playback the animation to see the arcs opening.

ClayBasic Example for Clay geometry node

This demonstration contains four examples of how a Clay SOP is used. The points have been animated to better visualize this.

Matrix - Point transformation is given by a matrix.

Vector - Point is translated along a vector.

Point - Point is moved to an absolute XYZ position in object space.

Primitive - Point snaps to the (U,V) of the primitive in the 2nd input of to a (U,V) on itself if no 2nd input is present.

ClipParticle Example for Clip geometry node

This is a very basic example of how the Clip SOP can be used to control particle flow by cutting it with an infinite plane.

Play animation to see the effects.

ClipVariations Example for Clip geometry node

This network compares the various ways in which the Clip SOP can be used with geometry. Depending on what parts of the clipped geometry we want to keep, different effects are achievable.

The Clip SOP can also be used as a grouping tool by specify group boundaries with clip planes.

Clip planes can be animated. Play the animation to view the results.

CaptureDeform Example for Cloth Deform geometry node

This example demonstrates how you can use the Cloth Capture and Cloth Deform nodes to transfer the simulation from a low-res piece of cloth to a hi-res piece of cloth.

ParticleClusters Example for Cluster geometry node

This example demonstrates how you can use the Cluster SOP to create clusters of points based on their attribute values. The color SOP is also used to help visualize the clusters.

Animated source points Example for Cluster Points geometry node

If you cluster point source geometry with a changing number of points, the clusters and cluster numbers can change randomly at each frame and you’ll get strange results. To prevent this, you must use a couple of tricks to create the clusters based on the final number of points, and only create the clusters that are needed.

First, connect the second input of the Cluster Points node to specify a set of point positions at which the Cluster Points node should cluster the points. This is called the rest position.

For example, the Impact analysis tool creates points from RBD object collisions. The number of points in the resulting geometry increases as more RBD objects collide.

  1. Cache the impact points geometry to disk using a ROP Output driver and File node combination.

    (The example file may not cache to disk for the sake of simplicity.)

  2. Branch a Timeshift node from the File node, and connect the output of the Timeshift to the Cluster Points node’s second (rest position) input.

  3. Set the Timeshift node’s Frame parameter to the frame you want to cluster at, usually the last frame of the effect. You can use the $NFRAMES variable, which always contains the number of the last frame in the scene.

Second, to create the smoke boxes only as they're needed you must turn on Continuous on the Smoke Object node. This will create a new smoke box on each instance point at every frame. To work around this so the boxes only get created at the frame where the cluster center appears, the example file uses a For Each SOP to delete every cluster center at every frame except the frame where it first appears.

See also how to make scattered points stick for how to make scattered point positions and numbers consistent across frames on deforming geometry.

CombGrass Example for Comb geometry node

This example shows how to use the Comb SOP to control the direction of point normals by interactively "painting" over the normals.

Two Comb SOPs are used to comb the normals on a grid in different directions. A Sequence Blend SOP blends between the two so that the normals look like they are swaying.

A simple line geometry is attached to those points.

The Comb SOP is a great way to animate things like hair and grass.

ConnectedBalls Example for Connectivity geometry node

This example demonstrates how to use an attribute generated by the Connectivity SOP to color different pieces of geometry from a DOPs simulation.

ConvToTrimSurface Example for Convert geometry node

This example shows how to create a trimmed NURBS or Bezier surface using the Convert SOP.

There are four examples contained that compare how a trimmed surface handles a texture.

  • Grid Surface a simple texture map on a grid.

  • Trimmed Circle Using the Trim SOP the conventional way of creating a trimmed surface using a Project SOP and a Trim SOP.

  • Trimmed Circle Using the Convert SOP creates a trimmed surface using a Convert SOP.

  • NURBS Surface Using the Convert SOP shows how a texture is parametrized over a surface that is not trimmed.

To get a better sense of the parameterization of the texture, turn on points and toggle between wireframe and shaded modes.

ConvertBasic Example for Convert geometry node

This example shows the various ways in which the Convert SOP converts geometry types using a simple sphere.

A chart is used for this demonstration.

The left column of the chart describes the original geometry type to convert from.

The top row of the chart describes the geometry type to convert to.

All Sphere SOPs and Convert SOPs in this demonstration use their default values to better visualize the differences.

CurveToPrimCircle Example for Convert geometry node

This example is a simple demonstration on how to convert a curve into a primitive circle.

To convert a NURBS or Bezier closed curve to a primitive circle, it must first be converted to a polygon.

Once converted to a closed polygon curve, you can convert the curve to a primitive circle.

Potatochip Example for Convert geometry node

This example demonstrates how to convert a closed curve into a surface using the Convert SOP.

There are two versions contained in this example. One curve has been successfully converted to a surface, the other has not because of the concave shape of the original curve.

View in shaded mode to get a better sense of this.

ConvertMetaballs Example for Convert Meta geometry node

This example demonstrates using the Convert Meta SOP to convert metaballs to polygons.

CookieBasic

This example displays the various ways in which a Cookie SOP operates.

CookieGear

This example demonstrates how to perform boolean operations using the Cookie SOP.

In this instance, the points are consolidated using a Facet SOP and a Divide SOP is used to create a smooth surface for the Cookie SOP to operate on.

CookieStar

This example creates a boolean operation using the Cookie SOP.

A star geometry is created and used to subtract the shape from the sphere geometry.

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.

CopyCubes Example for Copy Stamp geometry node

This network shows the most basic example of how to use a particle system to copy geometry. A Copy SOP is used to reference a POP network (which included a Source and Drag POP) while copying a box object to every birthed particle.

Play the animation to see the result.

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.

ParticleCopyScale Example for Copy Stamp geometry node

The Copy SOP is used to copy geometry to particles using the Particle SOP as a template. In the example, the Scale parameter of the Copy SOP is used to create the specific effect. The Copy SOP may also be used to control different attributes of the copied geometry beyond mere scale.

Play the animation to see the effects.

StampRandom Example for Copy Stamp geometry node

In this example, the Copy SOP is used to randomly copy various objects onto points of a given template geometry. We use the stamp capability of the Copy SOP for our purpose. Furthermore, the entire process is kept procedural so that we have the option of determining the type and the number of geometries to be copied and the kind of template to be used.

Inside the Stamp tab of the Copy SOP we create a variable named "switch" which will drive the input value of the Select Input parameter in the Switch SOP. In turn, the Copy SOP is able to copy at random any number of input geometry to template points.

StampStars Example for Copy Stamp geometry node

This example demonstrates the power of the Copy SOP’s Stamp operation.

Here, a Copy SOP is used to copy a circle onto the points of a sphere. The Stamp operation then applies various modifications to those copies based on division, scale, color, and extrusion. This results in the generation of a randomized variety of "stars".

Starting with a simple circle, a large number of variations are created using in the copies through the use of Stamping with expressions.

VelocityStamp Example for Copy Stamp geometry node

This example demonstrates the use of the Stamping function within the Copy SOP.

The Copy SOP creates multiple copies of its source geometry. The Stamping function allows for individual variations in each of these copies.

Press play to see the animation.

CreaseBasic Example for Crease geometry node

This demonstration contains four different examples of applying the creaseweight attribute to polygonal geometry utilizing the Crease SOP, Vertex SOP, Attribute Create SOP, and Subdivide SOP.

It also points out some of the differences between rendering with Mantra vs. RenderMan. It is important to know that Mantra can not render the creases due to Copyright laws.

Note

Rendering creases with Mantra requires the addition of a Subdivision SOP for calculating the geometry. The Render tab’s Geometry parameter at the object level should be set to: Geometry As Is.

If Renderman is being used, the Subdivide SOP is only for previewing the result. Renderman calculates creases during the render. The Render tab’s Geometry parameter at the object level should be set to: Polygons as Subdivision Surfaces.

CreepBlob Example for Creep geometry node

This example shows how to creep metaballs on a surface. In this case, the surface is a contorted tube and the metaballs look like a "blob" being pushed through the tract.

A tube is created and used as the creep surface. A circle is created by carving a profile out from that same tube. The circle is then animated with a Creep SOP down the length of the tube.

Metaballs are attached to the points on that carved circle to create the "blob".

CreepParticleTubeA Example for Creep geometry node

This example shows two different ways in which particles can be crept on a surface. In this case, the surface is a contorted tube.

One version shows how particles are crept inside the surface, the other shows how particles are crept outside the surface. This is done by changing the z scale in the Creep SOP, which offsets the particles perpendicular to the surface.

The particles are birthed from a circle that is carved from the tube geometry.

CreepSpiral Example for Creep geometry node

This example shows how to spiral a line geometry over a tube surface using the Creep SOP.

CreepText Example for Creep geometry node

In this example, some text geometry is creeped along an animated surface.

The surface is comprised of two skinned curves that have been animated using a Sequence Blend SOP. The Creep SOP requires that the creep surface be a surface and not a curve.

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.

PopulateRandomAgents Example for Crowd Source geometry node

This example demonstrates how populate a crowd with several different types of agents.

CurveHood Example for Curve geometry node

This example demonstrates how to use the Curve SOP to create a car’s hood.

It also shows how to make points on a new curve dependent on the points of a previous curve. This way, you can move the points on one curve and affect any curve further in the network.

CurveClayBasic Example for Curveclay geometry node

This is a demonstration of how the CurveClay SOP can create an embossed effect on nurbs or bezier geometry.

Two different methods of using the CurveClay SOP to imprint font onto a sphere are shown.

The first method uses a single projected profile, the second method uses two profiles.

UltraSharpFont Example for Curveclay geometry node

This example demonstrates how to refine a curveclay geometry.

A letter "t" is projected onto a grid. The CurveClay SOP understands profile information and uses it to deform the surface geometry.

To get sharp edges on a curveclay, play with the Sharpness and Refinement parameters.

CurvesectRods Example for Curvesect geometry node

This example demonstrates the two functions of the Curvesect SOP, cut and extract.

It also illustrates how these two functions can be applied to an animation at the SOP and POP levels.

The information extracted by the Curvesect SOP during geometry collisions will be used to drive particle birth.

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.

DeleteFan Example for Delete geometry node

The Delete SOP can be used to delete primitives through various methods.

Primitives can be deleted using a pattern range to create interesting objects, such as the fan in this example.

DeltaMushDemo Example for DeltaMush geometry node

This example demonstrates how the Delta Mush SOP is used to smooth out bone deformation.

DissolveBox Example for Dissolve geometry node

This example shows how the Dissolve SOP is used to remove points, edges or primitives of a geometry. The Dissolve SOP automatically patches any holes remaining after the dissolution of various elements.

RemoveSharedEdges Example for Divide geometry node

The Divide SOP is capable of removing edges from geometry. In this example a Divide SOP removes all the internal edges from a simple grid.

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.

ProxyGeometry Example for Dop Import geometry node

This example demonstrates a technique of using the DOP Import SOP to allow the use of proxy geometry in a DOP simulation. One set of geometries are used in the simulation, then the transform information for those objects is applied to higher resolution versions of the geometry.

dopimportrecordsexample Example for DOP Import Records geometry node

This example demonstrates a creating points for each matching record in the DOP simulation. This lets us create a point for each object or a point for each impact.

DuplicateBox

The Duplicate SOP, in this example, is used to create multiple iterations of a box geometry with each copy scaled and offset cumulatively. Expressions using copy number $CY may be used to control each iteration’s parameters.

EdgeCollapseBasic Example for Edge Collapse geometry node

The Edge Collapse SOP simply allows the deletion of edges, as shown in this example. Point numbers are rearranged to accommodate the missing edge.

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.

EdgeDivideBasic Example for Edge Divide geometry node

This is a simple example of the different ways the EdgeDivide SOP is used to insert points on the edges of polygons.

EdgeFlipBasic Example for Edge Flip geometry node

This example demonstrates how you can use the EdgeFlip SOP to flip a selected edge on a surface.

An edge is created on a polygon using the Polysplit SOP, then rotated using the EdgeFlip SOP.

ReferenceGeometry Example for Edit geometry node

This example creates an animation illustrating how the Edit SOP’s Reference Geometry input can be used to apply an edit on animated geometry.

TerrainEdit Example for Edit geometry node

This example demonstrates how to create a terrain using the Edit SOP.

ExtrudeFont Example for Extrude geometry node

This is an example of the Extrude SOP. It illustrates how volume and geometry are created from flat primitives.

It also demonstrates how to separate parts of the geometry into groups, and how to apply different shaders to each group.

FacetVariations Example for Facet geometry node

This example shows the different ways to use the Facet SOP to let you control the smoothness or faceting of a given object. It also shows how you can consolidate points.

Press the right arrow key to show each example.

PackedPoints Example for File geometry node

This example shows how you can use the file sop to do a delayed load of packed disk primitives to have multiple geometry samples per frame for rendering motion blur. If you save out the packed disk geometry, you're really only saving out the point geometry with references to the disk files (which is very light weight).

PackedSamples Example for File geometry node

This example shows how you can use the file sop to do a delayed load of packed primitives to have multiple geometry samples per frame for rendering motion blur.

GridFillet Example for Fillet geometry node

The Fillet SOP is used to create a bridge between two NURBS surfaces with control over its parameterization. The fillet uses the original surface uv information for bridging.

Fillet types may include Freeform, Convex or Circular. The Freeform fillet usually provides a smooth natural form. Such parameters as the left and right UV, Width, Scale, and Offset may be used to control the fillet location between the surfaces.

FitCurves Example for Fit geometry node

This is an example of how to use the Fit SOP to fit a NURBs curve to a basic polygon curve.

Fitting builds a new NURBs or Bezier curve through the input geometry’s points.

There are two methods for doing this:

Interpolation fitting outputs the same number of cv’s as the input curve (Original Polygon Curve).

Approximation fitting reduces the number of cv’s, while approximating a curve through the input points.

Play the animation to see how these two methods affect the resultant curve over time.

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.

ColourAdvect Example for Fluid Source geometry node

This example demonstrates how you can use the Fluid Source SOP to source and advect colours from an additional volume into a smoke simulation.

CoolLava Example for Fluid Source geometry node

This example demonstrates how to cool Lava using the Cool Within Object shelf tool.

TorusVolume Example for Fluid Source geometry node

This example demonstrates how you can use the Fluid Source SOP to create a volume for fluid simulations from a torus.

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.

ForEachMagnet

This example uses the ForEach SOP in all three modes (by group, by attribute and by iteration) for you to study and use. You can make any SOP that doesn’t support local variables (like Magnet, for example) behave like one that does using any of the three methods shown here.

cheese

This example shows how to use the For Each SOP to individually boolean a bunch of self intersecting spheres with a cheese wedge.

cutup

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.

Clumping Example for Fur geometry node

The Fur SOP is used to instance hair-like curves.

In this case, the Fur SOP is used to create curves that can be used for clumping. A second Fur SOP is used to illustrate how to create hairs that use the clumping geometry.

FurBall Example for Fur geometry node

This example demonstrates how the Fur SOP builds hair-like curves based on guide curves and skin geometry.

FurBallWorkflow Example for Fur geometry node

This example demonstrates how the Fur SOP and Mantra Fur Procedural can be applied to an animated skin geometry. CVEX shaders are used to apply a custom look to the hairs based upon attributes assigned to the geometry.

FurPipelineExample Example for Fur geometry node

This example illustrates how custom shaders can be used to define the appearance of fur generated by the Fur SOP.

FurRandomScale Example for Fur geometry node

This example demonstrates how a CVEX shader can be used to apply procedural effects to the curves generated by the Fur SOP. All attributes from the Fur SOP’s guide geometry and the skin geometry inputs are made available to the CVEX shaders. The CVEX shader makes use of the attributes, a unique identifier for each curve, "fur_id", and the position of each point, "P".

FurTextureMap Example for Fur geometry node

This example demonstrates how to use a texturemap to color fur.

Shaved Example for Fur geometry node

This example demonstrates how to use a texture to control hair density.

FuseHood Example for Fuse geometry node

This example shows how to consolidate points between unique curves using the Fuse SOP.

Three panels of a car hood are created and then fused together using the Fuse SOP.

glueclusterexample Example for Glue Cluster geometry node

This example shows how to use the gluecluster SOP and glue constraint networks to cluster together the pieces of a voronoi fracture. This allows clustering to be used with Bullet without introducing concave objects.

GridBasic Example for Grid geometry node

The Grid SOP is a very commonly used primitive, especially as a particle source. It is very versatile and has many surface parameterization options.

In this example, there is a series of grids with alternative Primitive Types and Connectivity.

FeaturedEdges

This example demonstrates how feature edges of your object can be preserved during a polyreduce by using an Edge Group.

GroupCopyBox Example for Group Copy geometry node

This example demonstrates how to group geometry based on a group from another network.

TransferProximity Example for Group Transfer geometry node

This example demonstrates how to use the proximity of a group’s primitives to transfer the group to a new set of geometry using the Group Transfer SOP.

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.

Brickify Example for IsoOffset geometry node

This example shows how to 'brickify' or make an object appear to be made of bricks using the IsoOffset SOP.

SquabVolume Example for IsoOffset geometry node

This example demonstrates the use of the Volume Visualizer on the Squab test object which has been converted to a volume using isooffset.

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.

BallBounce Example for Lattice geometry node

This is an example of how a Lattice SOP is used to create a bouncing ball.

DeformLattice Example for Lattice geometry node

The Lattice SOP creates animated deformations by manipulating simpler geometry that encloses the source geometry.

This example shows how the Lattice SOP can use an animated Box SOP to deform the source geometry. In this case, the source geometry is a sphere.

LatticePerChunk Example for Lattice geometry node

This example shows how you can use the foreach sop to apply a lattice to each fragment of a sphere.

MultiTexture

This example demonstrates the use of the layer SOP to layer multiple textures onto a single object.

MultiUV

This example demonstrates how to have multiple shading layers with different uv sets using the Layer SOP and the VEX Layered Surface SHOP.

LineDirection Example for Line geometry node

This example demonstrates how to generate a line using the Line SOP.

LSystemMaster Example for L-System geometry node

The LSystems SOP allows for the definition of complex shapes through the use of iteration. It uses a mathematical language in which an initial string of characters is evaluated repeatedly, and the results are used to generate geometry. The result of each evaluation becomes the basis for the next iteration of geometry, giving the illusion of growth.

The example networks located in this demonstration should be enough to get you started writing custom LSystem rules.

However, anyone seriously interested in creating LSystems should obtain the book:

The Algorithmic Beauty of Plants, Przemyslaw Prusinkiewicz and Aristid Lindenmayer

For a full list of LSystem commands, see the Houdini documentation.

LsystemBuilding Example for L-System geometry node

This example demonstrates how to use the L-System SOP to generate buildings with windows.

MagnetBubbles Example for Magnet geometry node

This example shows the use of the Magnet SOP, and illustraites its ability to deform geometry.

The Magnet SOP works by using the Density Field of a Metaball as a Magnetic Influence Field on a piece of geometry. The degree to which the Magnetic Field effects the surface it is deforming is based on the distance of that surface to the center of the Metaball.

Here, the Metaballs have been attached to a moving particle system which bounce across a plane. The Metaballs also interact with the plane, causing it to bubble upward as their Fields intersect the surface.

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.

MatchTopologySphere Example for Match Topology geometry node

This example demonstrates how the Match Topology SOP lines up the points and primitives between two geometries with equal amounts of points and primitives.

The Tracking Points, Reference Points, and Assume Primitives Match features are utilized to get a perfect match.

SimpleMDD

This example demonstrates how to use the MDD SOP and MDD File Writer ROP.

MeasureArea Example for Measure geometry node

This example demonstrates how to create groups based on the area of a primitive using the Measure SOP.

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.

MetaExpression Example for Metaball geometry node

This example demonstrates how to use a Meta Expression in an Attribute Create SOP to control how metaballs merge together.

MirrorSpout Example for Mirror geometry node

This example demonstrates how to mirror geometry using the Mirror SOP.

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.

PaintColour Example for Paint geometry node

This example demonstrates how to paint color onto geometry using the Paint SOP.

PaintPoints Example for Paint geometry node

This example demonstrates how to paint scattered points onto the surface of your geometry with a set number of points per area.

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.

ParticleAttractor Example for Particle geometry node

This example file demonstrates using the Metaball and Force SOPs to affect particles generated by the Particle SOP.

Particles are birthed from the origin and shot towards a still metaball. The metaball has a Force SOP applied to it causing the particles, upon reaching the metaball, to spread away from it out into space.

ParticleCollisionBasic Example for Particle geometry node

This is a basic example of using the Particle SOP to birth particles at the SOP level, and having the particles collide with geometry.

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

PeakEars Example for Peak geometry node

This is an example of how to use the Peak SOP to create pointed ears on a head.

The Peak SOP is given the point numbers of the points to be "peaked". It then translates them along their normals to create the pointed ears.

PlatonicSolidsTypes Example for Platonic Solids geometry node

The Platonic Solids SOP generates platonic solids of different types. Platonic solids are polyhedrons which are convex and have all the vertices and faces of the same type. There are only five such objects, which form the first five choices of this operation.

This example shows all seven of the different polyhedron forms that can be made using the Platonic Solids SOP.

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.

AlphaOmega Example for Points from Volume geometry node

This example demonstrates how to use a Points From Volume SOP to create a target goal for a flip simulation and make it fill a given piece of geometry.

PolybevelBox Example for PolyBevel geometry node

This example demonstrates how to bevel geometry using the Poly Bevel SOP.

BridgeCurvesandPrims Example for Poly Bridge geometry node

This contains two examples of how to use the Bridge SOP.

The first example illustrates how to use the Bridge SOP on projected and trimmed curves. The second illustrates how to use the Bridge SOP on two carved primitives.

Press Play to see an animated version of the Bridge over Two Carves.

PolycapTube

This example demonstrates how to cap off a hole in a piece of geometry using the Poly Cap SOP.

PolyCutBasic Example for PolyCut geometry node

This is a simple example of some different ways that the PolyCut SOP can be used to break curves based on attribute changes.

PolyextrudeTube Example for Poly Extrude geometry node

This example demonstrates how to extrude geometry using the Poly Extrude SOP, as well as demonstrating the different extrude controls, Global and Local.

PolyKnitBasic

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.

PolyreduceBatwing Example for PolyReduce geometry node

This example demonstrates how to reduce the number of polygons on a piece of geometry using the Polyreduce SOP.

PolysoupTorus Example for PolySoup geometry node

This example demonstrates how to use the Polysoup SOP to convert a high-res polygonal object into a single primitive that requires less memory.

PolySplitHood Example for PolySplit geometry node

This example shows how to use the PolySplit SOP to refine the geometry of a car hood by splitting polygons.

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.

PopMerge

This example demonstrates how to reference a particle simulation using the POP Merge SOP.

PrimCenter Example for Primitive geometry node

This is an example of how to use the Primitive SOP to correctly sweep primitives on a curve.

The Sweep SOP places the origin of a primitive on a curve by default. If the primitive centroid is away from the origin, the primitive will be placed away from the curve.

In order to correctly place the primitive’s centroid on the backbone, its centroid must be at the origin. For this, the Primitive SOP is used.

PrimRotate Example for Primitive geometry node

This example demonstrates how to rotate individual primitives on a grid surface using the Primitive SOP.

A Group SOP is used to animate a bounding box over the grid surface, thereby activating the randomized rotations in the Primitive SOP.

PrimitiveColors Example for Primitive geometry node

This example demonstrates using the Primitive SOP to add a Color attribute to primitive geometry.

The rand() function is used in the RGB fields to generate different random colors for each primitive.

Then the prim() function is used to reference the attribute values of one SOP, to drive the attribute values of another SOP.

PrimitiveExplode Example for Primitive geometry node

This file demonstrates the ability of the Primitive SOP to control the individual primitives of the object.

With expressions in the Translate Parameter, motion is created driving the primitives away from their centroid. Yet another expression presents the primitives with a randomized rotation. Another randomizing expression colorizes each of the primitives.

Together these parameter create an explosion destroying the original sphere.

PrimitiveMetaWeight Example for Primitive geometry node

This example demonstrates the how the Primitive SOP can be used to drive the attributes of other geometry. In this case it is used to affect the Weight Parameter of a Metaball SOP.

In addition, the parameter can be animated over time. Press Play to see the animation.

FlagProfiles Example for Profile geometry node

This example shows how to use the Project SOP to create a profile on a surface.

The Profile SOP is then used to extract the profile from the surface or remap the profile on it. It also shows how the profile will animate with the surface or independent of it.

ProjectCurve Example for Project geometry node

This example shows the Project SOP projecting a Circle onto a Tube geometry.

By projecting along a vector the Circle profile is attached to the tube. With the use of a Trim SOP the profile can then be used to cut holes in the Tube.

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.

BasicRefine Example for Refine geometry node

This example contains a few methods of how the Refine SOP can be used to add or remove detail from many types of surfaces.

Squidremesh Example for Remesh geometry node

This example demonstrates how to use the Remesh SOP to remesh a model of a giant squid crab while preserving the hard edges of the model.

ResampleLines Example for Resample geometry node

This example demonstrates the use of the Resample SOP on three types of curves. (Polygon, NURBS and Bezier)

The Resample SOP rebuilds the curve by converting it into a series of Polygon Line Segments.

The curve may be rebuilt "Along Arc" or "Along Chord". "Along Arc" utilizes the Hull information as a basis of reconstruction, and can be defined by a Maximum Segment Length and/or Maximum Segment number. "Along Chord" can only be defined by Maximum Segment Length.

Resampling the curve based on Maximum Segment number divides the line into segments of equal, but unspecified length, spanning from start to endpoint. Line detail is directly proportional to the Segment number.

Resampling the curve based on Maximum Segment Length will rebuild the entire line into equal length segments except the last segment. If the Maintain Last Vertex option is on, the last segment will be less than or equal to the Maximum Segment Length value, depending on its distance to the endpoint. With the option off, the endpoint is disregarded and the line is created out of equal lengths.

Turn on Points in the display to see how the Resample SOP resamples line segments.

BasicRest Example for Rest Position geometry node

The Rest Position SOP creates an attribute based on the surface normals that allows a shader to stick to a deforming surface.

All primitives support the rest attribute, but, in the case of quadric primitives (circle, tube, sphere and metaball primitives), the rest position is only translational. This means that rest normals will not work correctly for these primitive types either.

Use the Rest Position SOP only when you are deforming your geometry and you are assigning volumetric or solid materials/patterns in your shader.

Rest normals are required if feathering is used on polygons and meshes in Mantra. NURBs/Beziers will use the rest position to compute the correct resting normals.

It will be necessary to render the setup in order to see the effect.

BasicRevolve Example for Revolve geometry node

This example demonstrates the Revolve SOP’s ability to create geometry by spinning curves and surfaces around any described axis. Simple objects, such as a torus and a vase, are generated by the Revolve SOP and user-defined inputs.

This file also shows off how different geometry types react to different Revolve SOP parameter changes.

SkinBasic Example for Skin geometry node

This is a demonstration of using the Skin SOP to create complex forms by creating surfaces between one or two input geometries.

It also demonstrates how the Skin SOP can interpret between different geometry types and varying point numbers.

SkinCurves Example for Skin geometry node

This demonstration contains example networks showing 3 different methods by which the Skin SOP can assemble input curves to produce a variety of forms.

The methods covered in this demonstration are how the Skin SOP can make a form from a single asymmetrical curve, based on grouping primitives, or from multiple curves.

SkinShip Example for Skin geometry node

This example displays a creative use for the Skin SOP involving the creation of an alien ship.

Curves are first created with the Curve SOP. Then, with the Skin SOP individual curves can be selected to be used as reference for a generated surface.

SkinSurfaceCopies Example for Skin geometry node

This is an example of how to create a new surface using the Skin SOP.

Here a surface is extracted from a torus, copied and used to create a skin that shoots up from the torus.

Hills Example for Smooth geometry node

The Smooth SOP is used to refine the distance between a number of points into more uniform values.

The process evens out minor variances in the points defining the curve, while still maintaining the value trends of the larger, overall curve.

CircleSolvers Example for Solver geometry node

This example demonstrates various ways in which you can use a solver node to transform an object based on ordinary differential equations.

There are 6 different solvers in this example. There is also the exact answer as a point of reference. The solvers are numerical methods that solve the following coupled Ordinary Differential Equations with initial conditions:

x' = y ; x(0) = 1
y' = -x ; y(0) = 0

The numerical methods for Ordinary Differential Equations are: Forward Euler, Runge-Kutta Second Order, Runge-Kutta Third Order, Runge-Kutta Fourth Order, and Parker-Sochacki solved two ways. In one version, Parker-Sochacki is hard coded at order 5. In another version Parker-Sochacki is written in a for loop where the order can be adjusted by the user.

Footsteps Example for Solver geometry node

This is an example of simple footsteps using sdfs on a grid.

SimpleCloth Example for Solver geometry node

This is an example of a simple cloth using verlet integration and simple explicit springs.

SimplePop Example for Solver geometry node

This is an example of a simple particle system. It births particles from source geometry and has them fall with gravity.

SphereTypes Example for Sphere geometry node

This example shows all the geometry types the Sphere SOP can create and explains the differences between them.

Choosing the right geometry type can make a network flow and render much faster.

BoundLattice Example for Spring geometry node

This network utilizes three SOPs (Bound, Spring and Lattice) that commonly work together to simulate certain physical dynamics.

We have created a simple polygonal sphere to act as the source geometry. The sphere is then fed into a Bound SOP which will act as a deforming reference. The Bound SOP also behaves as re-enforcement for the deforming object.

Then the bounding box is wired into the Spring SOP with a group of grids as collision objects. The Spring SOP simulates the dynamics by calculating the proper deformations and behaviours of our source geometry as it collides with other objects. The Spring SOP is where we can apply external forces along with various attributes (characteristics such as mass and drag) which influence how the object deforms.

Finally the Lattice SOP takes the deformation information from the Spring SOP and applies it to the source sphere geometry.

SpringExamples Example for Spring geometry node

This example demonstrates the three main functions of the Spring SOP.

It shows how the Spring SOP can deform input geometry to create a cloth like effect by creating interactions between two objects, defining motion, and applying forces.

Play the animation to see the Spring SOP in action.

SpringFlag Example for Spring geometry node

This example shows how a flag can be simulated using a Spring SOP.

Here the Spring SOP applies forces that simulate the laws of physics on the points of a Grid SOP to create the flag effect.

SpringHair Example for Spring geometry node

This example demonstrates a way to create dynamic hair using the Spring SOP.

A Line is copied onto the points of a Sphere and input into the Spring SOP as a source. Then a Metaball and Force are input to further effect the motion of the hair.

SpringLine Example for Spring geometry node

Here the Spring SOP is used to give a line rubber band-like characteristics. Used in combination with an Xform SOP, the rubber band dances about on the floor.

StitchGrid Example for Stitch geometry node

This example demonstrates how the Stitch SOP can join the edges or surfaces of geometry.

A grid is created and duplicated in a stair fashion. Then the Stitch SOP is used to connect them together.

SubdivideCrease Example for Subdivide geometry node

This example shows a couple ways that you can keep the creases on the top of a box while subdividing the bottom.

SurfsectBasic Example for Surfsect geometry node

This example demonstrates the use of the Surfsect SOP’s boolean operation.

First a box is used to subtract from a Sphere leaving 4 disks. Then the Sphere is used to subtract from the Box leaving just the corners.

SweepBasic Example for Sweep geometry node

This example demonstrates how the Sweep SOP copies geometry onto the points of a curve.

The Sweep SOP is unique in that it automatically places the copied geometry perpendicular to the backbone it is copied to. Variations such as the Cross Section’s scale can be adjusted using expressions.

SweepCurve Example for Sweep geometry node

This network contains an example of the Sweep SOP. A NURBS curve and NURBS circles are used as the backbone and the cross section geometries of the sweep operation respectively.

By controling the scaling of the cross section geometry in the Sweep SOP various effects can be acheived. Finally, a Skin SOP completes the form by using the swept geometry as a kind of skeleton.

SweepDome Example for Sweep geometry node

In this example the Sweep SOP a grid is used as the backbone of a sweep operation with arcs (created by a Circle SOP) as the hull (cross sections) of the sweep object.

The final sweep object is then skinned with a Skin SOP to create the dome geometry.

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.

PlateBreak Example for TimeShift geometry node

This example demonstrates how to use the TimeShift SOP to achieve a slow-motion effect during a fracture simulation.

TorusExamples Example for Torus geometry node

This example contains the various geometry types possible when creating a torus.

Chainmail Example for Triangulate 2D geometry node

This example demonstrates advanced use of the new Triangulate2D SOP to create chainmail links.

BasicTwist Example for Twist geometry node

This example shows off the flexibility of the Twist SOP. The Twist SOP has many operations such as twist, bend, shear, taper, linear taper, and squash.

Contained are examples of how each Operation affects different geometry types: Polygon, Mesh, NURBs, NURBs Perfect, Bezier, and Bezier Perfect.

UnpackWithStyle Example for Unpack geometry node

This example demonstrates the Unpack SOPs ability to evaluate style sheet information while unpacking. Nested packed primitives are used to demonstrate partial unpacking while still preserving styling information. This example also demonstrates the use of a Python SOP to extract information from the per-primitive style sheets.

ProjectionTypes Example for UV Project geometry node

This example demonstrates the various projection types supported by the uvproject SOP.

SoftRotate Example for UV Transform geometry node

Animate the rotation of texture coordinates using the UV Transform SOP with a soft falloff.

Press Play to see the animation.

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.

VisibilityCheckers Example for Visibility geometry node

This example demonstrates the how the Visibility SOP can hide or expose selected primitives in the 2D or 3D view ports.

volumemerge Example for Volume Merge geometry node

This example shows how to use the Volume Merge SOP to flatten multiple instanced volumes onto a single camera frustum volume.

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.

ImportVolumes Example for Volume VOP geometry node

This example shows how to import multiple volumes into a Volume VOP SOP.

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.

TransformFracturedPieces Example for Transform Pieces geometry node

This example demonstrates using the Transform Pieces SOP to transform high-resolution geometry from the results a DOPs rigid-body fracture simulation that used low-resolution geometry.

GroupPainted Example for Add Point to Group VOP node

This example demonstrates how to take a painted attribute and build a point group from that attribute using the Add Point to Group VOP and the Create Point Group VOP.

VOPpointgroup Example for Add Point to Group VOP node

Example of building point Groups in a VOP SOP where every other point is added to a new group.

Only point groups are supported in VOPs.

The VOPs you need to learn are:

Add Point To Group VOP, Create Point Group VOP, and Point In Group VOP

WornMetal Example for Curvature VOP node

This example shows how the curvature vop can be added to a shader network to add a worn or distressed look to your material.

Fuzzy Logic Obstacle Avoidance Example Example for Fuzzy Defuzz VOP node

This example shows agent obstacle avoidance and path following implemented using a fuzzy logic controller.

Fuzzy Logic State Transition Example Example for Fuzzy Defuzz VOP node

This example shows a crowd setup where the state transition is triggered on a fuzzy network setup.

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.

IntersectGrid Example for Intersect VOP node

This example demonstrates how grid points can be transferred to particles on the surface of a sphere using the Intersect VOP.

SimpleMetaImport Example for Meta-Loop Import VOP node

This example demostrates how to use the Meta-Loop Start, Meta-Loop Next and Meta-Loop Import VOPs.

It calculates the sum of the densities of all metaballs in some input geometry, and uses that total to create an image in a Composite Network.

RampParameter Example for Parameter VOP node

This example shows how to control the particle colours using the temperature attributes from a pyro simulation using a Ramp Parameter VOP node.

PointCloudIterateAverage Example for Point Cloud Iterate VOP node

This example shows how the pciterate vop can be used to average together points returned by pcopen. First, a point cloud is generated with a floating point "check" channel initialized to 1 inside a circle in the x-z plane. Then, the points are filtered in a shader by looping using the pciterate vop and averaging the value of the "check" channel. The point cloud used in the example is stored inside the asset as points.pc.

PointCloudWrite Example for Point Cloud Write VOP node

This example shows how the pcwrite vop can be used to write out points to a point cloud file. Render the mantra1 ROP to generate the point cloud, then view the point cloud with gplay. The distribution of points will depend on where mantra shaders are executed - in this case, the mantra ROP is configured to shade hidden surfaces allowing the back faces of the sphere to generate points.

RaytraceVopShader Example for Ray Trace VOP node

This example demonstrates a simple ray traced shader using a vop vex network. To modify the shader properties, create a properties shader in the material and connect it to the output shaders node. You can then add rendering parameters to the properties node. For example to control the number of reflection bounces, you would add the reflect limit parameter.

SensorDeform Example for Sensor Panorama Create VOP node

Example demonstrating sensor creation and how depth information can be extracted using the cone command. This allows the centre sphere to be deform by observed sphere.

Object nodes

  • Agent Cam

    Create and attach camera to a crowd agent.

  • Alembic Archive

    Loads the objects from an Alembic scene archive (.abc) file into the object level.

  • Alembic Xform

    Loads only the transform from an object or objects in an Alembic scene archive (.abc).

  • Ambient Light

    Adds a constant level of light to every surface in the scene (or in the light’s mask), coming from no specific direction.

  • Atmosphere

    Creates a fog effect when rendered.

  • Auto Bone Chain Interface

    The Auto Bone Chain Interface is created by the IK from Objects and IK from Bones tools on the Rigging shelf.

  • Blend

    Switches or blends between the transformations of several input objects.

  • Blend Sticky

    Computes its transform by blending between the transforms of two or more sticky objects, allowing you to blend a position across a polygonal surface.

  • Bone

    The Bone Object is used to create hierarchies of limb-like objects that form part of a hierarchy …

  • COP2 Plane

    Container for the Compositing operators (COP2) that define a picture.

  • Camera

    You can view your scene through a camera, and render from its point of view.

  • Dop Network

    The DOP Network Object contains a dynamic simulation.

  • Environment Light

    Environment Lights provide background illumination from outside the scene.

  • Extract Transform

    The Extract Transform Object gets its transform by comparing the points of two pieces of geometry.

  • Fetch

    The Fetch Object gets its transform by copying the transform of another object.

  • Formation Crowd Example

    Crowd example showing a changing formation setup

  • Franken Muscle

    Creates a custom muscle by combining any number of geometry objects, muscle rigs, and muscle pins.

  • Fuzzy Logic Obstacle Avoidance Example

  • Fuzzy Logic State Transition Example

  • Geometry

    Container for the geometry operators (SOPs) that define a modeled object.

  • Groom Merge

    Merges groom data from multiple objects into one.

  • Guide Deform

    Moves the curves of a groom with animated skin.

  • Guide Groom

    Generates guide curves from a skin geometry and does further processing on these using an editable SOP network contained within the node.

  • Guide Simulate

    Runs a physics simulation on the input guides.

  • Hair Generate

    Generates hair from a skin geometry and guide curves.

  • Handle

    The Handle Object is an IK tool for manipulating bones.

  • Indirect Light

    Indirect lights produce illumination that has reflected from other objects in the scene.

  • Instance

    Instance Objects can instance other geometry, light, or even subnetworks of objects.

  • Light

    Light Objects cast light on other objects in a scene.

  • Light template

    A very limited light object without any built-in render properties. Use this only if you want to build completely custom light with your choice of properties.

  • Microphone

    The Microphone object specifies a listening point for the SpatialAudio CHOP.

  • Mocap Acclaim

    Import Acclaim motion capture.

  • Mocap Biped 1

    A male character with motion captured animations.

  • Mocap Biped 2

    A male character with motion captured animations.

  • Mocap Biped 3

    A male character with motion captured animations.

  • Muscle

    The Muscle object is a versatile tool that can be used when rigging characters and creatures with musculature.

  • Muscle Pin

    Creates a simple rigging component for attaching regions of a Franken Muscle to your character rig.

  • Muscle Rig

    Creates the internal components of a muscle (the rig), by stroking a curve onto a skin object.

  • Null

    Serves as a place-holder in the scene, usually for parenting. this object does not render.

  • Path

    The Path object creates an oriented curve (path)

  • PathCV

    The PathCV object creates control vertices used by the Path object.

  • Pxr AOV Light

    Pxr AOV Light object for RenderMan RIS.

  • Pxr Barn Light Filter

    Pxr Barn Light Filter object for RenderMan RIS.

  • Pxr Blocker Light Filter

    Pxr Blocker Light Filter object for RenderMan RIS.

  • Pxr Cookie Light Filter

    Pxr Cookie Light Filter object for RenderMan RIS.

  • Pxr Day Light

    Pxr Day Light object for RenderMan RIS.

  • Pxr Disk Light

    Pxr Disk Light object for RenderMan RIS.

  • Pxr Distant Light

    Pxr Distant Light object for RenderMan RIS.

  • Pxr Dome Light

    Pxr Dome Light object for RenderMan RIS.

  • Pxr Gobo Light Filter

    Pxr Gobo Light Filter object for RenderMan RIS.

  • Pxr Mesh Light

    Pxr Mesh Light object for RenderMan RIS.

  • Pxr Portal Light

    Pxr Portal Light object for RenderMan RIS.

  • Pxr Ramp Light Filter

    Pxr Ramp Light Filter object for RenderMan RIS.

  • Pxr Rectangle Light

    Pxr Rectangle Light object for RenderMan RIS.

  • Pxr Rod Light Filter

    Pxr Rod Light Filter object for RenderMan RIS.

  • Pxr Sphere Light

    Pxr Sphere Light object for RenderMan RIS.

  • Python Script

    The Python Script object is a container for the geometry operators (SOPs) that define a modeled object.

  • Ragdoll Run Example

    Crowd example showing a simple ragdoll setup.

  • Rivet

    Creates a rivet on an objects surface, usually for parenting.

  • Simple Biped

    A simple and efficient animation rig with full controls.

  • Simple Female

    A simple and efficient female character animation rig with full controls.

  • Simple Male

    A simple and efficient male character animation rig with full controls.

  • Sound

    The Sound object defines a sound emission point for the Spatial Audio chop.

  • Stereo Camera Rig

    Provides parameters to manipulate the interaxial lens distance as well as the zero parallax setting plane in the scene.

  • Stereo Camera Template

    Serves as a basis for constructing a more functional stereo camera rig as a digital asset.

  • Sticky

    Creates a sticky object based on the UV’s of a surface, usually for parenting.

  • Subnet

    Container for objects.

  • Switcher

    Acts as a camera but switches between the views from other cameras.

  • Tissue Solver

    Collects muscles, anatomical bone models, and skin objects and places them into a single dynamics simulation.

  • VR Camera

    Camera supporting VR image rendering.

  • Viewport Isolator

    A Python Script HDA providing per viewport isolation controls from selection.

  • pxr Int Mult Light Filter

    pxr Int Mult Light Filter object for RenderMan RIS.