MPxTransformationMatrix Class Reference
[OpenMaya - API module for common classesProxy classes]

#include <MPxTransformationMatrix.h>
Collaboration diagram for MPxTransformationMatrix:
Collaboration graph
[legend]

List of all members.


Detailed Description

Base class of all user defined transformation matrices.

MPxTransformationMatrix is the parent class for all user defined transformation matrices. A transformation matrix is a class that holds the individual components (i.e. translate, rotate, scale, pivots, etc.) that are used to construct a 4x4 matrix. Given that different combinations of transform components may produce similar 4x4 matrices, it is not always possible to get a generic 4x4 matrix and decompose it into unique components. This class allows better control over which components are changed than a generic 4x4 MMatrix could offer.

The MPxTransformationMatrix class is designed for use as the mathematical brains behind the MPxTransform node. This separation is useful for class reuse (different types of MPxTransform nodes may still use the same MPxTransformationMatrix class) as well as simplifying the MPxTransform class.

The MPxTransformationMatrix class is registered using the MFnPlugin::registerTransform() method. Both the MPxTransform and the MPxTransformationMatrix classes are registered in the same method. This allows for a clear association between a MPxTransform and a MPxTransformationMatrix.

When registering the MPxTransformationMatrix, a MTypeId is required. For nodes using the default MPxTransformationMatrix, a statically defined MTypeId is provided by the MPxTransformationMatrix::baseTransformationMatrixId data member.

Since the MPxTransformationMatrix class gives extended functionality to a native Maya class, several methods are given that are needed by Maya for this class to properly function in different settings.

To create a transformation matrix, derive from this class and overload the creator() method and the assignment operator for the derived class. If any additional data items are added to this class, the copyValues() method should also be overloaded. This will ensure that the new values will get properly handed by Maya. The rest of the methods may be overloaded as needed.

Examples:

rockingTransform.cpp, rockingTransform.h, rockingTransformCheck.cpp, and rockingTransformCheck.h.


Public Member Functions

  MPxTransformationMatrix ()
  MPxTransformationMatrix (const MTransformationMatrix &)
  MPxTransformationMatrix (const MPxTransformationMatrix &)
  MPxTransformationMatrix (const MMatrix &)
virtual  ~MPxTransformationMatrix ()
virtual void  copyValues (MPxTransformationMatrix *)
virtual MTypeId  typeId () const
MPxTransformationMatrix operator= (const MPxTransformationMatrix &src)
MPxTransformationMatrix operator= (const MMatrix &src)
MPxTransformationMatrix operator= (const MTransformationMatrix &src)
bool  operator== (const MPxTransformationMatrix &)
bool  operator!= (const MPxTransformationMatrix &)
bool  operator== (const MTransformationMatrix &)
bool  operator!= (const MTransformationMatrix &)
bool  operator== (const MMatrix &)
bool  operator!= (const MMatrix &)
virtual bool  isEquivalent (const MPxTransformationMatrix &, double tolerance=MMatrix_kTol) const
virtual bool  isEquivalent (const MTransformationMatrix &, double tolerance=MMatrix_kTol) const
virtual bool  isEquivalent (const MMatrix &, double tolerance=MMatrix_kTol) const
virtual MPxTransformationMatrix  reverse () const
virtual MPxTransformationMatrix transformBy (const MTransformationMatrix &)
virtual MMatrix  asMatrix () const
virtual MMatrix  asMatrixInverse () const
virtual MMatrix  asScaleMatrix () const
virtual MMatrix  asScaleMatrixInverse () const
virtual MMatrix  asRotateMatrix () const
virtual MMatrix  asRotateMatrixInverse () const
virtual MMatrix  asMatrix (double percent) const
virtual MMatrix  asInterpolationMatrix (const MTransformationMatrix &toM, double percent, bool rot, int direction=0) const
virtual MTransformationMatrix  asTransformationMatrix () const
virtual MVector  translation (MSpace::Space=MSpace::kTransform, MStatus *ReturnStatus=NULL) const
virtual MStatus  translateTo (const MVector &vector, MSpace::Space=MSpace::kTransform)
virtual MStatus  translateBy (const MVector &vector, MSpace::Space=MSpace::kTransform)
virtual MQuaternion  rotation (MSpace::Space=MSpace::kTransform, MStatus *ReturnStatus=NULL) const
virtual MEulerRotation  eulerRotation (MSpace::Space space=MSpace::kTransform, MStatus *ReturnStatus=NULL) const
virtual MStatus  rotateTo (const MQuaternion &q, MSpace::Space=MSpace::kTransform)
virtual MStatus  rotateBy (const MQuaternion &q, MSpace::Space=MSpace::kTransform)
virtual MStatus  rotateTo (const MEulerRotation &e, MSpace::Space=MSpace::kTransform)
virtual MStatus  rotateBy (const MEulerRotation &e, MSpace::Space=MSpace::kTransform)
virtual
MTransformationMatrix::RotationOrder 
rotationOrder (MStatus *ReturnStatus=NULL) const
virtual MStatus  setRotationOrder ( MTransformationMatrix::RotationOrder, bool preserve=true)
virtual MQuaternion  rotateOrientation (MSpace::Space=MSpace::kTransform, MStatus *ReturnStatus=NULL) const
virtual MStatus  setRotateOrientation (const MQuaternion &q, MSpace::Space=MSpace::kTransform, bool balance=true)
virtual MEulerRotation  eulerRotateOrientation (MSpace::Space=MSpace::kTransform, MStatus *ReturnStatus=NULL) const
virtual MStatus  setRotateOrientation (const MEulerRotation &euler, MSpace::Space=MSpace::kTransform, bool balance=true)
virtual MVector  scale (MSpace::Space=MSpace::kTransform, MStatus *ReturnStatus=NULL) const
virtual MStatus  scaleTo (const MVector &, MSpace::Space=MSpace::kTransform)
virtual MStatus  scaleBy (const MVector &, MSpace::Space=MSpace::kTransform)
virtual MVector  shear (MSpace::Space=MSpace::kTransform, MStatus *ReturnStatus=NULL) const
virtual MStatus  shearTo (const MVector &shear, MSpace::Space=MSpace::kTransform)
virtual MStatus  shearBy (const MVector &shear, MSpace::Space=MSpace::kTransform)
virtual MPoint  scalePivot (MSpace::Space=MSpace::kTransform, MStatus *ReturnStatus=NULL) const
virtual MStatus  setScalePivot (const MPoint &, MSpace::Space=MSpace::kTransform, bool balance=true)
virtual MVector  scalePivotTranslation (MSpace::Space=MSpace::kTransform, MStatus *ReturnStatus=NULL) const
virtual MStatus  setScalePivotTranslation (const MVector &vector, MSpace::Space=MSpace::kTransform)
virtual MPoint  rotatePivot (MSpace::Space=MSpace::kTransform, MStatus *ReturnStatus=NULL) const
virtual MStatus  setRotatePivot (const MPoint &, MSpace::Space=MSpace::kTransform, bool balance=true)
virtual MVector  rotatePivotTranslation (MSpace::Space=MSpace::kTransform, MStatus *ReturnStatus=NULL) const
virtual MStatus  setRotatePivotTranslation (const MVector &vector, MSpace::Space=MSpace::kTransform)
virtual MStatus  unSquishIt ()
virtual MMatrix  unSquishMatrix () const

Static Public Member Functions

static MPxTransformationMatrix creator ()
static
MEulerRotation::RotationOrder 
convertTransformationRotationOrder ( MTransformationMatrix::RotationOrder, MStatus *ReturnStatus=NULL)
static
MTransformationMatrix::RotationOrder 
convertEulerRotationOrder (MEulerRotation::RotationOrder, MStatus *ReturnStatus=NULL)
static
MEulerRotation::RotationOrder 
convertRotationOrder ( MTransformationMatrix::RotationOrder, MStatus *ReturnStatus=NULL)
  This method is obsolete. This method is not available in Python.
static
MTransformationMatrix::RotationOrder 
convertRotationOrder (MEulerRotation::RotationOrder, MStatus *ReturnStatus=NULL)
  This method is obsolete. This method is not available in Python.

Static Public Attributes

static const
MPxTransformationMatrix 
identity
  The identity transformation matrix.
static MTypeId  baseTransformationMatrixId = MTypeId(0x58A00001)
  Type id for the default MPxTransformationMatrix.

Protected Member Functions

virtual MStatus  decomposeMatrix (const MMatrix &)

Protected Attributes

MVector  scaleValue
  Scale component of transformation.
MEulerRotation  rotationValue
  Rotation component of transformation.
MVector  translationValue
  Translation component of transformation.
MVector  shearValue
  Shear component of transformation.
MPoint  scalePivotValue
  Position of pivot used for scaling.
MVector  scalePivotTranslationValue
  Translation to compensate for movement of the scale pivot.
MPoint  rotatePivotValue
  Position of pivot used for rotation.
MVector  rotatePivotTranslationValue
  Translation to compensate for movement of the rotate pivot.
MQuaternion  rotateOrientationValue
  Orientation of the local rotation space.

Friends

std::ostream &  operator<< (std::ostream &os, const MPxTransformationMatrix &m)
  This method is not available in Python.

Constructor & Destructor Documentation

MPxTransformationMatrix::MPxTransformationMatrix (  ) 

Class Constructor.

MPxTransformationMatrix::MPxTransformationMatrix ( const MTransformationMatrix src  ) 

Class constructor.

The contents of the passed MTransformationMatrix are used to initialize the new MPxTransformationMatrix.

Parameters:
[in]  src  matrix to be copied.

MPxTransformationMatrix::MPxTransformationMatrix ( const MPxTransformationMatrix src  ) 

A copy constructor.

The contents of the passed MPxTransformationMatrix are used to initialize this MPxTransformationMatrix.

Parameters:
[in]  src  The transformation matrix to copy.

MPxTransformationMatrix::MPxTransformationMatrix ( const MMatrix src  ) 

MMatrix copy constructor.

The contents of the passed MMatrix are used to initialize the new MPxTransformationMatrix. In order to fill the individual components of the transformation matrix, decomposeMatrix() is called with the passed MMatrix.

Parameters:
[in]  src  The matrix used for transformation initialization.

MPxTransformationMatrix::~MPxTransformationMatrix (  )  [virtual]

Class destructor.


Member Function Documentation

void MPxTransformationMatrix::copyValues ( MPxTransformationMatrix xform  )  [virtual]

This method should be overridden for any transform that uses more then the default transform values. The values from the passed class (which should be type checked and downcast to its appropriate value) should be copied to this class.

Without this method being overridden, only the default transform components will get copied.

Parameters:
[in]  xform  The user defined transformation matrix that should be copied.

MTypeId MPxTransformationMatrix::typeId (  )  const [virtual]

Returns the MTypeId of this transformation matrix. The MTypeId is a four byte identifier that uniquely identifies this type of transformation matrix.

Returns:
Type id of the transformation matrix.

MPxTransformationMatrix & MPxTransformationMatrix::operator= ( const MPxTransformationMatrix src  ) 

Assignment operator.

Parameters:
[in]  src  User defined transformation matrix to be copied.

MPxTransformationMatrix & MPxTransformationMatrix::operator= ( const MMatrix src  ) 

Assignment operator.

In order to convert the MMatrix to a MPxTransformationMatrix, decomposeMatrix() will be called.

Parameters:
[in]  src  The matrix to copy.

MPxTransformationMatrix & MPxTransformationMatrix::operator= ( const MTransformationMatrix src  ) 

Assignment operator.

Parameters:
[in]  src  Transformation matrix to be copied.

bool MPxTransformationMatrix::operator== ( const MPxTransformationMatrix rhs  ) 

Equality operator

Parameters:
[in]  rhs  The user defined transformation matrix to compare.
Returns:
Boolean value: true if the transformation matrices are identical, false otherwise.

bool MPxTransformationMatrix::operator!= ( const MPxTransformationMatrix rhs  ) 

Inequality operator

This method will compare the resulting 4x4 matrices for inequality.

Parameters:
[in]  rhs  The user defined transformation matrix to compare.
Returns:
Boolean value: true The transformation matrices are not identical false otherwise.

bool MPxTransformationMatrix::operator== ( const MTransformationMatrix rhs  ) 

Equality operator

This method will compare the resulting 4x4 matrices for equality.

Parameters:
[in]  rhs  The user defined transformation matrix to compare.
Returns:
Boolean value: true The transformation matrices are identical, false otherwise.

bool MPxTransformationMatrix::operator!= ( const MTransformationMatrix rhs  ) 

Inequality operator.

This method will compare the resulting 4x4 matrices for inequality.

Parameters:
[in]  rhs  The MTransformationMatrix to compare.
Returns:
Boolean value: true The matrices are not identical, false otherwise.

bool MPxTransformationMatrix::operator== ( const MMatrix rhs  ) 

Equality operator

Parameters:
[in]  rhs  the MMatrix to compare
Returns:
Boolean value: true The matrices are identical, false otherwise.

bool MPxTransformationMatrix::operator!= ( const MMatrix rhs  ) 

Equality operator.

This method will compare the resulting 4x4 matrices for equality.

Parameters:
[in]  rhs  The MMatrix to compare.
Returns:
Boolean value: true The matrices are not identical, false otherwise.

bool MPxTransformationMatrix::isEquivalent ( const MPxTransformationMatrix other,
double  tolerance = MMatrix_kTol  
) const [virtual]

Determine if the MPxTransformationMatrix is equivalent within a specified tolerance. The comparison is done with the resulting 4x4 MMatrix and not on a component by component basis.

Parameters:
[in]  other  The user defined transformation matrix to compare to.
[in]  tolerance  The tolerance used in the comparison.
Returns:
Boolean value; true The matrices are identical within the specified tolerance, false otherwise.

bool MPxTransformationMatrix::isEquivalent ( const MTransformationMatrix other,
double  tolerance = MMatrix_kTol  
) const [virtual]

Determine if the MTransformationMatrix is equivalent within a specified tolerance. The comparison is done with the resulting 4x4 MMatrix and not on a component by component basis.

Parameters:
[in]  other  The transformation matrix to compare to
[in]  tolerance  The tolerance used in the comparison.
Returns:
Boolean value; true The matrices are identical within the specified tolerance, false otherwise.

bool MPxTransformationMatrix::isEquivalent ( const MMatrix other,
double  tolerance = MMatrix_kTol  
) const [virtual]

Determine if the MMatrix is equivalent within a specified tolerance.

Parameters:
[in]  other  The matrix to compare to.
[in]  tolerance  The tolerance used in the comparison.
Returns:
Boolean value; true The matrices are identical within the specified tolerance, false otherwise.

MPxTransformationMatrix MPxTransformationMatrix::reverse (  )  const [virtual]

Returns the negated translate, rotate, and scale without taking the pivots into account.

Returns:
The reversed transformation matrix

MPxTransformationMatrix & MPxTransformationMatrix::transformBy ( const MTransformationMatrix transMat  )  [virtual]

Transforms the transformation matrix by the passed MTransformationMatrix. The individual components are considered with the exception of the pivot translations.

Parameters:
[in]  transMat  The transformation matrix to transform by.
Returns:
This transformation matrix.

MMatrix MPxTransformationMatrix::asMatrix (  )  const [virtual]

Returns the four by four matrix that describes this transformation. The default matrix math is defined by:

           -1                     -1
        [Sp]x[S]x[Sh]x[Sp]x[St]x[Rp]x[Ro]x[R]x[Rp]x[Rt]x[T]

Where [Sp] is the scale pivot, [S] is the scale matrix, [Sh] is the shear matrix, [St] is the scale pivot translation, [Rp] is the rotate pivot, [Ro] is the rotate orientation, [R] is the rotate matrix, [Rt] is the rotate picot translation, and [T] is the translation.

Returns:
The resulting matrix.
Examples:

MMatrix MPxTransformationMatrix::asMatrixInverse (  )  const [virtual]

Returns the inverse of the four by four matrix that describes this transformation.

By default this is described as:

             -1                     -1                         -1
        [ [Sp]x[S]x[Sh]x[Sp]x[St]x[Rp]x[Ro]x[R]x[Rp]x[Rt]x[T] ]

Where [Sp] is the scale pivot, [S] is the scale matrix, [Sh] is the shear matrix, [St] is the scale pivot translation, [Rp] is the rotate pivot, [Ro] is the rotate orientation, [R] is the rotate matrix, [Rt] is the rotate picot translation, and [T] is the translation.

Returns:
The inverse matrix.

MMatrix MPxTransformationMatrix::asScaleMatrix (  )  const [virtual]

Returns scale matrix. The scale matrix takes points from object space to the space immediately following scale and shear transformations.

For the default matrix, the scale matrix combines the space pivot [Sp], scale [S], shear [Sh], and scale translate [St] components as follows:

           -1
        [Sp]x[S]x[Sh]x[Sp]x[St]

Where [Sp] is the scale pivot, [S] is the scale matrix, [Sh] is the shear matrix, and [St] is the scale pivot translation.

Returns:
The scale matrix.

MMatrix MPxTransformationMatrix::asScaleMatrixInverse (  )  const [virtual]

Returns inverse of the scale matrix. The scale matrix takes points from object space to the space immediately following scale and shear transformations.

By default this value is described by:

             -1                    -1
        [ [Sp]x[S]x[Sh]x[Sp]x[St] ]

Where [Sp] is the scale pivot, [S] is the scale matrix, [Sh] is the shear matrix, and [St] is the scale pivot translation.

Returns:
The inverse space matrix.

MMatrix MPxTransformationMatrix::asRotateMatrix (  )  const [virtual]

Returns the rotate section of the transformation matrix. By default this is described as:

           -1
        [Rp]x[Ro]x[R]x[Rp]

Where [Rp] is the rotate pivot, [Ro] is the rotate orientation, [R] is the rotate matrix, and [Rt] is the rotate pivot translation.

Returns:
The rotate matrix.
Examples:

MMatrix MPxTransformationMatrix::asRotateMatrixInverse (  )  const [virtual]

Returns the inverse of the rotate matrix. By default this is described as:

             -1                    -1
        [ [Rp]x[Ro]x[R]x[Rp]x[Rt] ]

Where [Rp] is the rotate pivot, [Ro] is the rotate orientation, [R] is the rotate matrix, and [Rt] is the rotate picot translation.

Returns:
The inverse rotate matrix.

MMatrix MPxTransformationMatrix::asMatrix ( double  percent  )  const [virtual]

Returns a matrix that represents the specified percentage of this transformation matrix. This is performed on a component basis.

Returns:
The resulting matrix.

MMatrix MPxTransformationMatrix::asInterpolationMatrix ( const MTransformationMatrix toM,
double  percent,
bool  rot,
int  direction = 0  
) const [virtual]

Returns a matrix that represents the specified percentage of this transformation matrix. The two matrices involved in the interpolation are this transformation matrix and the passed transformation matrix, toMatrix.

This is used by clusters.

Parameters:
[in]  toM  The matrix to interpolate to.
[in]  percent  The percentage of the interpolation (between 0 and 1)
[in]  rot  Should the rotation values be included?
[in]  direction  The desired direction of the interpolation.
  • 0 Closest path between this matrix and toMatrix.
  • 1 From this matrix to toMatrix.
  • 2 From toMatrix to this matrix.
Returns:
The interpolated matrix.

MTransformationMatrix MPxTransformationMatrix::asTransformationMatrix (  )  const [virtual]

Returns the custom transformation matrix as a standard MTransformationMatrix.

Returns:
The transformation matrix.

MVector MPxTransformationMatrix::translation ( MSpace::Space  space = MSpace::kTransform,
MStatus ReturnStatus = NULL  
) const [virtual]

Returns the translation component of the transformation matrix as a MVector in centimeters (the internal Maya linear unit).

Parameters:
[in]  space  The space to use.
[out]  ReturnStatus  Return status.
Returns:
The translation vector in centimeters.
Status Codes:

MStatus MPxTransformationMatrix::translateTo ( const MVector t,
MSpace::Space  space = MSpace::kTransform  
) [virtual]

Sets the translate component of the transformation matrix in centimeters.

Parameters:
[in]  t  The new translate value in centimeters.
[in]  space  The space to use.
Returns:
Return status.
Status Codes:

MStatus MPxTransformationMatrix::translateBy ( const MVector t,
MSpace::Space  space = MSpace::kTransform  
) [virtual]

Add to the translate component by translating relative to the existing transformation. The relative translate should be in centimeters.

Parameters:
[in]  t  The relative translate value in centimeters.
[in]  space  The space to use.
Returns:
Return status.
Status Codes:

MQuaternion MPxTransformationMatrix::rotation ( MSpace::Space  space = MSpace::kTransform,
MStatus ReturnStatus = NULL  
) const [virtual]

Returns the rotation component of the transformation matrix as a quaternion. If an invalid space is used, MQuaternion::identity will be returned.

Parameters:
[in]  space  The space in which to get the rotation.
[out]  ReturnStatus  The status.
Returns:
The quaternion that is the rotation component of the transformation matrix
Status Codes:

MEulerRotation MPxTransformationMatrix::eulerRotation ( MSpace::Space  space = MSpace::kTransform,
MStatus ReturnStatus = NULL  
) const [virtual]

Returns the rotation component of the transformation matrix as a euler rotation. If an invalid space is used, MEulerRotation::identity will be returned.

Parameters:
[in]  space  The space in which to get the rotation.
[out]  ReturnStatus  Return status.
Returns:
The euler angle that is the rotation component of the transformation matrix.
Status Codes:
Examples:

MStatus MPxTransformationMatrix::rotateTo ( const MQuaternion quat,
MSpace::Space  space = MSpace::kTransform  
) [virtual]

Sets the rotation component of the transformation matrix using a quaternion.

Parameters:
[in]  quat  The quaternion used to set the rotation component of the transformation matrix.
[in]  space  The space to use.
Returns:
Return status.
Status Codes:
Examples:

MStatus MPxTransformationMatrix::rotateBy ( const MQuaternion quat,
MSpace::Space  space = MSpace::kTransform  
) [virtual]

Rotates relative to the current rotation value of the transformation matrix. By default, the only valid transformation spaces for this method are MSpace::kTransform and MSpace::kPreTransform. All other spaces are treated as being equivalent to MSpace::kTransform.

Parameters:
[in]  quat  The relative rotation as a quaternion.
[in]  space  The space in which the rotation is performed.
Returns:
Return status.
Status Codes:

MStatus MPxTransformationMatrix::rotateTo ( const MEulerRotation euler,
MSpace::Space  space = MSpace::kTransform  
) [virtual]

Sets the rotation component of the transformation matrix using an euler rotation.

Parameters:
[in]  euler  The euler rotation used to set the transformation matrix.
[in]  space  The space used to set the rotation.
Returns:
Return status.
Status Codes:

MStatus MPxTransformationMatrix::rotateBy ( const MEulerRotation euler,
MSpace::Space  space = MSpace::kTransform  
) [virtual]

Rotates relative to the current rotation value of the transformation matrix. By default, the only valid transformation spaces for this method are MSpace::kTransform and MSpace::kPreTransform. All other spaces are treated as being equivalent to MSpace::kTransform.

Parameters:
[in]  euler  The relative rotation as an euler angle.
[in]  space  The space in which the rotation is performed.
Returns:
Return status.
Status Codes:

MTransformationMatrix::RotationOrder MPxTransformationMatrix::rotationOrder ( MStatus ReturnStatus = NULL  )  const [virtual]

Returns the rotation order used by the rotation component of the transformation matrix.

Parameters:
[out]  ReturnStatus  Return status.
Returns:
The rotation order use by the rotation component of the transformation matrix.
Status Codes:

MStatus MPxTransformationMatrix::setRotationOrder ( MTransformationMatrix::RotationOrder  rotOrder,
bool  preserve = true  
) [virtual]

Sets the rotation order used by the rotation component of the transformation matrix.

Parameters:
[in]  rotOrder  The rotation order to use
[in]  preserve  If true then the values will change to preserve the rotation.
Returns:
The return status
Status Codes:

MQuaternion MPxTransformationMatrix::rotateOrientation ( MSpace::Space  space = MSpace::kTransform,
MStatus ReturnStatus = NULL  
) const [virtual]

Returns the rotate orientation for the transformation matrix as a quaternion. The rotate orientation orients the local rotation space.

Parameters:
[in]  space  The space to use.
[out]  ReturnStatus  The return status.
Returns:
The rotate orientation.
Status Codes:

MStatus MPxTransformationMatrix::setRotateOrientation ( const MQuaternion q,
MSpace::Space  space = MSpace::kTransform,
bool  balance = true  
) [virtual]

Sets the rotate orientation for the transformation matrix to the passed euler rotation. The rotate orientation is the rotation that orients the local rotation space.

Parameters:
[in]  q  The rotate orientation.
[in]  space  The space to use.
[in]  balance  If true, the overall rotation will be preserved by altering the rotation to compensate for the change in rotate orientation.
Returns:
Return status.
Status Codes:

MEulerRotation MPxTransformationMatrix::eulerRotateOrientation ( MSpace::Space  space = MSpace::kTransform,
MStatus ReturnStatus = NULL  
) const [virtual]

Returns the rotate orientation for the transformation matrix as an euler rotation. The rotate orientation orients the local rotation space.

Parameters:
[in]  space  The space to use.
[out]  ReturnStatus  Return status.
Returns:
The rotate orientation as an euler angle.
Status Codes:

MStatus MPxTransformationMatrix::setRotateOrientation ( const MEulerRotation euler,
MSpace::Space  space = MSpace::kTransform,
bool  balance = true  
) [virtual]

Sets the rotate orientation for the transformation matrix to the passed quaternion. The rotate orientation is the rotation that orients the local rotation space.

Parameters:
[in]  euler  The rotate orientation.
[in]  space  The space to use.
[in]  balance  If true, the overall rotation will be preserved by altering the rotation to compensate for the change in rotate orientation.
Returns:
Return status.
Status Codes:

MVector MPxTransformationMatrix::scale ( MSpace::Space  space = MSpace::kTransform,
MStatus ReturnStatus = NULL  
) const [virtual]

Returns the scale component of the transformation matrix. If the space is invalid a MVector with all of its components being 1.0 is returned.

Only the scale is returned, without the scale pivot, scale pivot translate, or shear values applied.

Parameters:
[in]  space  transform space in which to get the scale
[out]  ReturnStatus  return status
Returns:
Vector holding the x, y, and z scale components
Status Codes:

MStatus MPxTransformationMatrix::scaleTo ( const MVector newScale,
MSpace::Space  space = MSpace::kTransform  
) [virtual]

Set the scale component of the transformation matrix. If an invalid space is passed, the scale will not be changed.

Parameters:
[in]  newScale  A vector holding the scale components.
[in]  space  The space in which to perform the scale.
Returns:
Return status
Status Codes:

MStatus MPxTransformationMatrix::scaleBy ( const MVector scaleFactor,
MSpace::Space  space = MSpace::kTransform  
) [virtual]

Apply a relative scale to the existing scale.

Parameters:
[in]  scaleFactor  A MVector holding the scale components.
[in]  space  The space in which to perform the scale.
Returns:
Return status.
Status Codes:

MVector MPxTransformationMatrix::shear ( MSpace::Space  space = MSpace::kTransform,
MStatus ReturnStatus = NULL  
) const [virtual]

Returns the shear component of the transformation matrix.

Parameters:
[in]  space  The space to use.
[out]  ReturnStatus  Return status.
Returns:
A MVector holding the xy, xz, yz values of shear.
Status Codes:

MStatus MPxTransformationMatrix::shearTo ( const MVector newShear,
MSpace::Space  space = MSpace::kTransform  
) [virtual]

Sets the shear component of the transformation matrix.

Parameters:
[in]  newShear  The new shear value.
[in]  space  The space to use for setting the shear.
Returns:
Return status.
Status Codes:

MStatus MPxTransformationMatrix::shearBy ( const MVector shearOffset,
MSpace::Space  space = MSpace::kTransform  
) [virtual]

Apply a new shear to the existing shear component of the transformation matrix. The shear values are added by multiplying the individual shear components with the offset values.

Parameters:
[in]  shearOffset  The relative shear value.
[in]  space  The space to use.
Returns:
Return status.
Status Codes:

MPoint MPxTransformationMatrix::scalePivot ( MSpace::Space  space = MSpace::kTransform,
MStatus ReturnStatus = NULL  
) const [virtual]

Returns the pivot used by the scale. The value is in centimeters.

Parameters:
[in]  space  The space to use.
[out]  ReturnStatus  Return status.
Returns:
The scale pivot point.
Status Codes:

MStatus MPxTransformationMatrix::setScalePivot ( const MPoint scalePivot,
MSpace::Space  space = MSpace::kTransform,
bool  balance = true  
) [virtual]

Set the pivot used by the scale.

If balance if true, then the overall transformation matrix will not change and a compensating translation will be added to the scale pivot transformation to achieve this.

If an invalid space is used, the scale pivot will not change.

Parameters:
[in]  scalePivot  The new scale pivot value.
[in]  space  The space to use.
[in]  balance  Set true is the overall transform should remain unchanged after setting the new scale pivot value.
Returns:
Return status.
Status Codes:

MVector MPxTransformationMatrix::scalePivotTranslation ( MSpace::Space  space = MSpace::kTransform,
MStatus ReturnStatus = NULL  
) const [virtual]

Returns the scale pivot translation, which is used to compensate for changes of the scale pivot.

Parameters:
[in]  space  The space to use.
[out]  ReturnStatus  Return status.
Returns:
The scale pivot translation.
Status Codes:

MStatus MPxTransformationMatrix::setScalePivotTranslation ( const MVector v,
MSpace::Space  space = MSpace::kTransform  
) [virtual]

Set the scale pivot translation. When the scale pivot is changed, there is an option to automatically compensate for the change so that the overall transformation is not altered. The compensating factor is the scale pivot translation.

This method will manually change the scale pivot translation.

Parameters:
[in]  v  The new scale pivot translation.
[in]  space  The space to use.
Returns:
Return status.
Status Codes:

MPoint MPxTransformationMatrix::rotatePivot ( MSpace::Space  space = MSpace::kTransform,
MStatus ReturnStatus = NULL  
) const [virtual]

Returns the pivot used by the rotation.

Parameters:
[in]  space  The space to use.
[out]  ReturnStatus  Return status.
Returns:
The rotation pivot point.
Status Codes:

MStatus MPxTransformationMatrix::setRotatePivot ( const MPoint rotatePivot,
MSpace::Space  space = MSpace::kTransform,
bool  balance = true  
) [virtual]

Set the pivot used by the rotation.

If balance if true, then the overall transformation will not change and a compensating translation will be added to the rotation transformation to achieve this.

For the default case, the balance calculation is as follows:

    Let [Rp] be the previous rotate pivot and [Rt] be the previous
    rotate pivot translation. The new rotate pivot will be marked as
    [Rp'] and the new rotate pivot translation as [Rt']

    If balance is true the entire rotate section of the transform
    must be the same before and after the rotate pivot is changed:

       -1                         -1
    [Rp]x[Ro]x[R]x[Rp]x[Rt] = [Rp']x[Ro]x[R]x[Rp']x[Rt']

    solving for [Rt'] produces:
                 -1               -1     -1
    [Rt'] = [[Rp']x[Ro]x[R]x[Rp']]  x  [Rp]x[Ro]x[R]x[Rp]x[Rt]
Parameters:
[in]  rotatePivot  The new rotate pivot.
[in]  space  The space to use.
[in]  balance  Set true is the overall transform should remain unchanged after setting the new rotate pivot value.
Returns:
Return status.
Status Codes:

MVector MPxTransformationMatrix::rotatePivotTranslation ( MSpace::Space  space = MSpace::kTransform,
MStatus ReturnStatus = NULL  
) const [virtual]

Returns the rotate pivot translation, which is used to compensate for changes of the rotate pivot.

Parameters:
[in]  space  The space to use.
[out]  ReturnStatus  Return status.
Returns:
The rotate pivot translation.
Status Codes:

MStatus MPxTransformationMatrix::setRotatePivotTranslation ( const MVector v,
MSpace::Space  space = MSpace::kTransform  
) [virtual]

Set the rotate pivot translation. When the scale pivot is changed, there is an option to automatically compensate for the change so that the overall transformation is not altered. The compensating factor is the rotate pivot translation.

See the documentation for setRotatePivot for an explanation of the compensating calculation.

Parameters:
[in]  v  The new rotate pivot translation.
[in]  space  The space to use.
Returns:
Return status.
Status Codes:

MStatus MPxTransformationMatrix::unSquishIt (  )  [virtual]

Remove any shearing and any non-proportional scaling from this transform. If the scaling is non-proportional, then the maximum scale of the three scale axes will be used on all of the scale axes.

If new scaling or shearing types are added to a derived class, this method should be overloaded.

Returns:
Return status.
Status Codes:

MMatrix MPxTransformationMatrix::unSquishMatrix (  )  const [virtual]

Remove any shearing and any non-proportional scaling. If the scaling is non-proportional, then the maximum scale of the three scale axes will be used on all of the scale axes. The method creates a new 4x4 MMatrix and leaves this transformation matrix unchanged.

If new scaling or shearing types are added to a derived class, this method should be overloaded.

Returns:
The unsquished 4x4 matrix.
Status Codes:

MPxTransformationMatrix * MPxTransformationMatrix::creator (  )  [static]

A method to use when registering a custom transform that uses a default MPxTransformationMatrix.

The caller is responsible for deleting the memory created by this method.

Returns:
The new MPxTransformationMatrix
Examples:

MEulerRotation::RotationOrder MPxTransformationMatrix::convertTransformationRotationOrder ( MTransformationMatrix::RotationOrder  xformOrder,
MStatus ReturnStatus = NULL  
) [static]

Convert from MTransformationMatrix::RotationOrder to MEulerRotation::RotationOrder. If MTransformationMatrix::kLast or MTransformationMatrix::kInvalid is passed in, MEulerRotation::kXYZ will be returned along with a kInvalidParameter return status.

Parameters:
[in]  xformOrder  The MTransformationMatrix::RotationOrder
[out]  ReturnStatus  return status
Returns:
The corresponding MEulerRotation::RotationOrder.
Status Codes:

MTransformationMatrix::RotationOrder MPxTransformationMatrix::convertEulerRotationOrder ( MEulerRotation::RotationOrder  eulerOrder,
MStatus ReturnStatus = NULL  
) [static]

Convert from MEulerRotation::RotationOrder to MTransformationMatrix::RotationOrder.

Parameters:
[in]  eulerOrder  The MEulerRotation::RotationOrder
[out]  ReturnStatus  return status
Returns:
The corresponding MTransformationMatrix::RotationOrder.
Status Codes:

MEulerRotation::RotationOrder MPxTransformationMatrix::convertRotationOrder ( MTransformationMatrix::RotationOrder  xformOrder,
MStatus ReturnStatus = NULL  
) [static]

This method is obsolete. This method is not available in Python.

Deprecated:
Use the MPxTransformationMatrix::convertTransformationRotationOrder() method instead.

MTransformationMatrix::RotationOrder MPxTransformationMatrix::convertRotationOrder ( MEulerRotation::RotationOrder  eulerOrder,
MStatus ReturnStatus = NULL  
) [static]

This method is obsolete. This method is not available in Python.

Deprecated:
Use the MPxTransformationMatrix::convertEulerRotationOrder() method instead.

MStatus MPxTransformationMatrix::decomposeMatrix ( const MMatrix m  )  [protected, virtual]

This method converts a passed MMatrix into individual transformation matrix components. The default algorithm will solve under the assumption that the pivots and pivot translates are all zero.

It is possible that multiple transformation matrices may produce identical 4x4 matrices. This means that taking a generic transformation matrix and converting it to a MMatrix and back to a transformation matrix may have different components, but the net transformation will still be the same.

Parameters:
[in]  m  The matrix to break up into components.
Returns:
Return status.
Status Codes:

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
const MPxTransformationMatrix m  
) [friend]

This method is not available in Python.

A method to easily dump the contents of a transformation matrix.

Parameters:
[in]  os  The ostream to use.
[in]  m  The transformation matrix to print.
Returns:
Ostream

Autodesk® Maya® 2011 © 1997-2010 Autodesk, Inc. All rights reserved. Generated with doxygen 1.5.6