This reference page is linked to from the following overview topics: カスタムトランスフォームの概要.

Detailed Description

Create and access transform nodes.

The MFnTransform function set provides access to transformation DAG nodes called transforms.

DAG nodes are separated into two types, transforms and geometry nodes. All DAG nodes that are not transform nodes must exist as a child of a transform node. Only transforms provide transformation information. Transforms are also commonly used as parent nodes for the purpose of hierarchical grouping.

The transformation in the node is represented as a 4x4 transformation matrix. This function set allows access to the whole matrix, or the individual components (eg scale, rotation, shear, etc) of the transformation. The transform node is made up of many components that make up the final transformation matrix. This breakdown provides animators fine control over the animation of these parameters. Therefore, it is necessary to describe the order in which these attributes are applied to build the final matrix attribute.

A transformation matrix is composed of the following components, all components with units will be in maya's internal units (radians for rotations and centimeters for translations):

Scale pivot point point around which scales are performed [Sp]
Scale scaling about x, y, z axes [S]
Shear shearing in xy, xz, yx [Sh]
Scale pivot translation translation introduced to preserve existing scale transformations when moving pivot. This is used to prevent the object from moving when the objects pivot point is not at the origin and a non-unit scale is applied to the object [St].
Rotate pivot point point about which rotations are performed [Rp]
Rotation orientation rotation to orient local rotation space [Ro]
Rotation rotation [R]
Rotate pivot translation translation introduced to preserve exisitng rotate transformations when moving pivot. This is used to prevent the object from moving when the objects pivot point is not at the origin and the pivot is moved. [Rt]
Translate translation in x, y, z axes [T]

The matrices are post-multiplied in Maya. For example, to transform a point P from object-space to world-space (P') you would need to post-multiply by the worldMatrix. (P' = P x WM)

The transformation matrix is then constructed as follows:

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

where 'x' denotes matrix multiplication and '-1' denotes matrix inversion

     Sp = |  1    0    0    0 |     St = |  1    0    0    0 |
          |  0    1    0    0 |          |  0    1    0    0 |
          |  0    0    1    0 |          |  0    0    1    0 |
          | spx  spy  spz   1 |          | sptx spty sptz  1 |

     S  = |  sx   0    0    0 |     Sh = |  1    0    0    0 |
          |  0    sy   0    0 |          | shxy  1    0    0 |
          |  0    0    sz   0 |          | shxz shyz  1    0 |
          |  0    0    0    1 |          |  0    0    0    1 |

     Rp = |  1    0    0    0 |     Rt = |  1    0    0    0 |
          |  0    1    0    0 |          |  0    1    0    0 |
          |  0    0    1    0 |          |  0    0    1    0 |
          | rpx  rpy  rpz   1 |          | rptx rpty rptz  1 |

     Ro = AX * AY * AZ

     AX = |  1    0    0    0 |     AY = |  cy   0   -sy   0 |
          |  0    cx   sx   0 |          |  0    1    0    0 |
          |  0   -sx   cx   0 |          |  sy   0    cy   0 |
          |  0    0    0    1 |          |  0    0    0    1 |

     AZ = |  cz   sz   0    0 |     sx = sin(rax), cx = cos(rax)
          | -sz   cz   0    0 |     sy = sin(ray), cx = cos(ray)
          |  0    0    1    0 |     sz = sin(raz), cz = cos(raz)
          |  0    0    0    1 |

     R  = RX * RY * RZ  (Note: order is determined by rotateOrder)

     RX = |  1    0    0    0 |     RY = |  cy   0   -sy   0 |
          |  0    cx   sx   0 |          |  0    1    0    0 |
          |  0   -sx   cx   0 |          |  sy   0    cy   0 |
          |  0    0    0    1 |          |  0    0    0    1 |

     RZ = |  cz   sz   0    0 |     sx = sin(rx), cx = cos(rx)
          | -sz   cz   0    0 |     sy = sin(ry), cx = cos(ry)
          |  0    0    1    0 |     sz = sin(rz), cz = cos(rz)
          |  0    0    0    1 |

     T  = |  1    0    0    0 |
          |  0    1    0    0 |
          |  0    0    1    0 |
          |  tx   ty   tz   1 |

Note that internally the Maya transform does not store the individual component values in matrices. It stores them in the data structure which makes the most sense for that component. For example, translation is stored as a vector. The accessor methods on MFnTransform provide the data in their native structure rather than as a matrix.

Additionally, each transform can save a temporary "rest position" matrix using the setRestPosition method. The rest position is not used internally by Maya. It is exclusively for use from the API as a temporary cache, which can be set and restored within a single Maya session. Note that the rest position is not saved with the scene.

Examples:: closestPointOnNurbsSurfaceCmd.cpp, customAttrManip.cpp, footPrintManip.cpp, geometrySurfaceConstraint.cpp, intersectOnNurbsSurfaceCmd.cpp, lepTranslator.cpp, lineManip.cpp, lineManipContainer.cpp, moveNumericTool.cpp, moveTool.cpp, simpleSolverNode.cpp, squareScaleManip.cpp, squareScaleManipContext.cpp, surfaceBumpManip.cpp, and swissArmyManip.cpp.

#include <MFnTransform.h>

Inheritance diagram for MFnTransform:

[legend]

List of all members.

Public Types
enum	LimitType { kScaleMinX, kScaleMaxX, kScaleMinY, kScaleMaxY, kScaleMinZ, kScaleMaxZ, kShearMinXY, kShearMaxXY, kShearMinXZ, kShearMaxXZ, kShearMinYZ, kShearMaxYZ, kRotateMinX, kRotateMaxX, kRotateMinY, kRotateMaxY, kRotateMinZ, kRotateMaxZ, kTranslateMinX, kTranslateMaxX, kTranslateMinY, kTranslateMaxY, kTranslateMinZ, kTranslateMaxZ }
	Limit types. More...
Public Member Functions
virtual MFn::Type	type () const
	Function set type.
virtual	~MFnTransform ()
	Destructor.
	MFnTransform ()
	Default constructor.
	MFnTransform (MObject &object, MStatus *ReturnStatus=NULL)
	Constructor.
	MFnTransform (const MDagPath &object, MStatus *ret=NULL)
	Constructor.
MObject	create (MObject parent=MObject::kNullObj, MStatus *ReturnStatus=NULL)
	Creates a new transformation node.
MTransformationMatrix	transformation (MStatus *ReturnStatus=NULL) const
	Retrieve the transformation matrix represented by this transform.
MStatus	set (const MTransformationMatrix &transform)
	Change this transform to equal the given matrix.
MStatus	getScale (double scale[3]) const
	Retrieve the scaling component of this transformation.
MStatus	setScale (const double scale[3])
	Set the scaling component of this transformation.
MStatus	scaleBy (const double scale[3])
	Relatively scale this transformation.
MStatus	getShear (double scale[3]) const
	Retrieve the shearing component of this transformation.
MStatus	setShear (const double shear[3])
	Set the shearing component of this transformation.
MStatus	shearBy (const double shear[3])
	Relatively shear this transformation.
MStatus	getRotation (MQuaternion &quaternion, MSpace::Space=MSpace::kTransform) const
	Retrieve the rotation component of this transformation as a quaternion.
MStatus	setRotation (const MQuaternion &quaternion, MSpace::Space=MSpace::kTransform)
	Change the rotation component of this transformation using a quaternion.
MStatus	rotateBy (const MQuaternion &quaternion, MSpace::Space=MSpace::kTransform)
	Relatively change the rotation of this transformation using a quaternion.
MStatus	getRotation (MEulerRotation &rotation) const
	Retrieve the rotation component of this transformation.
MStatus	setRotation (const MEulerRotation &rotation)
	Change the rotation component of this transformation.
MStatus	rotateBy (const MEulerRotation &rotation, MSpace::Space=MSpace::kTransform)
	Relatively change the rotation component of this transformation.
MStatus	getRotationQuaternion (double &x, double &y, double &z, double &w, MSpace::Space=MSpace::kTransform) const
	Retrieve the rotation component of this transformation as a quaternion.
MStatus	setRotationQuaternion (double x, double y, double z, double w, MSpace::Space=MSpace::kTransform)
	Change the rotation component of this transformation using a quaternion.
MStatus	rotateByQuaternion (double x, double y, double z, double w, MSpace::Space=MSpace::kTransform)
	Relatively change the rotation of this transformation using a quaternion.
MStatus	getRotation (double rotation[3], MTransformationMatrix::RotationOrder &order) const
	Retrieve the rotation component of this transformation.
MStatus	setRotation (const double rotation[3], MTransformationMatrix::RotationOrder order)
	Change the rotation component of this transformation.
MStatus	rotateBy (const double rotation[3], MTransformationMatrix::RotationOrder order, MSpace::Space=MSpace::kTransform)
	Relatively change the rotation component of this transformation.
MVector	getTranslation (MSpace::Space space, MStatus *ReturnStatus=NULL) const
	Retrieve the translation component of this transformation in centimeters.
MStatus	setTranslation (const MVector &vec, MSpace::Space space)
	Change the translation component of this transformation.
MStatus	translateBy (const MVector &vec, MSpace::Space space)
	Relatively change the translation component of this transformation.
MPoint	scalePivot (MSpace::Space space, MStatus *ReturnStatus=NULL) const
	Returns the pivot around which the scale is applied.
MStatus	setScalePivot (const MPoint &point, MSpace::Space space, bool balance)
	Set the pivot around which the scale is applied in centimeters.
MVector	scalePivotTranslation (MSpace::Space space, MStatus *ReturnStatus=NULL) const
	Returns the scale pivot translation in centimeters.
MStatus	setScalePivotTranslation (const MVector &vec, MSpace::Space space)
	Set the scale pivot translation in centimeters.
MPoint	rotatePivot (MSpace::Space space, MStatus *ReturnStatus=NULL) const
	Returns the pivot about which the rotation is applied.
MStatus	setRotatePivot (const MPoint &point, MSpace::Space space, bool balance)
	Set the rotate pivot in centimeters about which rotation is applied.
MVector	rotatePivotTranslation (MSpace::Space space, MStatus *ReturnStatus=NULL) const
	Return the rotate pivot translation in centimeters.
MStatus	setRotatePivotTranslation (const MVector &vec, MSpace::Space space)
	Set the rotate pivot translation in centimeters.
MQuaternion	rotateOrientation (MSpace::Space space, MStatus *ReturnStatus=NULL) const
	Returns the rotation used to orient the local rotation space.
MStatus	setRotateOrientation (const MQuaternion &quat, MSpace::Space space, bool balance)
	Set the rotation used to orient the local rotation space.
MTransformationMatrix::RotationOrder	rotationOrder (MStatus *ReturnStatus=NULL) const
	Returns the rotation order for the transform matrix - the order in which the Euler angles are applied to create the end rotation.
MStatus	setRotationOrder (MTransformationMatrix::RotationOrder order, bool reorder)
	Change the rotation order for the transform - the order in which the Euler angles are applied to create the end rotation.
MTransformationMatrix	restPosition (MStatus *ReturnStatus) const
	Retrieve the saved rest position of this transform.
MStatus	setRestPosition (const MTransformationMatrix &matrix)
	Change the saved rest position of this transform.
MStatus	resetFromRestPosition ()
	Reset the transform to its rest position.
MStatus	clearRestPosition ()
	Clear the saved rest position of this transform.
MStatus	getRotation (double rotation[3], MTransformationMatrix::RotationOrder &order, MSpace::Space) const
	This method is obsolete.
MStatus	setRotation (const double rotation[3], MTransformationMatrix::RotationOrder order, MSpace::Space)
	This method is obsolete.
MVector	translation (MSpace::Space space, MStatus *ReturnStatus=NULL) const
	This method is obsolete.
bool	isLimited (MFnTransform::LimitType type, MStatus *ReturnStatus=NULL) const
	Determine if the specified limit attribute is enabled or disabled.
double	limitValue (MFnTransform::LimitType type, MStatus *ReturnStatus=NULL) const
	Determine the current value of the specified limit.
MStatus	setLimit (MFnTransform::LimitType type, double value)
	Change the limit value for the specified limit type, and automatically enable the limit to be true.
MStatus	enableLimit (MFnTransform::LimitType type, bool flag)
	Enable or disable the limit value for the specified limit type.
	MFnTransform (const MObject &object, MStatus *ret=NULL)
	Constructor.
Protected Member Functions
virtual const char *	className () const
	Class name.

kScaleMinX	Search for all occurrences
kScaleMaxX	Search for all occurrences
kScaleMinY	Search for all occurrences
kScaleMaxY	Search for all occurrences
kScaleMinZ	Search for all occurrences
kScaleMaxZ	Search for all occurrences
kShearMinXY	Search for all occurrences
kShearMaxXY	Search for all occurrences
kShearMinXZ	Search for all occurrences
kShearMaxXZ	Search for all occurrences
kShearMinYZ	Search for all occurrences
kShearMaxYZ	Search for all occurrences
kRotateMinX	Search for all occurrences
kRotateMaxX	Search for all occurrences
kRotateMinY	Search for all occurrences
kRotateMaxY	Search for all occurrences
kRotateMinZ	Search for all occurrences
kRotateMaxZ	Search for all occurrences
kTranslateMinX	Search for all occurrences
kTranslateMaxX	Search for all occurrences
kTranslateMinY	Search for all occurrences
kTranslateMaxY	Search for all occurrences
kTranslateMinZ	Search for all occurrences
kTranslateMaxZ	Search for all occurrences

MFnTransform	(	MObject &	object,
		MStatus *	ReturnStatus = `NULL`
	)

[in]	object	The MObject to attach the function set to
[out]	ReturnStatus	the return status

MFnTransform	(	const MDagPath &	object,
		MStatus *	ReturnStatus = `NULL`
	)

[in]	object	The const MDagPath to attach the function set to
[out]	ReturnStatus	The return status

MFnTransform	(	const MObject &	object,
		MStatus *	ReturnStatus = `NULL`
	)

MObject create	(	MObject	parent = `MObject::kNullObj`,
		MStatus *	ReturnStatus = `NULL`
	)

[in]	parent	the parent of the transform to be created
[out]	ReturnStatus	status code

MStatus getRotation	(	MQuaternion &	quaternion,
		MSpace::Space	space = `MSpace::kTransform`
	)		const

[out]	quaternion	the quaternion
[in]	space	transform space in which to get the rotation

MStatus setRotation	(	const MQuaternion &	quaternion,
		MSpace::Space	space = `MSpace::kTransform`
	)

MStatus rotateBy	(	const MQuaternion &	quaternion,
		MSpace::Space	space = `MSpace::kTransform`
	)

MStatus rotateBy	(	const MEulerRotation &	rotation,
		MSpace::Space	space = `MSpace::kTransform`
	)

[in]	rotation	the euler rotation
[in]	space	transform space in which to perform the rotation

MStatus getRotationQuaternion	(	double &	x,
		double &	y,
		double &	z,
		double &	w,
		MSpace::Space	space = `MSpace::kTransform`
	)		const

[out]	x	storage for the x component of the quaternion
[out]	y	storage for the y component of the quaternion
[out]	z	storage for the z component of the quaternion
[out]	w	storage for the w component of the quaternion
[in]	space	transform space in which to get the rotation

MStatus setRotationQuaternion	(	double	x,
		double	y,
		double	z,
		double	w,
		MSpace::Space	space = `MSpace::kTransform`
	)

[in]	x	x component of the quaternion
[in]	y	y component of the quaternion
[in]	z	z component of the quaternion
[in]	w	w component of the quaternion
[in]	space	transform space in which to perform the rotation

MStatus rotateByQuaternion	(	double	x,
		double	y,
		double	z,
		double	w,
		MSpace::Space	space = `MSpace::kTransform`
	)

MStatus getRotation	(	double	rotation[3],
		MTransformationMatrix::RotationOrder &	order
	)		const

MFnTransform Class Reference

OpenMaya - API module for common classes | FunctionSet classes

Detailed Description

Public Types

Public Member Functions

Protected Member Functions

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

[out]	rotation	storage for the rotation components
[out]	order	storage for the order of rotation

MStatus setRotation	(	const double	rotation[3],
		MTransformationMatrix::RotationOrder	order
	)

[in]	rotation	the new rotation components
[in]	order	the order in which to apply the rotations

[in]	rotation	the relative rotation components
[in]	order	the order in which to apply the rotations
[in]	space	transform space in which to perform the rotation

MVector getTranslation	(	MSpace::Space	space,
		MStatus *	ReturnStatus = `NULL`
	)		const

[in]	space	transform space in which to get the translation
[out]	ReturnStatus	return status

MStatus setTranslation	(	const MVector &	vector,
		MSpace::Space	space
	)

[in]	vector	the new translation vector in centimeters
[in]	space	transform space in which to perform the translation

MStatus translateBy	(	const MVector &	vector,
		MSpace::Space	space
	)

[in]	vector	the relative translation vector
[in]	space	transform space in which to perform the translation