Coherent Out-of-Core Point-Based Global Illumination - Janne Kontkanen - Eric Tabelliony - Ryan S. Overbeck

Aug 25, 2026

Coherent out-of-core point-based global illumination (PBGI) and ambient occlusion techniques enable film-grade rendering of extremely complex scenes under tight memory limits. The approach preprocesses point data with a two-pass out-of-core octree build using an external 1D sort on Z-curve/Morton order and a sequential construction stream. Directional radiance is stored compactly in spherical harmonics coefficients, while final shading uses top-down traversal, on-demand paging, and a two-level LRU cache to minimize redundant I/O. Benchmarks demonstrate billion-point scenes rendered with small fixed memory caps.

LanguageEnglish

CategoryResearch & Report

FormatPDF

Pages1

Reading Time3 min

AccessFree to download

Introduction

Out-of-Core Octree Build

Out-of-Core Shading

Conclusion

Coherent Out-of-Core Point-Based Global Illumination Janne Kontkanen 􀀃 Eric Tabelliony Ryan S. Overbeckz DreamWorks Animation (a) “City” scene from the movie ”Kung Fu Panda 2”. 128 million points, 7 GB, octree build time: 4:18s. PBGI shading for 3.2 million visible micropolygons: 6:23s. PBGI used for diffuse and glossy global illumination. (b) “Forest” scene from the movie ”Shrek Forever After”. 927 million points, 51 GB, octree build time: 37:02s. PBGI shading for 18.8 million visible micropolygons: 24:19s. PBGI used for ambient occlusion. Figure 1: Two production scenes from DreamWorks Animation movies that were rendered using the out-of-core method described in this talk. Timings are given in mm:ss. Both scenes were built and shaded within a modest memory cap of 2 GB for (a) and 3 .1 GB for (b). In our talk, we show scenes of up to 1. 7 billion points (88 GB of data) built and shaded within a 2 GB memory cap. 1 Introduction We introduce a new set of techniques for coherent out-of-core point-based global illumination and ambient occlusion. As described in [Christensen 2008], point-based global illumination (PBGI) operates on a dense point representation of the scene. Points are diffusely shaded and are roughly distributed according to a micropolygon tessellation. An octree is constructed over the points, where each octree node describes the light reﬂected from the corresponding cluster of points to any direction. The reﬂected radiance is stored as spherical harmonics coefﬁcients to compactly capture directional variation. After the octree has been constructed, each micropolygon is shaded by ﬁrst selecting a set of octree nodes that deﬁne a suitable level of detail, and then accumulating the radiance stored in these nodes using a cube rasterizer. PBGI is used in ﬁlm production to render tremendously complex scenes, therefore in-core storage of point and octree data structures quickly becomes a problem. Furthermore, a simple out-of-core extension of a classical top-down octree building algorithm would be extremely slow due to the large amount of I/O required. Our work addresses these problems and extends previous PBGI algorithms with efﬁcient out-of-core techniques. Using properties of a space-ﬁlling Z-curve, our octree build requires minimal I/O and additionally stores data on disk compactly and in coherent chunks. Later during shading, data is accessed using on-demand paging and caching. Our parallel system runs entirely within a small ﬁxed memory cap while handling extremely complex scenes, as shown in Figure 1 . 2 Out-of-Core Octree Build Our primary contribution is an out-of-core octree build algorithm that is able to preprocess the point data in just two passes: an external 1D-sort and a sequential octree construction pass. Our method requires minimal amount of I/O and stores both the points and theoctree nodes coherently on disk. We ﬁrst sort the points along a Zcurve, based on their Morton code. Utilizing the well-known property that the Z-curve exactly follows the depth ﬁrst traversal [Mor- © DreamWorks Animation, L. L.C. 2011. This is the author's version of the work. It is posted here for your personal use. Not for redistribution. The definitive version was published in Eurographics Conference on Rendering 2011 , [https://doi.org/10.1111/j.1467-8659.2011.01995.x](https://doi.org/10.1111/j.1467-8659.2011.01995.x). ton 1966], we build the PBGI octree in a single sequential streaming pass over the sorted points. This algorithm builds upon an N-body simulation method developed by Salmon and Warren [1997] . We also introduce a technique to organize the octree nodes into coherent chunks at no additional cost, which can improve the ﬁnal out-of-core shading performance more than 4􀀂 . 3 Out-of-Core Shading During the ﬁnal shading, we shade each visible micropolygon by choosing the suitable level of detail from the out-of-core octree. We perform a top-down recursive depth-ﬁrst traversal o

FAQs

What problem does the out-of-core PBGI approach solve?

It addresses the difficulty of storing dense point and octree data in-core for tremendously complex film scenes and avoids the extreme slowdown that a naive out-of-core extension would cause due to heavy I/O.

How is the out-of-core octree built efficiently?

The method sorts point data along a Z-curve using Morton codes with an external 1D-sort, then constructs the PBGI octree in a single sequential streaming pass over the sorted points.

How does the system perform shading with limited memory?

During final shading, it traverses the octree recursively with a depth-first order, loads only required pages of octree nodes and points on demand, and uses a two-level LRU cache to reduce redundant I/O across multiple processors.

Aug 25, 2026

Uploaded by Lucas Martin