G3D::PhysicsFrame Class Reference

#include <PhysicsFrame.h>

Public Member Functions
	PhysicsFrame ()
	PhysicsFrame (const Vector3 &translation)
	PhysicsFrame (const Quat &rot, const Vector3 &translation)
	PhysicsFrame (const Matrix3 &rot, const Vector3 &translation)
	PhysicsFrame (const Matrix3 &rot)
	PhysicsFrame (const CoordinateFrame &coordinateFrame)
PhysicsFrame &	operator= (const PhysicsFrame &p)
	PhysicsFrame (const class Any &any)
Any	toAny () const
PhysicsFrame	operator* (const PhysicsFrame &other) const
virtual	~PhysicsFrame ()
PhysicsFrame	lerp (const PhysicsFrame &other, float alpha) const
void	deserialize (class BinaryInput &b)
void	serialize (class BinaryOutput &b) const
	operator CFrame () const
PhysicsFrame &	operator*= (float f)
PhysicsFrame	operator* (float f) const
PhysicsFrame	operator+ (const PhysicsFrame &f) const
PhysicsFrame &	operator+= (const PhysicsFrame &f)
bool	operator== (const PhysicsFrame &other) const
bool	operator!= (const PhysicsFrame &other) const

Public Attributes
Quat	rotation
Point3	translation

Detailed Description

An RT transformation using a quaternion; suitable for physics integration.

This interface is in "Beta" and will change in the next release.

Constructor & Destructor Documentation

G3D::PhysicsFrame::PhysicsFrame

(

)

Initializes to the identity frame.

 {
 translation = Vector3::zero();
 rotation = Quat();
}

Here is the call graph for this function:

Here is the caller graph for this function:

G3D::PhysicsFrame::PhysicsFrame ( const Vector3 &  translation )

inline

Purely translational.

: translation(translation) {}

G3D::PhysicsFrame::PhysicsFrame ( const Quat &  rot, const Vector3 &  translation  )

inline

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

G3D::PhysicsFrame::PhysicsFrame ( const Matrix3 &  rot, const Vector3 &  translation  )

inline

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

G3D::PhysicsFrame::PhysicsFrame ( const Matrix3 &  rot )

inline

: rotation(rot), translation(Vector3::zero()) {}

G3D::PhysicsFrame::PhysicsFrame

(

const CoordinateFrame &

coordinateFrame

)

 {
 translation = coordinateFrame.translation;
 rotation = Quat(coordinateFrame.rotation);
}

G3D::PhysicsFrame::PhysicsFrame

(

const class Any &

any

)

• PhysicsFrame( [quat], [vec3] )
• Vector3( ... )
• CFrame( ... )
• CFrame::from...( ... )

virtual G3D::PhysicsFrame::~PhysicsFrame ( )

inlinevirtual

{}

Member Function Documentation

void G3D::PhysicsFrame::deserialize

(

class BinaryInput &

b

)

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

Here is the call graph for this function:

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

Linear interpolation (spherical linear for the rotations).

 {

 PhysicsFrame result;

 result.translation = translation.lerp(other.translation, alpha);
 result.rotation = rotation.slerp(other.rotation, alpha);

 return result;
}

Here is the call graph for this function:

G3D::PhysicsFrame::operator CFrame

(

)

const

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

inline

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

PhysicsFrame G3D::PhysicsFrame::operator*

(

const PhysicsFrame &

other

)

const

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

 {
 PhysicsFrame result;

 result.rotation = rotation * other.rotation;
 result.translation = translation + rotation.toRotationMatrix() * other.translation;

 return result;
}

Here is the call graph for this function:

PhysicsFrame G3D::PhysicsFrame::operator* ( float  f ) const

inline

Multiplies both pieces by f; note that this will result in a non-unit quaternion that needs to be normalized

 {
 return PhysicsFrame(rotation * f, translation * f);
 }

Here is the call graph for this function:

PhysicsFrame& G3D::PhysicsFrame::operator*= ( float  f )

inline

Multiplies both pieces by f; note that this will result in a non-unit quaternion that needs to be normalized

 {
 rotation *= f;
 translation *= f;
 return *this;
 }

PhysicsFrame G3D::PhysicsFrame::operator+ ( const PhysicsFrame &  f ) const

inline

 {
 return PhysicsFrame(rotation + f.rotation, translation + f.translation);
 }

Here is the call graph for this function:

PhysicsFrame& G3D::PhysicsFrame::operator+= ( const PhysicsFrame &  f )

inline

 {
 rotation += f.rotation;
 translation += f.translation;
 return *this;
 }

PhysicsFrame& G3D::PhysicsFrame::operator= ( const PhysicsFrame &  p )

inline

 {
 rotation = p.rotation;
 translation = p.translation;

 return *this;
 }

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

inline

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

void G3D::PhysicsFrame::serialize

(

class BinaryOutput &

b

)

const

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

Here is the call graph for this function:

Any G3D::PhysicsFrame::toAny

(

)

const

 {
 // Prefer to serialize as a CFrame, which is easier to read
 if (false) {
 Any a(Any::ARRAY, "PFrame");
 a.append(rotation, translation.toAny("Point3"));
 return a;
 } else {
 return CFrame(*this).toAny();
 }
}

Here is the call graph for this function:

Member Data Documentation

Quat G3D::PhysicsFrame::rotation

Point3 G3D::PhysicsFrame::translation

Origin of this reference frame in its parent's frame.

---

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

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