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 Disk Sequence 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.

• Null (representing a single point and rotation, sometimes called a "jack").

• 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 to choose whether they create, for example, a "primitive sphere" or a polygonal sphere.

You can convert most geometry types between each other 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. It is much more efficient that the equivalent polygons, and unlike most regular polygons you can convert it directly to NURBS. You can also use the Convert surface node to convert mesh primitives to regular polygons when you want a nice layout of polygons in rows and columns.

Use the tools on the Create shelf tab to create surfaces, and use the Primitive type pop-up menu on the operation controls toolbar to set the new surface to be created from polygons.

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 nodes operating on the soup as long as the topology does not change (where regular polygons require each node to retain a copy of every polgyon). The sharing also makes memory caches more efficient, meaning many modeling and rendering operations will be faster as well as using less memory.

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, Iso Surface, Point Cloud Iso, Subdivide, and Tetra Surface support creating polygon soups. 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 poly 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, Partition, point Connectivity, and Ray, among others.

Some operations modifying vertex or primitive attributes may still work on polygon soups, but may have slightly different meaning than for polygons. For example, each soup is only one primitive, so the polygons in a soup can’t have their own primitive attributes. Also, polygon soups often do not have as many vertices as polygon primitives (they merge identical vertices). This means, for example, UV Project can’t 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, don’t support soups, but a few do. For example, the Convex polygons option on the Divide node will convex a polygon soup, and will avoid adding any additional vertices, allowing the memory for the vertex attributes to be shared.

For nodes that don’t 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 will usually be overwhelmed by the conversion cost, so in most cases you should just use regular polygons. (If you're doing this type of conversion back and forth in an HDA, you should 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 when to use polygon soups, packed primitives, or regular polygons below.

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.

Metaballs create an implicit surface computed around a set of points. Metaballs are like spheres centered around points, but 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 some effect:

• 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 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. The shapes are defined by very simple mathematical parameters (for example, by height, and width for an ellipsoid) and a single center-point vertex. They can be moved, rotated, and scaled.

Quadratic primitives are extremely lightweight, and so can be used for 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 will work on quadratic primitives, but the primitives do not have any topology so, for example, operators that act on surface points will not work with quadratic primitives.