ggmath 0.17.1

A linear algebra library for games and graphics with generic SIMD types.
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

use bytemuck::{NoUninit, Pod, Zeroable};

use crate::{Affine, Alignment, Length, Mask, Matrix, Quaternion, Scalar, SupportedLength, Vector};

// SAFETY: Vectors are equivalent to structs where all fields are `Pod`. The
// `[T; N]` part is `Pod` because `T` is `Pod`, and the padding is guaranteed
// to have initialized bytes, and accepts any bit-pattern.
unsafe impl<const N: usize, T, A: Alignment> Pod for Vector<N, T, A>
where
    Length<N>: SupportedLength,
    T: Scalar + Pod,
{
}

// SAFETY: Vectors are equivalent to structs where all fields are `Zeroable`.
// The `[T; N]` part is `Zeroable` because `T` is `Zeroable`, and the padding is
// guaranteed to accept any bit-pattern.
unsafe impl<const N: usize, T, A: Alignment> Zeroable for Vector<N, T, A>
where
    Length<N>: SupportedLength,
    T: Scalar + Zeroable,
{
}

// SAFETY: Matrices are equivalent to structs where all fields are `Pod`. The
// `[Vector<N, T, A>; N]` part is `Pod` because `Vector<N, T, A>` is `Pod`, and
// the padding is guaranteed to have initialized bytes, and accepts any
// bit-pattern.
unsafe impl<const N: usize, T, A: Alignment> Pod for Matrix<N, T, A>
where
    Length<N>: SupportedLength,
    T: Scalar + Pod,
{
}

// SAFETY: Matrices are equivalent to structs where all fields are `Zeroable`.
// The `[Vector<N, T, A>; N]` part is `Zeroable` because `Vector<N, T, A>` is
// `Zeroable`, and the padding is guaranteed to accept any bit-pattern.
unsafe impl<const N: usize, T, A: Alignment> Zeroable for Matrix<N, T, A>
where
    Length<N>: SupportedLength,
    T: Scalar + Zeroable,
{
}

// SAFETY: `Vector<4, T, A>` implements `Pod` when `T` does.
unsafe impl<T, A: Alignment> Pod for Quaternion<T, A> where T: Scalar + Pod {}

// SAFETY: `Vector<4, T, A>` implements `Zeroable` when `T` does.
unsafe impl<T, A: Alignment> Zeroable for Quaternion<T, A> where T: Scalar + Zeroable {}

// SAFETY: Affines are equivalent to structs where all fields are `Pod`. The
// `Matrix<N, T, A>` part is `Pod`, the `Vector<N, T, A>` part is `Pod`, and
// padding bytes are initialized and accept all bit-patterns.
unsafe impl<const N: usize, T, A: Alignment> Pod for Affine<N, T, A>
where
    Length<N>: SupportedLength,
    T: Scalar + Pod,
{
}

// SAFETY: Affines are equivalent to structs where all fields are `Zeroable`.
// The `Matrix<N, T, A>` part is `Zeroable`, the `Vector<N, T, A>` part is
// `Zeroable`, and padding bytes are initialized and accept all bit-patterns.
unsafe impl<const N: usize, T, A: Alignment> Zeroable for Affine<N, T, A>
where
    Length<N>: SupportedLength,
    T: Scalar + Zeroable,
{
}

// SAFETY: Masks are guaranteed to have no uninitialized bytes, and accept the
// zero bit-pattern, meaning they are inhabited.
unsafe impl<const N: usize, T, A: Alignment> NoUninit for Mask<N, T, A>
where
    Length<N>: SupportedLength,
    T: Scalar + 'static,
{
}

// SAFETY: Masks are guaranteed to accept the zero bit-pattern.
unsafe impl<const N: usize, T, A: Alignment> Zeroable for Mask<N, T, A>
where
    Length<N>: SupportedLength,
    T: Scalar,
{
}