This document discusses techniques for visualizing massive 3D models. It covers culling methods like view frustum and occlusion culling to remove invisible geometry. Level of detail techniques generate lower detail versions of models to improve performance. Hierarchical LOD representations allow efficient refinement. Out-of-core techniques bring portions of models into memory as needed to handle models too large to fit entirely in memory. Compression, prefetching, and cache-coherent layouts further optimize rendering massive models. The goal is to keep processors busy and maintain performance as model complexity increases beyond memory limits.

1. Introduction to Massive Model Visualization Patrick Cozzi Analytical Graphics, Inc.

2. Contents Minimal computer graphics background Culling Level of Detail (LOD) Memory Management Videos throughout

3. Computer Graphics Background Goal: Convert 3D model to pixels 3D models are composed of triangles

4. Computer Graphics Background 1 triangle = 3 vertices Gross over simplification: 3 floats per vertex (x 0 , y 0 , z 0 ) (x 1 , y 1 , z 1 ) (x 2 , y 2 , z 2 )

5. Computer Graphics Background Triangles go through graphics pipeline to become pixels View parameters define the size and shape of the world viewer near plane far plane

6. Computer Graphics Background CPU GPU Monitor Vertex Processing Geometry Processing Fragment Processing PCIe Bus Color Depth Stencil

7. Computer Graphics Background Visible Surfaces

8. Example Massive Models Procedurally generated model of Pompeii: ~1.4 billion polygons. Image from [Mueller06]

9. Example Massive Models Boeing 777 model: ~350 million polygons. Image from http://graphics.cs.uni-sb.de/MassiveRT/boeing777.html

10. Example Massive Models

11. Trends No upper bound on model complexity Procedural generation Laser scans and aerial imagery Imagery Image from [Lakhia06]

12. Trends High GPU throughput At least 10-200 million triangles per second Widen gap between processor and memory performance CPU – GPU bottleneck

13. Goal output-sensitivity : performance as a function of the number of pixels rendered, not the size of the model

14. View Frustum Culling Use bounding volume: spheres, AABBs, OOBBs, etc rendered rendered rendered culled culled culled

15. View Frustum Culling 0 1 2 3 4 5 0 1 3 4 2 5

16. View Frustum Culling 0 1 2 3 4 5 0 1 3 4 2 5

17. View Frustum Culling Demo

18. Occlusion Culling Effective in scenes with high depth complexity culled

19. Occlusion Culling From-region or from-point Most are conservative Occluder Fusion Difficult for general scenes with arbitrary occluders. So make simplifying assumptions: [Wonka00] – urban environments [Ohlarik08] – planets and satellites

20. Hardware Occlusion Queries From-point visibility that handles general scenes with arbitrary occluders and occluder fusion How? Use the GPU

21. Hardware Occlusion Queries Render occluders Render object’s BV using HOQ Render full object based on result

22. Hardware Occlusion Queries CPU stalls and GPU starvation Draw o1 Draw o2 Draw o3 Draw o1 Draw o2 Draw o3 CPU GPU Query o1 Query o1 Draw o1 Draw o1 -- stall -- -- starve -- CPU GPU

23. Is Culling Enough?

24. Is Culling Enough?

25. Hardware Occlusion Queries Demo

26. Level of Detail Generation: less triangles, simpler shader Selection: distance, pixel size Switching: avoid popping Discrete, Continuous, Hierarchical

27. Discrete LOD 3,086 Triangles 52,375 Triangles 69,541 Triangles

28. Discrete LOD Not enough detail up close Too much detail in the distance

29. Continuous LOD edge collapse vertex split Image from [Luebke01]

30. Hierarchical LOD 1 Node 3,086 Triangles 4 Nodes 9,421 Triangles 16 Nodes 77,097 Triangles

31. Hierarchical LOD 1 Node 3,086 Triangles 4 Nodes 9,421 Triangles 16 Nodes 77,097 Triangles

32. Hierarchical LOD visit(node) { if (computeSSE(node) < pixel tolerance) { render(node); } else { foreach (child in node.children) visit(child); } } Node Refinement

33. Hierarchical LOD

34. Hierarchical LOD

35. Hierarchical LOD Demo

36. Hierarchical LOD Easy to Add view frustum culling Add occlusion culling via HOQs Render front to back Use VMSSE to drive refinement Requires preprocessing Is Culling + HLOD enough?

37. Memory Management Out-of-Core Compression Cache Coherent Layouts

38. Out-of-Core HLOD visit(node) { if ((computeSSE(node) < pixel tolerance) || (not all children resident)) { render(node); foreach (child in node.children) requestResidency(child); } else { foreach (child in node.children) visit(child); } }

39. Out-of-Core HLOD Multithreaded Disk reads Decompression, normal generation, etc Cache management Prioritize reads, e.g. distance from viewer Replacement policy Skeleton in memory? BV, error metric, parent – child relationships

40. Out-of-Core Prefetching Reduce geometry cache misses Predict and load required nodes

41. Out-of-Core Prefetching Predict camera position [Correa03] v v’ f f’

42. Out-of-Core Prefetching [Varadhan02] Coherence of Front Prefetch ascendants/descendants Prefetch with enlarged view frustum Prioritize 0 1 2 3 4 5 6 7

43. Compression “Size is Speed” Geometric Vertices, Indices I/O and Rendering Performance Texture Performance or Quality Render Disk De/re-compress

44. Cache Coherent Layouts Reorder vertices and indies to maximize GPU cache hits Vertex Shader Post VS Cache Pre VS Cache GPU Main Memory Primitive Assembly Reorder Triangles Reorder Vertices

45. Cache Coherent Layouts Minimize ACMR Average Cache Miss Ratio Cache Oblivious [Yoon05] Linear Time [Sander07]

46. Not Covered Today Clustered backface culling IBR Sorting Batching Ray Tracing

47. Summary Combine culling, LOD, and out-of-core techniques Keep the CPU and GPU busy Exploit Coherence: Spatial and Temporal