CCD performance with single-precision floating-point arithmetic on GPU

[WYK96]

Dear all,

Thanks for the great work! I am a beginner in collision detection. The techniques introduced in TightInclusion[1] and ScalableCCD[2] have inspired me a lot. After running the test program in ScalableCCD(some modifications were made to make the program executable on my local machine, see #7 for more details), I've noticed that the algorithm works well on double-precision floating-point arithmetic, all tests passed:

Nevertheless, the test program broke down on single-precision floating-point arithmetic:

All tests are performed in the following environment:

• Operation system: ubuntu20.04LTS
• Graphics card: NVIDIA GeForce GTX 1660
• nvcc version: 12.3
• gcc version: 9.4.0
• cmake version: 3.26.0

My question is: does ScalableCCD works well on single-precision floating-point arithmetic? I did not run TightInclusion since all algorithms discussed and implemented in [1] are CPU-based. What I am looking for is an algorithm that is:

1. uses single-precision floating-point arithmetic
2. GPU friendly
3. do not have false negative(strictly)
4. may have false positive

I wonder whether such algorithm exists and is publicly available.

Thanks for your attention. Please contact me if I missed anything.

References

[1] Wang, Bolun, et al. "A large-scale benchmark and an inclusion-based algorithm for continuous collision detection." ACM Transactions on Graphics (TOG) 40.5 (2021): 1-16.
[2] Belgrod, David, et al. "Time of Impact Dataset for Continuous Collision Detection and a Scalable Conservative Algorithm." arXiv preprint arXiv:2112.06300 (2021).