oxiphysics-collision 0.1.1

Collision detection algorithms for the OxiPhysics engine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

//! # NarrowPhaseDispatcher - Trait Implementations
//!
//! This module contains trait implementations for `NarrowPhaseDispatcher`.
//!
//! ## Implemented Traits
//!
//! - `Default`
//!
//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)

use crate::types::ContactManifold;
use oxiphysics_geometry::{BoxShape, Capsule, Shape, Sphere};

#[allow(unused_imports)]
use super::functions::*;
use super::functions::{gjk_fallback_dispatch, sphere_capsule_dispatch};
use super::types::{NarrowPhaseDispatcher, NarrowPhaseResult, ShapeType};
use crate::narrowphase::specialized;

impl Default for NarrowPhaseDispatcher {
    /// Build a dispatcher pre-registered with sphere/box/capsule pair algorithms.
    fn default() -> Self {
        let mut d = NarrowPhaseDispatcher::empty();
        d.register_pair(
            ShapeType::Sphere,
            ShapeType::Sphere,
            |sa, ta, sb, tb, pair| {
                let s1 = unsafe { &*(sa as *const dyn Shape as *const Sphere) };
                let s2 = unsafe { &*(sb as *const dyn Shape as *const Sphere) };
                match specialized::sphere_sphere(s1, ta, s2, tb) {
                    Some(contact) => {
                        let mut m = ContactManifold::new(pair);
                        m.add_contact(contact);
                        NarrowPhaseResult::contact(m)
                    }
                    None => NarrowPhaseResult::separated(),
                }
            },
        );
        d.register_pair(ShapeType::Sphere, ShapeType::Box, |sa, ta, sb, tb, pair| {
            let s = unsafe { &*(sa as *const dyn Shape as *const Sphere) };
            let b = unsafe { &*(sb as *const dyn Shape as *const BoxShape) };
            match specialized::sphere_box(s, ta, b, tb) {
                Some(contact) => {
                    let mut m = ContactManifold::new(pair);
                    m.add_contact(contact);
                    NarrowPhaseResult::contact(m)
                }
                None => NarrowPhaseResult::separated(),
            }
        });
        d.register_pair(ShapeType::Box, ShapeType::Box, |sa, ta, sb, tb, pair| {
            let b1 = unsafe { &*(sa as *const dyn Shape as *const BoxShape) };
            let b2 = unsafe { &*(sb as *const dyn Shape as *const BoxShape) };
            match specialized::box_box_sat(b1, ta, b2, tb) {
                Some(contact) => {
                    let mut m = ContactManifold::new(pair);
                    m.add_contact(contact);
                    NarrowPhaseResult::contact(m)
                }
                None => NarrowPhaseResult::separated(),
            }
        });
        d.register_pair(
            ShapeType::Capsule,
            ShapeType::Capsule,
            |sa, ta, sb, tb, pair| {
                let c1 = unsafe { &*(sa as *const dyn Shape as *const Capsule) };
                let c2 = unsafe { &*(sb as *const dyn Shape as *const Capsule) };
                match specialized::capsule_capsule(c1, ta, c2, tb) {
                    Some(contact) => {
                        let mut m = ContactManifold::new(pair);
                        m.add_contact(contact);
                        NarrowPhaseResult::contact(m)
                    }
                    None => NarrowPhaseResult::separated(),
                }
            },
        );
        d.register_pair(
            ShapeType::Sphere,
            ShapeType::Capsule,
            sphere_capsule_dispatch,
        );
        d.register_pair(ShapeType::Box, ShapeType::Capsule, gjk_fallback_dispatch);
        d
    }
}