G3D::UprightFrame Class Reference

Coordinate frame expressed in Euler angles. Unlike a G3D::Quat, UprightFrame always keeps the reference frame from rolling about its own z axis. Particularly useful for cameras. More...

#include <UprightFrame.h>

Public Member Functions
	UprightFrame (const Vector3 &t=Vector3::zero(), float p=0, float y=0)
	UprightFrame (const CoordinateFrame &cframe)
	UprightFrame (const Any &any)
Any	toAny () const
UprightFrame &	operator= (const Any &any)
	operator CoordinateFrame () const
CoordinateFrame	toCoordinateFrame () const
UprightFrame	operator+ (const UprightFrame &other) const
UprightFrame	operator* (const float k) const
void	serialize (class BinaryOutput &b) const
void	deserialize (class BinaryInput &b)

Static Public Member Functions
static void	unwrapYaw (UprightFrame *a, int N)

Public Attributes
Vector3	translation
float	pitch
float	yaw

Detailed Description

Coordinate frame expressed in Euler angles. Unlike a G3D::Quat, UprightFrame always keeps the reference frame from rolling about its own z axis. Particularly useful for cameras.

See also

G3D::CoordinateFrame, G3D::Matrix4, G3D::PhysicsFrame, G3D::UprightSpline, G3D::UprightSplineManipulator

Constructor & Destructor Documentation

G3D::UprightFrame::UprightFrame ( const Vector3 &  t = Vector3::zero(), float  p = 0, float  y = 0  )

inline

 : translation(t), pitch(p), yaw(y) {}

Here is the caller graph for this function:

G3D::UprightFrame::UprightFrame

(

const CoordinateFrame &

cframe

)

 {
 Vector3 look = cframe.lookVector();

 yaw = (float)(G3D::pi() + atan2(look.x, look.z));
 pitch = asin(look.y);

 translation = cframe.translation;
}

Here is the call graph for this function:

G3D::UprightFrame::UprightFrame ( const Any &  any )

explicit

Constructs an UprightFrame from an Any object.

The Any format for UprightFrame is:

pitch = ##, translation = Vector3(), yaw = ##

 {
 any.verifyName("UprightFrame");
 any.verifyType(Any::TABLE);

 translation = any["translation"];
 pitch = any["pitch"];
 yaw = any["yaw"];
}

Here is the call graph for this function:

Member Function Documentation

void G3D::UprightFrame::deserialize

(

class BinaryInput &

b

)

 {
 translation.deserialize(b);
 pitch = b.readFloat32();
 yaw = b.readFloat32();
}

Here is the call graph for this function:

G3D::UprightFrame::operator CoordinateFrame ( ) const

inline

Supports implicit cast to CoordinateFrame

 {
 return toCoordinateFrame();
 }

Here is the call graph for this function:

UprightFrame G3D::UprightFrame::operator*

(

const float

k

)

const

Required for use with spline

 {
 return UprightFrame(translation * k, pitch * k, yaw * k);
}

Here is the call graph for this function:

UprightFrame G3D::UprightFrame::operator+

(

const UprightFrame &

other

)

const

Required for use with spline

 {
 return UprightFrame(translation + other.translation, pitch + other.pitch, yaw + other.yaw);
}

Here is the call graph for this function:

UprightFrame & G3D::UprightFrame::operator=

(

const Any &

any

)

 {
 *this = UprightFrame(any);
 return *this;
}

Here is the call graph for this function:

void G3D::UprightFrame::serialize

(

class BinaryOutput &

b

)

const

 {
 translation.serialize(b);
 b.writeFloat32(pitch);
 b.writeFloat32(yaw);
}

Here is the call graph for this function:

Any G3D::UprightFrame::toAny

(

)

const

 {
 Any any(Any::TABLE, "UprightFrame");

 any["translation"] = translation;
 any["pitch"] = pitch;
 any["yaw"] = yaw;

 return any;
}

Here is the call graph for this function:

CoordinateFrame G3D::UprightFrame::toCoordinateFrame

(

)

const

 {
 CoordinateFrame cframe;

 Matrix3 P(Matrix3::fromAxisAngle(Vector3::unitX(), pitch));
 Matrix3 Y(Matrix3::fromAxisAngle(Vector3::unitY(), yaw));

 cframe.rotation = Y * P;
 cframe.translation = translation;

 return cframe;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::UprightFrame::unwrapYaw ( UprightFrame *  a, int  N  )

static

Unwraps the yaw values in the elements of the array such that they still represent the same angles but strictly increase/decrease without wrapping about zero. For use with Spline<UprightFrame>

 {
 // Use the first point to establish the wrapping convention
 for (int i = 1; i < N; ++i) {
 const float prev = a[i - 1].yaw;
 float& cur = a[i].yaw;

 // No two angles should be more than pi (i.e., 180-degrees) apart. 
 if (abs(cur - prev) > G3D::pi()) {
 // These angles must have wrapped at zero, causing them
 // to be interpolated the long way.

 // Find canonical [0, 2pi] versions of these numbers
 float p = (float)wrap(prev, twoPi());
 float c = (float)wrap(cur, twoPi());
 
 // Find the difference -pi < diff < pi between the current and previous values
 float diff = c - p;
 if (diff < -G3D::pi()) {
 diff += (float)twoPi();
 } else if (diff > G3D::pi()) {
 diff -= (float)twoPi();
 } 

 // Offset the current from the previous by the difference
 // between them.
 cur = prev + diff;
 }
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

float G3D::UprightFrame::pitch

-pi/2 < pitch < pi/2 in radians about the X-axis

Vector3 G3D::UprightFrame::translation

float G3D::UprightFrame::yaw

In radians about the Y-axis

---

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

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