G3D::CoordinateFrame Class Reference

A rigid body RT (rotation-translation) transformation. More...

#include <CoordinateFrame.h>

Public Member Functions
	CoordinateFrame (const Any &any)
Any	toAny () const
bool	operator== (const CoordinateFrame &other) const
bool	operator!= (const CoordinateFrame &other) const
bool	fuzzyEq (const CoordinateFrame &other) const
bool	fuzzyIsIdentity () const
bool	isIdentity () const
	CoordinateFrame ()
	CoordinateFrame (const Point3 &_translation)
	CoordinateFrame (const Matrix3 &rotation, const Point3 &translation)
	CoordinateFrame (const Matrix3 &rotation)
	CoordinateFrame (const class UprightFrame &f)
std::string	toXYZYPRDegreesString () const
	CoordinateFrame (class BinaryInput &b)
void	deserialize (class BinaryInput &b)
void	serialize (class BinaryOutput &b) const
	CoordinateFrame (const CoordinateFrame &other)
CoordinateFrame	inverse () const
	~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
float	getHeading () const
CoordinateFrame	toObjectSpace (const CoordinateFrame &c) const
Vector4	toObjectSpace (const Vector4 &v) const
Vector4	toWorldSpace (const Vector4 &v) const
Point3	pointToWorldSpace (const Point3 &v) const
Point3	pointToObjectSpace (const Point3 &v) const
Vector3	vectorToWorldSpace (const Vector3 &v) const
Vector3	normalToWorldSpace (const Vector3 &v) const
class Ray	toObjectSpace (const Ray &r) const
Ray	toWorldSpace (const Ray &r) const
Frustum	toWorldSpace (const Frustum &f) const
Vector3	vectorToObjectSpace (const Vector3 &v) const
Vector3	normalToObjectSpace (const Vector3 &v) const
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
CoordinateFrame	operator+ (const Vector3 &v) const
CoordinateFrame	operator- (const Vector3 &v) const
void	moveTowards (const CoordinateFrame &goal, float maxTranslation, float maxRotation)
void	lookAt (const Point3 &target)
void	lookAt (const Point3 &target, Vector3 up)
Vector3	lookVector () const
class Ray	lookRay () const
Vector3	upVector () const
Vector3	rightVector () const
Vector3	leftVector () const
CoordinateFrame	lerp (const CoordinateFrame &other, float alpha) const

Static Public Member Functions
static CoordinateFrame	fromXYZYPRRadians (float x, float y, float z, float yaw=0.0f, float pitch=0.0f, float roll=0.0f)
static CoordinateFrame	fromXYZYPRDegrees (float x, float y, float z, float yaw=0.0f, float pitch=0.0f, float roll=0.0f)

Public Attributes
Matrix3	rotation
Point3	translation

Detailed Description

A rigid body RT (rotation-translation) transformation.

CoordinateFrame abstracts a 4x4 matrix that maps object space to world space:

v_world = C * v_object

CoordinateFrame::rotation is the upper 3x3 submatrix, CoordinateFrame::translation is the right 3x1 column. The 4th row is always [0 0 0 1], so it isn't stored. So you don't have to remember which way the multiplication and transformation work, it provides explicit toWorldSpace and toObjectSpace methods. Also, points, vectors (directions), and surface normals transform differently, so they have separate methods.

Some helper functions transform whole primitives like boxes in and out of object space.

Convert to Matrix4 using CoordinateFrame::toMatrix4. You can construct a CoordinateFrame from a Matrix4 using Matrix4::approxCoordinateFrame, however, because a Matrix4 is more general than a CoordinateFrame, some information may be lost.

See also

G3D::UprightFrame, G3D::PhysicsFrame, G3D::Matrix4, G3D::Quat

Constructor & Destructor Documentation

G3D::CoordinateFrame::CoordinateFrame

(

const Any &

any

)

Parameters

any	Must be in one of the following forms: CFrame((matrix3 expr), (Point3 expr)) CFrame::fromXYZYPRDegrees(#, #, #, #, #, #) CFrame { rotation = (Matrix3 expr), translation = (Point3 expr) } Point3( ... ) Matrix3( ... )

 {
 *this = CFrame();

 const std::string& n = toUpper(any.name());

 if (beginsWith(n, "VECTOR3") || beginsWith(n, "POINT3")) {
 translation = Point3(any);
 } else if (beginsWith(n, "MATRIX3")) {
 rotation = Matrix3(any);
 } else if (beginsWith(n, "MATRIX4")) {
 *this = Matrix4(any).approxCoordinateFrame();
 } else if ((n == "CFRAME") || (n == "COORDINATEFRAME")) {
 any.verifyType(Any::TABLE, Any::ARRAY);
 if (any.type() == Any::ARRAY) {
 any.verifySize(2);
 rotation = any[0];
 translation = any[1];
 } else {
 AnyTableReader r(any);
 r.getIfPresent("translation", translation);
 r.getIfPresent("rotation", rotation);
 r.verifyDone();
 }
 } else if (beginsWith(n, "PHYSICSFRAME") || beginsWith(n, "PFRAME")) {
 *this = PhysicsFrame(any);
// } else if (beginsWith(n, "UPRIGHTFRAME") || beginsWith(n, "UFRAME")) {
// *this = UprightFrame(any);
 } else {
 any.verifyName("CFrame::fromXYZYPRDegrees", "CoordinateFrame::fromXYZYPRDegrees");
 any.verifyType(Any::ARRAY);
 any.verifySize(3, 6);

 int s = any.size();

 *this = fromXYZYPRDegrees(any[0], any[1], any[2], 
 (s > 3) ? (float)any[3].number() : 0.0f,
 (s > 4) ? (float)any[4].number() : 0.0f,
 (s > 5) ? (float)any[5].number() : 0.0f);
 }
}

Here is the call graph for this function:

G3D::CoordinateFrame::CoordinateFrame

(

)

Initializes to the identity coordinate frame.

 : 
 rotation(Matrix3::identity()), translation(Vector3::zero()) {
}

Here is the caller graph for this function:

G3D::CoordinateFrame::CoordinateFrame ( const Point3 &  _translation )

inline

 :
 rotation(Matrix3::identity()), translation(_translation) {
 }

G3D::CoordinateFrame::CoordinateFrame ( const Matrix3 &  rotation, const Point3 &  translation  )

inline

 :
 rotation(rotation), translation(translation) {
 }

G3D::CoordinateFrame::CoordinateFrame ( const Matrix3 &  rotation )

inline

 :
 rotation(rotation), translation(Point3::zero()) {
 }

G3D::CoordinateFrame::CoordinateFrame

(

const class UprightFrame &

f

)

 {
 *this = f.toCoordinateFrame();
}

Here is the call graph for this function:

G3D::CoordinateFrame::CoordinateFrame

(

class BinaryInput &

b

)

 : rotation(Matrix3::zero()) {
 deserialize(b);
}

Here is the call graph for this function:

G3D::CoordinateFrame::CoordinateFrame ( const CoordinateFrame &  other )

inline

 :
 rotation(other.rotation), translation(other.translation) {}

G3D::CoordinateFrame::~CoordinateFrame ( )

inline

{}

Member Function Documentation

void G3D::CoordinateFrame::deserialize

(

class BinaryInput &

b

)

 {
 rotation.deserialize(b);
 translation.deserialize(b);
}

Here is the call graph for this function:

Here is the caller graph for this function:

CoordinateFrame G3D::CoordinateFrame::fromXYZYPRDegrees ( float  x, float  y, float  z, float  yaw = 0.0f, float  pitch = 0.0f, float  roll = 0.0f  )

static

Construct a coordinate frame from translation = (x,y,z) and rotations (in that order) about Y, object space X, object space Z. Note that because object-space axes are used, these are not equivalent to Euler angles; they are known as Tait-Bryan rotations and are more convenient for intuitive positioning.

 {
 return fromXYZYPRRadians(x, y, z, toRadians(yaw), toRadians(pitch), toRadians(roll));
}

Here is the call graph for this function:

Here is the caller graph for this function:

CoordinateFrame G3D::CoordinateFrame::fromXYZYPRRadians ( float  x, float  y, float  z, float  yaw = 0.0f, float  pitch = 0.0f, float  roll = 0.0f  )

static

 {
 const Matrix3& rotation = Matrix3::fromEulerAnglesYXZ(yaw, pitch, roll);
 const Vector3 translation(x, y, z);
 
 return CoordinateFrame(rotation, translation);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::CoordinateFrame::fuzzyEq

(

const CoordinateFrame &

other

)

const

 {

 for (int c = 0; c < 3; ++c) {
 for (int r = 0; r < 3; ++r) {
 if (! G3D::fuzzyEq(other.rotation[r][c], rotation[r][c])) {
 return false;
 }
 }
 if (! G3D::fuzzyEq(translation[c], other.translation[c])) {
 return false;
 }
 }

 return true;
}

Here is the call graph for this function:

bool G3D::CoordinateFrame::fuzzyIsIdentity

(

)

const

 {
 const Matrix3& I = Matrix3::identity();

 for (int c = 0; c < 3; ++c) {
 for (int r = 0; r < 3; ++r) {
 if (fuzzyNe(I[r][c], rotation[r][c])) {
 return false;
 }
 }
 if (fuzzyNe(translation[c], 0)) {
 return false;
 }
 }

 return true;
}

Here is the call graph for this function:

float G3D::CoordinateFrame::getHeading ( ) const

inline

Returns the heading of the lookVector as an angle in radians relative to the world -z axis. That is, a counter-clockwise heading where north (-z) is 0 and west (-x) is PI/2.

Note that the heading ignores the Y axis, so an inverted object has an inverted heading.

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

Here is the call graph for this function:

void G3D::CoordinateFrame::getXYZYPRDegrees	(	float &	x,
		float &	y,
		float &	z,
		float &	yaw,
		float &	pitch,
		float &	roll
	)		const

 {
 getXYZYPRRadians(x, y, z, yaw, pitch, roll);
 yaw = toDegrees(yaw);
 pitch = toDegrees(pitch);
 roll = toDegrees(roll);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::CoordinateFrame::getXYZYPRRadians	(	float &	x,
		float &	y,
		float &	z,
		float &	yaw,
		float &	pitch,
		float &	roll
	)		const

 {
 x = translation.x;
 y = translation.y;
 z = translation.z;
 
 rotation.toEulerAnglesYXZ(yaw, pitch, roll);
}

Here is the call graph for this function:

Here is the caller graph for this function:

CoordinateFrame G3D::CoordinateFrame::inverse ( ) const

inline

Computes the inverse of this coordinate frame.

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

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::CoordinateFrame::isIdentity

(

)

const

 {
 return 
 (translation == Vector3::zero()) &&
 (rotation == Matrix3::identity());
}

Here is the call graph for this function:

Vector3 G3D::CoordinateFrame::leftVector ( ) const

inline

If a viewer looks along the look vector, this is the viewer's "left". Useful for strafing motions and building alternative coordinate frames.

 {
 return -rotation.column(0);
 }

Here is the call graph for this function:

CoordinateFrame G3D::CoordinateFrame::lerp	(	const CoordinateFrame &	other,
		float	alpha
	)		const

Linearly interpolates between two coordinate frames, using Quat::slerp for the rotations.

See also

moveTowards

 {

 if (alpha == 1.0f) {
 return other;
 } else if (alpha == 0.0f) {
 return *this;
 } else {
 const Quat q1(this->rotation);
 const Quat q2(other.rotation);

 return CoordinateFrame(
 q1.slerp(q2, alpha).toRotationMatrix(),
 translation * (1 - alpha) + other.translation * alpha);
 }
} 

Here is the call graph for this function:

void G3D::CoordinateFrame::lookAt

(

const Point3 &

target

)

 {
 lookAt(target, Vector3::unitY());
}

Here is the call graph for this function:

void G3D::CoordinateFrame::lookAt	(	const Point3 &	target,
		Vector3	up
	)

 {

 up = up.direction();

 Vector3 look = (target - translation).direction();
 if (fabs(look.dot(up)) > .99f) {
 up = Vector3::unitX();
 if (fabs(look.dot(up)) > .99f) {
 up = Vector3::unitY();
 }
 }

 up -= look * look.dot(up);
 up = up.direction();

 Vector3 z = -look;
 Vector3 x = -z.cross(up);
 x = x.direction();

 Vector3 y = z.cross(x);

 rotation.setColumn(0, x);
 rotation.setColumn(1, y);
 rotation.setColumn(2, z);
}

Here is the call graph for this function:

Ray G3D::CoordinateFrame::lookRay

(

)

const

Returns the ray starting at the camera origin travelling in direction CoordinateFrame::lookVector.

 {
 return Ray::fromOriginAndDirection(translation, lookVector());
}

Here is the call graph for this function:

Vector3 G3D::CoordinateFrame::lookVector ( ) const

inline

The direction this camera is looking (its negative z axis)

 {
 return -rotation.column(2);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Transform this coordinate frame towards goal, but not past it, goverened by maximum rotation and translations. This is a useful alternative to lerp, especially if the goal is expected to change every transformation step so that constant start and end positions will not be available.

Parameters

goal	Step from this towards goal
maxTranslation	Meters
maxRotation	Radians

See also

lerp

 {
 translation.moveTowards(goal.translation, maxTranslation);
 Quat q(rotation);
 q.moveTowards(Quat(goal.rotation), maxRotation);
 rotation = Matrix3(q);
}

Here is the call graph for this function:

Vector3 G3D::CoordinateFrame::normalToObjectSpace ( const Vector3 &  v ) const

inline

 {
 // Multiply on the left (same as rotation.transpose() * v)
 return v * rotation;
 }

Here is the caller graph for this function:

void G3D::CoordinateFrame::normalToObjectSpace	(	const Array< Vector3 > &	v,
		Array< Vector3 > &	vout
	)		const

 {
 vout.resize(v.size());

 for (int i = v.size() - 1; i >= 0; --i) {
 vout[i] = normalToObjectSpace(v[i]);
 }
}

Here is the call graph for this function:

Vector3 G3D::CoordinateFrame::normalToWorldSpace ( const Vector3 &  v ) const

inline

 {
 return rotation * v;
 }

Here is the caller graph for this function:

void G3D::CoordinateFrame::normalToWorldSpace	(	const Array< Vector3 > &	v,
		Array< Vector3 > &	vout
	)		const

 {
 vout.resize(v.size());

 for (int i = 0; i < v.size(); ++i) {
 vout[i] = normalToWorldSpace(v[i]);
 }
}

Here is the call graph for this function:

bool G3D::CoordinateFrame::operator!= ( const CoordinateFrame &  other ) const

inline

 {
 return !(*this == other);
 }

CoordinateFrame G3D::CoordinateFrame::operator* ( const CoordinateFrame &  other ) const

inline

Compose: create the transformation that is other followed by this.

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

Here is the call graph for this function:

CoordinateFrame G3D::CoordinateFrame::operator+ ( const Vector3 &  v ) const

inline

 {
 return CoordinateFrame(rotation, translation + v);
 }

Here is the call graph for this function:

CoordinateFrame G3D::CoordinateFrame::operator- ( const Vector3 &  v ) const

inline

 {
 return CoordinateFrame(rotation, translation - v);
 }

Here is the call graph for this function:

bool G3D::CoordinateFrame::operator== ( const CoordinateFrame &  other ) const

inline

 {
 return (translation == other.translation) && (rotation == other.rotation);
 }

Point3 G3D::CoordinateFrame::pointToObjectSpace ( const Point3 &  v ) const

inline

Transforms the point into object space. Assumes that the rotation matrix is orthonormal.

 {
 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]);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::CoordinateFrame::pointToObjectSpace	(	const Array< Point3 > &	v,
		Array< Point3 > &	vout
	)		const

 {
 vout.resize(v.size());

 for (int i = v.size() - 1; i >= 0; --i) {
 vout[i] = pointToObjectSpace(v[i]);
 }
}

Here is the call graph for this function:

Point3 G3D::CoordinateFrame::pointToWorldSpace ( const Point3 &  v ) const

inline

Transforms the point into world space.

 {
 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]);
 }

Here is the caller graph for this function:

void G3D::CoordinateFrame::pointToWorldSpace	(	const Array< Point3 > &	v,
		Array< Point3 > &	vout
	)		const

 {
 vout.resize(v.size());

 for (int i = 0; i < v.size(); ++i) {
 vout[i] = pointToWorldSpace(v[i]);
 }
}

Here is the call graph for this function:

Vector3 G3D::CoordinateFrame::rightVector ( ) const

inline

 {
 return rotation.column(0);
 }

Here is the call graph for this function:

void G3D::CoordinateFrame::serialize

(

class BinaryOutput &

b

)

const

 {
 rotation.serialize(b);
 translation.serialize(b);
}

Here is the call graph for this function:

Any G3D::CoordinateFrame::toAny

(

)

const

Converts the CFrame to an Any.

 {
 float x, y, z, yaw, pitch, roll;
 getXYZYPRDegrees(x, y, z, yaw, pitch, roll); 
 Any a(Any::ARRAY, "CFrame::fromXYZYPRDegrees");
 a.append(x, y, z);
 if ( ! G3D::fuzzyEq(yaw, 0.0f) || ! G3D::fuzzyEq(pitch, 0.0f) || ! G3D::fuzzyEq(roll, 0.0f)) {
 a.append(yaw);
 if (! G3D::fuzzyEq(pitch, 0.0f) || ! G3D::fuzzyEq(roll, 0.0f)) {
 a.append(pitch);
 if (! G3D::fuzzyEq(roll, 0.0f)) {
 a.append(roll);
 }
 }
 }
 return a;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Matrix4 G3D::CoordinateFrame::toMatrix4

(

)

const

See also Matrix4::approxCoordinateFrame

 {
 return Matrix4(*this);
}

CoordinateFrame G3D::CoordinateFrame::toObjectSpace ( const CoordinateFrame &  c ) const

inline

Takes the coordinate frame into object space. this->inverse() * c

 {
 return this->inverse() * c;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Vector4 G3D::CoordinateFrame::toObjectSpace ( const Vector4 &  v ) const

inline

 {
 return this->inverse().toWorldSpace(v);
 }

Here is the call graph for this function:

Ray G3D::CoordinateFrame::toObjectSpace

(

const Ray &

r

)

const

 {
 return Ray::fromOriginAndDirection(pointToObjectSpace(r.origin()), vectorToObjectSpace(r.direction()));
}

Here is the call graph for this function:

Box G3D::CoordinateFrame::toObjectSpace

(

const AABox &

b

)

const

 {
 return toObjectSpace(Box(b));
}

Here is the call graph for this function:

Plane G3D::CoordinateFrame::toObjectSpace

(

const Plane &

p

)

const

 {
 // TODO
 Vector3 N, P;
 double d;
 p.getEquation(N, d);
 P = N * (float)d;
 P = pointToObjectSpace(P);
 N = normalToObjectSpace(N);
 debugAssertM(isFinite(d), "Not implemented for infinite planes");
 return Plane(N, P);
}

Here is the call graph for this function:

Box G3D::CoordinateFrame::toObjectSpace

(

const Box &

b

)

const

 {
 return inverse().toWorldSpace(b);
}

Here is the call graph for this function:

Sphere G3D::CoordinateFrame::toObjectSpace

(

const Sphere &

b

)

const

 {
 return Sphere(pointToObjectSpace(b.center), b.radius);
}

Here is the call graph for this function:

Triangle G3D::CoordinateFrame::toObjectSpace

(

const Triangle &

t

)

const

 {
 return Triangle(pointToObjectSpace(t.vertex(0)),
 pointToObjectSpace(t.vertex(1)),
 pointToObjectSpace(t.vertex(2)));
}

Here is the call graph for this function:

Vector4 G3D::CoordinateFrame::toWorldSpace ( const Vector4 &  v ) const

inline

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

Here is the caller graph for this function:

Ray G3D::CoordinateFrame::toWorldSpace

(

const Ray &

r

)

const

 {
 return Ray::fromOriginAndDirection(pointToWorldSpace(r.origin()), vectorToWorldSpace(r.direction()));
}

Here is the call graph for this function:

Frustum G3D::CoordinateFrame::toWorldSpace

(

const Frustum &

f

)

const

 {
 Frustum g;
 g.vertexPos.resize(f.vertexPos.size());
 g.faceArray.resize(f.faceArray.size());

 for (int i = 0; i < f.vertexPos.size(); ++i) {
 g.vertexPos[i] = toWorldSpace(f.vertexPos[i]);
 }
 for (int i = 0; i < f.faceArray.size(); ++i) {
 g.faceArray[i].plane = toWorldSpace(f.faceArray[i].plane);
 for (int j = 0; j < 4; ++j) {
 g.faceArray[i].vertexIndex[j] = f.faceArray[i].vertexIndex[j];
 }
 }

 return g;
}

Here is the call graph for this function:

class Box G3D::CoordinateFrame::toWorldSpace

(

const class Box &

b

)

const

class Cylinder G3D::CoordinateFrame::toWorldSpace

(

const class Cylinder &

b

)

const

class Box G3D::CoordinateFrame::toWorldSpace

(

const class AABox &

b

)

const

void G3D::CoordinateFrame::toWorldSpace	(	const class AABox &	b,
		class AABox &	result
	)		const

class Capsule G3D::CoordinateFrame::toWorldSpace

(

const class Capsule &

b

)

const

class Triangle G3D::CoordinateFrame::toWorldSpace

(

const class Triangle &

t

)

const

class Sphere G3D::CoordinateFrame::toWorldSpace

(

const class Sphere &

b

)

const

class Plane G3D::CoordinateFrame::toWorldSpace

(

const class Plane &

p

)

const

std::string G3D::CoordinateFrame::toXML

(

)

const

Produces an XML serialization of this coordinate frame.

Deprecated:

 {
 return G3D::format(
 "<COORDINATEFRAME>\n %lf,%lf,%lf,%lf,\n %lf,%lf,%lf,%lf,\n %lf,%lf,%lf,%lf,\n %lf,%lf,%lf,%lf\n</COORDINATEFRAME>\n",
 rotation[0][0], rotation[0][1], rotation[0][2], translation.x,
 rotation[1][0], rotation[1][1], rotation[1][2], translation.y,
 rotation[2][0], rotation[2][1], rotation[2][2], translation.z,
 0.0, 0.0, 0.0, 1.0);
}

Here is the call graph for this function:

std::string G3D::CoordinateFrame::toXYZYPRDegreesString

(

)

const

                                                       {
    float x,y,z,yaw,pitch,roll;
    getXYZYPRDegrees(x,y,z,yaw,pitch,roll);
    
    return format("CFrame::fromXYZYPRDegrees(% 5.1ff, % 5.1ff, % 5.1ff, % 5.1ff, % 5.1ff, % 5.1ff)", 
                  x,y,z,yaw,pitch,roll);
}

Here is the call graph for this function:

Vector3 G3D::CoordinateFrame::upVector ( ) const

inline

Up direction for this camera (its y axis).

                                    {
        return rotation.column(1);
    }

Here is the call graph for this function:

Vector3 G3D::CoordinateFrame::vectorToObjectSpace ( const Vector3 &  v ) const

inline

Transforms the vector into object space (no translation).

                                                               {
        // Multiply on the left (same as rotation.transpose() * v)
        return v * rotation;
    }

Here is the caller graph for this function:

void G3D::CoordinateFrame::vectorToObjectSpace	(	const Array< Vector3 > &	v,
		Array< Vector3 > &	vout
	)		const

                                                                                             {
    vout.resize(v.size());

    for (int i = v.size() - 1; i >= 0; --i) {
        vout[i] = vectorToObjectSpace(v[i]);
    }
}

Here is the call graph for this function:

Vector3 G3D::CoordinateFrame::vectorToWorldSpace ( const Vector3 &  v ) const

inline

Transforms the vector into world space (no translation).

                                                              {
        return rotation * v;
    }

Here is the caller graph for this function:

void G3D::CoordinateFrame::vectorToWorldSpace	(	const Array< Vector3 > &	v,
		Array< Vector3 > &	vout
	)		const

                                                                                            {
    vout.resize(v.size());

    for (int i = v.size() - 1; i >= 0; --i) {
        vout[i] = vectorToWorldSpace(v[i]);
    }
}

Here is the call graph for this function:

Member Data Documentation

Matrix3 G3D::CoordinateFrame::rotation

Takes object space points to world space.

Point3 G3D::CoordinateFrame::translation

The origin of this coordinate frame in world space (or its parent's space, if nested).

---

The documentation for this class was generated from the following files:

• dep/g3dlite/include/G3D/CoordinateFrame.h
• dep/g3dlite/source/CoordinateFrame.cpp