view.drawText("Swiss Army Manipulator", textPos, OpenMayaUI.M3dView.kLeft)
		view.endGL()


	def plugToManipConversion(self, theIndex):
		numData = OpenMaya.MFnNumericData()
		numDataObj = numData.create(OpenMaya.MFnNumericData.k3Float)
    def plugToManipConversion(self, manipIndex):
        try:
            #Get parent transform node of the locator node

            parentTransform = self.fNodePath.transform()

            #Get the transform node DAG path
            transformPath = OpenMaya.MDagPath()
            OpenMaya.MDagPath.getAPathTo(parentTransform, transformPath)

            #Retrieve world space translation
            fnTrans = OpenMaya.MFnTransform(transformPath)
            translation = OpenMaya.MVector()
            translation = fnTrans.getTranslation(OpenMaya.MSpace.kWorld)

            numData = OpenMaya.MFnNumericData()
            numDataValue = numData.create(OpenMaya.MFnNumericData.k3Double)
            status = numData.setData3Double(translation.x, translation.y,
                                            translation.z)
            manipData = OpenMayaUI.MManipData(numDataValue)
        except:
            sys.stderr.write("ERROR: arrowManip.plugToManipConversion\n")
            raise

        return manipData
    def startPointCallback(self, index):
        numData = OpenMaya.MFnNumericData()
        numDataObj = numData.create(OpenMaya.MFnNumericData.k3Double)

        vec = self.nodeTranslation()
        numData.setData3Double(vec.x, vec.y, vec.z)

        return OpenMayaUI.MManipData(numDataObj)
Beispiel #4
0
    def manipToPlugConversion(self, plugIndex):
        #print "manipToPlugConversion", plugIndex

        try:

            if plugIndex in self.ffpIdxMap:  # front float plug
                helix = self.ffpIdxMap[plugIndex]
                numData = OpenMaya.MFnNumericData()
                numDataObj = numData.create(OpenMaya.MFnNumericData.k3Double)

                sp = OpenMaya.MPoint()
                cp = OpenMaya.MPoint()

                frontManip = OpenMayaUI.MFnDistanceManip(
                                                    self.fDistanceFrontManip)

                self.getConverterManipValue(frontManip.startPointIndex(), sp)
                self.getConverterManipValue(frontManip.currentPointIndex(), cp)

                m2 = self.getTransformMtxFromNode(helix.helixTransform)
                m = m2.inverse()

                self.sp = sp * m
                self.cp = cp * m

                # distance is...
                distance = self.computeDistance(
                                        helix, self.sp, self.cp, self.frontDir
                                                ) - self.manipHandleOffset

                self.frontDistance = distance

                delta = self.distanceToBase(helix, distance)
                self.resizeCNHelixFront(helix, delta)

                numData.setData3Double(cp.x, cp.y, cp.z)
                returnData = OpenMayaUI.MManipData(numDataObj)

            elif plugIndex in self.epIdxMap:
                helix = self.epIdxMap[plugIndex]
                numData = OpenMaya.MFnNumericData()
                numDataObj = numData.create(OpenMaya.MFnNumericData.k3Double)

                ep = OpenMaya.MPoint()
                ecp = OpenMaya.MPoint()

                backManip = OpenMayaUI.MFnDistanceManip(
                                                    self.fDistanceBackManip)

                self.getConverterManipValue(backManip.startPointIndex(), ep)
                self.getConverterManipValue(backManip.currentPointIndex(), ecp)

                m2 = self.getTransformMtxFromNode(helix.helixTransform)
                m = m2.inverse()

                self.ep = ep * m
                self.ecp = ecp * m

                # distance is...
                distance = self.computeDistance(
                                        helix, self.ep, self.ecp, self.backDir
                                                ) - self.manipHandleOffset

                self.backDistance = distance

                delta = self.distanceToBase(helix, distance)
                self.resizeCNHelixBack(helix, delta)

                numData.setData3Double(ecp.x, ecp.y, ecp.z)
                returnData = OpenMayaUI.MManipData(numDataObj)
        except:
            sys.stderr.write("ERROR: helixManip.manipToPlugConversion\n")
            raise

        return returnData
Beispiel #5
0
    def plugToManipConversion(self, manipIndex):

        #print "plugToManipCalled"

        manipData = OpenMayaUI.MManipData()
        try:

            frontManip = OpenMayaUI.MFnDistanceManip(self.fDistanceFrontManip)
            backManip = OpenMayaUI.MFnDistanceManip(self.fDistanceBackManip)

            boundBoxCenter = OpenMaya.MVector()
            boundBoxScale = OpenMaya.MVector()

            selectedItems = cmds.ls(
                                Mom().helixTransformName + "*", selection=True)
            bbox = cmds.exactWorldBoundingBox(selectedItems)
            boundBoxCenter.x = float((bbox[0] + bbox[3]) / 2)
            boundBoxCenter.y = float((bbox[1] + bbox[4]) / 2)
            boundBoxCenter.z = float((bbox[2] + bbox[5]) / 2)
            boundBoxScale.x = float(bbox[3] - bbox[0])
            boundBoxScale.y = float(bbox[4] - bbox[1])
            boundBoxScale.z = float(bbox[5] - bbox[2])

            if(manipIndex == frontManip.currentPointIndex()):

                ws = boundBoxCenter + project(boundBoxScale / 2, self.frontDir)
                ws += self.frontDir * \
                                (self.manipHandleOffset + self.frontDistance)

                numData = OpenMaya.MFnNumericData()
                numDataObj = numData.create(OpenMaya.MFnNumericData.k3Double)
                numData.setData3Double(ws.x, ws.y, ws.z)
                manipData = OpenMayaUI.MManipData(numDataObj)

            elif(manipIndex == backManip.currentPointIndex()):

                ws = boundBoxCenter + project(boundBoxScale / 2, self.backDir)
                ws += self.backDir * \
                                (self.manipHandleOffset + self.backDistance)

                numData = OpenMaya.MFnNumericData()
                numDataObj = numData.create(OpenMaya.MFnNumericData.k3Double)
                numData.setData3Double(ws.x, ws.y, ws.z)
                manipData = OpenMayaUI.MManipData(numDataObj)

            elif(manipIndex == frontManip.startPointIndex()):

                ws = boundBoxCenter + project(boundBoxScale / 2, self.frontDir)

                numData = OpenMaya.MFnNumericData()
                numDataObj = numData.create(OpenMaya.MFnNumericData.k3Float)
                numData.setData3Float(ws.x, ws.y, ws.z)
                manipData = OpenMayaUI.MManipData(numDataObj)

            elif(manipIndex == backManip.startPointIndex()):

                ws = boundBoxCenter + project(boundBoxScale / 2, self.backDir)

                numData = OpenMaya.MFnNumericData()
                numDataObj = numData.create(OpenMaya.MFnNumericData.k3Float)
                numData.setData3Float(ws.x, ws.y, ws.z)
                manipData = OpenMayaUI.MManipData(numDataObj)
        except:
            sys.stderr.write("ERROR: helixManip.plugToManipConversion\n")
            raise

        return manipData