3ds Max C++ API Reference
RotationValue Class Reference

#include <euler.h>

Public Types

enum  EulerType {
  kXYZ = EULERTYPE_XYZ , kXZY , kYZX , kYXZ ,
  kZXY , kZYX , kXYX , kYZY ,
  kZXZ
}
 
enum  { kReptd = kXYX , kQuat = 100 }
 

Public Member Functions

void Set (const Point3 &a, EulerType et)
 
void Set (const Quat &q)
 
 RotationValue ()
 
 RotationValue (const Point3 &a, EulerType et)
 
 RotationValue (const Quat &q)
 
 RotationValue (const RotationValue &src)
 
Point3 Euler (EulerType et=kXYZ) const
 
 operator Quat () const
 
 operator Matrix3 () const
 
void PreApplyTo (Matrix3 &m) const
 
void PostApplyTo (Matrix3 &m) const
 
void PostRotate (const AngAxis &aa)
 
int NativeRep () const
 
Quat GetNative () const
 

Static Public Member Functions

static bool IsEuler (int rep)
 
static bool IsRepetitive (int rep)
 
static bool IsQuat (int rep)
 

Static Public Attributes

static const int kAxisToOrdinal [kReptd][3]
 
static const int kOrdinalToAxis [kZXZ+1][3]
 

Protected Member Functions

Point3 ToEulerAngles (EulerType et) const
 
Quat ToQuat () const
 

Detailed Description

Note
This class is only available in release 5 or later.

This class is to hold different representations of the rotation. In particular, it holds rotation value as represented by Euler angles or quaternion. Different types of rotation controllers may use different representations. To avoid losing information due to converting from one representation to another, we can use RotationValue to hold the result.

For example, the Skin pose feature reads rotation of a node from the rotation controller and stores the result in RotationValue (c.f. maxsdk/include/iSkinPose.h).

// Assuming node is a valid pointer to INode.
// skpose should not be null for Max version 5.0 or later.
RotationValue rv = skpose-\>SkinRot();
Definition: iSkinPose.h:31
static ISkinPose * GetISkinPose(INode &n)
Definition: iSkinPose.h:43
Definition: euler.h:96

It is guaranteed that rv keeps the original representation of the controller.

Being asked of Euler angles, RotationValue will return 3 float numbers in the format of Point3. There must be an association between numbers and axes.

There are two classes of Euler angle types. In one class, the rotation axes are not repeated (non-repetitive). They are enum's from kXYZ to kZYX. In the other class, one of the rotation axes is repeated (repetitive). They are enum's from kXYX to kZXZ. For convenience, enum kReptd is used to denote the starting one: kRept == kXYX.

For non-repetitive Euler angles, there are two well-defined methods to associate three ordered angles, to three axes.

First, we can associate angles with x-, y-, and z-, axes, respectively. The first angle, for example, is always associated with the x-axis, no matter where it appears in the Euler order. Suppose

Point3 a(0.1, 0.2, 0.3)

then a.x (==0.1), a.y(==0.2), a.z (==0.3), are the angles of the x-axis, y-axis, and z-axis, respectively, no matter whether the order (type) of the Euler angles is kXYZ or kZXY.

Let's call this way of association by axis (name).

Second, we can associate them by position: the first angle, from left, is always associated with the first axis in the Euler angle order. For examples, the first angle is applied to the x-axis for kXYZ and kXZY, but to the y-axis for kYXZ and kYZX, etc. Suppose a is a Point3, a0, a1, a2, are the angles of the z-axis, x-axis, and y-axis, respectively, for Euler type kZXY.

Let's call this way of association by order.

For repetitive Euler type, the association by axis is ambiguous because one axis may appear twice in the Euler axes. In this case, "by order" is well defined.

This class uses the association of by axis for non-repetitive types and by order for repetitive type. Suppose,

Point3 a = rv.Euler(RotationValue::kZXZ) // repetitive Euler type

Then, a[0] and a[2] are both applied to the Z axis, but a[0] corresponds to the first z-axis from left, a[2] corresponds to the second z-axis (third axis) from left, and a[1] corresponds to the x-axis.

Member Enumeration Documentation

◆ EulerType

enum EulerType
Enumerator
kXYZ 
kXZY 
kYZX 
kYXZ 
kZXY 
kZYX 
kXYX 
kYZY 
kZXZ 
124  {
126  kXZY,
127  kYZX,
128  kYXZ,
129  kZXY,
130  kZYX,
131  kXYX,
132  kYZY,
133  kZXZ
134  };
@ kZXY
Definition: euler.h:129
@ kXZY
Definition: euler.h:126
@ kZYX
Definition: euler.h:130
@ kYXZ
Definition: euler.h:128
@ kZXZ
Definition: euler.h:133
@ kXYX
Definition: euler.h:131
@ kYZX
Definition: euler.h:127
@ kXYZ
Definition: euler.h:125
@ kYZY
Definition: euler.h:132
#define EULERTYPE_XYZ
Definition: euler.h:21

◆ anonymous enum

anonymous enum
Enumerator
kReptd 
kQuat 
136  {
137  kReptd = kXYX,
138  kQuat = 100
139  };
@ kReptd
Definition: euler.h:137
@ kQuat
Definition: euler.h:138

Constructor & Destructor Documentation

◆ RotationValue() [1/4]

RotationValue ( )
inline
Remarks
Constructor
190  : mQ()
191  , mRep(kXYZ)
192  {
193  }

◆ RotationValue() [2/4]

RotationValue ( const Point3 a,
EulerType  et 
)
inline
Remarks
Constructor
196  {
197  Set(a, et);
198  }
void Set(const Point3 &a, EulerType et)
Definition: euler.h:173

◆ RotationValue() [3/4]

RotationValue ( const Quat q)
inline
Remarks
K Prototype

Constructor.
202  {
203  Set(q);
204  }

◆ RotationValue() [4/4]

RotationValue ( const RotationValue src)
inline
Remarks
Copy constructor.
207  : mQ(src.mQ)
208  , mRep(src.mRep)
209  {
210  }

Member Function Documentation

◆ IsEuler()

static bool IsEuler ( int  rep)
inlinestatic
Remarks
Conveniency (static) method to test whether an integer corresponds to an enum of rotation representations used in RotationValue of type Euler angles

145  {
146  return (kXYZ <= rep && rep <= kZXZ);
147  }

◆ IsRepetitive()

static bool IsRepetitive ( int  rep)
inlinestatic
Remarks
Conveniency (static) method to test whether in cases where a call to IsEuler(int rep) is made, and the return value is of type Euler angles, this method call returns whether it has repetitive axes (such as XYX).

154  {
155  // Pre-cond: IsEuler(rep)
156  return rep >= kReptd;
157  }

◆ IsQuat()

static bool IsQuat ( int  rep)
inlinestatic
Remarks
Conveniency (static) method to test whether an integer corresponds to an enum of rotation representations used in RotationValue of type Quaternion.

163  {
164  return rep == kQuat;
165  }

◆ Set() [1/2]

void Set ( const Point3 a,
EulerType  et 
)
inline
Remarks
Set an object of RotationValue to an Euler angle representation. Angles are assumed in radians. To set to Euler angles of x, y, z, of order XYZ, do, for example:

RotationValue a;

a.Set(Point3(x, y, z), RotationValue::kXYZ);

174  {
175  mQ.x = a.x;
176  mQ.y = a.y;
177  mQ.z = a.z;
178  mRep = (short)et;
179  }
float y
Definition: point3.h:57
float x
Definition: point3.h:56
float z
Definition: point3.h:58
float y
Definition: quat.h:177
float x
Definition: quat.h:176
float z
Definition: quat.h:178

◆ Set() [2/2]

void Set ( const Quat q)
inline
Remarks
Set an object of RotationValue to a quaternion representation.

184  {
185  mQ = q;
186  mRep = kQuat;
187  }

◆ Euler()

Point3 Euler ( EulerType  et = kXYZ) const
inline
Remarks
Used to get the rotation in specific representation. Suppose rv is a RotationValue, to get it in terms of Euler angles of order XYZ:

rv.Euler();

in order ZXY:

rv.Euler(RotationValue::kZXY);

or, to get it in quaternion:

(Quat)rv;

to get it in matrix form:

(Matrix3)rv
222  {
223  if (et == mRep)
224  return Point3(mQ.x, mQ.y, mQ.z);
225  else
226  return ToEulerAngles(et);
227  }
Definition: point3.h:54
Point3 ToEulerAngles(EulerType et) const

◆ operator Quat()

operator Quat ( ) const
inline
Remarks
Please see method Euler() for fuller explanation.
230  {
231  if (mRep == kQuat)
232  return mQ;
233  else
234  return ToQuat();
235  }
Quat ToQuat() const

◆ operator Matrix3()

operator Matrix3 ( ) const
Remarks
Please see method Euler() for fuller explanation.

◆ PreApplyTo()

void PreApplyTo ( Matrix3 m) const
Remarks
Given a matrix, m, we can apply the rotation, rv, of RotationValue from left side (PreApplyTo)

rv.PreApplyTo(m) == ((Matrix3)rv) * m

◆ PostApplyTo()

void PostApplyTo ( Matrix3 m) const
Remarks
Given a matrix, m, we can apply the rotation, rv, of RotationValue from right side (PoseApplyTo)

rv.PoseApplyTo(m) == m * (Matrix3)rv)

◆ PostRotate()

void PostRotate ( const AngAxis aa)
Remarks
To apply a rotation, aa, as represented as AngAxis to a RotationValue, rv, from the right side,

rv.PostRotate(aa)

The internal representation of rv after applying to it will not be change. Mathematically,

(Matrix3)rv.PostRotate(aa) == ((Matrix3)rv) * MatrixOf(aa)

If rv is in Euler angles, this method will try to keep the Euler angles from jumping at the borders of (+/-)180 degrees.

◆ NativeRep()

int NativeRep ( ) const
inline
Remarks
Used to get the internal representation and returns the representation type. If it is a Euler angle type, the first three numbers of the Quat returned from GetNative() are to be interpreted as Euler angles.
263  {
264  return mRep;
265  }

◆ GetNative()

Quat GetNative ( ) const
inline
Remarks
Used to get the internal representation and returns the actual float numbers.
269  {
270  return mQ;
271  }

◆ ToEulerAngles()

Point3 ToEulerAngles ( EulerType  et) const
protected

◆ ToQuat()

Quat ToQuat ( ) const
protected

Member Data Documentation

◆ kAxisToOrdinal

const int kAxisToOrdinal[kReptd][3]
static

◆ kOrdinalToAxis

const int kOrdinalToAxis[kZXZ+1][3]
static