1. Quick-CULLIDE: Efficient Inter- and Intra- Object Collision Culling using Graphics Hardware Naga K. Govindaraju, Ming C. Lin, Dinesh Manocha University of North Carolina at Chapel Hill [IEEE VR 2005]

2. Introduction

3. Commonly used Alg.  Bounding volume hierarchies  Work well Object undergoing rigid motion  Challenge Non-rigid or deformable object Intra-object or self-collisions

4. Commonly used Alg. (GPU Based)  Increasingly used Check for overlaps Involve no pre-computation  Applicable to deformable and non- rigid models  However, Restricted to closed objects Do not check for self-collisions

5. Main Contributions  Similar to CULLIDE Uses visibility queries to compute a potentially colliding set (PCS)  Two major extensions Formulation generalization  For both inter- and intra-object Pruning and culling alg. improvement  To compute collision-free subsets

6. Feature  No assumptions about models  Low bandwidth requirements  Inter- and intra-object collision  Image-precision

7. Implementation environment  3.4GHz PC  NVIDIA GeForce FX 6800 Ultra card  Objects composed of 10K to 250K triangles

8. Related Work

9. Rigid Body Algorithms  Use spatial data structures  Include Spatial-partitioning structures Bounding-volume hierarchies  Built during the pre-processing stage and are used to accelerate run-time queries

10. Deformable Models and Cloth Simulation  Hierarchical data structures  Objects undergoing non-rigid motion  Fast update of hierarchies of axis- aligned bounding boxes (AABBs)  Also check for self-collisions

11. GPU-Based Algorithms  No pre-processing Suited for handling non-rigid motion  limited to closed objects or involve frame-buffer readbacks  Frame-buffer readbacks Slow on current graphics systems Involve graphics pipeline stalls Limited by the bandwidth to CPU

12. Hybrid Algorithms  Combine some of the benefits of the object-space approaches along with GPU-based accelerations  Heidelberger et al., 2003 Layer depth images (LDIs) Vertex-in-volume tests was extended to check for self- collisions between water-tight objects

13. Collision Culling Using Visibility Queries CULLIDE

14. Overview  Given n objects that are potentially colliding P 1,..., P n, CULLIDE performs the full-visibility tests and computes a potentially colliding set (PCS) of objects  The full visibility of P is a sufficient condition that P does not overlap with S

15. Algorithm  Begins with an empty frame buffer  First pass: Rasterize the primitives in the order P 1,..., P n and test if they are fully visible. In this pass, if a primitive P i is fully visible, then it does not intersect with any of the objects P 1,..., P i−1

16. Algorithm -cont’  Second pass: Perform the same operations as in the first pass but the order of rendering is changed to P n,.., P 1. In this pass, if a primitive P i is fully visible, then it does not intersect any of the objects P n,.., P i+1  Pruned if fully visible in both

17. Separating surface

18. Limitations  Self-collisions CULLIDE is based on the existence of a separating surface between the geometric primitives PCS is very conservative on meshes with connected triangles  Culling performance affects performance of the overall algorithm  Two novel alg. to overcome those

19. Collision Culling Using Visibility Queries Self-Collision Culling using GPUs

20. Possible Contacts  Touching Contacts Primitives touch each other at a point or an edge  Penetrating Contacts Primitives penetrate each other  Touching contacts often lead to robustness issues. Ignore.  Considers only the 2 nd Contacts

21. Self-Colliding  A geometric primitive P is not potentially penetrating with a set of rasterized geometric primitives if all the fragments generated by the rasterization of P have depth values less than or equal to those of the corresponding pixels in the frame buffer

22. Lemma 1 – to compute the PCS  Given n geometric primitives P 1, P 2,..., P n, a geometric primitive P i does not belong to the PCS of self-colliding primitives if it does not penetrate with P 1,.., P i−1, P i+1,..., P n, 1  i  n. This test can be easily decomposed as follows: a geometric primitive P i does not belong to the PCS of self-colliding primitives if it does not penetrate with P 1,.., P i−1 and with P i+1,..., P n, 1  i  n

23. Self-intersecting

24. Quick-CULLIDE Efficient Culling

25. Collision-free Sets  Improve the culling efficiency Remove redundant visibility computations  Improve rasterization performance Reduce the number of rendering opeartions  Reduce the number of pair-wise collision tests

26. PCS Object Classification  BFV Fully visible in both the passes Are pruned from the PCS  FFV Fully visible only in the first pass  SFV Fully visible only in the second pass  NFV Not fully visible in both the passes

27. Properties  The objects in each of these sets are ordered based on their rendering order in the first pass of the algorithm  BFV, FFV, SFV, and NFV are disjoint  Lemmas & Proofs are upcoming …

28. Lemma 2  FFV and SFV are collision-free sets

29. Proof  Let S denote the set FFV and be composed of objects {O 1 S,O 2 S,...O m S }. We now prove that no two objects O i S and O j S in S collide with each other. Without loss of generality, let i < j. Then, in the two-pass rendering algorithm, the object O i S is rendered prior to the object O j S. As the object O j S is fully visible with respect to O i S, using Lemma 1 in CULLIDE, we conclude that the two objects do not collide. Therefore, FFV is collision-free. The proof for S = SFV is collision-free is similar

30. Lemma 3  For each object O i  FFV, let S i = {O j, j > i, O j  S} where S = SFV ∪ NFV. If an object O i  FFV does not collide with S i, then it does not collide with any of the objects in SFV or NFV and can be pruned from the PCS

31. Proof  Follows from Lemma 1 in CULLIDE. This lemma implies that if an object O i  FFV and is fully visible in the second pass of the pruning algorithm, then it provides a sufficient condition to prune the object from the PCS

32. Lemma 4  For each object Oi  SFV, let S i = {O j, j < i, O j  S} where S = FFV ∪ NFV. If an object Oi  SFV does not collide with Si, then it does not collide with any of the objects in FFV or NFV and can be pruned from the PCS

33. Proof  Follows from Lemma 1 in CULLIDE. This lemma implies that if an object O i  SFV and is fully visible in the first pass of the pruning algorithm, then it provides a sufficient condition to prune the object from the PCS

34. Lemma 5  Let S 1 = FFV ∪ NFV be a set ordered by object indices in the increasing order and S 2 = SFV ∪ NFV be a set ordered by object indices in the decreasing order. In the two-pass rendering algorithm, if we perform the first pass using objects in S 1 and the second pass using objects in S 2, and an object O i is fully visible in both the passes, then it does not collide with any of the objects in FFV, SFV or NFV

35. Proof  Clearly the object O i belongs to NFV = S 1 ∩ S 2 as it is fully visible in both the passes. It is trivial to see that the object does not collide with any of the objects in NFV.  We now prove that the object does not collide with any object O j  FFV. If j < i, then O i does not collide with O j as O i is fully visible in the first pass. If j > i, then O j does not collide with O i as O j  FFV.  Similarly, we prove that the O i does not collide with the objects in SFV

36. QED  Using Lemmas 3, 4, and 5, it comes up with an efficient culling alg.  The first pass and second pass of CULLIDE are modified as follows …

37. First Pass  For each object O i in PCS, i=1,..,n If O i  SFV or O i  NFV, test whether the object is fully visible using an occlusion query If O i  FFV or O i  NFV, render the object into the frame buffer  For each object Oi in PCS, i=1,..,n If O i  SFV or O i  NFV, and the occlusion query determines O i as fully visible  If O i  SFV, then tag O i as a member of BFV  If O i  NFV, then tag O i as a member of FFV

38. Second Pass  For each object O i in PCS, i=n,..,1 If O i  FFV or O i  NFV, test whether the object is fully visible using an occlusion query If O i  SFV or O i  NFV, render the object into the frame buffer  For each object Oi in PCS, i=n,..,1 If O i  FFV or O i  NFV, and the occlusion query determines Oi as fully visible  If O i  FFV, then tag O i as a member of BFV  If O i  NFV, then tag O i as a member of SFV

39. Both the passes 1. Objects that are fully visible in both the passes This subset of objects belonging to NFV are pruned from the PCS (based on Lemma 5)

40. The first pass 2. Objects that are fully visible in the first pass NFV: These objects are removed from NFV and placed in FFV SFV: These objects are removed from the PCS (based on Lemma 4) FFV: Visibility computations are not performed for these objects in this pass as they are not needed

41. The second pass 3. Objects that are fully visible in the second pass NFV: These objects are removed from NFV and placed in SFV FFV: These objects are removed from the PCS (based on Lemma 3) SFV: Visibility computations are not performed for these objects in this pass as they are not needed

42. Improvement  The improved culling algorithm reduces the number of rendering operations and occlusion queries each by sizeof(FFV ∪ SFV ), as compared to CULLIDE

43. Collision Detection 1. Compute the PCS at the object level using this improved alg. Sweep-and-prune on the PCS to compute the overlapping pairs 2. Compute the PCS at the sub-object level and the overlapping pairs 3. Perform exact interference tests between the triangles on the CPU

44. Implementation

45. Cloth  20K tri., 21 ms/f; X, Z views

46. Breaking objects  35K,250K tri., 25 ms/f; 3 axes views

47. Non-rigid objects  25 ms/f; deformable leaves

48. Performance

49. Cloth Simulation

51. Performance

52. Factors  Depth complexity Depend upon the number of objects that project onto the screen-space  Order of rendering Back-to-front works best  Number of views # of Views increase, smaller PCS

53. Advantages  Self-collisions  Large number of objects  Not perform framebuffer readbacks  High image-space resolution  Just a few milliseconds (<40ms)  deformable, breaking, and non-rigid geometry, as well as polygon-soup models

54. Disadvantage  No overlap information or the extent of penetration  Limited to image resolution  Ignores touching contacts  Best when back-to-front rendering  Depends on object configurations and the depth complexity

55. Future Work  Provide proximity computations Including distance and penetration depth computation  Explore the new programmability features of GPUs