Multi-View Visibility Orderings for Real-Time Point-Sampled Rendering

Abstract Occlusion-compatible traversals and z-buffering are often regarded as the only choices for resolving visibility in the image- and point-based rendering community. These algorithms do either per-frame or per-pixel computations. This paper first discusses visibility orderings for point samples in general and then discusses orderings that are valid for multiple views. Then we present a novel, highly efficient, visibility algorithm for point-sampled models that has much smaller per-frame cost than previous approaches. We also discuss a high-performance, cache friendly implementation of this visibility method and present results. Finally, we speculate on possible hardware implementations. 1. Introduction Real world environments are usually very complex. While computer graphics has made great progress, the generation of images of “real” scenes in real-time (>20Hz) is still a challenge. There are two fundamental problems in creating an image – identifying the pixels covered by any given object and determining which parts are visible to the viewer. These two problems are usually called rasterization and visibility. Naive rasterization algorithms perform a number of operations proportional to the number of covered pixels. Recently, output-sensitive algorithms have been introduced, with rasterization time proportional to the number of pixels covered. For this progressively simpler versions are pre-computed. These simpler versions are used for more distant parts of the scene (as they appear in less detail on-screen). For visibility computations, there are two fundamental approaches. Visibility can be computed at linear cost in the number of primitives or on a per-pixel basis. The former assumes that visibility is computed on the primitives directly and is in the worst case proportional to the number of primitives. The latter takes time proportional to the number of pixels covered. An alternative that can compute visibility in sub-linear time is to order the primitives a priori in such a way that rendering them in that order yields the correct result. This ordering can be done at run-time with logarithmic cost if primitives are organized in a hierarchical data structure. For highest efficiency there are two more requirements. It is important that primitives are read in a cache-coherent manner, otherwise memory latencies play a large factor, and ideally, a visibility algorithm should not require any frame-buffer reads. Finally, any rendering algorithm needs to compute a correct result. Due to the limits of sampling this is usually hard to guarantee, but the maximum error that can be tolerated is one pixel wide (usually around the boundary of an object). Consequently, a high-performance rendering algorithm should have the following properties: • store a complete object representation • rasterization cost proportional to the number pixels covered on the screen • sublinear time for visibility computation (assuming some pre-processing) • correct and consistent visibility (limited by sampling) • cache-coherent data reads and writes • only frame-buffer writes (no reads) • the ability to efficiently utilize existing hardware • the potential for hardware implementation Our approach fulfills all of the above criteria. In the following, we first discuss relevant previous work. Then, we describe the theory behind our algorithm and consider its correctness under some assumptions. Later, we discuss practical considerations related to sampled images and pixel grids. We then describe the first implementation of the algorithm and present results.