implementation of the constructors

CONSTRUCTOR for identical float-types. It initializes a Matrix33 with 9 floats. Matrix33(0,1,2, 3,4,5, 6,7,8);

CONSTRUCTOR for different float-types. It initializes a Matrix33 with 3 vectors stored in the columns and converts between floats/doubles. Matrix33r(v0,v1,v2);

CONSTRUCTOR for different float-types. It converts a Diag33 into a Matrix33 and also converts between double/float. Matrix33(diag33);

CONSTRUCTOR for different float-types. It converts a Matrix34 into a Matrix33 and converts between double/float. Needs to be 'explicit' because we loose the translation vector in the conversion process. Matrix33(m34r);

CONSTRUCTOR for different float-types. It converts a Matrix44 into a Matrix33 and converts between double/float. Needs to be 'explicit' because we loose the translation vector and the 3rd row in the conversion process. Matrix33(m44r);

CONSTRUCTOR for different float-types. It converts a Quat into a Matrix33 and converts between double/float. Needs to be 'explicit' because we loose fp-precision in the conversion process. Matrix33(quatr);

CONSTRUCTOR for different float-types. It converts a Euler Angle into a Matrix33 and converts between double/float. Needs to be 'explicit' because we loose fp-precision in the conversion process. Matrix33(Ang3r(1,2,3));

Calculate 2 vector that form a orthogonal base with a given input vector (by M.M.).

Parameters

invDirection	input direction (has to be normalized)
outvA	first output vector that is perpendicular to the input direction
outvB	second output vector that is perpendicular the input vector and the first output vector

Calculate a real inversion of a Matrix33. An inverse-matrix is an UnDo-matrix for all kind of transformations.

Note

If the return value of Invert33() is zero, then the inversion failed! Example 1: Matrix33 im33; bool st=i33.Invert(); assert(st); Example 2: matrix33 im33=Matrix33::GetInverted(m33);

Bracket OPERATOR: initializes a Matrix33 with 9 floats. Matrix33 m; m(0,1,2, 3,4,5, 6,7,8);

Note

All vectors are stored in columns.

Create a rotation matrix around an arbitrary axis (Eulers Theorem). The axis is specified as a normalized Vec3. The angle is assumed to be in radians. Example: Matrix34 m34; Vec3 axis=GetNormalized( Vec3(-1.0f,-0.3f,0.0f) ); m34.SetRotationAA( rad, axis );

Creates a rotation matrix that rotates the vector "v0" into "v1". If both vectors are exactly parallel it returns an identity-matrix. CAUTION: If both vectors are exactly diametrical it returns a matrix that rotates pi-radians about a "random" axis that is orthogonal to v0. CAUTION: If both vectors are almost diametrical we have to normalize a very small vector and the result is inaccurate. It is recommended to use this function with 64-bit precision.

Given a view-direction and a radiant to rotate about Y-axis, this function builds a 3x3 look-at matrix using only simple vector arithmetic. This function is always using the implicit up-vector Vec3(0,0,1). The view-direction is always stored in column(1). IMPORTANT: The view-vector is assumed to be normalized, because all trig-values for the orientation are being extracted directly out of the vector. This function must NOT be called with a view-direction that is close to Vec3(0,0,1) or Vec3(0,0,-1). If one of these rules is broken, the function returns a matrix with an undefined rotation about the Z-axis.

Rotation order for the look-at-matrix is Z-X-Y. (Zaxis=YAW / Xaxis=PITCH / Yaxis=ROLL) Example: Matrix33 orientation=Matrix33::CreateRotationVDir( Vec3(0,1,0), 0 );

COORDINATE-SYSTEM

z-axis ^ | | y-axis | / | / |/ +------------—> x-axis

Parameters

vdir	normalized view direction.
roll	radiant to rotate about Y-axis.

Create rotation-matrix about X axis using an angle. The angle is assumed to be in radians. Example: Matrix m33; m33.SetRotationX(0.5f);

Direct-Matrix-Slerp: for the sake of completeness, I have included the following expression for Spherical-Linear-Interpolation without using quaternions. This is much faster then converting both matrices into quaternions in order to do a quaternion slerp and then converting the slerped quaternion back into a matrix. This is a high-precision calculation. Given two orthonormal 3x3 matrices this function calculates the shortest possible interpolation-path between the two rotations. The interpolation curve forms a great arc on the rotation sphere (geodesic). Not only does Slerp follow a great arc it follows the shortest great arc. Furthermore Slerp has constant angular velocity. All in all Slerp is the optimal interpolation curve between two rotations.

STABILITY PROBLEM: There are two singularities at angle=0 and angle=PI. At 0 the interpolation-axis is arbitrary, which means any axis will produce the same result because we have no rotation. Thats why I'm using (1,0,0). At PI the rotations point away from each other and the interpolation-axis is unpredictable. In this case I'm also using the axis (1,0,0). If the angle is ~0 or ~PI, then we have to normalize a very small vector and this can cause numerical instability. The quaternion-slerp has exactly the same problems. Example: Matrix33 slerp=Matrix33::CreateSlerp( m,n,0.333f );