def connectToDependNode(self, node):
self.nodeFn.setObject(node)
# input curve plug
curvePositionPlug = self.nodeFn.findPlug(positionOnCurve.curvePositionAttribute)
curvePlug = self.nodeFn.findPlug(positionOnCurve.inputCurveAttribute)
connections = OpenMaya.MPlugArray()
curvePlug.connectedTo(connections, True, False)
curveNodeFn = OpenMaya.MFnDagNode(connections[0].node())
curveNode = OpenMaya.MDagPath()
curveNodeFn.getPath(curveNode)
curveFn = OpenMaya.MFnNurbsCurve(curveNode)
manipPos = OpenMaya.MPoint()
curveFn.getPointAtParam(0.001, manipPos, OpenMaya.MSpace.kWorld)
# get curve position plug
# and set manip translation
distanceManipFn = OpenMayaUI.MFnDistanceManip(self.distManip)
distanceManipFn.setDirection(OpenMaya.MVector(0, 1, 0))
distanceManipFn.connectToDistancePlug(curvePositionPlug)
distanceManipFn.setTranslation(OpenMaya.MVector(manipPos), OpenMaya.MSpace.kWorld)
mscriptutil = OpenMaya.MScriptUtil()
# scale Manip
mscriptutil.createFromList([10, 10, 10], 3)
scaleDoubleArrayPtr = mscriptutil.asDoublePtr()
distanceManipFn.setScale(scaleDoubleArrayPtr)
self.finishAddingManips()
OpenMayaMPx.MPxManipContainer.connectToDependNode(self, node)
def createChildren(self):
self.fDistanceManip = self.addDistanceManip("distanceManip", "distance")
distanceManipFn = OpenMayaUI.MFnDistanceManip(self.fDistanceManip)
startPoint = OpenMaya.MPoint(0.0, 0.0, 0.0)
direction = OpenMaya.MVector(0.0, 1.0, 0.0)
distanceManipFn.setStartPoint(startPoint)
distanceManipFn.setDirection(direction)
self.fFreePointManip = self.addFreePointTriadManip("pointManip", "freePoint")
def connectToDependNode(self, helix):
#print "connectToDependNode called"
nodeFn = OpenMaya.MFnDependencyNode(helix.helixNode)
try:
frontPlug = nodeFn.findPlug("startBaseFloat")
backPlug = nodeFn.findPlug("endBaseFloat")
frontManip = OpenMayaUI.MFnDistanceManip(self.fDistanceFrontManip)
frontManip.connectToDistancePlug(frontPlug)
backManip = OpenMayaUI.MFnDistanceManip(self.fDistanceBackManip)
backManip.connectToDistancePlug(backPlug)
# hookup the converter functions
self.addPlugToManipConversion(frontManip.startPointIndex())
self.addPlugToManipConversion(frontManip.currentPointIndex())
self.addPlugToManipConversion(backManip.startPointIndex())
self.addPlugToManipConversion(backManip.currentPointIndex())
idx = self.addManipToPlugConversion(frontPlug)
self.ffpIdxMap[idx] = helix
idx = self.addManipToPlugConversion(backPlug)
self.epIdxMap[idx] = helix
# initially, current points and start/end points match
startPos = nodeFn.findPlug("startPos")
startPoint = self.getFloat3PlugValue(startPos)
self.sp = startPoint
self.cp = startPoint + self.frontDir * self.manipHandleOffset
endPos = nodeFn.findPlug("endPos")
endPoint = self.getFloat3PlugValue(endPos)
self.ep = endPoint
self.ecp = endPoint + self.backDir * self.manipHandleOffset
except:
sys.stderr.write(
"helixManip: Error finding and connecting plugs\n")
sys.stderr.write(sys.exc_info()[0])
raise
def createChildren(self):
self.helices = {}
self.helicesNames = []
#print "helixManip: createChildren being called..."
# startPoint should correspond to the end of the helix
# read the attribute to get the offset from the starting position
self.fDistanceFrontManip = self.addDistanceManip(
"distanceManip", "distance")
distanceManipFn = OpenMayaUI.MFnDistanceManip(self.fDistanceFrontManip)
startPoint = OpenMaya.MPoint(0.0, 0.0, 0.0)
self.frontDir = OpenMaya.MVector(0.0, 0.0, 1.0)
distanceManipFn.setStartPoint(startPoint)
distanceManipFn.setDirection(self.frontDir)
self.fDistanceBackManip = self.addDistanceManip(
"distancgeteManip", "distance")
distanceManipFn = OpenMayaUI.MFnDistanceManip(self.fDistanceBackManip)
startPoint = OpenMaya.MPoint(0.0, 0.0, 0.0)
self.backDir = OpenMaya.MVector(0.0, 0.0, -1.0)
distanceManipFn.setStartPoint(startPoint)
distanceManipFn.setDirection(self.backDir)
def createChildren(self):
try:
startPoint = OpenMaya.MPoint(0.0, 0.0, 0.0)
direction = OpenMaya.MVector(0.0, 1.0, 0.0)
self.fDistanceManip = self.addDistanceManip("distanceManip", "distance")
distanceManipFn = OpenMayaUI.MFnDistanceManip(self.fDistanceManip)
distanceManipFn.setStartPoint(startPoint)
distanceManipFn.setDirection(direction)
except:
sys.stderr.write("ERROR: footPrintLocatorManip.createChildren\n")
raise
def connectToDependNode(self, node):
nodeFn = OpenMaya.MFnDependencyNode(node)
try:
syPlug = nodeFn.findPlug("scaleY")
tPlug = nodeFn.findPlug("translate")
distanceManipFn = OpenMayaUI.MFnDistanceManip(self.fDistanceManip)
distanceManipFn.connectToDistancePlug(syPlug)
freePointManipFn = OpenMayaUI.MFnFreePointTriadManip(self.fFreePointManip)
freePointManipFn.connectToPointPlug(tPlug)
OpenMayaMPx.MPxManipContainer.finishAddingManips(self)
OpenMayaMPx.MPxManipContainer.connectToDependNode(self,node)
except:
sys.stderr.write( "Error finding and connecting plugs\n" )
raise
def createChildren(self):
# FreePointTriadManip
self.fFreePointTriadManip = self.addFreePointTriadManip(
"freePointTriadManip", "point")
freePointTriadManipFn = OpenMayaUI.MFnFreePointTriadManip(
self.fFreePointTriadManip)
# DirectionManip
self.fDirectionManip = self.addDirectionManip("directionManip",
"direction")
directionManipFn = OpenMayaUI.MFnDirectionManip(self.fDirectionManip)
# ToggleManip
self.fToggleManip = self.addToggleManip("toggleManip", "toggle")
toggleManipFn = OpenMayaUI.MFnToggleManip(self.fToggleManip)
# StateManip
self.fStateManip = self.addStateManip("stateManip", "state")
stateManipFn = OpenMayaUI.MFnStateManip(self.fStateManip)
# DiscManip
self.fDiscManip = self.addDiscManip("discManip", "angle")
discManipFn = OpenMayaUI.MFnDiscManip(self.fDiscManip)
# CircleSweepManip
self.fCircleSweepManip = self.addCircleSweepManip(
"circleSweepManip", "angle")
circleSweepManipFn = OpenMayaUI.MFnCircleSweepManip(
self.fCircleSweepManip)
circleSweepManipFn.setCenterPoint(OpenMaya.MPoint(0, 0, 0))
circleSweepManipFn.setNormal(OpenMaya.MVector(0, 1, 0))
circleSweepManipFn.setRadius(2.0)
circleSweepManipFn.setDrawAsArc(True)
# DistanceManip
self.fDistanceManip = self.addDistanceManip("distanceManip",
"distance")
distanceManipFn = OpenMayaUI.MFnDistanceManip(self.fDistanceManip)
distanceManipFn.setStartPoint(OpenMaya.MPoint(0, 0, 0))
distanceManipFn.setDirection(OpenMaya.MVector(0, 1, 0))
# RotateManip
self.fRotateManip = self.addRotateManip("RotateManip", "rotation")
rotateManipFn = OpenMayaUI.MFnRotateManip(self.fRotateManip)
# ScaleManip
self.fScaleManip = self.addScaleManip("scaleManip", "scale")
scaleManipFn = OpenMayaUI.MFnScaleManip(self.fScaleManip)
def connectToDependNode(self, node):
try:
dagNodeFn = OpenMaya.MFnDagNode(node)
dagNodeFn.getPath(self.fNodePath)
distanceManipFn = OpenMayaUI.MFnDistanceManip(self.fDistanceManip)
nodeFn = OpenMaya.MFnDependencyNode(node)
sizePlug = nodeFn.findPlug('size')
distanceManipFn.connectToDistancePlug(sizePlug)
self.finishAddingManips()
OpenMayaMPx.MPxManipContainer.connectToDependNode(self, node)
except:
sys.stderr.write("ERROR: footPrintLocatorManip.connectToDependNode\n")
raise
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
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
self.fScaleManip = self.addScaleManip("scaleManip", "scale")
scaleManipFn = OpenMayaUI.MFnScaleManip(self.fScaleManip)
def connectToDependNode(self, node):
# Get the DAG path
dagNodeFn = OpenMaya.MFnDagNode(node)
dagNodeFn.getPath(self.fNodePath)
parentNode = dagNodeFn.parent(0)
parentNodeFn = OpenMaya.MFnDagNode(parentNode)
# Connect the plugs
nodeFn = OpenMaya.MFnDependencyNode()
nodeFn.setObject(node)
# FreePointTriadManip
freePointTriadManipFn = OpenMayaUI.MFnFreePointTriadManip(self.fFreePointTriadManip)
try:
translationPlug = parentNodeFn.findPlug("t")
freePointTriadManipFn.connectToPointPlug(translationPlug)
except:
pass
# DirectionManip
directionManipFn = OpenMayaUI.MFnDirectionManip()
directionManipFn.setObject(self.fDirectionManip)
try:
directionPlug = nodeFn.findPlug("arrow2Direction")
directionManipFn.connectToDirectionPlug(directionPlug)
startPointIndex = directionManipFn.startPointIndex()
self.addPlugToManipConversion(startPointIndex)
except:
pass
# DistanceManip
distanceManipFn = OpenMayaUI.MFnDistanceManip()
distanceManipFn.setObject(self.fDistanceManip)
try:
sizePlug = nodeFn.findPlug("size")
distanceManipFn.connectToDistancePlug(sizePlug)
startPointIndex = distanceManipFn.startPointIndex()
self.addPlugToManipConversion(startPointIndex)
except:
pass
# CircleSweepManip
circleSweepManipFn = OpenMayaUI.MFnCircleSweepManip(self.fCircleSweepManip)
try:
arrow1AnglePlug = nodeFn.findPlug("arrow1Angle")
circleSweepManipFn.connectToAnglePlug(arrow1AnglePlug)
centerIndex = circleSweepManipFn.centerIndex()
self.addPlugToManipConversion(centerIndex)
except:
pass
# DiscManip
discManipFn = OpenMayaUI.MFnDiscManip(self.fDiscManip)
try:
arrow3AnglePlug = nodeFn.findPlug("arrow3Angle")
discManipFn.connectToAnglePlug(arrow3AnglePlug)
centerIndex = discManipFn.centerIndex()
self.addPlugToManipConversion(centerIndex)
except:
pass
# StateManip
stateManipFn = OpenMayaUI.MFnStateManip(self.fStateManip)
try:
statePlug = nodeFn.findPlug("state")
stateManipFn.connectToStatePlug(statePlug)
positionIndex = stateManipFn.positionIndex()
self.addPlugToManipConversion(positionIndex)
except:
pass
# ToggleManip
toggleManipFn = OpenMayaUI.MFnToggleManip(self.fToggleManip)
try:
togglePlug = nodeFn.findPlug("toggle")
toggleManipFn.connectToTogglePlug(togglePlug)
startPointIndex = toggleManipFn.startPointIndex()
self.addPlugToManipConversion(startPointIndex)
except:
pass
# Determine the transform node for the locator
transformPath = OpenMaya.MDagPath(self.fNodePath)
transformPath.pop()
transformNode = OpenMaya.MFnTransform(transformPath)
# RotateManip
rotateManipFn = OpenMayaUI.MFnRotateManip(self.fRotateManip)
try:
rotatePlug = transformNode.findPlug("rotate")
rotateManipFn.connectToRotationPlug(rotatePlug)
rotateManipFn.displayWithNode(node)
except:
pass
# ScaleManip
scaleManipFn = OpenMayaUI.MFnScaleManip(self.fScaleManip)
try:
scalePlug = transformNode.findPlug("scale")
scaleManipFn.connectToScalePlug(scalePlug)
scaleManipFn.displayWithNode(node)
except:
