mathx 1.1.0

A mathematics library designed to work with no_std
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


use crate::{Vector3, Vector2};

/// A builder structure used to create a raycast info struct
#[derive(Debug)]
pub struct RaycastInfoBuilder {
	/// The point of contact
	point: Option<Vector3>,
	/// The normal from the contact
	normal: Option<Vector3>,
	/// The UV of the mesh from the contact
	uv: Option<Vector2>,
	/// The distance from the origin of the ray to the point of contact
	distance: Option<f32>,
	/// Set to true if the ray hit something
	is_hit: bool,
}

/// Constructors
impl RaycastInfoBuilder {
	/// Creates a new raycast information builder
	/// 
	/// **Returns**: Returns a new raycast information builder
	pub fn new() -> Self {
		RaycastInfoBuilder { is_hit: false, point: None, normal: None, uv: None, distance: None }
	}
}

/// Public Methods
impl RaycastInfoBuilder {
	/// Builds the raycast information
	/// 
	/// **Returns**: Returns a newly built raycast information
	pub fn build(self) -> RaycastInfo {
		RaycastInfo {
			is_hit: self.is_hit,
			point: self.point.unwrap_or(Vector3::zero()),
			normal: self.normal.unwrap_or(Vector3::zero()),
			uv: self.uv.unwrap_or(Vector2::zero()),
			distance: self.distance.unwrap_or(0.0),
		}
	}
	
	/// Sets the point of contact for the information
	/// - **value**: The point of contact to set into the information
	/// 
	/// **Returns**: Returns the builder to chain methods together
	pub fn set_point(mut self, value: Vector3) -> Self {
		self.point = Some(value);
		return self;
	}
	
	/// Sets the normal from the point of contact for the information
	/// - **value**: The normal from the point of contact to set into the information
	/// 
	/// **Returns**: Returns the builder to chain methods together
	pub fn set_normal(mut self, value: Vector3) -> Self {
		self.normal = Some(value);
		return self;
	}
	
	/// Sets the distance from the origin of the ray to the point of contact for the information
	/// - **value**: The distance from the origin of the ray to the point of contact to set into the information
	/// 
	/// **Returns**: Returns the builder to chain methods together
	pub fn set_distance(mut self, value: f32) -> Self {
		self.distance = Some(value);
		return self;
	}
	
	/// Sets if the raycast hit anything
	/// - **value**: Set to true to indicate that the raycast hit something
	/// 
	/// **Returns**: Returns the builder to chain methods together
	pub fn set_hit(mut self, value: bool) -> Self {
		self.is_hit = value;
		return self;
	}
}

/// A structure that holds information from a raycast
#[derive(Debug)]
pub struct RaycastInfo {
	/// The point of contact
	point: Vector3,
	/// The normal from the contact
	normal: Vector3,
	/// The UV of the mesh from the contact
	uv: Vector2,
	/// The distance from the origin of the ray to the point of contact
	distance: f32,
	/// Set to true if the ray hit something
	is_hit: bool,
}

/// Constructors
impl RaycastInfo {
	/// Gets an empty raycast information
	/// 
	/// **Returns**: Returns an empty raycast information
	pub fn empty() -> Self {
		RaycastInfo {
			is_hit: false,
			point: Vector3::zero(),
			normal: Vector3::zero(),
			uv: Vector2::zero(),
			distance: 0.0
		}
	}
}

/// Properties
impl RaycastInfo {
	/// Gets the point of contact
	/// 
	/// **Returns**: Returns the point of contact
	pub fn point(&self) -> Vector3 { self.point }
	
	/// Gets the normal from the contact
	/// 
	/// **Returns**: Returns the normal from the contact
	pub fn normal(&self) -> Vector3 { self.normal }
	
	/// Gets the UV of the mesh from the contact
	/// 
	/// **Returns**: Returns the UV of the mesh from the contact
	pub fn uv(&self) -> Vector2 { self.uv }
	
	/// Gets the distance from the origin of the ray to the point of contact
	/// 
	/// **Returns**: Returns the distance from the origin of the ray to the point of contact
	pub fn distance(&self) -> f32 { self.distance }
	
	/// Gets if the ray hit something
	/// 
	/// **Returns**: Returns true if the ray hit something
	pub fn is_hit(&self) -> bool { self.is_hit }
}