rapier3d 0.32.0

3-dimensional physics engine in Rust.
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
89
90

//! SimdBasis trait for computing orthonormal bases.

#[cfg(feature = "dim3")]
use crate::math::Real;
use crate::math::Vector;
use crate::utils::{CopySign, SimdRealCopy};
use na::{Vector2, Vector3};

/// Trait to compute the orthonormal basis of a vector.
pub trait OrthonormalBasis: Sized {
    /// The type of the array of orthonormal vectors.
    type Basis;
    /// Computes the vectors which, when combined with `self`, form an orthonormal basis.
    fn orthonormal_basis(self) -> Self::Basis;
    /// Computes a vector orthogonal to `self` with a unit length (if `self` has a unit length).
    fn orthonormal_vector(self) -> Self;
}

impl<N: SimdRealCopy> OrthonormalBasis for Vector2<N> {
    type Basis = [Vector2<N>; 1];
    fn orthonormal_basis(self) -> [Vector2<N>; 1] {
        [Vector2::new(-self.y, self.x)]
    }
    fn orthonormal_vector(self) -> Vector2<N> {
        Vector2::new(-self.y, self.x)
    }
}

impl<N: SimdRealCopy + CopySign<N>> OrthonormalBasis for Vector3<N> {
    type Basis = [Vector3<N>; 2];
    // Robust and branchless implementation from Pixar:
    // https://graphics.pixar.com/library/OrthonormalB/paper.pdf
    fn orthonormal_basis(self) -> [Vector3<N>; 2] {
        let sign = self.z.copy_sign_to(N::one());
        let a = -N::one() / (sign + self.z);
        let b = self.x * self.y * a;

        [
            Vector3::new(
                N::one() + sign * self.x * self.x * a,
                sign * b,
                -sign * self.x,
            ),
            Vector3::new(b, sign + self.y * self.y * a, -self.y),
        ]
    }

    fn orthonormal_vector(self) -> Vector3<N> {
        let sign = self.z.copy_sign_to(N::one());
        let a = -N::one() / (sign + self.z);
        let b = self.x * self.y * a;
        Vector3::new(b, sign + self.y * self.y * a, -self.y)
    }
}

// Glam implementations for concrete Vector type
#[cfg(feature = "dim2")]
impl OrthonormalBasis for Vector {
    type Basis = [Vector; 1];
    fn orthonormal_basis(self) -> [Vector; 1] {
        [Vector::new(-self.y, self.x)]
    }
    fn orthonormal_vector(self) -> Vector {
        Vector::new(-self.y, self.x)
    }
}

#[cfg(feature = "dim3")]
impl OrthonormalBasis for Vector {
    type Basis = [Vector; 2];
    // Robust and branchless implementation from Pixar:
    // https://graphics.pixar.com/library/OrthonormalB/paper.pdf
    fn orthonormal_basis(self) -> [Vector; 2] {
        let sign = Real::copysign(1.0, self.z);
        let a = -1.0 / (sign + self.z);
        let b = self.x * self.y * a;

        [
            Vector::new(1.0 + sign * self.x * self.x * a, sign * b, -sign * self.x),
            Vector::new(b, sign + self.y * self.y * a, -self.y),
        ]
    }

    fn orthonormal_vector(self) -> Vector {
        let sign = Real::copysign(1.0, self.z);
        let a = -1.0 / (sign + self.z);
        let b = self.x * self.y * a;
        Vector::new(b, sign + self.y * self.y * a, -self.y)
    }
}