In Houdini, primitives refer to a unit of geometry, lower-level than an object but above points. Houdini supports several different types of primitives:

• Polygon face

• Packed primitives, Packed Disk primitives, and Packed Disk Sequence primitives

• Packed USD primitives

• Polygon soup

• Volume

• Tetrahedron

• Bezier/NURBS surfaces

• Polygon/Bezier/NURBS curves

• Metaballs

There is also a special primitive called a packed primitive that represents a lightweight reference to geometry stored somewhere else. This is very useful for copying/instancing and working with heavy geometry. Alembic files are represented in Houdini as packed primitives.

There are also several quadratic primitive types that represent geometric figures mathematically rather than as polygonal surfaces. These may be useful as lightweight geometry:

• Circle (defined by a single point, rotation, and radius)

• Sphere/ellipsoid (defined by a single point and radii)

• Tube/cone (defined by a single point, rotation, radii, and length)

Houdini’s Circle, Sphere, and Tube have parameters that allow you to choose whether to create, for example, a “primitive sphere” or a polygonal sphere.

You can convert most geometry types to other geometry types using the Convert SOP.

Polygons are shapes constructed from a series of straight edges. These edges are defined by a series of vertices. Polygons are ideal for dealing with complex topologies that go beyond the four sided nature of meshes and NURBS surfaces.

A mesh is a collection of polygons with guaranteed ordering. A mesh is much more efficient than the equivalent polygons, and unlike most regular polygons, you can convert a mesh directly to NURBS. You can also use the Convert SOP to convert mesh primitives to regular polygons when you want a nice layout of polygons in rows and columns.

Polygons have the following properties:

Use the tools on the Create shelf tab to create surfaces. On the operation control toolbar above the viewport, choose an option from the Primitive Type menu to tell Houdini how to construct the polygon.

Use the tools on the Polygon shelf tab to edit and reshape faces and polygonal surfaces.

See packed primitives.

A polygon soup is a primitive that stores polygons using a compact memory representation, and very efficiently stores faces whose primitive attributes are the same. Its in-memory representation allows almost all the memory of a large soup to be shared between the nodes operating on the soup as long as the topology does not change. In contrast, regular polygons require each node to retain a copy of every polygon. This memory sharing also makes memory caches more efficient, resulting in generally faster modeling and rendering operations, in addition to less memory usage. The more polygons in a soup, the greater the benefit over regular polygons. For simple geometry with few polygons, the management overhead of soups can make them slower than regular polygons, although soups will always use less memory.

You can convert geometry to a polygon soup using the Polysoup node.

Loading a soup from a file can be much faster than loading regular polygons (for Mantra as well as Houdini). You can load Alembic files as polygon soups. Creating Grid, Sphere, Tube, and Torus shapes is faster when you use the option to create soups.

Along with the shape nodes, you can create soups with Convert, Convert Meta, Convert VDB, Convert Volume, Iso Offset, Point Cloud Iso, Subdivide, and Tetra Surface. You can use the Subdivide node to subdivide soups if you choose one of the OpenSubdiv methods.

Many (but not all) geometry nodes can operate “natively” on polygon soups. You get the benefits of the soup’s sharing with operations that modify attributes, such as Edit, Transform, Sculpt, Attribute Transfer onto points, point Group, Attribute Create, Attribute Wrangle, Attribute Copy, computing point normals with Facet, point UV Project, Paint, Groups from Name, point Connectivity, and Ray, among others.

Some operations modifying vertex or primitive attributes may still work on polygon soups, but could have a slightly different meaning than for polygons. For example, each soup is only one primitive, so the polygons in a soup cannot have their own primitive attributes. Also, polygon soups often do not have as many vertices as polygon primitives (they merge identical vertices). This means that, for example, UV Project cannot compute vertex texture coordinates correctly, and cusping vertex normal isn’t supported.

Most operations that change polygon topology, such as Poly Extrude and Poly Split, do not support soups, but a few do. For example, the Convex Polygons option on the Divide node will convex a polygon soup and avoid adding any additional vertices, allowing the memory for the vertex attributes to be shared.

For nodes that do not support soups, you can use Convert to convert a soup to regular polygons, and then convert the polygons back to a soup using Polysoup. However, the benefits of polygon soups is usually overwhelmed by the conversion cost, so in most cases, you should just use regular polygons. (If you are doing this type of conversion back and forth in an HDA, set the Unload flag on all nodes whose output is polygons, so the SOP cache won’t hold onto the polygons longer than necessary.)

See the section below for when to use polygon soups, packed primitives, or regular polygons.

See also instancing using packed geometry and polygon soups.

You can see how much memory a node is using by pressing on the node. A pop-up will appear showing various ways of measuring the memory usage of the node:

This display has some limitations:

• The memory referenced by packed primitives is not yet counted for performance reasons.

• The SOP cache manager and the Cache SOP do not yet track memory usage correctly.

• Pressing on a subnet (such as a digital asset) only shows the memory used by the subnet itself, not the memory usage of the network inside the subnet.

Like Alembic packed primitives, USD packed primitives store foreign data (in this case, USD geometry) inside a SOP primitive. The viewport knows how to display the geometry encoded in these primitives, but if you want to modify the data inside, you first need to unpack it.

Points in the packed primitive represent USD prims, and the point position and standard point instancing attributes represent each prim’s transform. You can modify these to move/rotate/scale the prims without unpacking them. (This is common when working the RBD sims.)

Use the Unpack USD SOP to convert packed USD geometry into SOP geometry so you can modify it using subsequent SOP nodes. You can convert the USD geometry to polygons or packed SOP primitives. Unless you only want to use SOPs that work directly on packed primitives, you should choose to convert to polygons.

Metaballs create an implicit surface computed around a set of points. Metaballs are like spheres centered around points. When two metaballs are placed near each other, their surfaces merge smoothly.

Metaballs may be useful for representing blobby or weird surfaces. You can also change how the surface is computed, which may be useful to achieve certain effects:

NURBS is an acronym for Non-Uniform Rational B-Spline. NURBS are smooth curves and surfaces defined by control vertices (CVs). See the Wikipedia definition for more information. The advantage of NURBS is that moving a CV reshapes the surrounding curve/surface while maintaining the continuity of the curve/surface. This allows you to “pull and tug” on the CVs of the NURBS curve or surface to generate a desired shape without causing kinks or discontinuities.

Bézier curves/surfaces are simpler than NURBS. See the Wikipedia definition for more information. Bézier curves allow discontinuities at the knots, making it easier to create corners, but harder to create smooth continuous curves/surfaces.

Houdini supports primitive spheres/ellipsoids, circles/ellipses, and tubes/cones. These shapes are defined by very simple mathematical parameters (for example, height and width) and a single center-point vertex. They can be moved, rotated, and scaled.

Quadratic primitives are extremely lightweight, and work well in applications such as:

• Showing hundreds of thousands or millions of copies of simple shapes, as in instancing.

• Stand-in geometry.

• Envelope geometry (for example, for bouncing particles off of).

Many modeling tools work on quadratic primitives, but the primitives do not have any topology, so operators that act on surface points will not work with quadratic primitives.