Esempio n. 1
0
def setRotate_keepJointOrient(mtx, jnt):
    jntP = cmds.listRelatives(jnt, p=1)[0]
    joValue = cmds.getAttr(jnt + '.jo')[0]
    joMEuler = om.MEulerRotation(math.radians(joValue[0]),
                                 math.radians(joValue[1]),
                                 math.radians(joValue[2]))
    joTransform = mpx.MPxTransformationMatrix(om.MMatrix())
    joTransform.rotateBy(joMEuler)
    jo_im = joTransform.asMatrixInverse()

    jntP_wim_list = cmds.getAttr(jntP + '.wim')
    jntP_wim = om.MMatrix()
    om.MScriptUtil.createMatrixFromList(jntP_wim_list, jntP_wim)

    cuMtx = mtx * jntP_wim * jo_im

    transform = mpx.MPxTransformationMatrix(cuMtx)
    rot = transform.eulerRotation().asVector()

    degrees = [math.degrees(rot.x), math.degrees(rot.y), math.degrees(rot.z)]

    for i in range(len(degrees)):
        if degrees[i] > 180:
            degrees[i] = degrees[i] - 360
        elif degrees[i] < -180:
            degrees[i] = degrees[i] + 360
    cmds.setAttr(jnt + '.r', *degrees)
Esempio n. 2
0
    def setFlyControlPoint(self, target, *args):

        ns = self.getNamespace(target)
        rootCtl = ns + 'Root_CTL'
        flyCtl = ns + 'Fly_CTL'

        flyCtlMtxList = cmds.getAttr(flyCtl + '.wm')
        rootCtlMtxList = cmds.getAttr(rootCtl + '.wm')

        flyCtlMtx = om.MMatrix()
        rootCtlMtx = om.MMatrix()

        om.MScriptUtil.createMatrixFromList(flyCtlMtxList, flyCtlMtx)
        om.MScriptUtil.createMatrixFromList(rootCtlMtxList, rootCtlMtx)

        localMtx = rootCtlMtx * flyCtlMtx.inverse()

        mpxTrans = mpx.MPxTransformationMatrix(localMtx)
        trans = mpxTrans.translation()
        rotate = mpxTrans.eulerRotation().asVector()

        cmds.setAttr(flyCtl + '.pivTx', trans.x)
        cmds.setAttr(flyCtl + '.pivTy', trans.y)
        cmds.setAttr(flyCtl + '.pivTz', trans.z)
        cmds.setAttr(flyCtl + '.pivRx', math.degrees(rotate.x))
        cmds.setAttr(flyCtl + '.pivRy', math.degrees(rotate.y))
        cmds.setAttr(flyCtl + '.pivRz', math.degrees(rotate.z))

        cmds.setAttr(flyCtl + '.blend', 1)
Esempio n. 3
0
def initializePlugin(obj):
    plugin = OpenMayaMPx.MFnPlugin(obj, 'David Zuber', '1.0', 'Any')
    matrixcreator = OpenMayaMPx.MPxTransformationMatrix.creator
    matrixid = OpenMayaMPx.MPxTransformationMatrix().baseTransformationMatrixId
    try:
        plugin.registerTransform(JB_AssetNode.kNodeName,
                                 JB_AssetNode.kPluginNodeId,
                                 JB_AssetNode.creator, JB_AssetNode.initialize,
                                 matrixcreator, matrixid)
    except:
        raise PluginInitError('Failed to register %s node' %
                              JB_AssetNode.kNodeName)
    def asMatrix(self, percent=None):
        """
		Find the new matrix and return it
		"""
        if percent == None:
            matrix = OpenMayaMPx.MPxTransformationMatrix.asMatrix(self)
            tm = OpenMaya.MTransformationMatrix(matrix)
            quat = self.rotation()
            rockingValue = self.getRockInX()
            newTheta = math.radians(rockingValue)
            quat.setToXAxis(newTheta)
            tm.addRotationQuaternion(quat.x, quat.y, quat.z, quat.w,
                                     OpenMaya.MSpace.kTransform)
            return tm.asMatrix()
        else:
            m = OpenMayaMPx.MPxTransformationMatrix(self)
            #
            trans = m.translation()
            rotatePivotTrans = m.rotatePivot()
            scalePivotTrans = m.scalePivotTranslation()
            trans = trans * percent
            rotatePivotTrans = rotatePivotTrans * percent
            scalePivotTrans = scalePivotTrans * percent
            m.translateTo(trans)
            m.setRotatePivot(rotatePivotTrans)
            m.setScalePivotTranslation(scalePivotTrans)
            #
            quat = self.rotation()
            rockingValue = self.getRockInX()
            newTheta = math.radians(rockingValue)

            quat.setToXAxis(newTheta)
            m.rotateBy(quat)
            eulerRotate = m.eulerRotation()
            m.rotateTo(eulerRotate * percent, OpenMaya.MSpace.kTransform)
            #
            s = self.scale(OpenMaya.MSpace.kTransform)
            s.x = 1.0 + (s.x - 1.0) * percent
            s.y = 1.0 + (s.y - 1.0) * percent
            s.z = 1.0 + (s.z - 1.0) * percent
            m.scaleTo(s, OpenMaya.MSpace.kTransform)
            #
            return m.asMatrix()
Esempio n. 5
0
def setRotMMatrix(target, MMatrix, **options):
    os = True  # objectSpace
    ws = False  # worldSpace

    items = options.items()

    for item in items:
        if item[0] in ['os', 'objectSpace']:
            os = item[1]
            ws = not item[1]
        elif item[0] in ['ws', 'worldSpace']:
            ws = item[1]
            os = not item[1]

    mpxMatrix = mpx.MPxTransformationMatrix(MMatrix)
    rot = mpxMatrix.eulerRotation().asVector()

    cmds.xform(
        target,
        os=os,
        ws=ws,
        ro=[math.degrees(rot.x),
            math.degrees(rot.y),
            math.degrees(rot.z)])
Esempio n. 6
0
def getRotateFromMatrix(mtx):
    transform = mpx.MPxTransformationMatrix(mtx)
    r = transform.eulerRotation().asVector()
    return math.degrees(r.x), math.degrees(r.y), math.degrees(r.z)