4
4
#include " common.h"
5
5
#include < glm/gtx/vector_angle.hpp>
6
6
7
+ #ifndef K_ANGLE_UNIT
8
+ #define K_ANGLE_UNIT TURNS
9
+ #endif
10
+
7
11
class Angle
8
12
{
9
13
10
- float m_fDeg ;
14
+ float m_fTurns ;
11
15
12
16
public:
13
17
14
18
enum Type{
19
+ TURNS = 0 ,
15
20
DEGREES,
16
21
RADIANS
17
- // TURNS
18
22
};
19
23
20
- Angle (float a = 0 .0f , Type t = DEGREES )
24
+ Angle (float a = 0 .0f , Type t = K_ANGLE_UNIT )
21
25
{
22
- m_fDeg = t==DEGREES ? a : RAD2DEGf (a);
26
+ switch (t){
27
+ case DEGREES:
28
+ m_fTurns = a;
29
+ break ;
30
+ case RADIANS:
31
+ m_fTurns = RAD2DEGf (a);
32
+ break ;
33
+ case TURNS:
34
+ m_fTurns = RAD2DEGf (a*K_TAU);
35
+ break ;
36
+ default :
37
+ assert (false );
38
+ }
23
39
wrap ();
24
40
}
25
41
26
42
// Angle(const glm::vec2& v) {
27
- // m_fDeg = glm::angle(Axis::X, glm::normalize(v));
43
+ // m_fTurns = glm::angle(Axis::X, glm::normalize(v));
28
44
// }
29
45
30
46
glm::vec2 vector () const {
31
- return glm::vec2 (cos (), sin ());
47
+ return glm::vec2 (Angle:: cos (), Angle:: sin ());
32
48
}
33
49
34
50
// static Angle between(const Angle& a, const Angle& b) {
@@ -39,108 +55,109 @@ class Angle
39
55
return Angle (deg, DEGREES);
40
56
}
41
57
static Angle radians (float rad) {
42
- return Angle (rad, RADIANS);
58
+ return Angle (RAD2DEGf ( rad) , RADIANS);
43
59
}
44
60
static Angle turns (float t) {
45
61
return Angle (t * 360 .0f , DEGREES);
46
62
}
47
63
48
64
void wrap ()
49
65
{
50
- while (m_fDeg >= 180 . 0f )
51
- m_fDeg -= 360 .0f ;
52
- while (m_fDeg < -180 . 0f )
53
- m_fDeg += 360 .0f ;
66
+ while (m_fTurns >= 0 . 5f )
67
+ m_fTurns -= 1 .0f ;
68
+ while (m_fTurns < -0 . 5f )
69
+ m_fTurns += 1 .0f ;
54
70
}
55
71
56
72
glm::vec2 vector (float mag = 1 .0f ) {
57
- float rad = DEG2RADf (m_fDeg) ;
73
+ float rad = m_fTurns*K_TAU ;
58
74
return glm::vec2 (
59
75
mag * std::cos (rad),
60
76
mag * std::sin (rad)
61
77
);
62
78
}
63
79
64
80
float cos () const {
65
- return std::cos (DEG2RADf (m_fDeg ));
81
+ return std::cos (DEG2RADf (m_fTurns ));
66
82
}
67
83
float sin () const {
68
- return std::sin (DEG2RADf (m_fDeg ));
84
+ return std::sin (DEG2RADf (m_fTurns ));
69
85
}
70
86
71
- Angle flip () {
72
- return *this +Angle::degrees ( 180 . 0f );
87
+ Angle flip () const {
88
+ return *this +Angle::turns ( 0 . 5f );
73
89
}
74
90
75
- float degrees () const { return m_fDeg; }
76
- float radians () const { return DEG2RADf (m_fDeg); }
91
+ float degrees () const { return m_fTurns*360 .0f ; }
92
+ float radians () const { return m_fTurns*K_TAU; }
93
+ float turns () const { return DEG2RADf (m_fTurns*K_TAU); }
77
94
// void degrees(float deg) {
78
- // m_fDeg = deg;
95
+ // m_fTurns = deg;
79
96
// wrap();
80
97
// }
81
98
// void radians(float rad) {
82
- // m_fDeg = RAD2DEGf(rad);
99
+ // m_fTurns = RAD2DEGf(rad);
83
100
// wrap();
84
101
// }
85
102
86
103
Angle operator +(const Angle& a) const {
87
- return Angle (m_fDeg + a.degrees ());
104
+ return Angle (m_fTurns + a.turns ());
88
105
}
89
106
const Angle& operator +=(const Angle& a) {
90
107
return (*this = *this +a);
91
108
}
92
109
Angle operator -(const Angle& a) const {
93
- return Angle (m_fDeg - a.degrees ());
110
+ return Angle (m_fTurns - a.turns ());
94
111
}
95
112
Angle operator -() const {
96
- return Angle (-m_fDeg );
113
+ return Angle (-m_fTurns );
97
114
}
98
115
Angle operator *(float f) const {
99
- return Angle (m_fDeg * f);
116
+ return Angle (m_fTurns * f);
100
117
}
101
118
const Angle& operator *=(float f) {
102
119
return (*this = *this *f);
103
120
}
104
121
bool operator ==(const Angle& a) const {
105
- return floatcmp (m_fDeg , a.degrees ());
122
+ return floatcmp (m_fTurns , a.turns ());
106
123
}
107
124
108
125
bool operator ==(float f) const {
109
- return floatcmp (m_fDeg , Angle::degrees (f).degrees ());
126
+ return floatcmp (m_fTurns , Angle::turns (f).turns ());
110
127
}
111
128
bool operator !=(float f) const {
112
- return !floatcmp (m_fDeg , Angle::degrees (f).degrees ());
129
+ return !floatcmp (m_fTurns , Angle::turns (f).turns ());
113
130
}
114
131
const Angle& operator =(float f) {
115
- m_fDeg = f;
132
+ m_fTurns = f;
116
133
wrap ();
117
134
return *this ;
118
135
}
119
136
120
137
bool operator >(float f) const {
121
- return degrees () > f;
138
+ return turns () > f;
122
139
}
123
140
bool operator >=(float f) const {
124
- return degrees () >= f;
141
+ return turns () >= f;
125
142
}
126
143
bool operator <(float f) const {
127
- return degrees () < f;
144
+ return turns () < f;
128
145
}
129
146
bool operator <=(float f) const {
130
- return degrees () <= f;
147
+ return turns () <= f;
131
148
}
132
149
133
150
bool operator >(const Angle& a) const {
134
- return degrees () > a.degrees ();
151
+ return turns () > a.turns ();
135
152
}
136
153
bool operator >=(const Angle& a) const {
137
- return degrees () >= a.degrees ();
154
+ return turns () >= a.turns ();
138
155
}
139
156
bool operator <(const Angle& a) const {
140
- return degrees () < a.degrees ();
157
+ return turns () < a.turns ();
141
158
}
142
159
bool operator <=(const Angle& a) const {
143
- return degrees () <= a.degrees ();
160
+ return turns () <= a.turns ();
144
161
}
145
162
};
146
163
0 commit comments