MPxTransform Class Reference
[OpenMaya - API module for common classes, Proxy classes]

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

List of all members.

Detailed Description

Base class for user defined transforms.

MPxTransform allows the creation of user defined transform nodes. User defined transform nodes can introduce new transform types or change the transformation order. They are designed to be an extension of the standard Maya transform node and include all of the normal transform attributes. Standard behaviors such as limit enforcement and attribute locking are managed by this class, but may be overriden in derived classes.

In general, a complete implementation of user defined transforms will require the deriving from two classes; MPxTransform defines the node while MPxTransformationMatrix describes the mathematical functions of the user defined transform.

The MPxTransform 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. Both the MPxTransform and the MPxTransformationMatrix classes need unique MTypeIds.

MPxTransform nodes are DAG nodes and therefore a change to one element will affect every node beneath the changed node. Since this can involve quite a bit of calculation, DAG nodes internally handle clean and dirty differently than other nodes. What this means is that the updateMatrixAttrs() method should be used when getting one of the matrix attributes from a method on this node. Additionally, after a value is changed, the appropriate dirty method (i.e. dirtyTranslate(), dirtyRotate(), etc.) should be called. When in doubt, dirtyMatrix() will flag everything as needing to be updated.

It is up to each transform node to determine if it will obey limits or Since transform attributes may have limits or may be involved in some sort of constraint, there needs to be a way to accept, reject, or modify a value when a plug is set on the node. The mustCallValidateAndSet() method allows for this kind of control. When an attribute is flagged with the mustCallValidateAndSet() method in the initialize() method, every plug change will call the validateAndSetValue() method for approval. From the validateAndSetValue() method things like limits and value locking can be enforced. It is important to note that for new attributes on the transform node, any locking or limits are left as an implementation detail.

If any of the public methods are affected by the addition of transform components, or by the order of computation, they should be overriden in the derived class. Many of the public methods are used by internal Maya code and exist for more than just convenience.

The createTransformationMatrix() class must be overloaded if a transformation matrix other than the default MPxTransformationMatrix is used.

NOTES: 1) The setDependentsDirty() virtual method is available in this class since MPxTransform derives from MPxNode. During a call to MPxTransform::setDependentsDirty(), a plug-in should not invoke any of the dirty*() or updateMatrixAttrs() calls of this class. For example, the methods dirtyMatrix(), dirtyTranslation() or updateMatrixAttrs() should not be called. 2) Updating world space attributes is an expensive operation. Maya updates world space attributes on demand such as in the case of a getAttr being issued or a connection exists for the attribute.

Examples:

rockingTransform.h.


Public Member Functions
  MPxTransform ()
  MPxTransform (MPxTransformationMatrix *)
virtual  ~MPxTransform ()
virtual void  postConstructor ()
virtual MPxNode::Type  type () const
virtual MPxTransformationMatrix *  createTransformationMatrix ()
virtual bool  isBounded () const
virtual MBoundingBox  boundingBox () const
virtual bool  treatAsTransform () const
const MPxTransformationMatrix &  transformationMatrix () const
MPxTransformationMatrix *  transformationMatrixPtr () const
virtual void  resetTransformation (const MMatrix &)
virtual void  resetTransformation (MPxTransformationMatrix *)
virtual MStatus  compute (const MPlug &plug, MDataBlock &data)
virtual MStatus  computeLocalTransformation (MPxTransformationMatrix *, MDataBlock &)
virtual MStatus  clearLimits ()
bool  isLimited (MFnTransform::LimitType type, MStatus *ReturnStatus=NULL) const
double  limitValue (MFnTransform::LimitType type, MStatus *ReturnStatus=NULL) const
MStatus  setLimit (MFnTransform::LimitType type, double value)
MStatus  enableLimit (MFnTransform::LimitType type, bool flag)
virtual MStatus  validateAndSetValue (const MPlug &, const MDataHandle &, const MDGContext &)
virtual MMatrix  getMatrix (const MDGContext &=MDGContext::fsNormal, MStatus *ReturnStatus=NULL)
virtual MMatrix  getMatrixInverse (const MDGContext &=MDGContext::fsNormal, MStatus *ReturnStatus=NULL)
virtual MVector  getTranslation (MSpace::Space=MSpace::kTransform, const MDGContext &=MDGContext::fsNormal, MStatus *ReturnStatus=NULL)
virtual MStatus  translateTo (const MVector &, MSpace::Space=MSpace::kTransform, const MDGContext &=MDGContext::fsNormal)
virtual MStatus  translateBy (const MVector &, MSpace::Space=MSpace::kTransform, const MDGContext &=MDGContext::fsNormal)
virtual MQuaternion  getRotation (MSpace::Space=MSpace::kTransform, const MDGContext &=MDGContext::fsNormal, MStatus *ReturnStatus=NULL)
virtual MEulerRotation  getEulerRotation (MSpace::Space=MSpace::kTransform, const MDGContext &=MDGContext::fsNormal, MStatus *ReturnStatus=NULL)
virtual MStatus  rotateTo (const MQuaternion &, MSpace::Space=MSpace::kTransform, const MDGContext &=MDGContext::fsNormal)
virtual MStatus  rotateBy (const MQuaternion &, MSpace::Space=MSpace::kTransform, const MDGContext &=MDGContext::fsNormal)
virtual MStatus  rotateTo (const MEulerRotation &, MSpace::Space=MSpace::kTransform, const MDGContext &=MDGContext::fsNormal)
virtual MStatus  rotateBy (const MEulerRotation &, MSpace::Space=MSpace::kTransform, const MDGContext &=MDGContext::fsNormal)
virtual MVector  getScale (MSpace::Space=MSpace::kTransform, const MDGContext &=MDGContext::fsNormal, MStatus *ReturnStatus=NULL)
virtual MStatus  scaleTo (const MVector &, MSpace::Space=MSpace::kTransform, const MDGContext &=MDGContext::fsNormal)
virtual MStatus  scaleBy (const MVector &, MSpace::Space=MSpace::kTransform, const MDGContext &=MDGContext::fsNormal)
virtual MVector  getShear (MSpace::Space=MSpace::kTransform, const MDGContext &=MDGContext::fsNormal, MStatus *ReturnStatus=NULL)
virtual MStatus  shearTo (const MVector &, MSpace::Space=MSpace::kTransform, const MDGContext &=MDGContext::fsNormal)
virtual MStatus  shearBy (const MVector &, MSpace::Space=MSpace::kTransform, const MDGContext &=MDGContext::fsNormal)
virtual MPoint  getScalePivot (MSpace::Space=MSpace::kTransform, const MDGContext &=MDGContext::fsNormal, MStatus *ReturnStatus=NULL)
virtual MPoint  getRotatePivot (MSpace::Space=MSpace::kTransform, const MDGContext &=MDGContext::fsNormal, MStatus *ReturnStatus=NULL)
virtual MVector  getScalePivotTranslation (MSpace::Space=MSpace::kTransform, const MDGContext &=MDGContext::fsNormal, MStatus *ReturnStatus=NULL)
virtual MVector  getRotatePivotTranslation (MSpace::Space=MSpace::kTransform, const MDGContext &=MDGContext::fsNormal, MStatus *ReturnStatus=NULL)
virtual MStatus  setScalePivot (const MPoint &, MSpace::Space=MSpace::kTransform, bool balance=true, const MDGContext &=MDGContext::fsNormal)
virtual MStatus  setScalePivotTranslation (const MVector &, MSpace::Space=MSpace::kTransform, const MDGContext &=MDGContext::fsNormal)
virtual MStatus  setRotatePivot (const MPoint &, MSpace::Space=MSpace::kTransform, bool balance=true, const MDGContext &=MDGContext::fsNormal)
virtual MStatus  setRotatePivotTranslation (const MVector &, MSpace::Space=MSpace::kTransform, const MDGContext &=MDGContext::fsNormal)
virtual
MTransformationMatrix::RotationOrder 		 getRotationOrder (const MDGContext &apiContext=MDGContext::fsNormal)
virtual MStatus  setRotationOrder ( MTransformationMatrix::RotationOrder ro, bool reorder=true, const MDGContext &apiContext=MDGContext::fsNormal)
virtual MQuaternion  getRotateOrientation (MSpace::Space apiSpace=MSpace::kTransform, const MDGContext &apiContext=MDGContext::fsNormal, MStatus *ReturnStatus=NULL)
virtual MStatus  setRotateOrientation (const MQuaternion &q, MSpace::Space apiSpace=MSpace::kTransform, bool balance=true, const MDGContext &apiContext=MDGContext::fsNormal)
void  updateMatrixAttrs (const MDGContext &apiContext=MDGContext::fsNormal)
MStatus  updateMatrixAttrs (MObject &attr, const MDGContext &context=MDGContext::fsNormal)
virtual void  copyInternalData (MPxNode *)

Static Public Member Functions
static void  mustCallValidateAndSet (MObject &)
static MStatus  setNonAffineMatricesEnabled (bool)
static bool  isNonAffineMatricesEnabled (MStatus *ReturnStatus)

Static Public Attributes
static MObject  nodeBoundingBox
  bounding box attribute
static MObject  nodeBoundingBoxMin
  bounding box minimum point
static MObject  nodeBoundingBoxMinX
  X component of nodeBoundingBoxMin.
static MObject  nodeBoundingBoxMinY
  Y component of nodeBoundingBoxMin.
static MObject  nodeBoundingBoxMinZ
  Z component of nodeBoundingBoxMin.
static MObject  nodeBoundingBoxMax
  bounding box maximum point
static MObject  nodeBoundingBoxMaxX
  X component of nodeBoundingBoxMax.
static MObject  nodeBoundingBoxMaxY
  Y component of nodeBoundingBoxMax.
static MObject  nodeBoundingBoxMaxZ
  Z component of nodeBoundingBoxMax.
static MObject  nodeBoundingBoxSize
  bounding box size vector
static MObject  nodeBoundingBoxSizeX
  X component of nodeBoundingBoxSize.
static MObject  nodeBoundingBoxSizeY
  Y component of nodeBoundingBoxSize.
static MObject  nodeBoundingBoxSizeZ
  Z component of nodeBoundingBoxSize.
static MObject  center
  object center attribute
static MObject  boundingBoxCenterX
  X component of the bounding box center.
static MObject  boundingBoxCenterY
  Y component of the bounding box center.
static MObject  boundingBoxCenterZ
  Z component of the bounding box center.
static MObject  matrix
  matrix attribute
static MObject  inverseMatrix
  inverse matrix attribute
static MObject  worldMatrix
  world matrix attribute
static MObject  worldInverseMatrix
  Inverse world matrix attribute.
static MObject  parentMatrix
  Parent matrix attribute.
static MObject  parentInverseMatrix
  Inverse parent matrix attribute.
static MObject  visibility
  Visibility attribute.
static MObject  intermediateObject
  Intermediate object attribute.
static MObject  isTemplated
  Template attribute.
static MObject  ghosting
  Ghosting attribute.
static MObject  instObjGroups
  Instances object group info attribute.
static MObject  objectGroups
  Object groups attributes.
static MObject  objectGrpCompList
  Component in object groups attribute.
static MObject  objectGroupId
  Group id attribute.
static MObject  objectGroupColor
  Group id attribute.
static MObject  useObjectColor
  Controls choice of wireframe dormant object color.
static MObject  objectColor
  The per object dormant wireframe color.
static MObject  renderInfo
  Obsolete attribute.
static MObject  identification
  Obsolete attribute.
static MObject  layerRenderable
  Obsolete attribute.
static MObject  layerOverrideColor
  Obsolete attribute.
static MObject  renderLayerInfo
  Render layer attribute.
static MObject  renderLayerId
  Render layer attribute.
static MObject  renderLayerRenderable
  Render layer attribute.
static MObject  renderLayerColor
  Render layer attribute.
static MObject  translate
  translate attribute
static MObject  translateX
  translateX attribute
static MObject  translateY
  translateY attribute
static MObject  translateZ
  translateZ attribute
static MObject  rotate
  rotate attribute
static MObject  rotateX
  rotateX attribute
static MObject  rotateY
  rotateY attribute
static MObject  rotateZ
  rotateZ attribute
static MObject  rotateOrder
  Rotate order attribute.
static MObject  scale
  scale attribute
static MObject  scaleX
  scaleX attribute
static MObject  scaleY
  scaleY attribute
static MObject  scaleZ
  scaleZ attribute
static MObject  shearXY
  shearXY attribute
static MObject  shearXZ
  shearXZ attribute
static MObject  shearYZ
  shearYZ attribute
static MObject  rotatePivot
  rotate pivot attribute
static MObject  rotatePivotX
  rotate pivot X attribute
static MObject  rotatePivotY
  rotate pivot Y attribute
static MObject  rotatePivotZ
  rotate pivot Z attribute
static MObject  rotatePivotTranslate
  rotate pivot translate attribute
static MObject  rotatePivotTranslateX
  rotate pivot translate X attribute
static MObject  rotatePivotTranslateY
  rotate pivot translate Y attribute
static MObject  rotatePivotTranslateZ
  rotate pivot translate Z attribute
static MObject  scalePivot
  scale pivot attribute
static MObject  scalePivotX
  scale pivot X attribute
static MObject  scalePivotY
  scale pivot Y attribute
static MObject  scalePivotZ
  scale pivot Z attribute
static MObject  scalePivotTranslate
  Scale pivot translate attribute.
static MObject  scalePivotTranslateX
  scale pivot translate X attribute
static MObject  scalePivotTranslateY
  scale pivot translate Y attribute
static MObject  scalePivotTranslateZ
  scale pivot translate Z attribute
static MObject  rotateAxis
  Rotate orientation attribute.
static MObject  rotateAxisX
  rotate orientation X attribute
static MObject  rotateAxisY
  rotate orientation Y attribute
static MObject  rotateAxisZ
  rotate orientation Z attribute
static MObject  transMinusRotatePivot
  translate minus rotate pivot attribute
static MObject  transMinusRotatePivotX
  translateX minus rotate pivotX attribute
static MObject  transMinusRotatePivotY
  translateY minus rotate pivotY attribute
static MObject  transMinusRotatePivotZ
  translateZ minus rotate pivotZ attribute
static MObject  minTransLimit
  Minumum translation limits attribute.
static MObject  minTransXLimit
  Minimum translate X limit attribute.
static MObject  minTransYLimit
  Minimum translate Y limit attribute.
static MObject  minTransZLimit
  Minimum translate Z limit attribute.
static MObject  maxTransLimit
  Maximum translation limits attribute.
static MObject  maxTransXLimit
  Maximum translate X limit attribute.
static MObject  maxTransYLimit
  Maximum translate Y limit attribute.
static MObject  maxTransZLimit
  Maximum translate Z limit attribute.
static MObject  minTransLimitEnable
  Enable the mimimum translation limits attribute.
static MObject  minTransXLimitEnable
  Enable the minimum translate X limit attribute.
static MObject  minTransYLimitEnable
  Enable the minimum translate Y limit attribute.
static MObject  minTransZLimitEnable
  Enable the minimum translate Z limit attribute.
static MObject  maxTransLimitEnable
  Enable the maximum translation limits attribute.
static MObject  maxTransXLimitEnable
  Enable the maximum translate X limit attribute.
static MObject  maxTransYLimitEnable
  Enable the maximum translate Y limit attribute.
static MObject  maxTransZLimitEnable
  Enable the maximum translate Z limit attribute.
static MObject  minRotLimit
  Minimum rotation limits attribute.
static MObject  minRotXLimit
  Minimum rotate X limit attribute.
static MObject  minRotYLimit
  Minimum rotate Y limit attribute.
static MObject  minRotZLimit
  Minimum rotate Z limit attribute.
static MObject  maxRotLimit
  Maximum rotation limits attribute.
static MObject  maxRotXLimit
  Maximum rotate X limit attribute.
static MObject  maxRotYLimit
  Maximum rotate Y limit attribute.
static MObject  maxRotZLimit
  Maximum rotate Z limit attribute.
static MObject  minRotLimitEnable
  Enable minimum rotation limits attribute.
static MObject  minRotXLimitEnable
  Enable minimum rotate X limit attribute.
static MObject  minRotYLimitEnable
  Enable minimum rotate Y limit attribute.
static MObject  minRotZLimitEnable
  Enable minimum rotate Z limit attribute.
static MObject  maxRotLimitEnable
  Enable maximum rotation limits attribute.
static MObject  maxRotXLimitEnable
  Enable maximum rotate X limit attribute.
static MObject  maxRotYLimitEnable
  Enable maximum rotate Y limit attribute.
static MObject  maxRotZLimitEnable
  Enable maximum rotate Z limit attribute.
static MObject  minScaleLimit
  Minimum scale limit attribute.
static MObject  minScaleXLimit
  Minimum scale X limit attribute.
static MObject  minScaleYLimit
  Minimum scale Y limit attribute.
static MObject  minScaleZLimit
  Minimum scale Z limit attribute.
static MObject  maxScaleLimit
  Maximum scale limit attribute.
static MObject  maxScaleXLimit
  Maximum scale X limit attribute.
static MObject  maxScaleYLimit
  Maximum scale Y limit attribute.
static MObject  maxScaleZLimit
  Maximum scale Z limit attribute.
static MObject  minScaleLimitEnable
  Enable minimum scale limit attribute.
static MObject  minScaleXLimitEnable
  Enable minimum scale X limit attribute.
static MObject  minScaleYLimitEnable
  Enable minimum scale Y limit attribute.
static MObject  minScaleZLimitEnable
  Enable minimum scale Z limit attribute.
static MObject  maxScaleLimitEnable
  Enable aximum scale limit attribute.
static MObject  maxScaleXLimitEnable
  Enable maximum scale X limit attribute.
static MObject  maxScaleYLimitEnable
  Enable maximum scale Y limit attribute.
static MObject  maxScaleZLimitEnable
  Enable maximum scale Z limit attribute.

Protected Member Functions
virtual MVector  applyTranslationLimits (const MVector &unclampedT, MDataBlock &block, MStatus *ReturnStatus=NULL)
virtual MVector  applyTranslationLocks (const MVector &toTest, const MVector &savedT, MStatus *ReturnStatus=NULL)
virtual MEulerRotation  applyRotationLimits (const MEulerRotation &unclampedR, MDataBlock &block, MStatus *ReturnStatus=NULL)
virtual MEulerRotation  applyRotationLocks (const MEulerRotation &toTest, const MEulerRotation &savedR, MStatus *ReturnStatus=NULL)
virtual MVector  applyScaleLimits (const MVector &unclampedS, MDataBlock &block, MStatus *ReturnStatus=NULL)
virtual MVector  applyScaleLocks (const MVector &toTest, const MVector &savedS, MStatus *ReturnStatus=NULL)
virtual MVector  applyShearLocks (const MVector &toTest, const MVector &savedSh, MStatus *ReturnStatus=NULL)
virtual MEulerRotation  applyRotateOrientationLocks (const MEulerRotation &toTest, const MEulerRotation &savedRO, MStatus *ReturnStatus=NULL)
virtual MVector  applyScaleLocksPivot (const MPoint &toTest, const MPoint &savedSP, MStatus *ReturnStatus=NULL)
virtual MVector  applyRotatePivotLocks (const MPoint &toTest, const MPoint &savedRP, MStatus *ReturnStatus=NULL)
virtual MVector  applyScaleLocksPivotTranslate (const MVector &toTest, const MVector &savedSPT, MStatus *ReturnStatus=NULL)
virtual MVector  applyRotatePivotLocksTranslate (const MVector &toTest, const MVector &savedRPT, MStatus *ReturnStatus=NULL)
MStatus  dirtyMatrix ()
  USE _dirtyMatrix() IN SCRIPT.
MStatus  dirtyTranslation (const MVector &)
  USE _dirtyTranslation() IN SCRIPT.
MStatus  dirtyRotation (const MEulerRotation &)
  USE _dirtyRotation() IN SCRIPT.
MStatus  dirtyScale (const MVector &)
  USE _dirtyScale() IN SCRIPT.
MStatus  dirtyShear (const MVector &)
  USE _dirtyShear() IN SCRIPT.
MStatus  dirtyRotateOrientation (const MEulerRotation &)
  USE _dirtyRotateOrientation() IN SCRIPT.
MStatus  dirtyScalePivot (const MPoint &)
  USE _dirtyScalePivot() IN SCRIPT.
MStatus  dirtyRotatePivot (const MPoint &)
  USE _dirtyRotatePivot() IN SCRIPT.
MStatus  dirtyScalePivotTranslation (const MVector &)
  USE _dirtyScalePivotTranslation() IN SCRIPT.
MStatus  dirtyRotatePivotTranslation (const MVector &)
  USE _dirtyRotatePivotTranslation() IN SCRIPT.
virtual MStatus  checkAndSetTranslation (MDataBlock &block, const MPlug &, const MVector &, MSpace::Space=MSpace::kTransform)
virtual MStatus  checkAndSetRotation (MDataBlock &block, const MPlug &, const MEulerRotation &, MSpace::Space=MSpace::kTransform)
virtual MStatus  checkAndSetScale (MDataBlock &block, const MPlug &, const MVector &, MSpace::Space=MSpace::kTransform)
virtual MStatus  checkAndSetShear (MDataBlock &block, const MPlug &, const MVector &, MSpace::Space=MSpace::kTransform)
virtual MStatus  checkAndSetRotateOrientation (MDataBlock &block, const MPlug &, const MEulerRotation &, MSpace::Space=MSpace::kTransform, bool balance=true)
virtual MStatus  checkAndSetRotatePivot (MDataBlock &, const MPlug &, const MPoint &, MSpace::Space=MSpace::kTransform, bool balance=true)
virtual MStatus  checkAndSetRotatePivotTranslation (MDataBlock &, const MPlug &, const MVector &, MSpace::Space=MSpace::kTransform)
virtual MStatus  checkAndSetScalePivot (MDataBlock &, const MPlug &, const MPoint &, MSpace::Space=MSpace::kTransform, bool=true)
virtual MStatus  checkAndSetScalePivotTranslation (MDataBlock &, const MPlug &, const MVector &, MSpace::Space=MSpace::kTransform)

Protected Attributes
MPxTransformationMatrix *  baseTransformationMatrix
  Cached MPxTransformationMatrix (same as returned by transformationMatrix() method).

Constructor & Destructor Documentation

MPxTransform::MPxTransform (  ) 

Class constructor.

MPxTransform::MPxTransform ( MPxTransformationMatrix *  tm  ) 

Class constructor. The passed pointer to a MPxTransformationMatrix derived object will be used for the transformation matrix calculation. This class will assume responsibility to delete this memory.

Parameters:
[in]  tm  A pointer to a MPxTransformationMatrix derived object.

MPxTransform::~MPxTransform (  )  [virtual]

Class destructor.

Member Function Documentation

void MPxTransform::postConstructor (  )  [virtual]

Post constructor.

Internally maya creates two objects when a user defined node is created, the internal MObject and the user derived object. The association between the these two objects is not made until after the MPxNode constructor is called. This implies that no MPxNode member function can be called from the MPxNode constructor. The postConstructor will get called immediately after the constructor when it is safe to call any MPxNode member function.

Reimplemented from MPxNode.

Examples:
rockingTransform.h.

MPxNode::Type MPxTransform::type (  )  const [virtual]

This method returns the type of the node. This method should not be overridden by the user. It will return MPxNode::kTransformNode.

Returns:
An enum specifying the node type.
Status Codes:

Reimplemented from MPxNode.

MPxTransformationMatrix * MPxTransform::createTransformationMatrix (  )  [virtual]

This method returns a new transformation matrix. The function that calls this method is responsible for deleting the transformation matrix.

If a derived MPxTransformationMatrix is used as the transformation matrix for the node, then this method must be overridden.

Returns:
A pointer to the new transformation matrix.
Examples:
rockingTransform.h.

bool MPxTransform::isBounded (  )  const [virtual]

This method should be overridden to return true if the user supplies a bounding box routine. Supplying a bounding box routine makes refresh and selection more efficient.

Returns:
A boolean value indicating whether a bounding box routine has been supplied.

MBoundingBox MPxTransform::boundingBox (  )  const [virtual]

This method should be overridden to return a bounding box for the transform. If this method is overridden, then MPxTransform::isBounded should also be overridden to return true.

Returns:
The bounding box of the transform.

bool MPxTransform::treatAsTransform (  )  const [virtual]

Maya's base transform node type is treated differently from node types which are derived from it. For example, the 'viewFit' command does not include transform nodes in its calculations but does include pointConstraint nodes which are derived from the transform node.

By default, all custom transform node types are treated the same as Maya's base transform node type. Using the same example, by default a custom transform node will be excluded from the 'viewFit' command's calculations.

This method allows that default behaviour to be changed. By overriding this method to return false, a custom node can turn off the special treatment accorded to transform nodes and instead have itself treated the same as Maya treats derived transform nodes.

Returns:
True to be treated like a base transform node, false to be treated as a derived transform node.

const MPxTransformationMatrix & MPxTransform::transformationMatrix (  )  const

This method returns a reference to the transformation matrix used by this transform.

Returns:
The transformation matrix.

MPxTransformationMatrix * MPxTransform::transformationMatrixPtr (  )  const

This function returns the associated transformation matrix.

void MPxTransform::resetTransformation ( const MMatrix &  matrix  )  [virtual]

This method will reset the transformation matrix to one that is constructed with the passed MMatrix. How the new transformation matrix is created will depend on the transformation matrix class and its decomposeMatrix() method.

Parameters:
[in]  matrix  The matrix used for resetting this transform.
Examples:
rockingTransform.h.

void MPxTransform::resetTransformation ( MPxTransformationMatrix *  xform  )  [virtual]

This method will reset the transformation matrix to the one specified by the passed transformation matrix pointer. The contents of the passed transformation matrix are copied into this class's transformation matrix.

Parameters:
[in]  xform  A pointer to the source transformation matrix.

MStatus MPxTransform::compute ( const MPlug &  plug,
MDataBlock &  block  
) [virtual]

The transform's compute method. The compute method should call any supporting methods to proper handle limits as well as the cases where the plug's value should not change. The MPlug::isFreeToChange() method is used to determine if a plug's value may be changed.

When the compute method on derived classes is invoked for an attribute not handled by the derived class, the derived class should call MPxTransform::compute to allow the base classes to handle the attribute.

Parameters:
[in]  plug  The plug to compute.
[in]  block  The data block.
Returns:
Status code.
Status Codes:

Reimplemented from MPxNode.

MStatus MPxTransform::computeLocalTransformation ( MPxTransformationMatrix *  xform,
MDataBlock &  block  
) [virtual]

This method computes the transformation matrix for a passed data block and places the output into a passed transformation matrix.

The caller needs to allocate space for the passed transformation matrix.

Parameters:
[in]  xform  The transformation matrix to fill with computed values.
[in]  block  The data block used for the transformation matrix computation.
Returns:
Status code.
Status Codes:

MStatus MPxTransform::clearLimits (  )  [virtual]

This method turns off all of the limits and sets them to their default values. Before this method is called, the base class clears all of the limits on the standard transform attributes, so this method only needs to be implemented for custom transform attributes.

Returns:
Return status.
Status Codes:

bool MPxTransform::isLimited ( MFnTransform::LimitType  type,
MStatus *  ReturnStatus = NULL  
) const

Determine if the specified limit attribute is enabled or disabled.

Parameters:
[in]  type  An enum specifying the type of limit to query.
[out]  ReturnStatus  Status.
Returns:
Returns true if the limit is enabled, otherwise false is returned.
Status Codes:

double MPxTransform::limitValue ( MFnTransform::LimitType  type,
MStatus *  ReturnStatus = NULL  
) const

Returns the current value of the specified limit in internal units as a double.

Parameters:
[in]  type  An enum indicating the type of limit to query.
[out]  ReturnStatus  Status.
Returns:
Returns the current value of the specified limit in internal units as a double.
Status Codes:

MStatus MPxTransform::setLimit ( MFnTransform::LimitType  type,
double  value  
)

Change the limit value for the specified limit type, and automatically enable the limit to be true.

Parameters:
[in]  type  An enum indicating the limit to set.
[in]  value  The new limit value in internal units (centimeters or radians).
Returns:
Status code.
Status Codes:

MStatus MPxTransform::enableLimit ( MFnTransform::LimitType  type,
bool  flag  
)

Enable or disable the limit value for the specified limit type.

Parameters:
[in]  type  An enum indicating the limit to enable or disable.
[in]  flag  The enable value; true will enable while false will disable the limit.
Returns:
Status code.
Status Codes:

MStatus MPxTransform::validateAndSetValue ( const MPlug &  plug,
const MDataHandle &  handle,
const MDGContext &  context  
) [virtual]

When a plug's value is set, and the plug is on a default transform attribute, or has been flagged by the mustCallValidateAndSet() method, then this method will be called. The purpose of validateAndSetValue() is to enforce limits, constraints, or plug value locking.

If the plug passed into this method is not an attribute related to the derived class, the derived class should call the validateAndSetValue method of its parent class in order to allow the base classes to handle their attributes.

If any adjustments or corrections are required, they are placed in the data block and if the context is normal, into the cached transformation matrix. Values on the data block are in transform space.

Parameters:
[in]  plug  The plug that is to be set.
[in]  handle  The inputValue handle of the data.
[in]  context  The context for the data.
Returns:
Status code.
Status Codes:
Examples:
rockingTransform.h.

MMatrix MPxTransform::getMatrix ( const MDGContext &  context = MDGContext::fsNormal,
MStatus *  ReturnStatus = NULL  
) [virtual]

This method returns a 4x4 matrix that is produced by applying all of the components of the transform.

Parameters:
[in]  context  The context for getting the matrix.
[out]  ReturnStatus  Return status.
Returns:
The transform as a MMatrix.
Status Codes:

MMatrix MPxTransform::getMatrixInverse ( const MDGContext &  context = MDGContext::fsNormal,
MStatus *  ReturnStatus = NULL  
) [virtual]

This method returns the inverse of the 4x4 matrix that describes this transformation.

Parameters:
[in]  context  The context for getting the inverse MMatrix.
[out]  ReturnStatus  Return status.
Returns:
The inverse of the transform as a MMatrix.
Status Codes:

MVector MPxTransform::getTranslation ( MSpace::Space  space = MSpace::kTransform,
const MDGContext &  context = MDGContext::fsNormal,
MStatus *  ReturnStatus = NULL  
) [virtual]

This method returns the translation component of the transform as a MVector in internal units (centimeters).

Parameters:
[in]  space  The space used for setting the translation.
[in]  context  The context used for setting the translation.
[out]  ReturnStatus  Return status.
Returns:
The translation MVector in internal units (centimeters).
Status Codes:

MStatus MPxTransform::translateTo ( const MVector &  newTrans,
MSpace::Space  space = MSpace::kTransform,
const MDGContext &  context = MDGContext::fsNormal  
) [virtual]

Set the translation component of the transform in centimeters.

Parameters:
[in]  newTrans  The new translation component in centimeters.
[in]  space  The space in which to perform the translation.
[in]  context  The context of the translation.
Returns:
Status code.
Status Codes:

MStatus MPxTransform::translateBy ( const MVector &  transOffset,
MSpace::Space  space = MSpace::kTransform,
const MDGContext &  context = MDGContext::fsNormal  
) [virtual]

Add to the translation component by translating relative to the existing transform. The transform value should be in internal units (centimeters).

Parameters:
[in]  transOffset  The relative translation value in centimeters.
[in]  space  The space in which to perform the translation.
[in]  context  The context for the translation.
Returns:
Status code.
Status Codes:

MQuaternion MPxTransform::getRotation ( MSpace::Space  space = MSpace::kTransform,
const MDGContext &  context = MDGContext::fsNormal,
MStatus *  ReturnStatus = NULL  
) [virtual]

This method returns the rotation of the transform as a quaternion. The rotation is returned in MSpace::kTransform space. If an invalid space is used, MQuaternion::identity will be returned.

Parameters:
[in]  space  The space used for getting the rotate value.
[in]  context  The context used for getting the rotate value.
[out]  ReturnStatus  Return status.
Returns:
The rotate component of the transform as a quaternion.
Status Codes:

MEulerRotation MPxTransform::getEulerRotation ( MSpace::Space  space = MSpace::kTransform,
const MDGContext &  context = MDGContext::fsNormal,
MStatus *  ReturnStatus = NULL  
) [virtual]

Returns the rotation component of the transform as a euler rotation. The rotation is returned in MSpace::kTransform space. If an invalid space is used, MEulerRotation::identity will be returned.

Parameters:
[in]  space  The space used for getting the rotation.
[in]  context  The context used for getting the rotation.
[out]  ReturnStatus  Return status.
Returns:
The rotation component of the transform as an euler rotation.
Status Codes:

MStatus MPxTransform::rotateTo ( const MQuaternion &  newRot,
MSpace::Space  space = MSpace::kTransform,
const MDGContext &  context = MDGContext::fsNormal  
) [virtual]

Sets the rotation component of the transform using a quaternion. The rotation is performed in MSpace::kTransform space. The transform's existing order of rotation is preserved.

Parameters:
[in]  newRot  The new rotation value as a quaternion.
[in]  space  The space of the passed rotation value.
[in]  context  The context used for setting the rotation.
Returns:
Return Status.
Status Codes:

MStatus MPxTransform::rotateBy ( const MQuaternion &  rotateOffset,
MSpace::Space  space = MSpace::kTransform,
const MDGContext &  context = MDGContext::fsNormal  
) [virtual]

Adds to the rotation component of the transform by rotating relative to the existing transformation using a quaternion. 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. The transform's existing order of rotation is preserved.

Parameters:
[in]  rotateOffset  The relative rotation to apply to the transform.
[in]  space  The space of the passed rotation.
[in]  context  The context used for setting the rotation.
Returns:
Status code.
Status Codes:

MStatus MPxTransform::rotateTo ( const MEulerRotation &  euler,
MSpace::Space  space = MSpace::kTransform,
const MDGContext &  context = MDGContext::fsNormal  
) [virtual]

Sets the rotation component of the transform using an euler rotation. If the new rotation's order of rotation is different from that of the transform it will be reordered to match the transform.

Parameters:
[in]  euler  The new rotation value as an euler rotation.
[in]  space  The space of the passed rotation value.
[in]  context  The context used for setting the rotation.
Returns:
Status code.
Status Codes:

MStatus MPxTransform::rotateBy ( const MEulerRotation &  euler,
MSpace::Space  space = MSpace::kTransform,
const MDGContext &  context = MDGContext::fsNormal  
) [virtual]

Adds to the rotation component of the transform by rotating relative to the existing transform using a euler rotation. The only valid transformation spaces for this method are MSpace::kTransform and MSpace::kPreTransform/MSpacekObject. All other spaces are treated as being equivalent to MSpace::kTransform. If the supplied rotation's order of rotation is different from that of the transform, it will be reordered to match the transform before being added in.

Parameters:
[in]  euler  The rotation value of the relative euler rotation.
[in]  space  The space used for the relative rotation.
[in]  context  The context used for setting the rotation.
Returns:
Status code.
Status Codes:

MVector MPxTransform::getScale ( MSpace::Space  space = MSpace::kTransform,
const MDGContext &  context = MDGContext::fsNormal,
MStatus *  ReturnStatus = NULL  
) [virtual]

Returns the scale component of the transform. If the space is invalid a <1.0, 1.0, 1.0> vector is returned.

Parameters:
[in]  space  The space used to get the scale.
[in]  context  The context used to get the scale.
[out]  ReturnStatus  The return status.
Returns:
A MVector holding the x, y, and z scale components
Status Codes:

MStatus MPxTransform::scaleTo ( const MVector &  newScale,
MSpace::Space  space = MSpace::kTransform,
const MDGContext &  context = MDGContext::fsNormal  
) [virtual]

This method will set the scale of the transform to the passed value.

Parameters:
[in]  newScale  A MVector holding the scale components.
[in]  space  The space of the passed scale value.
[in]  context  The context used for setting the scale.
Returns:
Status code.
Status Codes:

MStatus MPxTransform::scaleBy ( const MVector &  scaleOffset,
MSpace::Space  space = MSpace::kTransform,
const MDGContext &  context = MDGContext::fsNormal  
) [virtual]

This method will apply a relative scale to an existing scale.

Parameters:
[in]  scaleOffset  A MVector holding the scale components.
[in]  space  The space of the passed scale values.
[in]  context  The context used for the scale.
Returns:
Status code.
Status Codes:

MVector MPxTransform::getShear ( MSpace::Space  space = MSpace::kTransform,
const MDGContext &  context = MDGContext::fsNormal,
MStatus *  ReturnStatus = NULL  
) [virtual]

Get the shear value for this transform.

Parameters:
[in]  space  The space used for retrieving the shear value.
[in]  context  The context used for getting the shear value.
[out]  ReturnStatus  Return status.
Returns:
A MVector holding the xy, xz, yz values of shear.
Status Codes:

MStatus MPxTransform::shearTo ( const MVector &  newShear,
MSpace::Space  space = MSpace::kTransform,
const MDGContext &  context = MDGContext::fsNormal  
) [virtual]

The method sets the shear component of the transform.

Parameters:
[in]  newShear  A MVector holding the new shear value.
[in]  space  The space of the passed shear value.
[in]  context  The context used for setting the shear value.
Returns:
Status code.
Status Codes:

MStatus MPxTransform::shearBy ( const MVector &  shearOffset,
MSpace::Space  space = MSpace::kTransform,
const MDGContext &  context = MDGContext::fsNormal  
) [virtual]

This method will apply a relative shear to the existing shear.

Parameters:
[in]  shearOffset  The relative shear value as a MVector.
[in]  space  The space of the passed shear value.
[in]  context  The context used for setting the shear.
Returns:
Status code.
Status Codes:

MPoint MPxTransform::getScalePivot ( MSpace::Space  space = MSpace::kTransform,
const MDGContext &  context = MDGContext::fsNormal,
MStatus *  ReturnStatus = NULL  
) [virtual]

This method returns the position of the pivot used by the scale component of the transform. The position is represented in internal units (centimeters).

Parameters:
[in]  space  The space used to get the scale pivot.
[in]  context  The context for getting the scale pivot.
[out]  ReturnStatus  Return status.
Returns:
A MPoint given the position of the scale pivot in centimeters.
Status Codes:

MPoint MPxTransform::getRotatePivot ( MSpace::Space  space = MSpace::kTransform,
const MDGContext &  context = MDGContext::fsNormal,
MStatus *  ReturnStatus = NULL  
) [virtual]

This method returns the position of the pivot used by the rotate component of the transform. The position is represented in internal units (centimeters).

  • space The space used to get the rotate pivot.
  • context The context for getting the rotate pivot.
  • ReturnStatus Return status.
Returns:
A MPoint given the position of the rotate pivot in centimeters.
Status Codes:

MVector MPxTransform::getScalePivotTranslation ( MSpace::Space  space = MSpace::kTransform,
const MDGContext &  context = MDGContext::fsNormal,
MStatus *  ReturnStatus = NULL  
) [virtual]

This method returns the scale pivot translation in internal units (centimeters). The scale pivot translation is an offset applied to the transform to allow adjustments to the scale pivot to be made without changing the overall transform.

Parameters:
[in]  space  The spaced used to get the scale pivot translation.
[in]  context  The context for getting the scale pivot translation.
[out]  ReturnStatus  Return status.
Returns:
An MVector containing the value of the scale pivot translation in centimeters.
Status Codes:

MVector MPxTransform::getRotatePivotTranslation ( MSpace::Space  space = MSpace::kTransform,
const MDGContext &  context = MDGContext::fsNormal,
MStatus *  ReturnStatus = NULL  
) [virtual]

This method returns the rotate pivot translation in internal units (centimeters). The rotate pivot translation is an offset applied to the transform to allow adjustments to the rotate pivot to be made without changing the overall transform.

Parameters:
[in]  space  The spaced used to get the rotate pivot translation.
[in]  context  The context for getting the rotate pivot translation.
[out]  ReturnStatus  Return status.
Returns:
An MVector containing the value of the rotate pivot translation in centimeters.
Status Codes:

MStatus MPxTransform::setScalePivot ( const MPoint &  newSP,
MSpace::Space  space = MSpace::kTransform,
bool  balance = true,
const MDGContext &  context = MDGContext::fsNormal  
) [virtual]

This method sets the position of the scale pivot. The position of the pivot is defined as a MPoint in internal units (centimeters).

If the balance argument is true, then the scale pivot translation will be adjusted such that the overall transform remains unchanged after the new scale pivot is set.

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

Parameters:
[in]  newSP  The position of the new scale pivot.
[in]  space  The space used to set the scale pivot.
[in]  context  The context used for setting the scale pivot.
Returns:
Return status.
Status Codes:

MStatus MPxTransform::setScalePivotTranslation ( const MVector &  newPT,
MSpace::Space  space = MSpace::kTransform,
const MDGContext &  context = MDGContext::fsNormal  
) [virtual]

This method sets the scale pivot translation in internal units (centimeters). The scale pivot translation is normally used to automatically compensate for changes in the scale pivot when the setScalePivot() method is used.

Parameters:
[in]  newPT  The scale pivot translation as a MVector.
[in]  space  The space used to set the scale pivot translation.
[in]  context  The context used in setting the scale pivot translation.
Returns:
Return status.
Status Codes:

MStatus MPxTransform::setRotatePivot ( const MPoint &  newRP,
MSpace::Space  space = MSpace::kTransform,
bool  balance = true,
const MDGContext &  context = MDGContext::fsNormal  
) [virtual]

This method sets the position of the rotate pivot. The position of the pivot is defined as a MPoint in internal units (centimeters).

If the balance argument is true, then the rotate pivot translation will be adjusted such that the overall transform remains unchanged after the new rotate pivot is set.

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

Parameters:
[in]  newRP  The position of the new rotate pivot.
[in]  space  The space used to set the rotate pivot.
[in]  context  The context used for setting the rotate pivot.
Returns:
Return status.
Status Codes:

MStatus MPxTransform::setRotatePivotTranslation ( const MVector &  newPT,
MSpace::Space  space = MSpace::kTransform,
const MDGContext &  context = MDGContext::fsNormal  
) [virtual]

This method sets the rotate pivot translation in internal units (centimeters). The rotate pivot translation is normally used to automatically compensate for changes in the rotate pivot when the setRotatePivot() method is used.

Parameters:
[in]  newPT  The rotate pivot translation as a MVector.
[in]  space  The space used to set the rotate pivot translation.
[in]  context  The context used in setting the rotate pivot translation.
Returns:
Return status.
Status Codes:

MTransformationMatrix::RotationOrder MPxTransform::getRotationOrder ( const MDGContext &  context = MDGContext::fsNormal  )  [virtual]

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

Note that there are two different enumerations used to represent order of rotation: MTransformationMatrix::RotationOrder and MEulerRotation::RotationOrder. The actual value stored in the transform's rotateOrder attribute is an MEulerRotation::RotationOrder. The value returned by this method is the corresponding MTransformationMatrix::RotationOrder value. If you need to convert between these two rotation order representations use the MPxTransformationMatrix::convertTransformationRotationOrder and MPxTransformationMatrix::convertEulerRotationOrder methods.

Parameters:
[in]  context  The context for getting the rotation order.
Returns:
The MTransformationMatrix::RotationOrder enum describing the rotation order of the transform.

MStatus MPxTransform::setRotationOrder ( MTransformationMatrix::RotationOrder  ro,
bool  reorder = true,
const MDGContext &  context = MDGContext::fsNormal  
) [virtual]

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

See the getRotationOrder method for a discussion of the difference between MTransformationMatrix::RotationOrder values and MEulerRotation::RotationOrder values.

Parameters:
[in]  ro  The new rotation order as a MTransformationMatrix::RotationOrder enum.
[in]  context  The context for setting the rotation order.
Returns:
Return status.
Status Codes:

MQuaternion MPxTransform::getRotateOrientation ( MSpace::Space  space = MSpace::kTransform,
const MDGContext &  context = MDGContext::fsNormal,
MStatus *  ReturnStatus = NULL  
) [virtual]

Returns the rotate orientation for the transformation matrix as a quaternion. The rotate orientation is the value associated with the rotateAxis attribute on this node. The rotate orientation value is used to orient the local rotation space of the transform.

Parameters:
[in]  space  The space used for getting the rotate orientation.
[in]  context  The context for getting the rotate orientation.
[out]  ReturnStatus  Return status.
Returns:
A MQuaternion representing the rotate orientation.
Status Codes:

MStatus MPxTransform::setRotateOrientation ( const MQuaternion &  newRO,
MSpace::Space  space = MSpace::kTransform,
bool  balance = true,
const MDGContext &  context = MDGContext::fsNormal  
) [virtual]

This method sets the rotate orientation for this transform. The rotate orientation is used to define the local rotation space. The rotate orientation is the value associated with the rotateAxis attribute on this node.

The balance argument allows the rotate orientation to be changed without affecting the overall transformation. The rotate value is adjusted to compensate for the change in rotate orientation.

Parameters:
[in]  newRO  The quaternion used to set the rotate orientation.
[in]  space  The space used when setting the rotate orientation.
[in]  balance  If true is used, then the rotation will change to compensate for the change in the rotate orientation.
[in]  context  The context used for setting the rotate orientation.
Returns:
Return status.
Status Codes:

void MPxTransform::updateMatrixAttrs ( const MDGContext &  context = MDGContext::fsNormal  ) 

This method is used only for the MPxTransform and MPxTransform derived classes. It will ensure that the values which change the resulting 4x4 matrix are current. It should be called before getting values that affect the matrix calculation.

If only a specific value needs to be updated, then use the updateMatrixAttrs(MObject &attr, const MDGContext &context) method.

Parameters:
[in]  context  The context to use when updating the values.

MStatus MPxTransform::updateMatrixAttrs ( MObject &  attr,
const MDGContext &  context = MDGContext::fsNormal  
)

This method ensures that a passed attribute will have its values current.

Parameters:
[in]  attr  The attribute.
[in]  context  The context to use.
Returns:
Return status.
Status Codes:

void MPxTransform::mustCallValidateAndSet ( MObject &  obj  )  [static]

This method must be called in the initialize() method for all attributes that affect the matrix of the transform. It will ensure that the matrix is properly calculated when the passed attribute is changed and that the validateAndSetValue method will get called for this attribute.

It is only for MPxTransform derived classes.

If a custom attribute on an MPxTransform derived classes is declared as "mustValidateAndSetValue", then the validateAndSetValue method must be implemented, so that it takes the data out of the data handle, and sets it into the datablock of the node.

Parameters:
[in]  obj  the attribute

MStatus MPxTransform::setNonAffineMatricesEnabled ( bool  enabled  )  [static]

Normal Maya transforms consist of translate, rotate, scale, and shear. All of these transform types produce an affine matrix. With MPxTransform it is possible to introduce non-affine matrices into places that previously did not consider their effects.

If non-affine matrices are enabled, then all calculations which require additional operations when handling non-affine matrices will perform the addition mathematical operations.

This is a static method and will affect all transforms when enabled.

Parameters:
[in]  enabled  If true, then non-afine calculations will be used.
Returns:
Return status
Status Codes:

bool MPxTransform::isNonAffineMatricesEnabled ( MStatus *  ReturnStatus  )  [static]

This method returns true is non-affine matrix calculations are being used for transforms.

Parameters:
[out]  ReturnStatus  The status
Returns:
true if non-affine matrix calculations are enabled.
Status Codes:

void MPxTransform::copyInternalData ( MPxNode *  node  )  [virtual]

This function copies the internal data of the transform node.

Parameters:
[in]  node  the node that is being duplicated

Reimplemented from MPxNode.

MVector MPxTransform::applyTranslationLimits ( const MVector &  unlimitedT,
MDataBlock &  block,
MStatus *  ReturnStatus = NULL  
) [protected, virtual]

This method returns a copy of the passed translation value with its members limited by any enabled translation limits on this node.

Parameters:
[in]  unlimitedT  The value before limits are applied.
[in]  block  The datablock to use.
[out]  ReturnStatus  Return status.
Returns:
The limited translation value.
Status Codes:

MVector MPxTransform::applyTranslationLocks ( const MVector &  toTest,
const MVector &  savedT,
MStatus *  ReturnStatus = NULL  
) [protected, virtual]

This method allows the custom transform to apply its own locking mechanism to translation. Standard dependency graph attribute locking happens automatically and cannot be modified by custom nodes.

If the plug should not be changed, then the value from the passed savedT argument should be return to be used in the transformation matrix.

Parameters:
[in]  toTest  The values to use if the plug is not locked.
[in]  savedT  The values to revert to if the plug cannot be changed.
[out]  ReturnStatus  status
Returns:
The value after the locking checks are applied.
Status Codes:

MEulerRotation MPxTransform::applyRotationLimits ( const MEulerRotation &  unlimitedR,
MDataBlock &  block,
MStatus *  ReturnStatus = NULL  
) [protected, virtual]

This method returns a copy of the passed rotation value with its members limited by any enabled rotation limits on this node.

Parameters:
[in]  unlimitedR  The value before applying the limits.
[in]  block  The datablock.
[out]  ReturnStatus  Return status.
Returns:
A MEulerRotation with limits applied to it.
Status Codes:

MEulerRotation MPxTransform::applyRotationLocks ( const MEulerRotation &  toTest,
const MEulerRotation &  savedR,
MStatus *  ReturnStatus = NULL  
) [protected, virtual]

This method allows the custom transform to apply its own locking mechanism to rotation. Standard dependency graph attribute locking happens automatically and cannot be modified by custom nodes.

If the plug should not be changed, then the value from the passed savedR argument should be returned to be used in the transformation matrix.

Parameters:
[in]  toTest  The values to use if the plug is not locked.
[in]  savedR  The values to revert to if the plug cannot be changed.
[in]  ReturnStatus  status
Returns:
The value after the locking checks are applied.
Status Codes:

MVector MPxTransform::applyScaleLimits ( const MVector &  unlimitedS,
MDataBlock &  block,
MStatus *  ReturnStatus = NULL  
) [protected, virtual]

This method returns a copy of the passed scale value with its members limited by any enabled scale limits on this node.

Parameters:
[in]  unlimitedS  The scale before applying limits.
[in]  block  The datablock.
[out]  ReturnStatus  Return status.
Returns:
The scale value with limits applied.
Status Codes:

MVector MPxTransform::applyScaleLocks ( const MVector &  toTest,
const MVector &  savedS,
MStatus *  ReturnStatus = NULL  
) [protected, virtual]

This method allows the custom transform to apply its own locking mechanism to scale. Standard dependency graph attribute locking happens automatically and cannot be modified by custom nodes.

If the plug should not be changed, then the value from the passed savedS argument should be return to be used in the transformation matrix.

Parameters:
[in]  toTest  The values to use if the plug is not locked.
[in]  savedS  The values to revert to if the plug cannot be changed.
[out]  ReturnStatus  status
Returns:
The scale value after the locking checks are applied.
Status Codes:

MVector MPxTransform::applyShearLocks ( const MVector &  toTest,
const MVector &  savedS,
MStatus *  ReturnStatus = NULL  
) [protected, virtual]

This method allows the custom transform to apply its own locking mechanism to shear. Standard dependency graph attribute locking happens automatically and cannot be modified by custom nodes.

If the plug should not be changed, then the value from the passed savedS argument should be return to be used in the transformation matrix.

Parameters:
[in]  toTest  The values to use if the plug is not locked.
[in]  savedS  The values to revert to if the plug cannot be changed.
[out]  ReturnStatus  status
Returns:
The shear value after the locking checks are applied.
Status Codes:

MEulerRotation MPxTransform::applyRotateOrientationLocks ( const MEulerRotation &  toTest,
const MEulerRotation &  savedRO,
MStatus *  ReturnStatus = NULL  
) [protected, virtual]

This method allows the custom transform to apply its own locking mechanism to rotation orientation. Standard dependency graph attribute locking happens automatically and cannot be modified by custom nodes.

If the plug should not be changed, then the value from the passed savedRO argument should be return to be used in the transformation matrix.

Parameters:
[in]  toTest  The values to use if the plug is not locked.
[in]  savedRO  The values to revert to if the plug cannot be changed.
[out]  ReturnStatus  status
Returns:
The rotate orientation value after the locking checks are applied.
Status Codes:

MVector MPxTransform::applyScaleLocksPivot ( const MPoint &  toTest,
const MPoint &  savedSP,
MStatus *  ReturnStatus = NULL  
) [protected, virtual]

This method allows the custom transform to apply its own locking mechanism to scale pivot. Standard dependency graph attribute locking happens automatically and cannot be modified by custom nodes.

If the plug should not be changed, then the value from the passed savedSP argument should be return to be used in the transformation matrix.

Parameters:
[in]  toTest  The values to use if the plug is not locked.
[in]  savedSP  The values to revert to if the plug cannot be changed.
[out]  ReturnStatus  status
Returns:
The scale pivot value after the locking checks are applied.
Status Codes:

MVector MPxTransform::applyRotatePivotLocks ( const MPoint &  toTest,
const MPoint &  savedRP,
MStatus *  ReturnStatus = NULL  
) [protected, virtual]

This method allows the custom transform to apply its own locking mechanism to rotation pivots. Standard dependency graph attribute locking happens automatically and cannot be modified by custom nodes.

If the plug should not be changed, then the value from the passed savedRP argument should be return to be used in the transformation matrix.

Parameters:
[in]  toTest  The values to use if the plug is not locked.
[in]  savedRP  The values to revert to if the plug cannot be changed.
[out]  ReturnStatus  status
Returns:
The value after the locking checks are applied.
Status Codes:

MVector MPxTransform::applyScaleLocksPivotTranslate ( const MVector &  toTest,
const MVector &  savedSPT,
MStatus *  ReturnStatus = NULL  
) [protected, virtual]

This method allows the custom transform to apply its own locking mechanism to the scalePivotTranslate attribute. Standard dependency graph attribute locking happens automatically and cannot be modified by custom nodes.

If the plug should not be changed, then the value from the passed savedR argument should be return to be used in the transformation matrix.

Parameters:
[in]  toTest  The values to use if the plug is not locked.
[in]  savedSPT  The values to revert to if the plug cannot be changed.
[out]  ReturnStatus  status
Returns:
The value after the locking checks are applied.
Status Codes:

MVector MPxTransform::applyRotatePivotLocksTranslate ( const MVector &  toTest,
const MVector &  savedRPT,
MStatus *  ReturnStatus = NULL  
) [protected, virtual]

This method allows the custom transform to apply its own locking mechanism to the rotatePivotTranslate attribute. Standard dependency graph attribute locking happens automatically and cannot be modified by custom nodes.

If the plug should not be changed, then the value from the passed savedR argument should be return to be used in the transformation matrix.

Parameters:
[in]  toTest  The values to use if the plug is not locked.
[in]  savedRPT  The values to revert to if the plug cannot be changed.
[out]  ReturnStatus  status
Returns:
The value after the locking checks are applied.
Status Codes:

MStatus MPxTransform::dirtyMatrix (  )  [protected]

USE _dirtyMatrix() IN SCRIPT.

This marks the entire matrix dirty. When a value is changed and that value should also update the matrix, use this method, or one of the specific dirty methods (i.e. dirtyTranslation())

Returns:
Status Code.
Status Codes:

MStatus MPxTransform::dirtyTranslation ( const MVector &  savedT  )  [protected]

USE _dirtyTranslation() IN SCRIPT.

If the current transformation matrix translation values are different than the passed translation value, then the translation portion of the matrix will be marked dirty.

Parameters:
[in]  savedT  The previous translation values.
Returns:
Status Code.
Status Codes:

MStatus MPxTransform::dirtyRotation ( const MEulerRotation &  savedR  )  [protected]

USE _dirtyRotation() IN SCRIPT.

If the current transformation matrix rotation values are different than the passed rotation value, then the rotation portion of the matrix will be marked dirty.

Parameters:
[in]  savedR  The previous rotation values.
Returns:
Status code.
Status Codes:

MStatus MPxTransform::dirtyScale ( const MVector &  savedS  )  [protected]

USE _dirtyScale() IN SCRIPT.

If the current transformation matrix scale values are different than the passed scale value, then the scale portion of the matrix will be marked dirty.

Parameters:
[in]  savedS  The previous scale values.
Returns:
Status
Status Codes:

MStatus MPxTransform::dirtyShear ( const MVector &  savedSh  )  [protected]

USE _dirtyShear() IN SCRIPT.

If the current transformation matrix shear values are different than the passed shear value, then the shear portion of the matrix will be marked dirty.

Parameters:
[in]  savedSh  The previous shear values.
Returns:
status
Status Codes:

MStatus MPxTransform::dirtyRotateOrientation ( const MEulerRotation &  savedRO  )  [protected]

USE _dirtyRotateOrientation() IN SCRIPT.

If the current transformation matrix rotate orientation values are different than the passed rotate orientation value, then the rotate orientation portion of the matrix will be marked dirty.

Parameters:
[in]  savedRO  The previous rotate orientation values.
Returns:
Status
Status Codes:

MStatus MPxTransform::dirtyScalePivot ( const MPoint &  savedSP  )  [protected]

USE _dirtyScalePivot() IN SCRIPT.

If the current transformation matrix scale pivot values are different than the passed scale pivot value, then the scale pivot portion of the matrix will be marked dirty.

Parameters:
[in]  savedSP  The previous scale pivot values.
Returns:
Status
Status Codes:

MStatus MPxTransform::dirtyRotatePivot ( const MPoint &  savedRP  )  [protected]

USE _dirtyRotatePivot() IN SCRIPT.

If the current transformation matrix rotate pivot values are different than the passed rotate pivot value, then the rotate pivot portion of the matrix will be marked dirty.

Parameters:
[in]  savedRP  The previous rotate pivot values.
Returns:
Status
Status Codes:

MStatus MPxTransform::dirtyScalePivotTranslation ( const MVector &  savedST  )  [protected]

USE _dirtyScalePivotTranslation() IN SCRIPT.

If the current transformation matrix scale pivot translation values are different than the passed scale pivot translation value, then the scale pivot translation portion of the matrix will be marked dirty.

Parameters:
[in]  savedST  The previous scale pivot translation values.
Returns:
Status
Status Codes:

MStatus MPxTransform::dirtyRotatePivotTranslation ( const MVector &  savedRT  )  [protected]

USE _dirtyRotatePivotTranslation() IN SCRIPT.

If the current transformation matrix rotate pivot translation values are different than the passed rotate pivot translation value, then the rotate pivot translation portion of the matrix will be marked dirty.

Parameters:
[in]  savedRT  The previous rotate pivot translation values.
Returns:
Status
Status Codes:

MStatus MPxTransform::checkAndSetTranslation ( MDataBlock &  block,
const MPlug &  plug,
const MVector &  newT,
MSpace::Space  space = MSpace::kTransform  
) [protected, virtual]

This method is used to modify and set the new translate values being passed in from the compute method or from the validateAndSetValue. The data block should be set with the corrected values. Corrections would come from enforcing any active limits as well as verifying that the plug's value may be changed. If the plug is locked or if it is the destination in a connection that disallows value changes, then the plug will be set to its unchanged value.

Parameters:
[in]  block  The data block to set.
[in]  plug  The translate plug (or one of its child plugs).
[in]  newT  The new translate value.
[in]  space  The space used for the new translation value.
Returns:
Status
Status Codes:

MStatus MPxTransform::checkAndSetRotation ( MDataBlock &  block,
const MPlug &  plug,
const MEulerRotation &  newR,
MSpace::Space  space = MSpace::kTransform  
) [protected, virtual]

This method verifies that the passed value can be set on the rotate plugs. In the base class, limits as well as locking are checked by this method.

The compute, validateAndSetValue, and rotateTo functions all use this method.

Parameters:
[in]  block  The data block
[in]  plug  The plug. This should be rotate or one of its children.
[in]  newR  The new rotate value.
[in]  space  The space that the newR value is using.
Returns:
Status
Status Codes:

MStatus MPxTransform::checkAndSetScale ( MDataBlock &  block,
const MPlug &  plug,
const MVector &  newS,
MSpace::Space  space = MSpace::kTransform  
) [protected, virtual]

This method verifies that the passed value can be set on the scale plugs. In the base class, limits as well as locking are checked by this method.

The compute, validateAndSetValue, and scaleTo functions all use this method.

Parameters:
[in]  block  The data block
[in]  plug  The plug. This should be scale or one of its children.
[in]  newS  The new scale value.
[in]  space  The space that the newS value is using.
Returns:
Status
Status Codes:

MStatus MPxTransform::checkAndSetShear ( MDataBlock &  block,
const MPlug &  plug,
const MVector &  newS,
MSpace::Space  space = MSpace::kTransform  
) [protected, virtual]

This method verifies that the passed value can be set on the shear plugs. In the base class, only the locking conditions are enforced.

The compute, validateAndSetValue, and shearTo functions all use this method. If limits are desired on shear, then the limit enforcement should be implemented in this method in a derived class.

Parameters:
[in]  block  The data block
[in]  plug  The plug. This should be shear or one of its children.
[in]  newS  The new shear value.
[in]  space  The space that the newS value is using.
Returns:
Status
Status Codes:

MStatus MPxTransform::checkAndSetRotateOrientation ( MDataBlock &  block,
const MPlug &  plug,
const MEulerRotation &  newRO,
MSpace::Space  space = MSpace::kTransform,
bool  balance = true  
) [protected, virtual]

This method verifies that the passed value can be set on the rotateAxis plugs. In the base class, only the locking conditions are enforced. This method will also update the rotation value if balance is true.

The compute, validateAndSetValue, and setRotateOrientation functions all use this method. If limits are desired on rotateAxis, then the limit enforcement should be implemented in this method in a derived class.

Parameters:
[in]  block  The data block
[in]  plug  The plug. This should be rotateAxis or one of its children.
[in]  newRO  The new rotate orientation value.
[in]  space  The space that the newRO value is using.
[in]  balance  If balance is true, then the rotation is modified to compensate for the change in rotateAxis such that the transform remains unchanged.
Returns:
Status
Status Codes:

MStatus MPxTransform::checkAndSetRotatePivot ( MDataBlock &  block,
const MPlug &  plug,
const MPoint &  newRP,
MSpace::Space  space = MSpace::kTransform,
bool  balance = true  
) [protected, virtual]

This method verifies that the passed value can be set on the rotatePivot plugs. In the base class, only the locking conditions are enforced. This method will also update the rotatePivotTranslate value if balance is true.

The compute, validateAndSetValue, and setRotatePivot functions all use this method. If limits are desired on rotatePivot, then the limit enforcement should be implemented in this method in a derived class.

Parameters:
[in]  block  The data block
[in]  plug  The plug. This should be rotatePivot or one of its children.
[in]  newRP  The new rotate pivot value.
[in]  space  The space that the newRP value is using.
[in]  balance  If balance is true, then the rotatePivotTranslate is modified to compensate for the change in rotatePivot such that the transform remains unchanged.
Returns:
Status
Status Codes:

MStatus MPxTransform::checkAndSetRotatePivotTranslation ( MDataBlock &  block,
const MPlug &  plug,
const MVector &  newPT,
MSpace::Space  space = MSpace::kTransform  
) [protected, virtual]

This method verifies that the passed value can be set on the rotatePivotTranslate plugs. In the base class, only the locking conditions are enforced.

The compute, validateAndSetValue, and setRotatePivotTranslation functions all use this method. If limits are desired on rotatePivotTranslate, then the limit enforcement should be implemented in this method in a derived class.

Parameters:
[in]  block  The data block
[in]  plug  The plug. This should be rotatePivotTranslate or one of its children.
[in]  newPT  The new rotate pivot translate value.
[in]  space  The space that the newPT value is using.
Returns:
Status
Status Codes:

MStatus MPxTransform::checkAndSetScalePivot ( MDataBlock &  block,
const MPlug &  plug,
const MPoint &  newSP,
MSpace::Space  space = MSpace::kTransform,
bool  balance = true  
) [protected, virtual]

This method verifies that the passed value can be set on the scalePivot plugs. In the base class, only the locking conditions are enforced. This method will also update the scalePivotTranslate value if balance is true.

The compute, validateAndSetValue, and setScalePivot functions all use this method. If limits are desired on scalePivot, then the limit enforcement should be implemented in this method in a derived class.

Parameters:
[in]  block  The data block
[in]  plug  The plug. This should be scalePivot or one of its children.
[in]  newSP  The new scale pivot value.
[in]  space  The space that the newSP value is using.
[in]  balance  If balance is true, then the scalePivotTranslate is modified to compensate for the change in scalePivot such that the transform remains unchanged.
Returns:
Status
Status Codes:

MStatus MPxTransform::checkAndSetScalePivotTranslation ( MDataBlock &  block,
const MPlug &  plug,
const MVector &  newPT,
MSpace::Space  space = MSpace::kTransform  
) [protected, virtual]

This method verifies that the passed value can be set on the scalePivotTranslate plugs. In the base class, only the locking conditions are enforced.

The compute, validateAndSetValue, and setScalePivotTranslation functions all use this method. If limits are desired on scalePivotTranslate, then the limit enforcement should be implemented in this method in a derived class.

Parameters:
[in]  block  The data block
[in]  plug  The plug. This should be scalePivotTranslate or one of its children.
[in]  newPT  The new scale pivot translate value.
[in]  space  The space that the newPT value is using.
Returns:
Status
Status Codes:
Autodesk® Maya® 2011 © 1997-2010 Autodesk, Inc. All rights reserved. Generated with doxygen 1.5.6