mirror of https://github.com/mosra/magnum.git
Vladimír Vondruš
13 years ago
9 changed files with 301 additions and 26 deletions
@ -0,0 +1,290 @@ |
|||||||
|
namespace Magnum { namespace Math { |
||||||
|
/** @page transformations 2D and 3D transformations |
||||||
|
|
||||||
|
@brief Introduction to essential operations on vectors and points. |
||||||
|
|
||||||
|
@tableofcontents |
||||||
|
|
||||||
|
Transformations are essential operations involved in scene management -- object |
||||||
|
relations, hierarchies, animations etc. %Magnum provides classes for |
||||||
|
transformations in both 2D and 3D. Each class is suited for different purposes, |
||||||
|
but their usage is nearly the same to make your life simpler. This page will |
||||||
|
explain the basic operation and differences between various representations. |
||||||
|
|
||||||
|
@section transformations-representation Representing transformations |
||||||
|
|
||||||
|
The first and most straightforward way to represent transformations is to use |
||||||
|
homogeneous transformation matrix, i.e. Matrix3 for 2D and Matrix4 for 3D. The |
||||||
|
matrices are able to represent all possible types of transformations -- rotation, |
||||||
|
translation, scaling, reflection etc. and also projective transformation, thus |
||||||
|
they are used at the very core of graphics pipeline and are supported natively |
||||||
|
in OpenGL. |
||||||
|
|
||||||
|
On the other hand, matrices need 9 or 16 floats to represent the transformation, |
||||||
|
which has implications on both memory usage and performance (relatively slow |
||||||
|
matrix multiplication). It is also relatively hard to extract transformation |
||||||
|
properties (such as rotation angle/axis) from them, interpolate between them or |
||||||
|
compute inverse transformation. They suffer badly from so-called floating-point |
||||||
|
drift -- e.g. after a few combined rotations the transformation won't be pure |
||||||
|
rotation anymore, but will involve also a bit of scaling, shearing and whatnot. |
||||||
|
|
||||||
|
However, you can trade some transformation features for improved performance and |
||||||
|
better behavior -- for just a rotation you can use Complex in 2D and Quaternion |
||||||
|
in 3D, or DualComplex and DualQuaternion if you want also translation. It is not |
||||||
|
possible to represent scaling, reflection or other transformations with them, |
||||||
|
but they occupy only 2 or 4 floats (4 or 8 floats in dual versions), can be |
||||||
|
easily inverted and interpolated and have many other awesome properties. However, |
||||||
|
they are not magic so they also suffer slightly from floating-point drift, but |
||||||
|
not too much and the drift can be accounted for more easily than with matrices. |
||||||
|
|
||||||
|
@section transformations-types Transformation types |
||||||
|
|
||||||
|
Transformation matrices and (dual) complex numbers or quaternions have completely |
||||||
|
different internals, but they share the same API to achieve the same things, |
||||||
|
greatly simplifying their usage. In many cases it is even possible to hot-swap |
||||||
|
the transformation class type without changing any function calls. |
||||||
|
|
||||||
|
@subsection transformations-default Default (identity) transformation |
||||||
|
|
||||||
|
Default-constructed Matrix3, Matrix4, Complex, Quaternion, DualComplex and |
||||||
|
DualQuaternion represent identity transformation, so you don't need to worry |
||||||
|
about them in initialization. |
||||||
|
|
||||||
|
@subsection transformations-rotation Rotation |
||||||
|
|
||||||
|
2D rotation is represented solely by its angle in counterclockwise direction and |
||||||
|
rotation transformation can be created by calling Matrix3::rotation(), |
||||||
|
Complex::rotation() or DualComplex::rotation(), for example: |
||||||
|
@code |
||||||
|
auto a = Matrix3::rotation(23.0_degf); |
||||||
|
auto b = Complex::rotation(Rad(Constants::pi()/2)); |
||||||
|
auto c = DualComplex::rotation(-1.57_radf); |
||||||
|
@endcode |
||||||
|
|
||||||
|
3D rotation is represented by angle and (three-dimensional) axis. The rotation |
||||||
|
can be created by calling Matrix4::rotation(), Quaternion::rotation() or |
||||||
|
DualQuaternion::rotation(). The axis must be always of unit length to avoid |
||||||
|
redundant normalization. Shortcuts Vector3::xAxis(), Vector3::yAxis() and |
||||||
|
Vector3::zAxis() are provided for convenience. %Matrix representation has also |
||||||
|
Matrix4::rotationX(), Matrix4::rotationY() and Matrix4::rotationZ() which are |
||||||
|
faster than using the generic function for rotation around primary axes. |
||||||
|
Examples: |
||||||
|
@code |
||||||
|
auto a = Quaternion::rotation(60.0_degf, Vector3::xAxis()); |
||||||
|
auto b = DualQuaternion::rotation(-1.0_degf, Vector3(1.0f, 0.5f, 3.0f).normalized()); |
||||||
|
auto c = Matrix4::rotationZ(angle); |
||||||
|
@endcode |
||||||
|
|
||||||
|
Rotations are always around origin. Rotation about arbitrary point can be done |
||||||
|
by applying translation to have the point at origin, performing the rotation and |
||||||
|
then translating back. Read below for more information. |
||||||
|
@todo DualQuaternion and rotation around arbitrary axis |
||||||
|
|
||||||
|
@subsection transformations-translation Translation |
||||||
|
|
||||||
|
2D translation is defined by two-dimensional vector and can be created with |
||||||
|
Matrix3::translation() or DualComplex::translation(). You can use Vector2::xAxis() |
||||||
|
or Vector2::yAxis() to translate only along given axis. Examples: |
||||||
|
@code |
||||||
|
auto a = Matrix3::translation(Vector2::xAxis(-5.0f)); |
||||||
|
auto b = DualComplex::translation({-1.0f, 0.5f}); |
||||||
|
@endcode |
||||||
|
|
||||||
|
3D translation is defined by three-dimensional vector and can be created with |
||||||
|
Matrix4::translation() or DualQuaternion::translation(). You can use |
||||||
|
Vector3::xAxis() and friends also here. Examples: |
||||||
|
@code |
||||||
|
auto a = Matrix4::translation(vector); |
||||||
|
auto b = DualQuaternion::translation(Vector3::zAxis(1.3f)); |
||||||
|
@endcode |
||||||
|
|
||||||
|
@subsection transformations-scaling Scaling and reflection |
||||||
|
|
||||||
|
Scaling is defined by two- or three-dimensional vector and is represented by |
||||||
|
matrices. You can create it with Matrix3::scaling() or Matrix4::scaling(). You |
||||||
|
can use Vector3::xScale(), Vector3::yScale(), Vector3::zScale() or their 2D |
||||||
|
counterparts to scale along one axis and leave the rest unchanged or call |
||||||
|
explicit one-parameter vector constructor to scale uniformly on all axes. |
||||||
|
Examples: |
||||||
|
@code |
||||||
|
auto a = Matrix3::scaling(Vector2::xScale(2.0f)); |
||||||
|
auto b = Matrix4::scaling({2.0f, -2.0f, 1.5f}); |
||||||
|
auto c = Matrix4::scaling(Vector3(10.0f)); |
||||||
|
@endcode |
||||||
|
|
||||||
|
Reflections are defined by normal along which to reflect (i.e., two- or |
||||||
|
three-dimensional vector of unit length) and they are also represented by |
||||||
|
matrices. Reflection is created with Matrix3::reflection() or Matrix4::reflection(). |
||||||
|
You can use Vector3::xAxis() and friends also here. Examples: |
||||||
|
@code |
||||||
|
auto a = Matrix3::reflection(Vector2::yAxis()); |
||||||
|
auto b = Matrix4::reflection(axis.normalized()); |
||||||
|
@endcode |
||||||
|
|
||||||
|
Scaling and reflection is also done relative to origin, you can use method |
||||||
|
mentioned above to scale or reflect around arbitrary point. |
||||||
|
|
||||||
|
Sscaling and reflection can be (to some extent) also represented by complex |
||||||
|
numbers and quaternions, but it has some bad properties and would make some |
||||||
|
operations more expensive, so it's not implemented. |
||||||
|
|
||||||
|
@subsection transformations-projective Projective transformations |
||||||
|
|
||||||
|
Projective transformations eploit the full potential of transformation matrices. |
||||||
|
In 2D there is only one projection type, which can be created with Matrix3::projection() |
||||||
|
and it is defined by area which will be projected into unit rectangle. In 3D |
||||||
|
there is orthographic projection, created with Matrix4::orthographicProjection() |
||||||
|
and defined by volume to project into unit cube, and perspective projection. |
||||||
|
Perspective projection is created with Matrix4::perspectiveProjection() and is |
||||||
|
defined either by field-of-view, aspect ratio and distance to near and far plane |
||||||
|
of view frustum or by size of near plane, its distance and distance to far |
||||||
|
plane. Some examples: |
||||||
|
@code |
||||||
|
auto a = Matrix3::projection({4.0f, 3.0f}); |
||||||
|
auto b = Matrix4::orthographicProjection({4.0f, 3.0f, 100.0f}); |
||||||
|
auto c = Matrix4::perspectiveProjection(35.0_degf, 1.333f, 0.001f, 100.0f); |
||||||
|
@endcode |
||||||
|
|
||||||
|
@section transformations-composing Composing and inverting transformations |
||||||
|
|
||||||
|
Transformations (of the same representation) can be composed simply by |
||||||
|
multiplying them, it works the same for matrices, complex numbers, quaternions |
||||||
|
and their dual counterparts. Order of multiplication matters -- the |
||||||
|
transformation on the right-hand side of multiplication is applied first, the |
||||||
|
transformation on the left-hand side is applied second. For example, rotation |
||||||
|
followed by translation is done like this: |
||||||
|
@code |
||||||
|
auto a = DualComplex::translation(Vector2::yAxis(2.0f))* |
||||||
|
DualComplex::rotation(25.0_degf); |
||||||
|
auto b = Matrix4::translation(Vector3::yAxis(5.0f))* |
||||||
|
Matrix4::rotationY(25.0_degf); |
||||||
|
@endcode |
||||||
|
|
||||||
|
Inverse transformation can be computed using Matrix3::inverted(), Matrix4::inverted(), |
||||||
|
Complex::inverted(), Quaternion::inverted(), DualComplex::inverted() or |
||||||
|
DualQuaternion::inverted(). %Matrix inversion is quite costly, so if your |
||||||
|
transformation involves only translation and rotation, you can use faster |
||||||
|
alternatives Matrix3::invertedEuclidean() and Matrix4::invertedEuclidean(). If |
||||||
|
you are sure that the (dual) complex number or (dual) quaternion is of unit |
||||||
|
length, you can use Complex::invertedNormalized(), Quaternion::invertedNormalized(), |
||||||
|
DualComplex::invertedNormalized() or DualQuaternion::invertedNormalized() which |
||||||
|
is a little bit faster, because it doesn't need to renormalize the result. |
||||||
|
|
||||||
|
@section transformations-transforming Transforming vectors and points |
||||||
|
|
||||||
|
Transformations can be used directly for transforming vectors and points. %Vector |
||||||
|
transformation does not involve translation, in 2D can be done using |
||||||
|
Matrix3::transformVector() and Complex::transformVector(), in 3D using |
||||||
|
Matrix4::transformVector() and Quaternion::transformVector(). For transformation |
||||||
|
with normalized quaternion you can use faster alternative Quaternion::transformVectorNormalized(). |
||||||
|
Example: |
||||||
|
@code |
||||||
|
auto transformation = Matrix3::rotation(-30.0_degf)*Matrix3::scaling(Vector2(3.0f)); |
||||||
|
Vector2 transformed = transformation.transformVector({1.5f, -7.9f}); |
||||||
|
@endcode |
||||||
|
|
||||||
|
Point transformation involves also translation, in 2D is done with |
||||||
|
Matrix3::transformPoint() and DualComplex::transformPoint(), in 3D with |
||||||
|
Matrix4::transformPoint() and DualQuaternion::transformPoint(). Also here you |
||||||
|
can use faster alternative Quaternion::transformPointNormalized(): |
||||||
|
@code |
||||||
|
auto transformation = DualQuaternion::rotation(-30.0_degf, Vector3::xAxis())* |
||||||
|
DualQuaternion::translation(Vector3::yAxis(3.0f)); |
||||||
|
Vector3 transformed = transformation.transformPointNormalized({1.5f, 3.0f, -7.9f}); |
||||||
|
@endcode |
||||||
|
|
||||||
|
@section transformations-properties Transformation properties and conversion |
||||||
|
|
||||||
|
It is possible to extract some transformation properties from transformation |
||||||
|
matrices, particularly translation vector, rotation/scaling part of the matrix |
||||||
|
(or pure rotation if the matrix has uniform scaling) and also base vectors: |
||||||
|
@code |
||||||
|
Matrix4 a; |
||||||
|
auto rotationScaling = transformation.rotationScaling(); |
||||||
|
Vector3 up = transformation.up(); |
||||||
|
Vector3 right = transformation.right(); |
||||||
|
|
||||||
|
Matrix3 b; |
||||||
|
auto rotation = b.rotation(); |
||||||
|
Float xTranslation = b.translation().x(); |
||||||
|
@endcode |
||||||
|
Extracting scaling and rotation from arbitrary transformation matrices is harder |
||||||
|
and can be done using Algorithms::svd(). Extracting rotation angle (and axis in |
||||||
|
3D) from rotation part is possible using by converting it to complex number or |
||||||
|
quaternion, see below. |
||||||
|
|
||||||
|
You can also recreate transformation matrix from rotation and translation parts: |
||||||
|
@code |
||||||
|
Matrix3 c = Matrix3::from(rotation, {1.0f, 3.0f}); |
||||||
|
@endcode |
||||||
|
|
||||||
|
%Complex numbers and quaternions are far better in this regard and they allow |
||||||
|
you to extract rotation angle using Complex::rotationAngle(), Quaternion::rotationAngle(), |
||||||
|
DualComplex::rotationAngle() or DualQuaternion::rotationAngle(), and rotation |
||||||
|
axis in 3D using Quaternion::rotationAxis() or DualQuaternion::rotationAxis(). |
||||||
|
It is also possible to extract translation from their dual versions using |
||||||
|
DualComplex::translation() const and DualQuaternion::translation() const. |
||||||
|
@code |
||||||
|
DualComplex a; |
||||||
|
Rad rotation = a.rotationAngle(); |
||||||
|
Vector2 translation = a.translation(); |
||||||
|
|
||||||
|
Quaternion b; |
||||||
|
Vector3 rotationAxis = b.rotationAxis(); |
||||||
|
@endcode |
||||||
|
|
||||||
|
You can convert Complex and Quaternion to rotation matrix using Complex::toMatrix() |
||||||
|
and Quaternion::toMatrix() or their dual version to rotation and translation |
||||||
|
matrix using DualComplex::toMatrix() and DualQuaternion::toMatrix(): |
||||||
|
@code |
||||||
|
Quaternion a; |
||||||
|
auto rotation = Matrix4::from(a.toMatrix(), {}); |
||||||
|
|
||||||
|
DualComplex b; |
||||||
|
Matrix3 transformation = b.toMatrix(); |
||||||
|
@endcode |
||||||
|
|
||||||
|
Conversion the other way around is possible only from rotation matrices using |
||||||
|
Complex::fromMatrix() or Quaternion::fromMatrix() and from rotation and |
||||||
|
translation matrices using DualComplex::fromMatrix() and |
||||||
|
DualQuaternion::fromMatrix(): |
||||||
|
@code |
||||||
|
Matrix3 rotation; |
||||||
|
auto a = Complex::fromMatrix(rotation.rotationScaling()); |
||||||
|
|
||||||
|
Matrix4 transformation; |
||||||
|
auto b = DualQuaternion::fromMatrix(transformation); |
||||||
|
@endcode |
||||||
|
|
||||||
|
@section transformations-interpolation Transformation interpolation |
||||||
|
|
||||||
|
@todoc Write this when interpolation is done also for (dual) complex numbers and |
||||||
|
dual quaternions |
||||||
|
|
||||||
|
@section transformations-normalization Normalizing transformations |
||||||
|
|
||||||
|
When doing multiplicative transformations, e.g. adding rotating to an |
||||||
|
transformation many times during an animation, the resulting transformation will |
||||||
|
accumulate rounding errors and behave strangely. For transformation matrices |
||||||
|
this can't always be fixed, because they can represent any transformation (and |
||||||
|
thus no algorithm can't tell if the transformation is in expected form or not). |
||||||
|
If you restrict yourselves (e.g. only uniform scaling and no skew), the matrix |
||||||
|
can be reorthogonalized using Algorithms::gramSchmidtOrthogonalize() (or |
||||||
|
Algorithms::gramSchmidtOrthonormalize(), if you don't have any scaling). You can |
||||||
|
also use Algorithms::svd() to more precisely (but way more slowly) account for |
||||||
|
the drift. Example: |
||||||
|
@code |
||||||
|
Matrix4 transformation; |
||||||
|
Math::Algorithms::gramSchmidtOrthonormalizeInPlace(transformation); |
||||||
|
@endcode |
||||||
|
|
||||||
|
For quaternions and complex number this problem can be solved far more easily |
||||||
|
using Complex::normalized(), Quaternion::normalized(), DualComplex::normalized() |
||||||
|
and DualQuaternion::normalized(). Transformation quaternions and complex numbers |
||||||
|
are always of unit length, thus normalizing them reduces the drift. |
||||||
|
@code |
||||||
|
DualQuaternion transformation; |
||||||
|
transformation = transformation.normalized(); |
||||||
|
@endcode |
||||||
|
*/ |
||||||
|
}} |
||||||
Loading…
Reference in new issue