aboutsummaryrefslogtreecommitdiffstats
path: root/LibOVR/Src/Kernel/OVR_Math.h
diff options
context:
space:
mode:
authorBrad Davis <[email protected]>2014-05-23 01:49:32 -0700
committerBrad Davis <[email protected]>2014-05-23 01:49:32 -0700
commit46acc0e194ff3c1f120199eeca8324b4502118e9 (patch)
treeb1030198d3ee4698445d1fc5161cebe4158e45d1 /LibOVR/Src/Kernel/OVR_Math.h
parent07d0f4d0bbf3477ac6a9584f726e8ec6ab285707 (diff)
Updating to 0.3.2 (windows version)
Diffstat (limited to 'LibOVR/Src/Kernel/OVR_Math.h')
-rw-r--r--LibOVR/Src/Kernel/OVR_Math.h107
1 files changed, 72 insertions, 35 deletions
diff --git a/LibOVR/Src/Kernel/OVR_Math.h b/LibOVR/Src/Kernel/OVR_Math.h
index 9bd5bad..4aa42b0 100644
--- a/LibOVR/Src/Kernel/OVR_Math.h
+++ b/LibOVR/Src/Kernel/OVR_Math.h
@@ -125,7 +125,7 @@ template<class T> class Vector2;
template<class T> class Vector3;
template<class T> class Matrix3;
template<class T> class Matrix4;
-template<class T> class Pose;
+template<class T> class Transform;
template<class T> class PoseState;
// CompatibleTypes::Type is used to lookup a compatible C-version of a C++ class.
@@ -140,7 +140,7 @@ struct CompatibleTypes
// Specializations providing CompatibleTypes::Type value.
template<> struct CompatibleTypes<Quat<float> > { typedef ovrQuatf Type; };
template<> struct CompatibleTypes<Quat<double> > { typedef ovrQuatd Type; };
-template<> struct CompatibleTypes<Matrix3<double> > { typedef ovrMatrix3d Type; };
+template<> struct CompatibleTypes<Matrix3<double> > { typedef ovrMatrix3d Type; };
template<> struct CompatibleTypes<Matrix4<float> > { typedef ovrMatrix4f Type; };
template<> struct CompatibleTypes<Size<int> > { typedef ovrSizei Type; };
template<> struct CompatibleTypes<Size<float> > { typedef ovrSizef Type; };
@@ -150,11 +150,11 @@ template<> struct CompatibleTypes<Vector2<float> > { typedef ovrVector2f Type;
template<> struct CompatibleTypes<Vector3<float> > { typedef ovrVector3f Type; };
template<> struct CompatibleTypes<Vector3<double> > { typedef ovrVector3d Type; };
-template<> struct CompatibleTypes<Pose<float> > { typedef ovrPosef Type; };
-template<> struct CompatibleTypes<PoseState<float> >{ typedef ovrPoseStatef Type; };
+template<> struct CompatibleTypes<Transform<float> > { typedef ovrPosef Type; };
+template<> struct CompatibleTypes<PoseState<float> > { typedef ovrPoseStatef Type; };
-template<> struct CompatibleTypes<Pose<double> > { typedef ovrPosed Type; };
-template<> struct CompatibleTypes<PoseState<double> >{ typedef ovrPoseStated Type; };
+template<> struct CompatibleTypes<Transform<double> > { typedef ovrPosed Type; };
+template<> struct CompatibleTypes<PoseState<double> > { typedef ovrPoseStated Type; };
//------------------------------------------------------------------------------------//
// ***** Math
@@ -509,7 +509,7 @@ public:
T Length() const { return sqrt(LengthSq()); }
// Returns squared distance between two points represented by vectors.
- T DistanceSq(Vector3& b) const { return (*this - b).LengthSq(); }
+ T DistanceSq(Vector3 const& b) const { return (*this - b).LengthSq(); }
// Returns distance between two points represented by vectors.
T Distance(Vector3 const& b) const { return (*this - b).Length(); }
@@ -705,7 +705,7 @@ public:
// C-interop support.
Quat(const typename CompatibleTypes<Quat<T> >::Type& s) : x(s.x), y(s.y), z(s.z), w(s.w) { }
- operator const typename CompatibleTypes<Quat<T> >::Type () const
+ operator typename CompatibleTypes<Quat<T> >::Type () const
{
typename CompatibleTypes<Quat<T> >::Type result;
result.x = x;
@@ -1091,36 +1091,73 @@ typedef Quat<double> Quatd;
// Position and orientation combined.
template<class T>
-class Pose
+class Transform
{
public:
- typedef typename CompatibleTypes<Pose<T> >::Type CompatibleType;
+ typedef typename CompatibleTypes<Transform<T> >::Type CompatibleType;
- Pose() { }
- Pose(const Quat<T>& orientation, const Vector3<T>& pos)
- : Orientation(orientation), Position(pos) { }
- Pose(const Pose& s)
- : Orientation(s.Orientation), Position(s.Position) { }
- Pose(const CompatibleType& s)
- : Orientation(s.Orientation), Position(s.Position) { }
- explicit Pose(const Pose<typename Math<T>::OtherFloatType> &s)
- : Orientation(s.Orientation), Position(s.Position) { }
+ Transform() { }
+ Transform(const Quat<T>& orientation, const Vector3<T>& pos)
+ : Rotation(orientation), Translation(pos) { }
+ Transform(const Transform& s)
+ : Rotation(s.Rotation), Translation(s.Translation) { }
+ Transform(const CompatibleType& s)
+ : Rotation(s.Orientation), Translation(s.Position) { }
+ explicit Transform(const Transform<typename Math<T>::OtherFloatType> &s)
+ : Rotation(s.Rotation), Translation(s.Translation) { }
- operator const typename CompatibleTypes<Pose<T> >::Type () const
+ operator typename CompatibleTypes<Transform<T> >::Type () const
{
- typename CompatibleTypes<Pose<T> >::Type result;
- result.Orientation = Orientation;
- result.Position = Position;
+ typename CompatibleTypes<Transform<T> >::Type result;
+ result.Orientation = Rotation;
+ result.Position = Translation;
return result;
}
- Quat<T> Orientation;
- Vector3<T> Position;
+ Quat<T> Rotation;
+ Vector3<T> Translation;
+
+ Vector3<T> Rotate(const Vector3<T>& v) const
+ {
+ return Rotation.Rotate(v);
+ }
+
+ Vector3<T> Translate(const Vector3<T>& v) const
+ {
+ return v + Translation;
+ }
+
+ Vector3<T> Apply(const Vector3<T>& v) const
+ {
+ return Translate(Rotate(v));
+ }
+
+ Transform operator*(const Transform& other) const
+ {
+ return Transform(Rotation * other.Rotation, Apply(other.Translation));
+ }
+
+ PoseState<T> operator*(const PoseState<T>& poseState) const
+ {
+ PoseState<T> result;
+ result.Pose = (*this) * poseState.Pose;
+ result.LinearVelocity = this->Rotate(poseState.LinearVelocity);
+ result.LinearAcceleration = this->Rotate(poseState.LinearAcceleration);
+ result.AngularVelocity = this->Rotate(poseState.AngularVelocity);
+ result.AngularAcceleration = this->Rotate(poseState.AngularAcceleration);
+ return result;
+ }
+
+ Transform Inverted() const
+ {
+ Quat<T> inv = Rotation.Inverted();
+ return Transform(inv, inv.Rotate(-Translation));
+ }
};
-typedef Pose<float> Posef;
-typedef Pose<double> Posed;
+typedef Transform<float> Transformf;
+typedef Transform<double> Transformd;
//-------------------------------------------------------------------------------------
@@ -1204,10 +1241,10 @@ public:
M[3][0] = 0; M[3][1] = 0; M[3][2] = 0; M[3][3] = 1;
}
- explicit Matrix4(const Pose<T>& p)
+ explicit Matrix4(const Transform<T>& p)
{
- Matrix4 result(p.Orientation);
- result.SetTranslation(p.Position);
+ Matrix4 result(p.Rotation);
+ result.SetTranslation(p.Translation);
*this = result;
}
@@ -1226,7 +1263,7 @@ public:
memcpy(M, s.M, sizeof(M));
}
- operator const typename CompatibleTypes<Matrix4<T> >::Type () const
+ operator typename CompatibleTypes<Matrix4<T> >::Type () const
{
typename CompatibleTypes<Matrix4<T> >::Type result;
OVR_COMPILER_ASSERT(sizeof(result) == sizeof(Matrix4));
@@ -1879,10 +1916,10 @@ public:
M[0][1] = M[0][2] = M[1][0] = M[1][2] = M[2][0] = M[2][1] = 0;
}
- explicit Matrix3(const Pose<T>& p)
+ explicit Matrix3(const Transform<T>& p)
{
- Matrix3 result(p.Orientation);
- result.SetTranslation(p.Position);
+ Matrix3 result(p.Rotation);
+ result.SetTranslation(p.Translation);
*this = result;
}
@@ -1901,7 +1938,7 @@ public:
memcpy(M, s.M, sizeof(M));
}
- operator const typename CompatibleTypes<Matrix3<T> >::Type () const
+ operator typename CompatibleTypes<Matrix3<T> >::Type () const
{
typename CompatibleTypes<Matrix3<T> >::Type result;
OVR_COMPILER_ASSERT(sizeof(result) == sizeof(Matrix3));