libosu 0.0.30

General-purpose osu! library.
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

use std::ops::{Add, Div, Mul, Neg, Sub};

use num::{cast, Float, NumCast};

/// Represents a 2D point (or any pair of objects).
#[allow(missing_docs)]
#[derive(
  Clone, Copy, Default, Debug, Display, PartialEq, Eq, Hash, PartialOrd,
)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[display("({}, {})", "x", "y")]
pub struct Point<T> {
  pub x: T,
  pub y: T,
}

impl<T> Point<T> {
  /// Create a new point
  pub const fn new(x: T, y: T) -> Point<T> {
    Point { x, y }
  }
}

impl<T: Div<Output = T>> Div for Point<T> {
  type Output = Self;

  fn div(self, rhs: Self) -> Self::Output {
    Self {
      x: self.x / rhs.x,
      y: self.y / rhs.y,
    }
  }
}

impl<T: Mul<Output = T>> Mul for Point<T> {
  type Output = Self;

  fn mul(self, rhs: Self) -> Self::Output {
    Self {
      x: self.x * rhs.x,
      y: self.y * rhs.y,
    }
  }
}

impl<T: Mul<Output = T> + Copy> Mul<T> for Point<T> {
  type Output = Self;

  fn mul(self, rhs: T) -> Self::Output {
    Self {
      x: self.x * rhs,
      y: self.y * rhs,
    }
  }
}

impl<T: Add<Output = T>> Add for Point<T> {
  type Output = Self;

  fn add(self, rhs: Self) -> Self::Output {
    Self {
      x: self.x + rhs.x,
      y: self.y + rhs.y,
    }
  }
}

impl<T: Sub<Output = T>> Sub for Point<T> {
  type Output = Self;

  fn sub(self, rhs: Self) -> Self::Output {
    Self {
      x: self.x - rhs.x,
      y: self.y - rhs.y,
    }
  }
}

impl<T: Neg<Output = T>> Neg for Point<T> {
  type Output = Self;

  fn neg(self) -> Self::Output {
    Self {
      x: -self.x,
      y: -self.y,
    }
  }
}

impl<T: Copy + NumCast> Point<T> {
  /// Converts this point to a floating point point
  #[inline]
  pub fn to_float<U: Float>(&self) -> Option<Point<U>> {
    Some(Point::new(cast(self.x)?, cast(self.y)?))
  }
}

impl<T: Mul<Output = T> + Add<Output = T>> Point<T> {
  #[inline]
  /// Dot product of two points (element-wise multiplication)
  pub fn dot(self, other: Self) -> T {
    self.x * other.x + self.y * other.y
  }
}

impl<T: Float> Point<T> {
  /// Calculates the Euclidean distance between 2 points.
  #[inline]
  pub fn distance(&self, other: Point<T>) -> T {
    self.distance_squared(other).sqrt()
  }

  /// Calculates the Euclidean distance squared between 2 points. Faster
  #[inline]
  pub fn distance_squared(&self, other: Point<T>) -> T {
    let dx = other.x.sub(self.x);
    let dy = other.y.sub(self.y);
    dx * dx + dy * dy
  }

  /// Calculates the Euclidean distance between this point and origin.
  #[inline]
  pub fn length(&self) -> T {
    self.length_squared().sqrt()
  }

  /// Calculates the Euclidean distance squared between this point and origin. Faster
  #[inline]
  pub fn length_squared(&self) -> T {
    self.x * self.x + self.y * self.y
  }

  /// Calculates the magnitude of the vector.
  #[inline]
  pub fn magnitude(&self) -> T {
    (self.x * self.x + self.y * self.y).sqrt()
  }

  /// Calculates the norm of the vector.
  #[inline]
  pub fn norm(&self) -> Point<T> {
    let m = self.magnitude();
    Point::new(self.x / m, self.y / m)
  }
}