Researchers present a GPU-based recursive subdivision method for bicubic Bézier surfaces using AMD GPU work graphs, achieving crack-free, view-adaptive tessellation with significantly fewer triangles than hardware tessellation. Instead of storing all 16 control points per sub-patch (192 bytes), sub-patches are encoded as 8-byte quad-tree positions, with control points reconstructed on demand using tensor product blossoms for bitwise-identical shared boundaries. The work graph drives the entire process from a single CPU dispatch with no explicit synchronization barriers or worst-case buffer pre-allocation, making implementation simpler than execute-indirect equivalents while matching hardware tessellation image quality.
Questions this post answers
How do you prevent cracks when adjacent Bézier patches reach different subdivision depths on the GPU?
Cracks from mismatched subdivision depths are closed by generating small wedge triangles independently at each patch boundary. Bitwise-identical shared-boundary positions are guaranteed by reconstructing control points using tensor product blossoms, so neighboring patches always compute the same positions without any inter-patch communication. Graphics engineers tackling watertight subdivision keep up with geometry processing techniques on daily.dev.
How does encoding Bézier sub-patches as quad-tree positions reduce GPU memory usage compared to storing full control points?
Storing all 16 control points per sub-patch costs 192 bytes each. Encoding a sub-patch as its position in a subdivision quad tree costs only 8 bytes. Control points are reconstructed on demand from the base patch using tensor product blossoms, eliminating worst-case buffer pre-allocation and making memory no longer the bottleneck. Developers optimizing GPU memory for real-time rendering find relevant research and techniques on daily.dev.
What is the advantage of using GPU work graphs for recursive patch subdivision over execute-indirect dispatches?
Work graphs eliminate explicit synchronization barriers between recursion levels and require no manual worst-case buffer allocation — the runtime allocates only what is actually needed. A single CPU dispatch drives the entire subdivision tree. The resulting implementation is considerably simpler than an execute-indirect equivalent while producing on-par image quality with significantly fewer triangles. Keeping up with GPU work graph developments and rendering architecture is easier when the relevant papers surface on daily.dev.