acme
Foundational cross-platform layer of the ca2 framework
Loading...
Searching...
No Matches
angle.h
1#pragma once
2
3
4struct with_t {};
5
6
7template < prototype_floating FLOATING_TYPE >
8class angle_type;
9
10
11template < prototype_floating FLOATING >
12constexpr angle_type < FLOATING > radians(FLOATING fAngle);
13
14
15
16template < prototype_floating FLOATING_TYPE >
17class angle_type
18{
19public:
20
21
22 using FLOATING = FLOATING_TYPE;
23
24
25 FLOATING m_fAngle; // in radians
26
27
28 constexpr angle_type() : m_fAngle(0.0) {}
29 constexpr angle_type(no_initialize_t) {}
30 constexpr angle_type(with_t, FLOATING u):m_fAngle(u) {}
31 //constexpr angle_type(nullptr_t) : m_fAngle(0.0) {}
32 template < prototype_floating FLOATING1 >
33 constexpr angle_type(const ::angle_type <FLOATING1 > & angle) : m_fAngle((FLOATING) angle.m_fAngle) {}
34
35 template < prototype_number Y, prototype_number X >
36 angle_type & atan(Y y, X x) { m_fAngle = ::std::atan2(y, x); return *this; }
37
38 angle_type operator -() const { return radians(-m_fAngle); }
39
40 operator FLOATING() const { return m_fAngle; }
41
42 FLOATING radian() const { return m_fAngle; }
43
44 FLOATING degree() const { return (FLOATING) m_fAngle * (FLOATING)180.0 / (FLOATING)MATH_PI; }
45
46 angle_type operator - (const angle_type & angle) const { return radians(m_fAngle - angle.m_fAngle); }
47 angle_type operator + (const angle_type & angle) const { return radians(m_fAngle + angle.m_fAngle); }
48
50 template < prototype_number NUMBER >
51 angle_type operator-(NUMBER radians) const { return ::radians(m_fAngle - (FLOATING)radians); }
52
54 template<prototype_number NUMBER>
55 angle_type operator+(NUMBER radians) const { return ::radians(m_fAngle + (FLOATING)radians); }
56
57 template < prototype_number NUMBER >
58 angle_type operator / (NUMBER n) const
59 {
60 return radians(m_fAngle / (FLOATING) n);
61 }
62
63 FLOATING operator / (const angle_type & angle) const { return m_fAngle / angle.m_fAngle; }
64
65 template<prototype_number NUMBER>
66 angle_type operator * (NUMBER n) const
67 {
68 return ::radians(m_fAngle * (FLOATING) n);
69 }
70
71 angle_type &operator-=(const angle_type &angle)
72 {
73
74 m_fAngle -= angle.m_fAngle;
75
76 return *this;
77
78 }
79
80 angle_type &operator+=(const angle_type &angle)
81 {
82
83 m_fAngle += angle.m_fAngle;
84
85 return *this;
86
87 }
88
89
90
91
92 ::f64 normalized() const { auto d = (FLOATING) fmod(m_fAngle, 2.0 * MATH_PI); return d < (FLOATING) 0.0 ? d + (FLOATING) (2.0 * MATH_PI) : d; }
93 void normalize() { m_fAngle = normalized(); }
94
95
96 static constexpr angle_type radians(FLOATING fAngle)
97 {
98
99 angle_type angle;
100
101 angle.m_fAngle = fAngle;
102
103 return angle;
104
105 }
106
107
108 constexpr FLOATING radians() const
109 {
110
111 return m_fAngle;
112
113 }
114
115
116 constexpr FLOATING degrees() const { return ::radians_to_degrees(m_fAngle); }
117
118
119 template < prototype_number NUMBER >
120 static constexpr angle_type degrees(NUMBER degrees)
121 {
122
123 return radians(degrees * MATH_PI / 180.0);
124
125 }
126
127
128
129 FLOATING cos() const
130 {
131
132 return ::std::cos(m_fAngle);
133
134 }
135
136 FLOATING sin() const
137 {
138
139 return ::std::sin(m_fAngle);
140
141 }
142
143};
144
145
146
147
148
149using f32_angle = angle_type < ::f32 >;
150using f64_angle = angle_type < ::f64 >;
151
152
153namespace geometry
154{
155
156
157 template<prototype_floating FLOATING>
158 inline angle_type<FLOATING> atan2(FLOATING y, FLOATING x)
159 {
160
161 return ::radians(::std::atan2(y, x));
162
163 }
164
165
166 template<prototype_floating FLOATING>
167 inline angle_type<FLOATING> asin(FLOATING s)
168 {
169
170 return ::radians(::std::asin(s));
171
172 }
173
174
175} // namespace geometry
176
177
178
180template<prototype_number NUMBER, prototype_floating FLOATING>
181constexpr angle_type<FLOATING> operator-(NUMBER radians, const angle_type<FLOATING> &angle)
182{
183
184 return ::radians((FLOATING)radians - angle.m_fAngle);
185
186}
187
188
190template<prototype_number NUMBER, prototype_floating FLOATING>
191constexpr angle_type<FLOATING> operator+(NUMBER radians, const angle_type<FLOATING> &angle)
192{
193
194 return ::radians((FLOATING)radians + angle.m_fAngle);
195
196}
197
198
199template<prototype_number NUMBER, prototype_floating FLOATING>
200constexpr angle_type<FLOATING> operator *(NUMBER n, const angle_type<FLOATING> &angle)
201{
202
203 return ::radians((FLOATING)n * angle.m_fAngle);
204
205}
206
207
208
209
210template < prototype_floating FLOATING >
211constexpr angle_type < FLOATING > radians(FLOATING fAngle)
212{
213
214 return angle_type < FLOATING >::radians(fAngle);
215
216}
217
218
219template<prototype_floating FLOATING>
220constexpr angle_type<FLOATING> degrees(FLOATING fAngle)
221{
222
223 return angle_type<FLOATING>::degrees(fAngle);
224}
225
226
227inline f64_angle operator""_degree(long double degrees) {
228
229 return radians(degrees_to_radians(degrees));
230
231}
232
233
234inline f64_angle operator""_degrees(long double degrees)
235{
236
237 return operator""_degree(degrees);
238
239}
240
241
242inline f32_angle operator""_f_degree(long double degrees)
243{
244
245 return radians(degrees_to_radians((::f32)degrees));
246
247}
248
249
250inline f32_angle operator""_f_degrees(long double degrees)
251{
252
253 return operator""_f_degree(degrees);
254
255}
256
257
258inline f64_angle operator""_degree(::u64 degrees)
259{
260
261 return radians(degrees_to_radians((::f64)degrees));
262
263}
264
265
266inline f64_angle operator""_degrees(::u64 hn)
267{
268
269 return operator""_degree(hn);
270
271}
272
273
274inline f32_angle operator""_f_degree(::u64 degrees)
275{
276
277 return radians(degrees_to_radians((::f32)degrees));
278
279}
280
281
282inline f32_angle operator""_f_degrees(::u64 hn)
283{
284
285 return operator""_f_degree(hn);
286
287}
288
289
290template < prototype_number NUMBER1, prototype_number NUMBER2 >
291inline auto angle(const ::point_type < NUMBER1 > & center, const ::point_type < NUMBER2 > & point)
292{
293
294 return ::geometry::atan2(point.y - center.y, point.x - center.x);
295
296}
297
298
299
angle_type
Definition angle.h:18
angle_type::operator+
angle_type operator+(NUMBER radians) const
assumes adding radians from angle
Definition angle.h:55
angle_type::operator-
angle_type operator-(NUMBER radians) const
assumes subtracting radians from angle
Definition angle.h:51
no_initialize_t
Definition _tags.h:5
with_t
Definition angle.h:4