Rethinking Collision Detection on GPU Ray Tracing Architecture

Abstract: Discrete Collision Detection (DCD) is a fundamental task in several domains including particle-based physics simulations. Efficient DCD uses indexing structures such as Bounding Volume Hierarchy (BVH), but accelerating irregular BVH traversals demands meticulous efforts to achieve performance. Modern GPUs feature Ray Tracing (RT) architecture that provides hardware acceleration for BVH traversal and optimized drivers for BVH construction. Recent work has attempted to exploit RT architecture to accelerate DCD on spherical particles by reducing DCD to fixed-radius neighbor search. However, this reduction breaks down for particles with different radii, necessitating the use of large bounding boxes that result in a higher number of duplicate collisions and poor performance. To address these limitations, we present Mochi, a new reduction that reformulates DCD on RT architecture by exploiting the symmetry of collision relations to support both uniform and non-uniform spherical particles efficiently. Mochi introduces per-object proxy spheres that decouple BVH bounding volumes from the collision search radius, enabling significantly tighter bounding boxes without sacrificing correctness. Mochi is provably sound and guarantees that all true collisions are detected. We integrate Mochi into an end-to-end particle simulation pipeline and evaluate it across large-scale particle workloads, showing consistent speedups over state-of-the-art BVH-based and RT-based DCD implementations. Mochi generalizes prior RT-based neighbor search formulations while avoiding their fundamental limitations for non-uniform spheres.

• The paper introduces Mochi, a novel reduction that exploits collision symmetry using proxy spheres to enable efficient and correct collision detection on GPU RT architectures.
• It achieves substantial performance improvements, with up to 23x speedup in BVH construction and significant reductions in overall runtime for simulations with millions of particles.
• The method minimizes false positives by tailoring per-object bounding volumes, supporting both uniform and non-uniform spheres while ensuring rigorous collision detection.

Rethinking Collision Detection on GPU Ray Tracing Architecture: The Mochi Reduction

Introduction and Motivation

Discrete Collision Detection (DCD) is a performance-critical component in large-scale particle-based simulations, graphics, and physical system modeling. With the proliferation of GPU-based ray tracing (RT) architectures offering hardware-accelerated Bounding Volume Hierarchy (BVH) construction and traversal, there have been attempts to leverage these new capabilities for DCD. However, prior efforts predominantly reduced DCD to fixed-radius neighbor searches, which are effective for uniform-size spheres but break down for non-uniform spheres—requiring overly conservative bounding volumes and introducing significant performance degradation due to increased false positives.

The paper introduces Mochi, a new reduction that fundamentally rethinks the mapping of DCD onto GPU RT architectures by exploiting the symmetry of collision relations. Mochi enables correct and efficient collision detection for both uniform and non-uniform spherical particles by introducing per-object proxy spheres, ensuring correctness without imposing excessive conservatism in bounding volumes. This approach substantially tightens BVH quality and avoids the proliferation of unnecessary intersection tests across a wide range of practical scenarios (2604.23520).

Methodology: Proxy Spheres and the Mochi Reduction

Collision Symmetry and Proxy Sphere Construction

A major limitation of conventional RT-based DCD reductions lies in their reliance on a neighbor-search abstraction with a single global search radius. For non-uniform spheres, this necessitates the use of the largest sphere radius for all AABBs in the BVH, incurring poor spatial partitioning and significant computational overhead.

Mochi circumvents this by explicitly exploiting the symmetry of collision relations: discovering a collision from either of the involved objects suffices. It constructs, for each sphere, a proxy sphere centered on the object with double its radius (Definition: proxy-sphere($S$) for sphere $S$ of radius $r$ is a sphere of radius $2r$ centered at the sphere's center). Rays—conceptualized as point queries—are launched from every particle center, and any intersection with a proxy sphere signals a candidate collision pair.

This symmetric detection enables the reduction to be provably sound: even though a ray from a larger sphere might not intersect the proxy of a smaller overlapping sphere (potential false negative at the per-ray level), the converse is always detected due to the geometric symmetry. A detailed formal proof of correctness is provided in the paper, ensuring that no colliding pair is omitted (Theorem 1).

Figure 1: Collisions occur within a distance of $2r$ for uniform spheres and $r_i + r_{max}$ for non-uniform spheres, illustrating the challenge of fixed-radius neighbor search.

Figure 2: Construction of proxy spheres (dotted) and point rays; uniform-case detection is correct with proxy spheres, but non-uniform cases result in missed collisions under prior reductions.

Implementation on GPU RT Architecture

Mochi is built atop NVIDIA's OptiX API, leveraging both optimized BVH construction on shader cores and BVH traversal on dedicated RT cores. The three-phase execution loop per simulation timestep is as follows:

1. BVH Construction: Build or refit BVH over proxy sphere AABBs.
2. Collision Detection: Launch a point ray from each particle center. BVH traversal is performed on RT cores; ray-proxy-sphere intersections are reported.
3. Narrow Phase & Response: For each candidate pair, validate collision by exact sphere-sphere intersection test and resolve the collision reactively.

Optimization includes deduplication of responses to avoid handling the same colliding pair multiple times due to bidirectional detection.

Evaluation

The paper rigorously benchmarks Mochi against the state-of-the-art DCD implementations:

• RT Core Baseline: Fixed-radius-based RT DCD (e.g., Zhao et al.).
• BVH-Based Shader Core Baseline: Oibvh.
• End-to-End Simulation Baseline: Taichi’s optimized CUDA pipelines.

Strong Numerical Results

Key findings:

• Kernel-only performance improvement: Mochi consistently outperforms the best prior RT-core and shader BVH baselines. Speedups range from 1.04x to 4.33x over RT-core baselines as particle radii become more heterogeneous (Figure 3; Figure 4).
• BVH Traversal and Construction: Against Oibvh, Mochi achieves up to 23.11x speedup overall, with 26.3x improvement in BVH construction and a consistent 2x improvement in the narrow collision phase (Figure 5).
• End-to-End Simulations: For DEM with millions of particles, Mochi reduces total runtime by up to an order of magnitude, outperforming Taichi in both uniform and highly non-uniform radius settings (Figure 6).
• Scalability: Speedups are robust as system sizes scale to 5 million particles—at which point alternative approaches often fail due to memory or computational bottlenecks.

  Figure 3: Mochi's performance versus SOTA shader and RT-core implementations, showing speedup increases with particle count.

  

  Figure 4: Mochi's speedup over RT-core baselines increases sharply with the maximum-to-minimum radius ratio.

  

  Figure 5: Comparison with Oibvh shows substantial total speedups from lower BVH construction and better BVH quality in traversal.

  

  Figure 6: Mochi versus Taichi for increasing system size; demonstrates robust scaling with particle count.

Analysis and Implications

Mochi demonstrates the following practical and theoretical advancements:

• Generalization: Prior neighbor-search RT reductions are shown as a special case within Mochi’s framework. The reduction unifies collision detection for both uniform and non-uniform spheres.
• Correctness Guarantee: The theoretical guarantee (backed by geometric proof) that all true collisions are detected without excessive conservatism in BVH construction.
• Reduced False Positives/Negatives: By tailoring proxy spheres per object, Mochi achieves dramatically tighter BVHs, significantly reducing broad-phase tests and associated computational costs.
• Immediate Applicability: Integration into GPU-based DEM simulation pipelines is straightforward, and runtime analysis shows clear practical gains even in challenging, high-dynamic-range scenarios (e.g., clustered objects, highly dynamic particle motion).

Figure 7: Expected simulation outcome versus incorrect result from prior proxy-sphere-only detection, illustrating failure modes avoided by Mochi.

Figure 8: Mochi's build and DCD times as a function of BVH rebuild interval, illustrating the trade-off between refit cost and BVH quality.

The approach is currently limited to rigid spheres, but in principle, the narrow phase can support any primitive for which efficient intersection tests are available. However, mathematical complexity (e.g., ellipsoid intersection) may limit generalization in practice.

Limitations and Considerations

Mochi's reduction is evaluated and theoretically validated for rigid spherical objects, employing single-precision arithmetic on OptiX-enabled NVIDIA RT hardware. The paper highlights:

• Limitations of RT Hardware: Opaque BVH structures complicate maintenance heuristics (rebalance/refit strategies must be empirically tuned).
• Precision Constraints: No direct support for double-precision; workaround involves broadening AABBs at the expense of minimal additional false positives.
• Scope of Applicability: While mechanical extension to more general objects is possible, computational cost or numerical instability in exact intersection checks limits direct application beyond spheres.

Future Directions

Due to its reliance only on core RT-architecture capabilities (BVH construction and traversal), Mochi is portable and expected to benefit from improvements in GPU RT hardware across vendors. Potential research directions include:

• Extension to More Complex Primitives: With advances in analytic or approximate intersection tests, the framework could handle more general particles—such as ellipsoids or convex polytopes.
• Integration with Continuous Collision Detection: Pairing Mochi’s discrete detection with continuous methods for high-velocity or highly deformable systems.
• Exploration of Dynamic BVH Tuning: Automated runtime adaptation of BVH rebuild/refit frequencies based on observed workload dynamics and motion heuristics.

Conclusion

Mochi reframes discrete collision detection as an object-centric, symmetry-exploiting reduction tailored to GPU RT architectures. It provably solves the non-uniform sphere DCD problem without the overhead or inaccuracy of prior neighbor-search-based methods, delivers strong empirical performance improvements, and is architected for extensibility as RT hardware and geometric modeling capabilities advance.

This work is positioned to shape the integration of RT hardware into high-performance simulation libraries and represents a formal blueprint for exploiting collision symmetry in spatial computations at scale.