diff options
Diffstat (limited to '')
| -rw-r--r-- | tools/globalcode/utility/transformmatrix.cpp | 904 |
1 files changed, 904 insertions, 0 deletions
diff --git a/tools/globalcode/utility/transformmatrix.cpp b/tools/globalcode/utility/transformmatrix.cpp new file mode 100644 index 0000000..1264fff --- /dev/null +++ b/tools/globalcode/utility/transformmatrix.cpp @@ -0,0 +1,904 @@ +/*=========================================================================== + transformmatrix.cpp + Created: October 16, 2000 + Auuthor: Bryan Brandt + + Copyright (c) 2000 Radical Entertainment, Inc. + All rights reserved. +===========================================================================*/ + +//#include <maya/MFnTransform.h> +//#include <maya/MPoint.h> +//#include <maya/MQuaternion.h> +//#include <maya/MEulerRotation.h> +//#include <maya/MVector.h> +//#include <maya/MDagPath.h> +//#include <maya/MFnIkJoint.h> +//#include <maya/MPlug.h> + +#include "transformmatrix.h" + + +TransformMatrix::TransformMatrix(): + rotateOrder(ORDER_XYZ) +{ + SetIdentity(); +} + + +TransformMatrix::TransformMatrix(const MDagPath& dagPath): + rotateOrder(ORDER_XYZ) +{ + SetIdentity(); + Assign(dagPath); +} + + +TransformMatrix::TransformMatrix(const MTransformationMatrix& xform): + rotateOrder(ORDER_XYZ) +{ + SetIdentity(); + Assign(xform); +} + + +bool TransformMatrix::Assign(const MDagPath& dagPath) +{ + MStatus status; + + MObject node = dagPath.node(&status); + if (!status) + return false; + + if (node.hasFn(MFn::kJoint)) + { + MDagPath tmpDagPath = dagPath; + return AssignJoint(tmpDagPath, node); + } + else if (node.hasFn(MFn::kTransform)) + { + MFnTransform xformNode(dagPath, &status); + if (!status) + return false; + + MTransformationMatrix xform = xformNode.transformation(&status); + if (!status) + return false; + + return Assign(xform); + } + + return false; +} + + +bool TransformMatrix::AssignJoint(MDagPath& dagPath, MObject& node) +{ + MStatus status; + + MFnIkJoint jointNode(node, &status); + if (!status) + return false; + + double tmp[3]; + MQuaternion tmpQuat; + MEulerRotation tmpEuler; + MVector tmpVector; + + scalePivot.x = 0.0f; + scalePivot.y = 0.0f; + scalePivot.z = 0.0f; + + status = jointNode.getScale(tmp); + if (!status) + return false; + scaleX = (float)tmp[0]; + scaleY = (float)tmp[1]; + scaleZ = (float)tmp[2]; + + // we've officially updated a scale dependency, + // so set the scale matrix dirty flag + scaleDirty = true; + + shearXY = 0.0f; + shearXZ = 0.0f; + shearYZ = 0.0f; + + scalePivotTranslate.x = 0.0f; + scalePivotTranslate.y = 0.0f; + scalePivotTranslate.z = 0.0f; + + rotatePivot.x = 0.0f; + rotatePivot.y = 0.0f; + rotatePivot.z = 0.0f; + + // we've officially updated a hierarchy dependency, + // so set the hierarchy matrix dirty flag + hierarchyDirty = true; + + status = jointNode.getScaleOrientation(tmpQuat); + if (!status) + return false; + tmpEuler = tmpQuat.asEulerRotation(); + tmpEuler.reorderIt(MEulerRotation::kXYZ); + rotateAxisX = (float)tmpEuler.x; + rotateAxisY = (float)tmpEuler.y; + rotateAxisZ = (float)tmpEuler.z; + + MTransformationMatrix::RotationOrder ro; + jointNode.getRotation(tmp, ro); + switch (ro) + { + case MTransformationMatrix::kXYZ: + rotateOrder = ORDER_XYZ; + break; + case MTransformationMatrix::kYZX: + rotateOrder = ORDER_YZX; + break; + case MTransformationMatrix::kZXY: + rotateOrder = ORDER_ZXY; + break; + case MTransformationMatrix::kXZY: + rotateOrder = ORDER_XZY; + break; + case MTransformationMatrix::kYXZ: + rotateOrder = ORDER_YXZ; + break; + case MTransformationMatrix::kZYX: + rotateOrder = ORDER_ZYX; + break; + + default: + return false; + } + + rotateX = (float)tmp[0]; + rotateY = (float)tmp[1]; + rotateZ = (float)tmp[2]; + + rotatePivotTranslate.x = 0.0f; + rotatePivotTranslate.y = 0.0f; + rotatePivotTranslate.z = 0.0f; + + status = jointNode.getOrientation(tmpEuler); + tmpEuler.reorderIt(MEulerRotation::kXYZ); + jointOrientX = (float)tmpEuler.x; + jointOrientY = (float)tmpEuler.y; + jointOrientZ = (float)tmpEuler.z; + + // default inverseScale to identity + inverseScaleX = 1.0f; + inverseScaleY = 1.0f; + inverseScaleZ = 1.0f; + + // retrieve the segment scale compensate attribute + MFnDependencyNode depNode(node, &status); + if (!status) + return false; + + MPlug plug = depNode.findPlug("segmentScaleCompensate", &status); + if (!status) + return false; + + bool segmentScaleCompensate; + status = plug.getValue(segmentScaleCompensate); + if (!status) + return false; + + // if we are compensating for parent scale, do so + if (segmentScaleCompensate) + { + plug = depNode.findPlug("inverseScaleX", &status); + if (!status) + return false; + status = plug.getValue(inverseScaleX); + if (!status) + return false; + if (inverseScaleX != 0.0f) + inverseScaleX = (1.0f / inverseScaleX); + + plug = depNode.findPlug("inverseScaleY", &status); + if (!status) + return false; + status = plug.getValue(inverseScaleY); + if (!status) + return false; + if (inverseScaleY != 0.0f) + inverseScaleY = (1.0f / inverseScaleY); + + plug = depNode.findPlug("inverseScaleZ", &status); + if (!status) + return false; + status = plug.getValue(inverseScaleZ); + if (!status) + return false; + if (inverseScaleZ != 0.0f) + inverseScaleZ = (1.0f / inverseScaleZ); + } + + tmpVector = jointNode.translation(MSpace::kWorld, &status); + if (!status) + return false; + translate.x = (float)tmpVector.x; + translate.y = (float)tmpVector.y; + translate.z = (float)tmpVector.z; + + return true; +} + + +bool TransformMatrix::Assign(const MTransformationMatrix& xform) +{ + MStatus status; + MPoint tmpPoint; + double tmpArray[3]; + MQuaternion tmpQuat; + MEulerRotation tmpEuler; + MVector tmpVector; + + tmpPoint = xform.scalePivot(MSpace::kWorld, &status); + if (!status) + return false; + scalePivot.x = (float)tmpPoint.x; + scalePivot.y = (float)tmpPoint.y; + scalePivot.z = (float)tmpPoint.z; + + // we've officially updated a scale dependency, + // so set the scale matrix dirty flag + scaleDirty = true; + + status = xform.getScale(tmpArray, MSpace::kWorld); + if (!status) + return false; + scaleX = (float)tmpArray[0]; + scaleY = (float)tmpArray[1]; + scaleZ = (float)tmpArray[2]; + + status = xform.getShear(tmpArray, MSpace::kWorld); + if (!status) + return false; + shearXY = (float)tmpArray[0]; + shearXZ = (float)tmpArray[1]; + shearYZ = (float)tmpArray[2]; + + tmpPoint = xform.scalePivotTranslation(MSpace::kWorld, &status); + if (!status) + return false; + scalePivotTranslate.x = (float)tmpPoint.x; + scalePivotTranslate.y = (float)tmpPoint.y; + scalePivotTranslate.z = (float)tmpPoint.z; + + tmpPoint = xform.rotatePivot(MSpace::kWorld, &status); + if (!status) + return false; + rotatePivot.x = (float)tmpPoint.x; + rotatePivot.y = (float)tmpPoint.y; + rotatePivot.z = (float)tmpPoint.z; + + // we've officially updated a hierarchy dependency, + // so set the hierarchy matrix dirty flag + hierarchyDirty = true; + + tmpQuat = xform.rotationOrientation(); + tmpEuler = tmpQuat.asEulerRotation(); + tmpEuler.reorderIt(MEulerRotation::kXYZ); + rotateAxisX = (float)tmpEuler.x; + rotateAxisY = (float)tmpEuler.y; + rotateAxisZ = (float)tmpEuler.z; + + MTransformationMatrix::RotationOrder ro = xform.rotationOrder(); + switch (ro) + { + case MTransformationMatrix::kXYZ: + rotateOrder = ORDER_XYZ; + break; + case MTransformationMatrix::kYZX: + rotateOrder = ORDER_YZX; + break; + case MTransformationMatrix::kZXY: + rotateOrder = ORDER_ZXY; + break; + case MTransformationMatrix::kXZY: + rotateOrder = ORDER_XZY; + break; + case MTransformationMatrix::kYXZ: + rotateOrder = ORDER_YXZ; + break; + case MTransformationMatrix::kZYX: + rotateOrder = ORDER_ZYX; + break; + + default: + return false; + } + + tmpQuat = xform.rotation(); + tmpEuler = tmpQuat.asEulerRotation(); + switch (rotateOrder) + { + case ORDER_XYZ: + tmpEuler.reorderIt(MEulerRotation::kXYZ); + break; + case ORDER_YZX: + tmpEuler.reorderIt(MEulerRotation::kYZX); + break; + case ORDER_ZXY: + tmpEuler.reorderIt(MEulerRotation::kZXY); + break; + case ORDER_XZY: + tmpEuler.reorderIt(MEulerRotation::kXZY); + break; + case ORDER_YXZ: + tmpEuler.reorderIt(MEulerRotation::kYXZ); + break; + case ORDER_ZYX: + tmpEuler.reorderIt(MEulerRotation::kZYX); + break; + + default: + return false; + } + rotateX = (float)tmpEuler.x; + rotateY = (float)tmpEuler.y; + rotateZ = (float)tmpEuler.z; + + tmpVector = xform.rotatePivotTranslation(MSpace::kWorld, &status); + if (!status) + return false; + rotatePivotTranslate.x = (float)tmpVector.x; + rotatePivotTranslate.y = (float)tmpVector.y; + rotatePivotTranslate.z = (float)tmpVector.z; + + // only used in joints + jointOrientX = 0.0f; + jointOrientY = 0.0f; + jointOrientZ = 0.0f; + + // only used in joints + inverseScaleX = 1.0f; + inverseScaleY = 1.0f; + inverseScaleZ = 1.0f; + + tmpVector = xform.translation(MSpace::kWorld, &status); + if (!status) + return false; + translate.x = (float)tmpVector.x; + translate.y = (float)tmpVector.y; + translate.z = (float)tmpVector.z; + + return true; +} + + +void TransformMatrix::SetScalePivot(const tlPoint& sp) +{ + scalePivot = sp; + scaleDirty = true; +} + + +void TransformMatrix::SetScale(float x, float y, float z) +{ + scaleX = x; + scaleY = y; + scaleZ = z; + scaleDirty = true; +} + + +void TransformMatrix::SetScaleX(float x) +{ + scaleX = x; + scaleDirty = true; +} + + +void TransformMatrix::SetScaleY(float y) +{ + scaleY = y; + scaleDirty = true; +} + + +void TransformMatrix::SetScaleZ(float z) +{ + scaleZ = z; + scaleDirty = true; +} + + +void TransformMatrix::SetShear(float xy, float xz, float yz) +{ + shearXY = xy; + shearXZ = xz; + shearYZ = yz; + scaleDirty = true; +} + + +void TransformMatrix::SetShearXY(float xy) +{ + shearXY = xy; + scaleDirty = true; +} + + +void TransformMatrix::SetShearXZ(float xz) +{ + shearXZ = xz; + scaleDirty = true; +} + + +void TransformMatrix::SetShearYZ(float yz) +{ + shearYZ = yz; + scaleDirty = true; +} + + +void TransformMatrix::SetScalePivotTranslate(float x, float y, float z) +{ + scalePivotTranslate.x = x; + scalePivotTranslate.y = y; + scalePivotTranslate.z = z; + scaleDirty = true; +} + + +void TransformMatrix::SetScalePivotTranslate(const tlPoint& spt) +{ + scalePivotTranslate = spt; + scaleDirty = true; +} + + +void TransformMatrix::SetScalePivotX(float x) +{ + scalePivotTranslate.x = x; + scaleDirty = true; +} + + +void TransformMatrix::SetScalePivotY(float y) +{ + scalePivotTranslate.y = y; + scaleDirty = true; +} + + +void TransformMatrix::SetScalePivotZ(float z) +{ + scalePivotTranslate.z = z; + scaleDirty = true; +} + + +void TransformMatrix::SetRotatePivot(float x, float y, float z) +{ + rotatePivot.x = x; + rotatePivot.y = y; + rotatePivot.z = z; + hierarchyDirty = true; +} + + +void TransformMatrix::SetRotatePivot(const tlPoint& rp) +{ + rotatePivot = rp; + hierarchyDirty = true; +} + + +void TransformMatrix::SetRotatePivotX(float x) +{ + rotatePivot.x = x; + hierarchyDirty = true; +} + + +void TransformMatrix::SetRotatePivotY(float y) +{ + rotatePivot.y = y; + hierarchyDirty = true; +} + + +void TransformMatrix::SetRotatePivotZ(float z) +{ + rotatePivot.z = z; + hierarchyDirty = true; +} + + +void TransformMatrix::SetRotateAxis(float x, float y, float z) +{ + rotateAxisX = x; + rotateAxisY = y; + rotateAxisZ = z; + hierarchyDirty = true; +} + + +void TransformMatrix::SetRotateAxisX(float rax) +{ + rotateAxisX = rax; + hierarchyDirty = true; +} + + +void TransformMatrix::SetRotateAxisY(float ray) +{ + rotateAxisY = ray; + hierarchyDirty = true; +} + + +void TransformMatrix::SetRotateAxisZ(float raz) +{ + rotateAxisZ = raz; + hierarchyDirty = true; +} + + +void TransformMatrix::SetRotate(float x, float y, float z) +{ + rotateX = x; + rotateY = y; + rotateZ = z; + hierarchyDirty = true; +} + + +void TransformMatrix::SetRotateX(float x) +{ + rotateX = x; + hierarchyDirty = true; +} + + +void TransformMatrix::SetRotateY(float y) +{ + rotateY = y; + hierarchyDirty = true; +} + + +void TransformMatrix::SetRotateZ(float z) +{ + rotateZ = z; + hierarchyDirty = true; +} + + +void TransformMatrix::SetRotateOrder(RotateOrder ro) +{ + rotateOrder = ro; + hierarchyDirty = true; +} + + +void TransformMatrix::SetRotatePivotTranslate(float x, float y, float z) +{ + rotatePivotTranslate.x = x; + rotatePivotTranslate.y = y; + rotatePivotTranslate.z = z; + hierarchyDirty = true; +} + + +void TransformMatrix::SetRotatePivotTranslate(const tlPoint& rpt) +{ + rotatePivotTranslate = rpt; + hierarchyDirty = true; +} + + +void TransformMatrix::SetRotatePivotTranslateX(float x) +{ + rotatePivotTranslate.x = x; + hierarchyDirty = true; +} + + +void TransformMatrix::SetRotatePivotTranslateY(float y) +{ + rotatePivotTranslate.y = y; + hierarchyDirty = true; +} + + +void TransformMatrix::SetRotatePivotTranslateZ(float z) +{ + rotatePivotTranslate.z = z; + hierarchyDirty = true; +} + + +void TransformMatrix::SetJointOrient(float x, float y, float z) +{ + jointOrientX = x; + jointOrientY = y; + jointOrientZ = z; + hierarchyDirty = true; +} + + +void TransformMatrix::SetJointOrientX(float x) +{ + jointOrientX = x; + hierarchyDirty = true; +} + + +void TransformMatrix::SetJointOrientY(float y) +{ + jointOrientY = y; + hierarchyDirty = true; +} + + +void TransformMatrix::SetJointOrientZ(float z) +{ + jointOrientZ = z; + hierarchyDirty = true; +} + + +void TransformMatrix::SetInverseScale(float x, float y, float z) +{ + inverseScaleX = x; + inverseScaleY = y; + inverseScaleZ = z; + hierarchyDirty = true; +} + + +void TransformMatrix::SetInverseScaleX(float x) +{ + inverseScaleX = x; + hierarchyDirty = true; +} + + +void TransformMatrix::SetInverseScaleY(float y) +{ + inverseScaleY = y; + hierarchyDirty = true; +} + + +void TransformMatrix::SetInverseScaleZ(float z) +{ + inverseScaleZ = z; + hierarchyDirty = true; +} + + +void TransformMatrix::SetTranslate(float x, float y, float z) +{ + translate.x = x; + translate.y = y; + translate.z = z; + hierarchyDirty = true; +} + + +void TransformMatrix::SetTranslate(const tlPoint& t) +{ + translate = t; + hierarchyDirty = true; +} + + +void TransformMatrix::SetTranslateX(float x) +{ + translate.x = x; + hierarchyDirty = true; +} + + +void TransformMatrix::SetTranslateY(float y) +{ + translate.y = y; + hierarchyDirty = true; +} + + +void TransformMatrix::SetTranslateZ(float z) +{ + translate.z = z; + hierarchyDirty = true; +} + + +void TransformMatrix::SetScaleMatrixIdentity() +{ + scalePivot.x = 0.0f; + scalePivot.y = 0.0f; + scalePivot.z = 0.0f; + + scaleX = 1.0f; + scaleY = 1.0f; + scaleZ = 1.0f; + + shearXY = 0.0f; + shearXZ = 0.0f; + shearYZ = 0.0f; + + scalePivotTranslate.x = 0.0f; + scalePivotTranslate.y = 0.0f; + scalePivotTranslate.z = 0.0f; + + scaleMatrix.IdentityMatrix(); + scaleDirty = false; +} + + +void TransformMatrix::SetHierarchyMatrixIdentity() +{ + rotatePivot.x = 0.0f; + rotatePivot.y = 0.0f; + rotatePivot.z = 0.0f; + + rotateAxisX = 0.0f; + rotateAxisY = 0.0f; + rotateAxisZ = 0.0f; + + rotateX = 0.0f; + rotateY = 0.0f; + rotateZ = 0.0f; + + rotatePivotTranslate.x = 0.0f; + rotatePivotTranslate.y = 0.0f; + rotatePivotTranslate.z = 0.0f; + + jointOrientX = 0.0f; + jointOrientY = 0.0f; + jointOrientZ = 0.0f; + + inverseScaleX = 1.0f; + inverseScaleY = 1.0f; + inverseScaleZ = 1.0f; + + translate.x = 0.0f; + translate.y = 0.0f; + translate.z = 0.0f; + + hierarchyMatrix.IdentityMatrix(); + hierarchyDirty = false; +} + + +void TransformMatrix::SetIdentity() +{ + SetScaleMatrixIdentity(); + SetHierarchyMatrixIdentity(); +} + + +void TransformMatrix::ComputeScaleMatrix() +{ + if (!scaleDirty) + return; + + scaleMatrix.IdentityMatrix(); + scaleMatrix.Translate(-scalePivot); + scaleMatrix.Scale(scaleX, scaleY, scaleZ, true); + scaleMatrix.Shear(shearXY, shearXZ, shearYZ); + scaleMatrix.Translate(scalePivot); + scaleMatrix.Translate(scalePivotTranslate); + + scaleMatrix.Scale(inverseScaleX, inverseScaleY, inverseScaleZ, true); + + scaleDirty = false; +} + + +void TransformMatrix::ComputeHierarchyMatrix() +{ + if (!hierarchyDirty) + return; + + hierarchyMatrix.IdentityMatrix(); + hierarchyMatrix.Translate(-rotatePivot); + + hierarchyMatrix.RotateX(rotateAxisX); + hierarchyMatrix.RotateY(rotateAxisY); + hierarchyMatrix.RotateZ(rotateAxisZ); + + switch (rotateOrder) + { + case ORDER_XYZ: + hierarchyMatrix.RotateX(rotateX); + hierarchyMatrix.RotateY(rotateY); + hierarchyMatrix.RotateZ(rotateZ); + break; + + case ORDER_YZX: + hierarchyMatrix.RotateY(rotateY); + hierarchyMatrix.RotateZ(rotateZ); + hierarchyMatrix.RotateX(rotateX); + break; + + case ORDER_ZXY: + hierarchyMatrix.RotateZ(rotateZ); + hierarchyMatrix.RotateX(rotateX); + hierarchyMatrix.RotateY(rotateY); + break; + + case ORDER_XZY: + hierarchyMatrix.RotateX(rotateX); + hierarchyMatrix.RotateZ(rotateZ); + hierarchyMatrix.RotateY(rotateY); + break; + + case ORDER_YXZ: + hierarchyMatrix.RotateY(rotateY); + hierarchyMatrix.RotateX(rotateX); + hierarchyMatrix.RotateZ(rotateZ); + break; + + case ORDER_ZYX: + hierarchyMatrix.RotateZ(rotateZ); + hierarchyMatrix.RotateY(rotateY); + hierarchyMatrix.RotateX(rotateX); + break; + } + + hierarchyMatrix.Translate(rotatePivot); + hierarchyMatrix.Translate(rotatePivotTranslate); + hierarchyMatrix.RotateX(jointOrientX); + hierarchyMatrix.RotateY(jointOrientY); + hierarchyMatrix.RotateZ(jointOrientZ); + //hierarchyMatrix.Scale(inverseScaleX, inverseScaleY, inverseScaleZ, true); + hierarchyMatrix.Translate(translate); + + hierarchyDirty = false; +} + + +const tlMatrix& TransformMatrix::GetScaleMatrix() const +{ + const_cast<TransformMatrix*>(this)->ComputeScaleMatrix(); + return scaleMatrix; +} + + +const tlMatrix& TransformMatrix::GetHierarchyMatrix() const +{ + const_cast<TransformMatrix*>(this)->ComputeHierarchyMatrix(); + return hierarchyMatrix; +} + + +void TransformMatrix::GetScaleMatrixLHS(tlMatrix& matrix) const +{ + GetScaleMatrixRHS(matrix); + matrix.RHSToLHS(); +} + + +void TransformMatrix::GetHierarchyMatrixLHS(tlMatrix& matrix) const +{ + GetHierarchyMatrixRHS(matrix); + matrix.RHSToLHS(); +} + + +void TransformMatrix::GetScaleMatrixRHS(tlMatrix& matrix) const +{ + const_cast<TransformMatrix*>(this)->ComputeScaleMatrix(); + matrix = scaleMatrix; +} + + +void TransformMatrix::GetHierarchyMatrixRHS(tlMatrix& matrix) const +{ + const_cast<TransformMatrix*>(this)->ComputeHierarchyMatrix(); + matrix = hierarchyMatrix; +} + + +// End of file. + |