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
|
#ifndef C_ANGLE_H
#define C_ANGLE_H
#include "SSystem/SComponent/c_xyz.h"
class cSAngle {
private:
s16 mAngle;
public:
const static cSAngle _0;
const static cSAngle _1;
const static cSAngle _90;
const static cSAngle _180;
const static cSAngle _270;
cSAngle() {}
~cSAngle() {}
cSAngle(const cSAngle&);
cSAngle(s16);
cSAngle(float);
s16 Val() const { return this->mAngle; }
// void Set(s16 angle) { this->mAngle = angle; }
void Val(const cSAngle&);
void Val(s16);
void Val(float);
float Degree(void) const;
float Radian(void) const;
float Norm(void) const;
s16 Abs(void) const;
s16 Inv(void) const;
float Sin(void) const;
float Cos(void) const;
cSAngle operator-(void) const;
cSAngle operator+(const cSAngle&) const;
cSAngle operator-(const cSAngle&) const;
void operator+=(const cSAngle&);
void operator-=(const cSAngle&);
cSAngle operator+(short) const;
cSAngle operator-(short) const;
void operator+=(short);
cSAngle operator*(float) const;
void operator*=(float);
bool operator<(const cSAngle& other) const { return mAngle < other.mAngle; }
bool operator>(const cSAngle& other) const { return mAngle > other.mAngle; }
operator s16(void) const { return mAngle; }
void operator=(const cSAngle& other) { mAngle = other.mAngle; }
static inline cSAngle getMaxNegative(void) { return cSAngle((s16)-0x8000); }
inline void mirrorAtMaxNeg(void) { *this = cSAngle((s16)-0x8000) - *this; }
};
cSAngle operator+(short, const cSAngle&);
cSAngle operator-(short, const cSAngle&);
struct cAngle {
static f32 Radian_to_Degree(f32 rad) { return rad * 57.2957763671875f; }
static f32 Degree_to_Radian(f32 deg) { return deg * 0.017453292f; }
static s16 Degree_to_SAngle(f32 deg) { return deg * 182.04444885253906f; }
static f32 SAngle_to_Degree(s16 angle) { return (360.0f / 65536.0f) * angle; }
static f32 SAngle_to_Radian(s16 angle) { return 9.58738E-5f * angle; }
static f32 SAngle_to_Normal(s16 angle) { return 3.0517578E-5f * angle; }
static s16 Radian_to_SAngle(f32 rad) { return rad * 10430.378f; }
/* Converts Radian value into Degree value */
static f32 r2d(f32 r) { return Radian_to_Degree(r); }
/* Converts Degree value to s16 angle */
static s16 d2s(f32 d) { return Degree_to_SAngle(d); }
template <typename T>
static T Adjust(T f1, T f2, T f3);
};
template <typename T>
T cAngle::Adjust(T f1, T f2, T f3) {
while (f1 >= f3) {
f1 -= f3 - f2;
}
while (f1 < f2) {
f1 += f3 - f2;
}
return f1;
}
class cDegree {
private:
float mDegree;
public:
cDegree(float);
~cDegree() {}
cDegree& Formal(void);
void Val(float);
float Radian(void) const;
float Sin(void) const;
float Cos(void) const;
float Tan(void) const;
};
class cSPolar {
private:
float mRadial;
cSAngle mAngle1;
cSAngle mAngle2;
public:
cSPolar() {}
cSPolar(const cXyz&);
cSPolar& Formal(void);
void Val(float, short, short);
void Val(const cXyz&);
cXyz Xyz(void) const;
void Globe(class cSGlobe*) const;
};
class cSGlobe {
public:
float mRadius;
cSAngle mAzimuth; // original: V
cSAngle mInclination; // original: U
cSGlobe() {}
cSGlobe(const cSGlobe&);
cSGlobe(float, short, short);
cSGlobe(float, const cSAngle&, const cSAngle&);
cSGlobe(const cXyz&);
~cSGlobe() {}
cSGlobe& Formal(void);
void Val(const cSGlobe&);
void Val(float, short, short);
void Val(float, const cSAngle&, const cSAngle&);
void Val(const cXyz&);
float R(void) const { return mRadius; }
const cSAngle& V(void) const { return mAzimuth; }
const cSAngle& U(void) const { return mInclination; }
cXyz Xyz(void) const;
void Polar(cSPolar*) const;
cXyz Norm(void) const;
cSGlobe& Invert(void);
};
#endif /* C_ANGLE_H */
|
