129 lines
3.1 KiB
C++
129 lines
3.1 KiB
C++
/**
|
|
\file PhysicsFrame.h
|
|
|
|
\maintainer Morgan McGuire, http://graphics.cs.williams.edu
|
|
|
|
\created 2002-07-08
|
|
\edited 2011-05-10
|
|
*/
|
|
|
|
#ifndef G3D_PhysicsFrame_h
|
|
#define G3D_PhysicsFrame_h
|
|
|
|
#include "G3D/platform.h"
|
|
#include "G3D/Vector3.h"
|
|
#include "G3D/Matrix3.h"
|
|
#include "G3D/Quat.h"
|
|
#include "G3D/CoordinateFrame.h"
|
|
#include <math.h>
|
|
#include <string>
|
|
|
|
|
|
namespace G3D {
|
|
|
|
/**
|
|
An RT transformation using a quaternion; suitable for
|
|
physics integration.
|
|
|
|
This interface is in "Beta" and will change in the next release.
|
|
*/
|
|
class PhysicsFrame {
|
|
public:
|
|
|
|
Quat rotation;
|
|
|
|
/**
|
|
Origin of this reference frame in its parent's frame.
|
|
*/
|
|
Point3 translation;
|
|
|
|
/**
|
|
Initializes to the identity frame.
|
|
*/
|
|
PhysicsFrame();
|
|
|
|
/**
|
|
Purely translational.
|
|
*/
|
|
PhysicsFrame(const Vector3& translation) : translation(translation) {}
|
|
PhysicsFrame(const Quat& rot, const Vector3& translation) : rotation(rot), translation(translation) {}
|
|
PhysicsFrame(const Matrix3& rot, const Vector3& translation) : rotation(rot), translation(translation) {}
|
|
PhysicsFrame(const Matrix3& rot) : rotation(rot), translation(Vector3::zero()) {}
|
|
PhysicsFrame(const CoordinateFrame& coordinateFrame);
|
|
|
|
PhysicsFrame& operator=(const PhysicsFrame& p) {
|
|
rotation = p.rotation;
|
|
translation = p.translation;
|
|
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
- PhysicsFrame( [quat], [vec3] )
|
|
- Vector3( ... )
|
|
- CFrame( ... )
|
|
- CFrame::from...( ... )
|
|
*/
|
|
PhysicsFrame(const class Any& any);
|
|
|
|
Any toAny() const;
|
|
|
|
/** Compose: create the transformation that is <I>other</I> followed by <I>this</I>.*/
|
|
PhysicsFrame operator*(const PhysicsFrame& other) const;
|
|
|
|
virtual ~PhysicsFrame() {}
|
|
|
|
/**
|
|
Linear interpolation (spherical linear for the rotations).
|
|
*/
|
|
PhysicsFrame lerp(
|
|
const PhysicsFrame& other,
|
|
float alpha) const;
|
|
|
|
void deserialize(class BinaryInput& b);
|
|
|
|
void serialize(class BinaryOutput& b) const;
|
|
|
|
operator CFrame() const;
|
|
|
|
/** Multiplies both pieces by \a f; note that this will result in a non-unit
|
|
quaternion that needs to be normalized */
|
|
PhysicsFrame& operator*=(float f) {
|
|
rotation *= f;
|
|
translation *= f;
|
|
return *this;
|
|
}
|
|
|
|
/** Multiplies both pieces by \a f; note that this will result in a non-unit
|
|
quaternion that needs to be normalized */
|
|
PhysicsFrame operator*(float f) const {
|
|
return PhysicsFrame(rotation * f, translation * f);
|
|
}
|
|
|
|
PhysicsFrame operator+(const PhysicsFrame& f) const {
|
|
return PhysicsFrame(rotation + f.rotation, translation + f.translation);
|
|
}
|
|
|
|
PhysicsFrame& operator+=(const PhysicsFrame& f) {
|
|
rotation += f.rotation;
|
|
translation += f.translation;
|
|
return *this;
|
|
}
|
|
|
|
bool operator==(const PhysicsFrame& other) const {
|
|
return (translation == other.translation) &&
|
|
((rotation == other.rotation) || (rotation == -other.rotation));
|
|
}
|
|
|
|
bool operator!=(const PhysicsFrame& other) const {
|
|
return ! ((*this) == other);
|
|
}
|
|
|
|
};
|
|
|
|
typedef PhysicsFrame PFrame;
|
|
|
|
} // namespace
|
|
|
|
#endif
|