vectorama 0.1.1

Very simple linear algebra library for 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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174

use std::{
    fmt::Debug,
    ops::{Deref, DerefMut},
};

use crate::vector::{Vector, vec3::Vec3};

pub mod add;
pub mod div;
pub mod mul;
pub mod neg;
pub mod sub;

#[repr(C)]
#[derive(Default, Debug, Clone, Copy)]
pub struct Vector2 {
    pub x: f32,
    pub y: f32,
}

#[derive(Clone, Copy)]
pub union Vector2Union {
    matrix: Vector<2>,
    vector: Vector2,
}

impl Default for Vector2Union {
    fn default() -> Self {
        Self {
            vector: Default::default(),
        }
    }
}

/// A 2D vector with `f32` components.
///
/// `Vec2` provides convenient methods for 2D vector arithmetic, normalization, and conversion.
///
/// # Example
/// ```
/// use vectorama::Vec2;
/// let v = Vec2::new(1.0, 2.0);
/// ```
#[derive(Default, Clone, Copy)]
pub struct Vec2 {
    data: Vector2Union,
}

impl Debug for Vec2 {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Vec2")
            .field("x", &self.x)
            .field("y", &self.y)
            .finish()
    }
}

impl Vec2 {
    /// Creates a new 2D vector from `x` and `y` components.
    ///
    /// # Parameters
    /// - `x`: The x component.
    /// - `y`: The y component.
    ///
    /// # Returns
    /// A new `Vec2` with the specified components.
    pub const fn new(x: f32, y: f32) -> Self {
        let vector2 = Vector2 { x, y };
        Self {
            data: Vector2Union { vector: vector2 },
        }
    }

    /// Returns a vector with both components set to zero.
    ///
    /// # Returns
    /// A zero vector.
    pub fn zeros() -> Self {
        Self::from(Vector::zeros())
    }

    /// Returns a vector with both components set to one.
    ///
    /// # Returns
    /// A vector with all components equal to 1.0.
    pub fn ones() -> Self {
        Self::from(Vector::ones())
    }

    /// Creates a 3D vector from this 2D vector and a given z component.
    ///
    /// # Parameters
    /// - `z`: The z component for the resulting `Vec3`.
    ///
    /// # Returns
    /// A `Vec3` with x, y from this vector and the specified z.
    pub fn xyz(&self, z: f32) -> Vec3 {
        Vec3::new(self.x, self.y, z)
    }

    /// Computes the dot product with another 2D vector.
    ///
    /// # Parameters
    /// - `other`: The other vector.
    ///
    /// # Returns
    /// The dot product as a `f32`.
    pub fn dot(&self, other: &Vec2) -> f32 {
        unsafe { self.data.matrix.dot(&other.data.matrix) }
    }

    /// Computes the magnitude (length) of the vector.
    ///
    /// # Returns
    /// The magnitude as a `f32`.
    pub fn magnitude(&self) -> f32 {
        unsafe { self.data.matrix.magnitude() }
    }

    /// Returns a normalized (unit length) version of this vector.
    ///
    /// # Returns
    /// The normalized vector.
    pub fn normalize(&self) -> Vec2 {
        let matrix = unsafe { self.data.matrix.normalize() };
        Vec2::from(matrix)
    }
}

// Deref and DerefMut -----------------------------------------------------------------------------
impl Deref for Vec2 {
    type Target = Vector2;

    fn deref(&self) -> &Self::Target {
        unsafe { &self.data.vector }
    }
}

impl DerefMut for Vec2 {
    fn deref_mut(&mut self) -> &mut Self::Target {
        unsafe { &mut self.data.vector }
    }
}
// Deref and DerefMut -----------------------------------------------------------------------------

// From -------------------------------------------------------------------------------------------
impl From<Vector<2>> for Vec2 {
    fn from(value: Vector<2>) -> Self {
        Self {
            data: Vector2Union { matrix: value },
        }
    }
}

impl From<[f32; 2]> for Vec2 {
    fn from(value: [f32; 2]) -> Self {
        Self::from(Vector::from(value))
    }
}

impl From<Vec2> for Vector<2> {
    fn from(value: Vec2) -> Self {
        unsafe { value.data.matrix }
    }
}
// From -------------------------------------------------------------------------------------------

// AsRef ------------------------------------------------------------------------------------------
impl AsRef<[f32]> for Vec2 {
    fn as_ref(&self) -> &[f32] {
        unsafe { self.data.matrix.as_ref() }
    }
}
// AsRef ------------------------------------------------------------------------------------------