CoordinateFrame.h

Go to the documentation of this file.

#ifndef G3D_CFrame_h
#define G3D_CFrame_h

#include "G3D/platform.h"
#include "G3D/Vector3.h"
#include "G3D/Vector4.h"
#include "G3D/Matrix3.h"
#include "G3D/Array.h"
#include <math.h>
#include <string>
#include <stdio.h>
#include <cstdarg>
#include <assert.h>

#ifdef _MSC_VER
// Turn off "conditional expression is constant" warning; MSVC generates this
// for debug assertions in inlined methods.
# pragma warning (disable : 4127)
#endif


namespace G3D {
class Any;
class Frustum;

class CoordinateFrame {
public:

 Matrix3 rotation;

 Point3 translation;

 CoordinateFrame(const Any& any);
 
 Any toAny() const;

 inline bool operator==(const CoordinateFrame& other) const {
 return (translation == other.translation) && (rotation == other.rotation);
 }

 inline bool operator!=(const CoordinateFrame& other) const {
 return !(*this == other);
 }

 bool fuzzyEq(const CoordinateFrame& other) const;

 bool fuzzyIsIdentity() const;

 bool isIdentity() const;

 CoordinateFrame();

 CoordinateFrame(const Point3& _translation) :
 rotation(Matrix3::identity()), translation(_translation) {
 }
 
 CoordinateFrame(const Matrix3& rotation, const Point3& translation) :
 rotation(rotation), translation(translation) {
 }

 CoordinateFrame(const Matrix3& rotation) :
 rotation(rotation), translation(Point3::zero()) {
 }

 CoordinateFrame(const class UprightFrame& f);

 static CoordinateFrame fromXYZYPRRadians(float x, float y, float z, float yaw = 0.0f, float pitch = 0.0f, float roll = 0.0f);

 std::string toXYZYPRDegreesString() const;

 static CoordinateFrame fromXYZYPRDegrees(float x, float y, float z, float yaw = 0.0f, float pitch = 0.0f, float roll = 0.0f);
 
 CoordinateFrame(class BinaryInput& b);

 void deserialize(class BinaryInput& b);

 void serialize(class BinaryOutput& b) const;

 CoordinateFrame(const CoordinateFrame &other) :
 rotation(other.rotation), translation(other.translation) {}

 inline CoordinateFrame inverse() const {
 CoordinateFrame out;
 out.rotation = rotation.transpose();
 out.translation = -out.rotation * translation;
 return out;
 }

 inline ~CoordinateFrame() {}

 class Matrix4 toMatrix4() const;

 void getXYZYPRRadians(float& x, float& y, float& z, float& yaw, float& pitch, float& roll) const;
 void getXYZYPRDegrees(float& x, float& y, float& z, float& yaw, float& pitch, float& roll) const;


 std::string toXML() const;

 inline float getHeading() const {
 Vector3 look = rotation.column(2);
 float angle = -(float) atan2(-look.x, look.z);
 return angle;
 }

 inline CoordinateFrame toObjectSpace(const CoordinateFrame& c) const {
 return this->inverse() * c;
 }

 inline Vector4 toObjectSpace(const Vector4& v) const {
 return this->inverse().toWorldSpace(v);
 }

 inline Vector4 toWorldSpace(const Vector4& v) const {
 return Vector4(rotation * Vector3(v.x, v.y, v.z) + translation * v.w, v.w);
 }

 inline Point3 pointToWorldSpace(const Point3& v) const {
 return Point3
 (rotation[0][0] * v[0] + rotation[0][1] * v[1] + rotation[0][2] * v[2] + translation[0],
 rotation[1][0] * v[0] + rotation[1][1] * v[1] + rotation[1][2] * v[2] + translation[1],
 rotation[2][0] * v[0] + rotation[2][1] * v[1] + rotation[2][2] * v[2] + translation[2]);
 }

 inline Point3 pointToObjectSpace(const Point3& v) const {
 float p[3];
 p[0] = v[0] - translation[0];
 p[1] = v[1] - translation[1];
 p[2] = v[2] - translation[2];
 debugAssert(G3D::fuzzyEq(fabsf(rotation.determinant()), 1.0f));
 return Point3(rotation[0][0] * p[0] + rotation[1][0] * p[1] + rotation[2][0] * p[2],
 rotation[0][1] * p[0] + rotation[1][1] * p[1] + rotation[2][1] * p[2],
 rotation[0][2] * p[0] + rotation[1][2] * p[1] + rotation[2][2] * p[2]);
 }

 inline Vector3 vectorToWorldSpace(const Vector3& v) const {
 return rotation * v;
 }

 inline Vector3 normalToWorldSpace(const Vector3& v) const {
 return rotation * v;
 }

 class Ray toObjectSpace(const Ray& r) const;

 Ray toWorldSpace(const Ray& r) const;

 Frustum toWorldSpace(const Frustum& f) const;

 inline Vector3 vectorToObjectSpace(const Vector3 &v) const {
 // Multiply on the left (same as rotation.transpose() * v)
 return v * rotation;
 }

 inline Vector3 normalToObjectSpace(const Vector3 &v) const {
 // Multiply on the left (same as rotation.transpose() * v)
 return v * rotation;
 }

 void pointToWorldSpace(const Array<Point3>& v, Array<Point3>& vout) const;

 void normalToWorldSpace(const Array<Vector3>& v, Array<Vector3>& vout) const;

 void vectorToWorldSpace(const Array<Vector3>& v, Array<Vector3>& vout) const;

 void pointToObjectSpace(const Array<Point3>& v, Array<Point3>& vout) const;

 void normalToObjectSpace(const Array<Vector3>& v, Array<Vector3>& vout) const;

 void vectorToObjectSpace(const Array<Vector3>& v, Array<Vector3>& vout) const;

 void toWorldSpace(const class AABox& b, class AABox& result) const;

 class Box toWorldSpace(const class AABox& b) const;

 class Box toWorldSpace(const class Box& b) const;

 class Cylinder toWorldSpace(const class Cylinder& b) const;

 class Capsule toWorldSpace(const class Capsule& b) const;

 class Plane toWorldSpace(const class Plane& p) const;

 class Sphere toWorldSpace(const class Sphere& b) const;
 
 class Triangle toWorldSpace(const class Triangle& t) const;

 class Box toObjectSpace(const AABox& b) const;

 class Box toObjectSpace(const Box& b) const;

 class Plane toObjectSpace(const Plane& p) const;
 
 class Sphere toObjectSpace(const Sphere& b) const;

 Triangle toObjectSpace(const Triangle& t) const;

 CoordinateFrame operator*(const CoordinateFrame &other) const {
 return CoordinateFrame(rotation * other.rotation,
 pointToWorldSpace(other.translation));
 }

 CoordinateFrame operator+(const Vector3& v) const {
 return CoordinateFrame(rotation, translation + v);
 }

 CoordinateFrame operator-(const Vector3& v) const {
 return CoordinateFrame(rotation, translation - v);
 }


 void moveTowards(const CoordinateFrame& goal, float maxTranslation, float maxRotation);

 void lookAt(const Point3& target);

 void lookAt
 (const Point3& target,
 Vector3 up);

 inline Vector3 lookVector() const {
 return -rotation.column(2);
 }
 
 class Ray lookRay() const;

 inline Vector3 upVector() const {
 return rotation.column(1);
 }

 inline Vector3 rightVector() const {
 return rotation.column(0);
 }

 inline Vector3 leftVector() const {
 return -rotation.column(0);
 }

 CoordinateFrame lerp
 (const CoordinateFrame& other,
 float alpha) const;

};

typedef CoordinateFrame CFrame;

} // namespace

#endif