Compact, Fast and Robust Grids for Ray Tracing

Compact, Fast and Robust Gridsfor Ray Tracing Ares Lagae & Philip Dutré Katholieke Universiteit Leuven Wednesday, 13 August

Contributions • Two memory-efficient representations for grids for ray tracing • Compact grid method  Optimal grid representation(1 word / cell, 1 word / object reference) • Hashed grid method  Applied perfect spatial hashing to grids for ray tracing • Simple and efficient

Motivation • Acceleration structures for ray tracing  Minimize time to image • Time to image = build time + render time • Especially for dynamic scenes

Motivation • Algorithms in general • CPU-bound • Execution time = f( CPU speed ) • Memory-bound • Execution time = f( memory access speed )  Accelerate by decreasing memory footprint  Minimize memory footprint • Especially for large models

0 1 2 0 0 1 1 2 2 Grid Data Structures • Grid and linearized grid 2D 2D C A B linearize 0 1 2 3 4 5 6 7 8 1D

Grid Data Structures • Data structure using linked lists 0 1 2 3 4 5 6 7 8 B B A C C A C C B B • 1 word / cell • 2/3 words / object reference A

: unused space Grid Data Structures • Data structure using dynamic arrays 0 1 2 3 4 5 6 7 8 2 0 2 1 2 1 2 1 4 3 2 2 2 1 2 1 2 1 B B A A B A C C B C C • 3 words / cell • 1-2 words / object reference

Compact Grid • Data structure • Concatenate object lists, store begin index 0 1 2 3 4 4 4 5 6 7 8 0 0 1 2 3 3 3 3 3 3 3 6 8 9 10 11 B B A A B C B C A C C 0 1 2 3 3 3 3 3 4 4 4 4 5 5 5 6 7 8 9 10 11  1 word / cell, 1 word / object reference

Compact Grid • Build algorithm (Bound – Count – Accumulate – Insert) 1. Bound  Compute bounding box of objects  Determine grid resolution  Grid sizelinear in number of objects

Compact Grid • Build algorithm (Bound – Count – Accumulate – Insert) 2. Count  Compute size of object lists (1st pass) 0 1 2 3 4 5 6 7 8 0 1 1 1 3 2 1 1 1 0 1 2 3 4 5 6 7 8 9 10 11

Compact Grid • Build algorithm (Bound – Count – Accumulate – Insert) 3. Accumulate  Compute indices of object lists 0 1 2 3 4 5 6 7 8 0 1 2 3 3 3 6 8 9 10 11 0 1 2 3 4 5 6 7 8 9 10 11

Compact Grid • Build algorithm (Bound – Count – Accumulate – Insert) 4. Insert  Reversely insert the object references (2nd pass) 0 1 2 3 4 5 6 7 8 0 1 2 3 3 3 5 8 9 10 11 C 0 1 2 3 4 5 6 7 8 9 10 11

Compact Grid • Build algorithm (Bound – Count – Accumulate – Insert) 4. Insert  Reversely insert the object references (2nd pass) 0 1 2 3 4 5 6 7 8 0 1 2 3 3 3 4 8 9 10 11 B C 0 1 2 3 4 5 6 7 8 9 10 11

Compact Grid • Build algorithm (Bound – Count – Accumulate – Insert) 4. Insert  Reversely insert the object references (2nd pass) 0 1 2 3 4 5 6 7 8 0 1 2 3 3 3 3 8 9 10 11 A B C 0 1 2 3 4 5 6 7 8 9 10 11

Compact Grid • Build algorithm (Bound – Count – Accumulate – Insert) 4. Insert  Reversely insert the object references (2nd pass) 0 1 2 3 4 5 6 7 8 0 0 1 2 3 3 3 6 8 9 10 B B A A B C B C A C C 0 1 2 3 4 5 6 7 8 9 10 11

Compact Grid • Build algorithm • Time complexity  Linear in the number of objects • Space complexity  Linear in the number of objects • Traversal algorithm • Any grid traversal algorithm

list array compact Results • Comparison to traditional grid data structures Memory usage Build time

Hashed Grid • Reduce memory footprint even further • Fast build algorithm • Efficient access during traversal • Redundancy • Object lists?  no Experiments with object list compression failed • Cells?  yes Grid is sparse, up to 99% of the cells are empty

Hashed Grid • Row displacement compression C 1 5 11 12 15

Hashed Grid • Row displacement compression C O 1 5 11 12 15 H

Hashed Grid • Row displacement compression C O 1 0 1 5 11 12 15 H H 1

Hashed Grid • Row displacement compression C O 1 1 1 1 1 1 0 1 1 1 5 5 5 5 5 5 1 5 5 5 11 11 11 11 11 12 12 12 12 12 12 15 15 15 15 H 1 1 5 5

Hashed Grid • Row displacement compression C O 1 1 1 1 1 1 1 0 1 1 1 1 1 5 5 5 5 5 5 5 5 1 5 5 5 5 11 11 11 11 11 11 1 11 11 11 12 12 12 12 12 12 12 12 12 15 15 15 15 15 15 H 1 5 11 11

Hashed Grid • Row displacement compression C O 1 0 1 1 1 5 1 5 5 5 11 1 11 11 11 12 15 3 12 12 12 15 15 15 H 1 5 12 11 11 15 15

Hashed Grid • Row displacement compression O 0 1 1 3 C[i,j]  H[O[i] + j] H 1 1 5 5 12 12 11 11 15

Hashed Grid • Row displacement compression D O 0 1 1 3 |D| + |O| + |H| << |C| H 1 1 1 1 1 5 5 5 5 12 12 12 11 11 15

Hashed Grid • Build algorithm • Bound • Compute domain bits • Compute hash function • Count • Accumulate • Insert • Time complexity: Added Now work directly on the hash table instead of the linearized cell array

Results • Compact grid  Hashed grid • Scene: 3.64 M triangles, 124.84 MB • Memory object lists: 28.84 MB • Memory cells: 55.48 MB  6.20 MB • Build time: 0.39 s  0.72 s • Render time: 2.49 s  2.52 s Cruiser • Scene: 28.06 M triangles, 343.32 MB • Memory object lists: 69.78 MB • Memory cells: 152.75 MB  8.97 MB • Build time: 1.17 s  1.76 s • Render time: 1.55 s  1.43 s Thai Statue

list array compact hashed Results • Comparison to traditional grid data structures Memory usage Build time

Applications • Interactive ray tracing of dynamic scenes Scene: 260 K triangles - FPS: 8.38 FPS (512 x 512)

Applications • Ray tracing large models (16 GB workstation) • Scene: 56.23 M triangles, 1.89 GB • Time to image: 7.55 s / 10.21 s • Memory usage: 1.17 GB / 379.94 MB David • Scene: 372.77 M triangles, 12.50 GB • Time to image: - / 60.75 s • Memory usage: - / 2.36 GB St. Matthew

Conclusion & Future Work • Conclusion Two memory-efficient representations for grids for ray tracing • Compact grid method  Optimal grid representation(1 word / cell, 1 word / object reference) • Hashed grid method  Applied perfect spatial hashing to grids for ray tracing • Future Work • Extend to hierarchical grids • Extend to other acceleration structures

Thanks! • Questions? http://www.cs.kuleuven.be/~ares/ Acknowledgments Ares Lagae is a Postdoctoral Fellow of the Research Foundation Flanders (FWO). The Stanford 3D Scanning Repository, The Digital Michelangelo Project, the bwfirt benchmark, Matthias Rolf, Bernhard Finkbeiner and Greg Ward.

Robust Grid Traversal • Discard intersections outside of cell  Not robust {} {} {…} {…}

Robust Grid Traversal • Discard intersections outside of cell  Not robust Regular grid traversal

Robust Grid Traversal  Do not discard intersections outside of cell • Keep closest intersection, terminate after the intersection Regular grid traversal Robust grid traversal

Parallelization • Using sort-middle approach of Ize et al. Asian Dragon Nature

Compact, Fast and Robust Grids for Ray Tracing