Catmull-Clark Subdivision and What the Limit Surface Actually Is

A bicubic patch is a rectangle. A character model is not. Subdivision surfaces exist to resolve that mismatch: they take a polygon cage of arbitrary connectivity and define a smooth surface as the limit of repeated refinement, so the artist works with a coarse control mesh whose topology can be anything and the renderer receives a surface that is smooth almost everywhere.

The refinement step

One Catmull-Clark iteration takes a polygon mesh and produces a mesh with four times as many faces. It works for arbitrary polygons on input, and after the first iteration every face is a quad. The construction inserts three kinds of new point.

A face point is the centroid of the face’s vertices. An edge point on an edge between vertices $P$ and $Q$, shared by faces with centroids $F_1$ and $F_2$, is $(P + Q + F_1 + F_2)/4$. A vertex point replacing an original vertex $P$ of valence $n$ with incident face centroids $F_i$ and incident edge midpoints $R_i$ is $(F + 2R + (n-3)P)/n$, where $F$ is the average of the $F_i$ and $R$ the average of the $R_i$.

Each original $n$-gon becomes $n$ quads. Each original edge spawns a new edge point, and each original vertex a new vertex point. The resulting mesh has $f’ = \sum_i n_i$ faces where $n_i$ is the vertex count of face $i$, $e’ = 2e + \sum_i n_i$ edges, and $v’ = v + e + f$ vertices. Face count quadruples per iteration for a quad input, so a cage with 6 quads becomes 24, then 96, then 384; after six iterations it is 24,576 quads. That growth is why nobody subdivides to convergence in an interactive context — they subdivide two or three levels and evaluate the remaining smoothness analytically.

The vertex rule is the one that carries the design. Written as weights, it is $(n-3)/n$ on the vertex itself, $2/n^2$ on each incident edge midpoint, and $1/n^2$ on each incident face centroid. The weights sum to one, so the scheme is affine invariant, and they are all non-negative for $n \ge 3$, which keeps the limit surface inside the convex hull of the control points. That boundedness is a practical property: with non-negative weights a subdivision surface cannot oscillate outside its cage, unlike a high-order interpolating spline.

def subdivide(verts, faces):
    """One Catmull-Clark step on a polygon mesh; returns (verts, quad faces)."""
    fp = [tuple(sum(verts[i][k] for i in f) / len(f) for k in range(3)) for f in faces]
    ef = {}
    for fi, f in enumerate(faces):
        for j in range(len(f)):
            ef.setdefault(frozenset((f[j], f[(j + 1) % len(f)])), []).append(fi)
    ep = {}
    for e, fs in ef.items():
        a, b = tuple(e)
        if len(fs) == 1:                       # boundary edge: plain midpoint
            ep[e] = tuple((verts[a][k] + verts[b][k]) / 2 for k in range(3))
        else:
            ep[e] = tuple((verts[a][k] + verts[b][k]
                           + sum(fp[i][k] for i in fs)) / (2 + len(fs)) for k in range(3))
    nv = []
    for vi, p in enumerate(verts):
        inc_e = [e for e in ef if vi in e]
        inc_f = [i for i, f in enumerate(faces) if vi in f]
        n = len(inc_e)
        if n < 3:                              # boundary/corner case, see below
            nv.append(p); continue
        F = [sum(fp[i][k] for i in inc_f) / len(inc_f) for k in range(3)]
        R = [sum((verts[a][k] + verts[b][k]) / 2 for a, b in inc_e) / n for k in range(3)]
        nv.append(tuple((F[k] + 2 * R[k] + (n - 3) * p[k]) / n for k in range(3)))
    base, out = len(nv), []
    fid = {i: base + i for i in range(len(faces))}
    eid = {e: base + len(faces) + i for i, e in enumerate(ep)}
    for fi, f in enumerate(faces):
        for j, v in enumerate(f):
            out.append([v, eid[frozenset((v, f[(j + 1) % len(f)]))],
                        fid[fi], eid[frozenset((f[j - 1], v))]])
    return nv + fp + list(ep.values()), out

The emitted quads walk a corner, the edge leaving it, the face point, and the edge arriving at it, in that order, which keeps the winding of the original face. Each original $n$-gon therefore becomes $n$ quads and the output is quad-only even when the input is not, which is why the scheme is described as quad-dominant after one iteration.

Four-valence vertices are bicubic patches

A vertex with exactly four incident edges is called regular. Around a regular vertex, the limit surface is exactly a uniform bicubic B-spline patch, and the subdivision rules are the B-spline knot insertion rules in disguise. The equivalence means a quad mesh of regular vertices can be evaluated as a network of bicubic patches stitched with $C^2$ continuity across edges, and there is no seam: the patches agree up to second derivative because they are the same spline.

Any vertex with valence other than four is extraordinary, and it is where the analogy dies. There is no tensor-product patch with that parameterization. The limit surface remains continuous and tangent-continuous, but the surface is no longer curvature-continuous at the extraordinary vertex, and the parametrization is singular there: the iso-parameter lines pinch. In practical terms, a highlight passing through an extraordinary vertex of valence 3 shows a visible kink, and a valence-6 vertex on a character’s shoulder shows a slightly broader reflection than the surrounding region.

The count of extraordinary vertices is a fixed property of the base cage. Catmull-Clark never creates one: all new vertices have valence 4 except the vertex points, which inherit the valence of the vertex they replace. Refinement moves extraordinary vertices closer together in parameter space but never removes them. Their number is bounded in aggregate by a topological identity: for a closed quad mesh, the valence defects satisfy $\sum_v (4 - n_v) = 4\chi$, where $\chi$ is the Euler characteristic. A closed genus-zero cage has $\chi = 2$, so it needs at least 8 units of total defect — eight valence-3 vertices, or a mixture of valence-3 and valence-5 vertices that cancel in pairs. A cage can therefore contain many extraordinary vertices, but only because defects of opposite sign are paired, and every such vertex is a place where the surface is not a bicubic patch.

Evaluating the limit without subdividing

Subdividing five levels to place one vertex is wasteful, and the error is not obviously bounded. The alternative is direct evaluation from the control neighbourhood. The standard approach assembles the 1-ring of control points around the target, applies the subdivision matrix repeatedly in a factored form, and extracts the limit point and the two tangent directions.

For an extraordinary vertex of valence $n$, the limit position of the vertex is a weighted sum whose weights depend only on $n$. The DeRose–Kass–Truong formulation expresses the surface locally as a small set of eigenfunctions of the subdivision matrix, and evaluation at an arbitrary parameter reduces to a matrix product plus a handful of polynomial basis evaluations. The cost per evaluated point is constant and depends only on valence, so the patch can be tessellated adaptively by screen-space error without ever building intermediate meshes.

The reason this factorization exists at all is that the subdivision matrix around a regular vertex is circulant, and around an extraordinary vertex it is block-circulant with a small block. Both have compact eigenstructure, which is why the local limit surface has a closed form at all. Away from the 1-ring, the surface is a plain B-spline patch and needs none of this machinery.

Creases, corners, and fractional sharpness

A pure subdivision surface is smooth everywhere, which is wrong for a table edge or a machined bevel. The standard extension tags edges with a sharpness value. A tagged edge is treated as a boundary during the edge-point and vertex-point rules, so its edge point becomes the midpoint of its two endpoints and the surface develops a crease along it. A vertex incident to two or more tagged edges behaves like a corner and stays fixed.

The useful property is that sharpness is a real number, not a boolean. An edge with sharpness above one is treated as sharp, and each subdivision step decrements it by one; below one, the edge’s contribution is blended linearly between the sharp and smooth rules with the fractional part as the blend weight. Sharpness 2.5 therefore produces a crease that persists for two levels and then softens. This gives artists a continuous dial between a rounded fillet and a hard edge without changing topology, and it costs one float per edge.

Shapes the scheme cannot hold

Subdivision surfaces cannot represent a true circular arc. A Catmull-Clark limit surface approximating a cylinder has a radius error that decreases with cage density but never reaches zero, so a shape that must meet a tolerance needs either enough control points or a different representation. A rational B-spline has exact circles, at the cost of losing arbitrary topology.

The other limitation is that the surface follows the cage only approximately. The limit surface lies within the cage’s convex hull but does not interpolate the control points, except at corners. A cage designed by eye is therefore not where the surface ends up; modelling tools compensate by letting the artist edit the limit surface directly and inverting the subdivision to find control points, or by using an interpolating variant. Interpolating subdivision schemes exist and trade the smoothness guarantees for exactly hitting their input.

Finally, the connectivity constraint is real. Non-manifold cages are common in imported assets and are not supported by the scheme as defined; a T-junction or an edge with three faces has no consistent subdivision rule. The checks that catch this are the same ones a half-edge adjacency structure enforces by construction, since a half-edge mesh cannot even be built from a non-manifold cage. Repairing such a mesh, or converting it to a quad-dominant cage, is a prerequisite rather than a detail.

Cage density also interacts with level-of-detail systems. A subdivision cage is cheap to store and expensive to evaluate per frame, so a pipeline that renders a distant character may evaluate the limit surface at coarse tessellation, while a close-up evaluates the same cage finely. That is a different mechanism from decimating the cage itself, which changes the limit surface rather than the sampling of it, and the two are easy to confuse when a frame budget has to be met.