sid/NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Switch from Nz prefix to namespace Nz

Browse Source 
What a huge commit


Former-commit-id: 38ac5eebf70adc1180f571f6006192d28fb99897
This commit is contained in:
Lynix
2015-09-25 19:20:05 +02:00
parent c214251ecf
commit df8da275c4
609 changed files with 68265 additions and 66534 deletions
Download Patch File Download Diff File Expand all files Collapse all files

319
include/Nazara/Math/EulerAngles.inl
View File

@@ -12,168 +12,171 @@
#define F(a) static_cast<T>(a)
template<typename T>
NzEulerAngles<T>::NzEulerAngles(T P, T Y, T R)
namespace Nz
{
Set(P, Y, R);
template<typename T>
EulerAngles<T>::EulerAngles(T P, T Y, T R)
{
Set(P, Y, R);
}
template<typename T>
EulerAngles<T>::EulerAngles(const T angles[3])
{
Set(angles);
}
template<typename T>
EulerAngles<T>::EulerAngles(const Quaternion<T>& quat)
{
Set(quat);
}
template<typename T>
template<typename U>
EulerAngles<T>::EulerAngles(const EulerAngles<U>& angles)
{
Set(angles);
}
template<typename T>
void EulerAngles<T>::MakeZero()
{
Set(F(0.0), F(0.0), F(0.0));
}
template<typename T>
void EulerAngles<T>::Normalize()
{
pitch = NormalizeAngle(pitch);
yaw = NormalizeAngle(yaw);
roll = NormalizeAngle(roll);
}
template<typename T>
void EulerAngles<T>::Set(T P, T Y, T R)
{
pitch = P;
yaw = Y;
roll = R;
}
template<typename T>
void EulerAngles<T>::Set(const T angles[3])
{
pitch = angles[0];
yaw = angles[1];
roll = angles[2];
}
template<typename T>
void EulerAngles<T>::Set(const EulerAngles& angles)
{
std::memcpy(this, &angles, sizeof(EulerAngles));
}
template<typename T>
void EulerAngles<T>::Set(const Quaternion<T>& quat)
{
Set(quat.ToEulerAngles());
}
template<typename T>
template<typename U>
void EulerAngles<T>::Set(const EulerAngles<U>& angles)
{
pitch = F(angles.pitch);
yaw = F(angles.yaw);
roll = F(angles.roll);
}
template<typename T>
Quaternion<T> EulerAngles<T>::ToQuaternion() const
{
T c1 = std::cos(ToRadians(yaw) / F(2.0));
T c2 = std::cos(ToRadians(roll) / F(2.0));
T c3 = std::cos(ToRadians(pitch) / F(2.0));
T s1 = std::sin(ToRadians(yaw) / F(2.0));
T s2 = std::sin(ToRadians(roll) / F(2.0));
T s3 = std::sin(ToRadians(pitch) / F(2.0));
return Quaternion<T>(c1 * c2 * c3 - s1 * s2 * s3,
s1 * s2 * c3 + c1 * c2 * s3,
s1 * c2 * c3 + c1 * s2 * s3,
c1 * s2 * c3 - s1 * c2 * s3);
}
template<typename T>
String EulerAngles<T>::ToString() const
{
StringStream ss;
return ss << "EulerAngles(" << pitch << ", " << yaw << ", " << roll << ')';
}
template<typename T>
EulerAngles<T> EulerAngles<T>::operator+(const EulerAngles& angles) const
{
return EulerAngles(pitch + angles.pitch,
yaw + angles.yaw,
roll + angles.roll);
}
template<typename T>
EulerAngles<T> EulerAngles<T>::operator-(const EulerAngles& angles) const
{
return EulerAngles(pitch - angles.pitch,
yaw - angles.yaw,
roll - angles.roll);
}
template<typename T>
EulerAngles<T>& EulerAngles<T>::operator+=(const EulerAngles& angles)
{
pitch += angles.pitch;
yaw += angles.yaw;
roll += angles.roll;
return *this;
}
template<typename T>
EulerAngles<T>& EulerAngles<T>::operator-=(const EulerAngles& angles)
{
pitch -= angles.pitch;
yaw -= angles.yaw;
roll -= angles.roll;
return *this;
}
template<typename T>
bool EulerAngles<T>::operator==(const EulerAngles& angles) const
{
return NumberEquals(pitch, angles.pitch) &&
NumberEquals(yaw, angles.yaw) &&
NumberEquals(roll, angles.roll);
}
template<typename T>
bool EulerAngles<T>::operator!=(const EulerAngles& angles) const
{
return !operator==(angles);
}
template<typename T>
EulerAngles<T> EulerAngles<T>::Zero()
{
EulerAngles angles;
angles.MakeZero();
return angles;
}
}
template<typename T>
NzEulerAngles<T>::NzEulerAngles(const T angles[3])
{
Set(angles);
}
template<typename T>
NzEulerAngles<T>::NzEulerAngles(const NzQuaternion<T>& quat)
{
Set(quat);
}
template<typename T>
template<typename U>
NzEulerAngles<T>::NzEulerAngles(const NzEulerAngles<U>& angles)
{
Set(angles);
}
template<typename T>
void NzEulerAngles<T>::MakeZero()
{
Set(F(0.0), F(0.0), F(0.0));
}
template<typename T>
void NzEulerAngles<T>::Normalize()
{
pitch = NzNormalizeAngle(pitch);
yaw = NzNormalizeAngle(yaw);
roll = NzNormalizeAngle(roll);
}
template<typename T>
void NzEulerAngles<T>::Set(T P, T Y, T R)
{
pitch = P;
yaw = Y;
roll = R;
}
template<typename T>
void NzEulerAngles<T>::Set(const T angles[3])
{
pitch = angles[0];
yaw = angles[1];
roll = angles[2];
}
template<typename T>
void NzEulerAngles<T>::Set(const NzEulerAngles& angles)
{
std::memcpy(this, &angles, sizeof(NzEulerAngles));
}
template<typename T>
void NzEulerAngles<T>::Set(const NzQuaternion<T>& quat)
{
Set(quat.ToEulerAngles());
}
template<typename T>
template<typename U>
void NzEulerAngles<T>::Set(const NzEulerAngles<U>& angles)
{
pitch = F(angles.pitch);
yaw = F(angles.yaw);
roll = F(angles.roll);
}
template<typename T>
NzQuaternion<T> NzEulerAngles<T>::ToQuaternion() const
{
T c1 = std::cos(NzToRadians(yaw) / F(2.0));
T c2 = std::cos(NzToRadians(roll) / F(2.0));
T c3 = std::cos(NzToRadians(pitch) / F(2.0));
T s1 = std::sin(NzToRadians(yaw) / F(2.0));
T s2 = std::sin(NzToRadians(roll) / F(2.0));
T s3 = std::sin(NzToRadians(pitch) / F(2.0));
return NzQuaternion<T>(c1 * c2 * c3 - s1 * s2 * s3,
s1 * s2 * c3 + c1 * c2 * s3,
s1 * c2 * c3 + c1 * s2 * s3,
c1 * s2 * c3 - s1 * c2 * s3);
}
template<typename T>
NzString NzEulerAngles<T>::ToString() const
{
NzStringStream ss;
return ss << "EulerAngles(" << pitch << ", " << yaw << ", " << roll << ')';
}
template<typename T>
NzEulerAngles<T> NzEulerAngles<T>::operator+(const NzEulerAngles& angles) const
{
return NzEulerAngles(pitch + angles.pitch,
yaw + angles.yaw,
roll + angles.roll);
}
template<typename T>
NzEulerAngles<T> NzEulerAngles<T>::operator-(const NzEulerAngles& angles) const
{
return NzEulerAngles(pitch - angles.pitch,
yaw - angles.yaw,
roll - angles.roll);
}
template<typename T>
NzEulerAngles<T>& NzEulerAngles<T>::operator+=(const NzEulerAngles& angles)
{
pitch += angles.pitch;
yaw += angles.yaw;
roll += angles.roll;
return *this;
}
template<typename T>
NzEulerAngles<T>& NzEulerAngles<T>::operator-=(const NzEulerAngles& angles)
{
pitch -= angles.pitch;
yaw -= angles.yaw;
roll -= angles.roll;
return *this;
}
template<typename T>
bool NzEulerAngles<T>::operator==(const NzEulerAngles& angles) const
{
return NzNumberEquals(pitch, angles.pitch) &&
NzNumberEquals(yaw, angles.yaw) &&
NzNumberEquals(roll, angles.roll);
}
template<typename T>
bool NzEulerAngles<T>::operator!=(const NzEulerAngles& angles) const
{
return !operator==(angles);
}
template<typename T>
NzEulerAngles<T> NzEulerAngles<T>::Zero()
{
NzEulerAngles angles;
angles.MakeZero();
return angles;
}
template<typename T>
std::ostream& operator<<(std::ostream& out, const NzEulerAngles<T>& angles)
std::ostream& operator<<(std::ostream& out, const Nz::EulerAngles<T>& angles)
{
return out << angles.ToString();
}