def create_planar_locators(nLocators, length=10.0, name='test', size=1):
  
    root = pm.spaceLocator(name='%s_root' %name)
    root.add_shape(shape='double_cross', axis='+z', size=size)
    locators=[root]    

    for i in range(nLocators):
        spacing = length / (nLocators - 1)
        tx = i * spacing        
        
        locator = pm.spaceLocator(name='%s_locator_%d' %(name, i+1))
        locator.getShape().localScale.set([size,size,size])
        #locator.add_parent_group()
       
        pm.parent(locator, root)
        locator.translateX.set(tx)
        
        
        locators.append(locator)

    for i in range(2, len(locators)):
        pm.aimConstraint(locators[i], locators[i-1], mo=False, aimVector=[1,0,0], upVector=[0,0,1], worldUpType='objectrotation', worldUpVector = [0,0,1], worldUpObject=root)

    for locator in locators[1:]:
        locator.tz.lock()
        locator.rotate.lock()
        
    for locator in locators[1:-1]:
        locator.add_rotate_arrows(size=size)

    return locators
        
    
Beispiel #2
0
def MakeStabilizedNode(nodeName=None):
    '''
    Very simple proc to generate a Stabilized node for
    raw MoCap tracking purposes... First selected node
    is used as the Aim axis, second selected is used as this
    aim's worldUp
    '''
    RequiredMarkers = pm.ls(sl=True, l=True)
    AimAt = RequiredMarkers[0]
    WorldUpObj = RequiredMarkers[1]

    #pos = pm.xform(WorldUpObj, q=True, ws=True, t=True)
    Curve = pm.curve(ws=True, d=1, p=(0, 0, 0), k=0)

    pm.pointConstraint(RequiredMarkers, Curve)
    pm.aimConstraint((AimAt, Curve),
                     weight=1,
                     aimVector=(0, 0, 1),
                     upVector=(0, 1, 0),
                     worldUpType="object",
                     worldUpObject=WorldUpObj)

    #Snap a curveKnot to the pivot of all referenceMarkers
    for node in RequiredMarkers:
        pm.curve(Curve,
                 a=True,
                 ws=True,
                 p=(pm.xform(node, q=True, ws=True, t=True)))
    pm.curve(Curve,
             a=True,
             ws=True,
             p=(pm.xform(AimAt, q=True, ws=True, t=True)))

    return Curve
def alignSecCtlAlongXfos(ctl, prevXfo=None, nextXfo=None):
    '''
    xAxis of ctl will always aim towards nextXfo, or away from prevXfo
    zAxis of ctl is used for upAxis
    '''
    # add offsets
    autoOffset = secCtl.addOffset(ctl, 'child', '_autoAlign')
    manualOffset = secCtl.addOffset(ctl, 'child', '_manualAlign')
    
    # manualOffset uses ctl's rotations
    ctl.r >> manualOffset.r
    
    # autoOffset uses aim constraints
    if prevXfo and nextXfo:
        # have to blend between two xfos
        blendTwoAimConstraints(autoOffset, prevXfo, nextXfo)
    else:
        # direct aim constraint to either
        if prevXfo:
            pm.aimConstraint(prevXfo, autoOffset, 
                             mo=True,
                             aim=(-1,0,0),
                             u=(0,0,1), 
                             wut='objectrotation',
                             wuo=ctl,
                             wu=(0,0,1))
        elif nextXfo:
            pm.aimConstraint(nextXfo, autoOffset, 
                             mo=True,
                             aim=(1,0,0),
                             u=(0,0,1), 
                             wut='objectrotation',
                             wuo=ctl,
                             wu=(0,0,1))
 def generateTwistSystem(self, _twistEnds, _twistTarget, _invert=False):
     j1Trans = pm.PyNode(_twistEnds[0]).getTranslation(space='world')
     j2Trans = pm.PyNode(_twistEnds[-1]).getTranslation(space='world')
     twistAim = pm.datatypes.Vector(j2Trans - j1Trans)
     twistAim.normalize()
     twistDist = self.distanceBetween(j1Trans, j2Trans)
     twistDiv = twistDist / 5
     i = 1
     splitLocName = str(_twistEnds[0])[5:]
     twistJts = []
     while i < 4:
         pos = j1Trans + (twistAim * (twistDiv * (i + 1)))
         newJt = pm.joint(n=splitLocName + '_twist_0' + str(i), p=pos)
         pm.parent(newJt, _twistEnds[0])
         newJt.jointOrient.set([0, 0, 0])
         twistJts.append(newJt)
         i += 1
     pm.orientConstraint(twistJts[-1], twistJts[0], w=1, mo=0)
     pm.orientConstraint(_twistEnds[0], twistJts[0], w=2, mo=0)
     pm.orientConstraint(twistJts[-1], twistJts[1], w=2, mo=0)
     pm.orientConstraint(_twistEnds[0], twistJts[1], w=1, mo=0)
     if _invert:
         pm.aimConstraint(_twistEnds[-1],
                          twistJts[-1],
                          aim=(1, 0, 0),
                          wuo=_twistTarget,
                          wut='objectrotation',
                          wu=(0, 1, 0))
     else:
         pm.aimConstraint(_twistEnds[-1],
                          twistJts[-1],
                          aim=(-1, 0, 0),
                          wuo=_twistTarget,
                          wut='objectrotation',
                          wu=(0, -1, 0))
Beispiel #5
0
    def createConnector(self, pt1, pt2, radius=0.5):

        # create cylinder and align between pt1/pt2
        base_name = pt1
        _logger.debug('Connector base name is %s' % base_name)
        viz_shape = pm.cylinder(n=base_name + 'Connector')
        pm.pointConstraint([pt1, pt2], viz_shape[0], mo=0)
        pm.aimConstraint(pt2, viz_shape[0], weight=1, upVector=(0, 1, 0), worldUpType="vector", offset=(0, 0, 0),
                         aimVector=(1, 0, 0), worldUpVector=(0, 1, 0))

        viz_direction = pm.cone(n=base_name + 'Direction', r=3 * radius)
        viz_shape[0].t >> viz_direction[0].t
        viz_shape[0].r >> viz_direction[0].r

        # measure distance between
        dist_node = pm.createNode('distanceBetween', n=base_name + '_distanceBetween')
        pm.connectAttr(pt1 + '.worldMatrix[0]', dist_node + '.inMatrix1', f=True)
        pm.connectAttr(pt2 + '.worldMatrix[0]', dist_node + '.inMatrix2', f=True)
        _logger.debug('Distance between base name is %s' % base_name)

        # length
        divide_half = pm.createNode('multiplyDivide', n=base_name + '_distceBetween_multiplyDivide')
        divide_half.input2X.set(0.5)
        dist_node.distance >> divide_half.input1X
        divide_half.outputX >> viz_shape[0].scaleX

        # radius
        viz_shape[0].scaleZ.set(radius)
        viz_shape[0].scaleY.set(radius)

        return [viz_shape[0], viz_direction[0]]
def connectPrims( a=None, b=None ):
	# if a and/or b are none, use current selection
	try:
		if a ==None or b == None:
			a = pm.selected()[0]
			b = pm.selected()[1]
	# if current selection different from 2, print error message and do nothing else
	except:
		print "Current selection must have two objects!"
	
	# have the two objects aim at each other
	global Aim1
	Aim1 = pm.aimConstraint( a, b)  
	global Aim2
	Aim2 = pm.aimConstraint( b, a)
	
	# create a curve with two points connecting the two prims
	myCurve = pm.curve(p=[(a.translate.get()), (b.translate.get())], degree=1) # creates the points at the location of the translate pivot (center of object)
	# create clusters for CVs
	cluster1 = pm.cluster(myCurve.cv[0]) # cluster for the first point of the myCurve
	cluster2 = pm.cluster(myCurve.cv[1]) # cluster for the second point of myCurve
	
	# Constrain the clusters to the points
	pm.pointConstraint( a, cluster1)
	pm.pointConstraint( b, cluster2)
	
	# rename all the objects so they relate to the their purpose
	pm.rename(a, 'ObjectA')
	pm.rename(b, 'ObjectB')
	pm.rename(Aim1, 'Aim1')
	pm.rename(Aim2, 'Aim2')
	pm.rename(myCurve, 'ConnectingLine')
Beispiel #7
0
def curveAim(crv, aimCrv, numJnts, mo=True, aimVector=(0,1,0), upVector=(0,1,0), worldUpType="vector", worldUpVector=(0,1,0)):
	'''Takes two curves, creates joints on the first and aims objects at the second.
	Args:
		crv (pm.nt.nurbsCurve): nurbs curve to generate things on
		aimCrv (pm.nt.nurbsCurve): nurbs curve to aim things to
		numJnts (int): number of joints to be generated
		other : all of the aim vector constraint settings
	Returns list(grp, list(joints))
	Usage:
		curveAim(pm.ls(sl=True)[0], pm.ls(sl=True)[1], 10)
	'''
	grp = pm.group(em=True, n=aimCrv+'AIMDRV_GRP')
	joints = rig_makeJointsAlongCurve("seatbeltDrive", crv, numJnts)
	for joint in joints:
		joint.setParent(w=True)
		pociOrig = atc.rig_getClosestPointNode(joint, crv)
		print pociOrig.parameter.get()
		
		poci = pm.nodetypes.PointOnCurveInfo(n=joint+"_POCI")
		aimCrv.getShape().attr("worldSpace[0]").connect(poci.inputCurve)
		poci.parameter.set(pociOrig.parameter.get())
		loc = pm.group(em=True, n=joint+'AIMDRV_GRP', p=grp)
		poci.position.connect(loc.t)
		
		pm.aimConstraint(loc, joint, mo=mo, aimVector=aimVector, upVector=upVector, worldUpType=worldUpType, worldUpVector=worldUpVector)
	return [grp, joints]
Beispiel #8
0
    def create_point_base(self, point, **kwargs):
        super(RigAim, self).create_point_base(point, **kwargs)
        root = self.create.group.point_base(point, type='world', name='root')
        aim = pm.duplicate(root)[0]
        self.name_convention.rename_name_in_format(aim, name='aim')

        pm.move(aim, 10, **{'move{}'.format(config.axis_order[0].upper()): True, 'objectSpace': True, 'relative': True})
        aim.setParent(self.rig_system.kinematics)
        root.setParent(self.rig_system.kinematics)
        reset = self.create.group.point_base(root, type='inserted', name='reset')

        self.tip = reset
        self.aim = root

        reset_control, control = self.create.controls.point_base(aim, name='aim')
        reset_control.setParent(self.rig_system.controls)
        parent = kwargs.pop('parent', control)
        aim_vector = [0, 0, 0]
        aim_vector[config.axis_order[0]] = 1
        up_vector = [0, 0, 0]
        up_vector[config.axis_order[1]] = 1
        self.create.constraint.point(point, reset, mo=True)
        pm.aimConstraint(aim, root, aimVector=aim_vector, worldUpType='objectrotation',
                         upVector=up_vector, worldUpObject=parent, worldUpVector=[0, 1, 0])
        self.rm.align(root, reset_control, translate=False)
        pm.parentConstraint(control, aim)
        self.reset_controls.append(reset_control)
        self.controls.append(control)
Beispiel #9
0
    def orient_joint(self, joint, aimAxis=[1, 0, 0], upAxis=[0, 0, 1],
                     worldUpType="vector",
                     worldUpVector=[0, 1, 0]):

        #joint should be pm.nt.Joint type
        if not isinstance(joint, pm.nt.Joint):
            raise TypeError("%s sholud be an instance of pm.nt.Joint Class"
                            % joint)
        jointUnder = self.jointUnder(joint)
        if jointUnder is None:
            return 0
        temporalGroup = DrawNode(Shape.transform, 'temporalGroup')
        pm.parent(jointUnder, temporalGroup.drawnNode)

        pm.setAttr(joint.jointOrient, (0, 0, 0))

        if worldUpType == "object":
            aimConst = pm.aimConstraint(jointUnder, joint, aimVector=aimAxis,
                                        upVector=upAxis,
                                        worldUpType=worldUpType,
                                        worldUpObject=worldUpVector)
        elif worldUpType == "vector":
            aimConst = pm.aimConstraint(jointUnder, joint, aimVector=aimAxis,
                                        upVector=upAxis,
                                        worldUpType=worldUpType,
                                        worldUpVector=worldUpVector)
        pm.delete(aimConst)
        pm.parent(jointUnder, joint)

        pm.setAttr(joint.jointOrient, (pm.getAttr(joint.rotate)))
        pm.setAttr((joint.rotate), [0, 0, 0])
        pm.delete(temporalGroup.drawnNode)
def addCurlJnt(side, finger):
    # create curl jnt
    baseJnt = pm.PyNode(side+finger+'_a_jnt')
    loc = pm.PyNode(baseJnt.replace('_a_jnt', 'Cup_loc'))
    parJnt = baseJnt.getParent()
    # orient loc so x is aimed to baseJnt
    if '_rt' in side:
        temp_con = pm.aimConstraint(baseJnt, loc, aim=(-1,0,0), u=(0,0,1), wuo=parJnt, wut='objectrotation')
    else:
        temp_con = pm.aimConstraint(baseJnt, loc, aim=(1,0,0), u=(0,0,1), wuo=parJnt, wut='objectrotation')
    pm.delete(temp_con)
    # create jnt
    pm.select(cl=True)
    curlJnt = pm.joint(n=side+finger+'Cup_jnt')
    curlJnt.radius.set(baseJnt.radius.get())
    mat = loc.getMatrix(ws=True)
    curlJnt.setMatrix(mat, ws=True)
    parJnt | curlJnt
    pm.makeIdentity(curlJnt, r=True, a=True)
    # find offset matrix for baseJnt
    currMat = baseJnt.getMatrix()
    offMat = currMat * curlJnt.getMatrix().inverse()
    txOffset = offMat.translate[0]
    # change parent for baseJnt
    curlJnt | baseJnt
    txMd = baseJnt.tx.inputs()[0]
    txMd.input2X.set(txOffset)
    return curlJnt
Beispiel #11
0
def make_stabilized_node(nodeName=None, centered=True):
    '''
    Very simple proc to generate a Stabilized node for
    raw MoCap tracking purposes... First selected node
    is used as the Aim axis, second selected is used as this
    aim's worldUp
    '''
    RequiredMarkers = pm.ls(sl=True, l=True)
    #pos = pm.xform(WorldUpObj, q=True, ws=True, t=True)
    curve = pm.curve(ws=True, d=1, p=(0, 0, 0), k=0)
    
    if centered:
        AimAt = RequiredMarkers[0]
        WorldUpObj = RequiredMarkers[1]
        pm.pointConstraint(RequiredMarkers, curve)
    else:
        AimAt = RequiredMarkers[1]
        WorldUpObj = RequiredMarkers[2]
        pm.pointConstraint(RequiredMarkers[0], curve)

    pm.aimConstraint((AimAt, curve),
                     weight=1,
                     aimVector=(0, 0, 1),
                     upVector=(0, 1, 0),
                     worldUpType="object",
                     worldUpObject=WorldUpObj)
        
    #Snap a curveKnot to the pivot of all referenceMarkers
    for node in RequiredMarkers:
        pm.curve(curve, a=True, ws=True, p=(pm.xform(node, q=True, ws=True, t=True)))
    pm.curve(curve, a=True, ws=True, p=(pm.xform(AimAt, q=True, ws=True, t=True)))
    
    return curve
Beispiel #12
0
    def AlignBindNode(self, **kws):
        '''
        Overwrite the default behaviour: Align the newly made BindNode as required for this bind
        '''

        #Parent the BindNode/UpVector Object to the upVectorParent Node
        #Parent the AimLocator Object to the Source node -used to modify the AimPoint
        pm.parent(self.BindNode['Root'], self.upVectorParent)
        pm.parent(self.BindNode['Up'], self.upVectorParent)
        pm.parent(self.BindNode['AimOffset'], self.SourceNode)

        #self.BindNode['Root'].scale.set(self.Settings.BaseScale,self.Settings.BaseScale,self.Settings.BaseScale)
        self.BindNode['Main'].rotateOrder.set(self.SourceNode.rotateOrder.get())
        self.BindNode['Root'].rotateOrder.set(self.DestinationNode.rotateOrder.get())

        #Aim Alignment
        pm.aimConstraint(self.BindNode['AimOffset'], self.BindNode['Root'], aimVector=(0,1,0),upVector=(0,0,1),\
                             worldUpType="object",worldUpObject=self.BindNode['Up'])

        #Positional Alignment
        pm.delete(pm.pointConstraint(self.SourceNode, self.BindNode['AimOffset']))
        pm.makeIdentity(self.BindNode['AimOffset'], apply=True, t=1, r=1, s=0) 
        pm.delete(pm.pointConstraint(self.upVectorParent, self.BindNode['Root']))
        pm.makeIdentity(self.BindNode['Root'], apply=True, t=1, r=0, s=0) 
        pm.delete(pm.pointConstraint(self.upVectorParent, self.BindNode['Up']))
        pm.makeIdentity(self.BindNode['Up'], apply=True, t=1, r=0, s=0) 
        pm.delete(pm.pointConstraint(self.DestinationNode, self.BindNode['Root']))
        
        #Rotate Alignment
        pm.delete(pm.orientConstraint(self.DestinationNode, self.BindNode['Main']))
    def align_bind_node(self, **kws):
        '''
        Overwrite the default behaviour: Align the newly made BindNode as required for this bind
        '''

        # Parent the BindNode/UpVector Object to the upVectorParent Node
        # Parent the AimLocator Object to the Source node -used to modify the AimPoint
        pm.parent(self.BindNode['Root'], self.upVectorParent)
        pm.parent(self.BindNode['Up'], self.upVectorParent)
        pm.parent(self.BindNode['AimOffset'], self.sourceNode)

        # self.BindNode['Root'].scale.set(self.settings.base_scale,self.settings.base_scale,self.settings.base_scale)
        self.BindNode['Main'].rotateOrder.set(self.sourceNode.rotateOrder.get())
        self.BindNode['Root'].rotateOrder.set(self.destinationNode.rotateOrder.get())

        # Aim Alignment
        pm.aimConstraint(self.BindNode['AimOffset'], self.BindNode['Root'], aimVector=(0, 1, 0), upVector=(0, 0, 1),
                             worldUpType="object", worldUpObject=self.BindNode['Up'])

        # Positional Alignment
        pm.delete(pm.pointConstraint(self.sourceNode, self.BindNode['AimOffset']))
        pm.makeIdentity(self.BindNode['AimOffset'], apply=True, t=1, r=1, s=0)
        pm.delete(pm.pointConstraint(self.upVectorParent, self.BindNode['Root']))
        pm.makeIdentity(self.BindNode['Root'], apply=True, t=1, r=0, s=0)
        pm.delete(pm.pointConstraint(self.upVectorParent, self.BindNode['Up']))
        pm.makeIdentity(self.BindNode['Up'], apply=True, t=1, r=0, s=0)
        pm.delete(pm.pointConstraint(self.destinationNode, self.BindNode['Root']))

        # Rotate Alignment
        pm.delete(pm.orientConstraint(self.destinationNode, self.BindNode['Main']))
Beispiel #14
0
def connectCtrls():
    ctrls = pm.ls(sl=1)

    masterGrp = groupTools.makeGroup(name='wingCtrlsConnect')
    coordsList = []
    midDrvLocs = []
    holdDrvLocs = []

    mdCtrlsCoord = vtxWalk.bbox(ctrls)['globalPvt']
    middle = controlTools.cntrlCrv(name='wingCtrlsConnect_mid_loc',
                                   coords=(mdCtrlsCoord, (0, 0, 0), (1, 1, 1)),
                                   cntrlSulfix='',
                                   parent=masterGrp,
                                   icone='null')
    tempConstraint = pm.pointConstraint(ctrls[0], ctrls[1], middle, mo=0)
    pm.delete(tempConstraint)
    pm.parentConstraint(ctrls[0].getParent().getParent(),
                        ctrls[1].getParent().getParent(),
                        middle,
                        mo=1,
                        sr=['x', 'y', 'z'])
    pm.aimConstraint(ctrls[0].getParent().getParent(),
                     middle,
                     wut='scene',
                     mo=0)
    orientMiddle = pm.xform(middle, q=1, ro=1, ws=1)

    for ctrl in ctrls:
        coord = vtxWalk.bbox(ctrl)['globalPvt']
        coordsList.append(coordsList)

        midLoc = controlTools.cntrlCrv(name=ctrl + '_mid_drv_loc',
                                       coords=(coord, (0, 0, 0), (1, 1, 1)),
                                       cntrlSulfix='',
                                       parent=middle,
                                       icone='null')
        midDrvLocs.append(midLoc)

        holdLoc = controlTools.cntrlCrv(name=ctrl + '_hold_drv_loc',
                                        coords=(coord, orientMiddle, (1, 1,
                                                                      1)),
                                        cntrlSulfix='',
                                        parent=masterGrp,
                                        icone='null')
        holdDrvLocs.append(holdLoc)
        pm.parentConstraint(ctrl.getParent().getParent(), holdLoc, mo=1)
        pm.addAttr(ctrl, ln='autoConnect', dv=0.8, min=0, max=1, k=1)

        drvPointConstraint = pm.pointConstraint(midLoc,
                                                holdLoc,
                                                ctrl.getParent(),
                                                mo=1)
        #drvOrientConstraint = pm.orientConstraint(middle, holdLoc, ctrl.getParent(), mo=1)

        revNode = pm.createNode('reverse', n='wingCtrlsConnect_rev')
        ctrl.autoConnect >> revNode.inputX
        pm.connectAttr(ctrl.autoConnect,
                       drvPointConstraint + '.' + midLoc + 'W0')
        pm.connectAttr(revNode.outputX,
                       drvPointConstraint + '.' + holdLoc + 'W1')
Beispiel #15
0
def ctrlAimConstraint():
    legsRootCtrl = pm.ls('*Leg*_1_ctrl')
    for ctrl in legsRootCtrl:
        pm.select(cl=1)
        aimposGrp = ctrl.getParent()
        aimCtrl = pm.ls(ctrl.name().replace('ctrl', 'aim_ctrl'))[0]
        pm.aimConstraint(aimCtrl, aimposGrp,
                         mo=1)  # aimConstraint -mo -weight 1 -aimVector 1 0 0 -upVector 0 1 1 -worldUpType "vector" -worldUpVector 0 1 0;
def aimConstraintRename(sels):
    if len(sels) >= 3 or len(sels) <= 1:
        pm.error('Please select two')

    part = sels[1].split("_")

    renameConstraint = '_'.join(['amc', part[1], part[2], part[3]])
    pm.aimConstraint(sels[0], sels[1], n=renameConstraint, mo=True, w=1)
Beispiel #17
0
    def FKIK_query_guide_orient(self, *args):
        print 'Querying the rotations of the guides which were placed.'
        POS_list = self.FKIK_query_guide_translation()

        # TODO:
        #     Replace all this code with something a little
        #     more elegant.

        #     Likely something with OpenMaya for querying the
        #     actual vectors and orientations of the objects
        #     in world space?

        #     Using cross products to determine the correct
        #     planar relationships between guide positions.

        A_LOC = pm.spaceLocator()
        B_LOC = pm.spaceLocator()
        C_LOC = pm.spaceLocator()

        if self.debugging: print 'Created:', A_LOC, B_LOC, C_LOC

        A_LOC.setTranslation(POS_list[0])
        B_LOC.setTranslation(POS_list[1])
        C_LOC.setTranslation(POS_list[2])

        A_orient = pm.aimConstraint(B_LOC,
                                    A_LOC,
                                    aimVector=[1, 0, 0],
                                    upVector=[0, 1, 0],
                                    worldUpType='object',
                                    worldUpObject=C_LOC)
        B_orient = pm.aimConstraint(C_LOC,
                                    B_LOC,
                                    aimVector=[1, 0, 0],
                                    upVector=[0, 1, 0],
                                    worldUpType='object',
                                    worldUpObject=A_LOC)
        C_orient = pm.aimConstraint(A_LOC,
                                    C_LOC,
                                    aimVector=[-1, 0, 0],
                                    upVector=[0, -1, 0],
                                    worldUpType='object',
                                    worldUpObject=B_LOC)

        A_value = A_LOC.getRotation()
        B_value = B_LOC.getRotation()
        C_value = C_LOC.getRotation()

        if not self.debugging:
            pm.delete(A_orient, B_orient, C_orient, A_LOC, B_LOC, C_LOC)

        else:
            print(
                'Successfully completed the creation and query of guide orientation'
            )
            print A_value, B_value, C_value

        return [A_value, B_value, C_value]
Beispiel #18
0
    def build_stack(self, stack, aim_target=None, **kwargs):
        nomenclature_rig = self.get_nomenclature_rig()

        # Build an aim node in-place for performance
        # This separated node allow the joints to be driven by the avars.
        aim_grp_name = nomenclature_rig.resolve('lookgrp')
        aim_grp = pymel.createNode('transform', name=aim_grp_name)

        aim_node_name = nomenclature_rig.resolve('looknode')
        aim_node = pymel.createNode('transform', name=aim_node_name)
        aim_node.setParent(aim_grp)

        aim_target_name = nomenclature_rig.resolve('target')
        aim_target = pymel.createNode('transform', name=aim_target_name)


        aim_target.setParent(aim_grp)
        self.target = aim_target

        # Build an upnode for the eyes.
        # I'm not a fan of upnodes but in this case it's better to guessing the joint orient.
        aim_upnode_name = nomenclature_rig.resolve('upnode')

        aim_upnode = pymel.createNode('transform', name=aim_upnode_name)
        #
        aim_upnode.setParent(self.grp_rig)
        pymel.parentConstraint(aim_grp, aim_upnode, maintainOffset=True)


        pymel.aimConstraint(aim_target, aim_node,
                            maintainOffset=True,
                            aimVector=(0.0, 0.0, 1.0),
                            upVector=(0.0, 1.0, 0.0),
                            worldUpObject=aim_upnode,
                            worldUpType='object'
                            )

        # Position objects
        aim_grp.setParent(self._grp_offset)  # todo: add begin , end property
        aim_grp.t.set(0,0,0)
        aim_grp.r.set(0,0,0)
        jnt_tm = self.jnt.getMatrix(worldSpace=True)
        jnt_pos = jnt_tm.translate
        aim_upnode_pos = pymel.datatypes.Point(0,1,0) + jnt_pos
        aim_upnode.setTranslation(aim_upnode_pos, space='world')
        aim_target_pos = pymel.datatypes.Point(0,0,1) + jnt_pos
        aim_target.setTranslation(aim_target_pos, space='world')

        pymel.parentConstraint(aim_node, stack, maintainOffset=True)

        # Convert the rotation to avars to additional values can be added.
        util_decomposeMatrix = libRigging.create_utility_node('decomposeMatrix', inputMatrix=aim_node.matrix)
        libRigging.connectAttr_withBlendWeighted(util_decomposeMatrix.outputTranslateX, self.attr_lr)
        libRigging.connectAttr_withBlendWeighted(util_decomposeMatrix.outputTranslateY, self.attr_ud)
        libRigging.connectAttr_withBlendWeighted(util_decomposeMatrix.outputTranslateZ, self.attr_fb)
        libRigging.connectAttr_withBlendWeighted(util_decomposeMatrix.outputRotateY, self.attr_yw)
        libRigging.connectAttr_withBlendWeighted(util_decomposeMatrix.outputRotateX, self.attr_pt)
        libRigging.connectAttr_withBlendWeighted(util_decomposeMatrix.outputRotateZ, self.attr_rl)
Beispiel #19
0
def directPlacementMode(card):

    assert len(card.joints) == 3

    grp = group(em=True, n='DirectPlacement_Deletable')

    ctrls = []
    for bpj in card.joints:
        ctrl = tempWidget()
        pdil.dagObj.matchTo(ctrl, bpj)
        ctrls.append(ctrl)
        ctrl.setParent(grp)

    base, up, aim = ctrls

    aimLoc = spaceLocator()
    aimLoc.setParent(aim)
    aimLoc.t.set(0, 0, 0)

    baseLoc = spaceLocator()
    baseLoc.setParent(base)
    baseLoc.t.set(0, 0, 0)

    dist = distanceDimension(baseLoc, aimLoc)
    dist.getParent().setParent(grp)
    hide(dist)

    pointConstraint(base, card, mo=True)

    aimConstraint(aim,
                  card,
                  wut='object',
                  wuo=up,
                  aim=[0, -1, 0],
                  u=[0, 0, -1],
                  mo=True)

    # save base dimension
    # current dimesion / base dimension
    # multiply x, z by card's existing scale

    dist.addAttr('baseDist', at='double', dv=dist.distance.get())

    scaled = pdil.math.divide(dist.distance, dist.baseDist)

    mult = createNode('multiplyDivide')

    scaled >> mult.input1X
    scaled >> mult.input1Y
    scaled >> mult.input1Z

    mult.input2Y.set(card.sy.get())
    mult.input2Z.set(card.sz.get())

    mult.outputY >> card.sy
    mult.outputZ >> card.sz

    pointConstraint(up, card.joints[1], sk='x')
Beispiel #20
0
    def doGuide(self, **kwargs):
        self.__dict__.update(kwargs)

        displaySetup = self.moveallGuideSetup.copy()
        cntrlName = displaySetup['nameTempl'] + self.guideSulfix

        if pm.objExists(cntrlName):
            pm.delete(cntrlName)

        self.guideMoveall = controlTools.cntrlCrv(name=cntrlName,
                                                  hasZeroGrp=False,
                                                  cntrlSulfix='',
                                                  **displaySetup)

        if not pm.objExists('GUIDES'):
            pm.group(self.guideMoveall, n='GUIDES')
        else:
            pm.parent(self.guideMoveall, 'GUIDES')

        self.startGuide = self.createCntrl('startGuide')
        self.midGuide = self.createCntrl('midGuide')
        self.endGuide = self.createCntrl('endGuide')

        pm.parent(self.startGuide, self.midGuide, self.endGuide,
                  self.guideMoveall)

        if self.lastJoint:
            self.lastGuide = self.createCntrl('lastGuide')

            pm.parent(self.lastGuide, self.endGuide)
            self.setCntrl(self.lastGuide, 'last', space='object')

        self.setCntrl(self.startGuide, 'start', space='object')
        self.setCntrl(self.midGuide, 'mid', space='object')
        self.setCntrl(self.endGuide, 'end', space='object')

        arrow = controlTools.cntrlCrv(obj=self.startGuide,
                                      name=self.name + 'PlaneDir',
                                      icone='seta',
                                      size=.35,
                                      color=(0, 1, 1))
        arrow.template.set(1)
        arrow.getParent().setParent(self.startGuide)
        pm.aimConstraint(self.endGuide,
                         arrow,
                         weight=1,
                         aimVector=(1, 0, 0),
                         upVector=(0, 0, -1),
                         worldUpObject=self.midGuide,
                         worldUpType='object')

        self.setCntrl(self.guideMoveall, 'moveall', space='world')

        pm.addAttr(self.guideMoveall, ln='limbDict', dt='string')
        # todo implementar funcao de exportar o dict
        self.guideMoveall.limbDict.set(json.dumps(self.exportDict()))
Beispiel #21
0
def create_jointChain( IdName = 'joint', inputCurve = pm.selected(), orientation = 'xyz' ):
    
    # get number of CVs on InputCurve
    numberOfCvs = pm.getAttr( inputCurve[0] + '.cp',s=1 )
    
    # create joints on world space cv locations
    Jnts = []
    for i in range(0, numberOfCvs):
        pm.select( clear = True )
        currentCvPos = pm.pointPosition( inputCurve[0].cv[i], w=1 )
        Jnt = pm.joint( name = '_'.join( ['bn', IdName, str( i+1 )] ) )
        pm.xform( Jnt, t = currentCvPos )
        Jnts.append( Jnt )
        
    # create end joint
    pm.select( clear = True )
    endJntPos = 0.1 * ( pm.getAttr( Jnts[len(Jnts)-1].translate ) - pm.getAttr( Jnts[len(Jnts)-2].translate ) ) + pm.getAttr( Jnts[len(Jnts)-1].translate )
    endJnt = pm.joint( name = 'be_' + IdName, position = endJntPos, a = True )
    Jnts.append( endJnt )
    
    # set aim and orientation vectors, always yup
    aimDict = {}
    aimDict[orientation[0]] = 1
    aimDict[orientation[1]] = 0
    aimDict[orientation[2]] = 0
    aimVec = ( aimDict['x'], aimDict['y'], aimDict['z'] )

    orientDict = {}
    orientDict[orientation[0]] = 0
    orientDict[orientation[1]] = 0
    orientDict[orientation[2]] = 1
    orientVec = ( orientDict['x'], orientDict['y'], orientDict['z'] )
    
    # orient first joint
    JntAimConstrain = pm.aimConstraint( Jnts[1], Jnts[0], aimVector = aimVec, upVector = (0,1,0), worldUpType = "scene" )
    pm.delete( JntAimConstrain )
    Jnts[0].jointOrient.set( Jnts[0].rotate.get() )
    Jnts[0].rotate.set( 0,0,0 )
    
    # orient middle joints
    for i in range( 1, len( Jnts ) - 1 ):
        JntAimConstrain = pm.aimConstraint( Jnts[i+1], Jnts[i], aimVector = aimVec, upVector = orientVec, worldUpType = "objectrotation", worldUpVector = orientVec, worldUpObject = Jnts[i-1] )
        pm.delete( JntAimConstrain )
        Jnts[i].jointOrient.set( Jnts[i].rotate.get() )
        Jnts[i].rotate.set( 0,0,0 )
    
    # orient last joint
    Jnts[len( Jnts ) -1 ].jointOrient.set( Jnts[len( Jnts ) -2 ].jointOrient.get() )
    
    # parent joints
    for i in range( 1, len( Jnts ) ):
        pm.parent( Jnts[i], Jnts[i-1], absolute = True)

    pm.select( Jnts[0] )
    print('Successfully created and oriented joint-chain. Continuing...')
    return Jnts
Beispiel #22
0
    def run(self,
            aim_this=None,
            at_this=None,
            up_target=None,
            flip_aim=False,
            flip_up=False):

        aim_this = aim_this or self.options.aim_this
        at_this = at_this or self.options.at_this
        up_target = up_target or self.options.up_target

        selection_list = pm.ls(sl=True)
        if len(selection_list) == 2:
            aim_this = selection_list[0]
            at_this = selection_list[1]
        elif len(selection_list) == 3:
            aim_this = selection_list[0]
            at_this = selection_list[1]
            up_target = selection_list[2]

        flip_aim = flip_aim or self.options.flip_aim
        flip_up = flip_up or self.options.flip_up

        if flip_aim:
            aim_vector = (-1, 0, 0)
        else:
            aim_vector = (1, 0, 0)

        if flip_up:
            up_vector = (0, 0, -1)
        else:
            up_vector = (0, 0, 1)

        scene_up = "scene"
        object_up = "object"

        if up_target:
            # aim with up target as upvector
            temp_constraint = pm.aimConstraint(
                at_this,
                aim_this,
                aimVector=aim_vector,
                upVector=up_vector,
                worldUpType=object_up,
                worldUpObject=up_target,
            )
        else:
            # aim with assumed scene as upvector
            temp_constraint = pm.aimConstraint(
                at_this,
                aim_this,
                aimVector=aim_vector,
                upVector=up_vector,
                worldUpType=scene_up,
            )
        pm.delete(temp_constraint)
Beispiel #23
0
def curveAimBelt(module, crv, aimCrv, numJnts, mo=True, aimVector=(0,1,0), upVector=(0,1,0), worldUpType="vector", worldUpVector=(0,1,0)):
	'''Takes two curves, creates joints on the first and aims objects at the second.
	Args:
		crv (pm.nt.nurbsCurve): nurbs curve to generate things on
		aimCrv (pm.nt.nurbsCurve): nurbs curve to aim things to
		numJnts (int): number of joints to be generated
		other : all of the aim vector constraint settings
	Returns list(grp, list(joints))
	Usage:
		curveAimBelt("path", pm.ls(sl=True)[0], pm.ls(sl=True)[1], 40)
	'''
	grp = pm.group(em=True, n=module+'_GRP')
	aimgrp = pm.group(em=True, n=module+'_AIMDRV_GRP', p=grp)
	
	joints = rig_makeJointsAlongCurve(module+"Drive", crv, numJnts)
	ikJoints = rig_makeJointsAlongCurve(module+"IK", crv, numJnts)
	skelgrp = pm.group(em=True, n=module+'Skeleton_GRP', p=grp)
	ikskelgrp = pm.group(em=True, n=module+'ikJNT_GRP', p=skelgrp)
	jntgrp = pm.group(em=True, n=module+'JNT_GRP', p=skelgrp)
	clstrGrp = pm.group(em=True, n=module+'Clusters_GRP', p=grp)
	crvGrp = pm.group(em=True, n=module+'Curves_GRP', p=grp)

	for joint,ikJoint in zip(joints,ikJoints):
		joint.setParent(jntgrp)
		pociResult = rig_getClosestPointAndPositionOnCurve(joint, crv)
		pociResult[2].setParent(aimgrp)
		pociOrig = pociResult[0]
		poci = pm.nodetypes.PointOnCurveInfo(n=joint+"_POCI")
		aimCrv.getShape().attr("worldSpace[0]").connect(poci.inputCurve)
		pociOrig.parameter.connect(poci.parameter)
		loc = pm.spaceLocator( n=joint+'AIMDRV_GRP' )
		loc.setParent(aimgrp)
		poci.position.connect(loc.t)
		
		pm.pointConstraint(ikJoint, joint, mo=True)
		pm.aimConstraint(loc, joint, mo=mo, aimVector=aimVector, upVector=upVector, worldUpType=worldUpType, worldUpVector=worldUpVector)
	ikHandle=pm.ikHandle(sj=ikJoints[0], ee=ikJoints[-1], sol='ikSplineSolver', c=crv, ccv=False, rtm=False)[0]
	
	origClusters = rig_clusterCurve(crv, ends=True)
	offsetClusters = rig_clusterCurve(aimCrv, ends=True)

	for clstr, oClstr in zip(origClusters, offsetClusters):
		pm.parentConstraint(clstr[1], oClstr[1], mo=True)
		oClstr[1].visibility.set(0)
		clstr[1].setParent(clstrGrp)
		oClstr[1].setParent(clstrGrp)

	ikJoints[0].setParent(ikskelgrp)
	ikskelgrp.visibility.set(0)
	crvGrp.visibility.set(0)
	crv.setParent(crvGrp)
	aimCrv.setParent(crvGrp)
	ikHandle.setParent(ikskelgrp)
	aimgrp.inheritsTransform.set(0)
	
	return [grp, joints]
Beispiel #24
0
def aimDeserialize(obj, data):  # type: (PyNode, Dict) -> None
    # If the world up object is absent, remove it entirely.
    kwargs = copy.deepcopy(data)
    if not kwargs['wuo']:
        del kwargs['wuo']
    else:
        kwargs['wuo'] = add.findFromIds(kwargs['wuo'])

    targets, reformattedKwargs = _constraintDeserialize(obj, kwargs)
    aimConstraint(targets, obj, mo=True, **reformattedKwargs)
Beispiel #25
0
    def reorientGuides(self):
        for i in range(len(self.guidesList)-1):
            guidePos = pm.xform(self.guidesList[i].name,q=1,rp=1,ws=1)
            self.guidesList[i].guideGrp.setPivots(guidePos,worldSpace=1)
            tempAim = pm.aimConstraint(self.guidesList[i+1].name,self.guidesList[i].guideGrp,offset = [0,0,0],aimVector = [1,0,0],upVector=[0,1,0],worldUpType='scene')
            pm.delete(tempAim)
        guidePos = pm.xform(self.guidesList[-1].name,q=1,rp=1,ws=1)
        self.guidesList[-1].guideGrp.setPivots(guidePos,worldSpace=1)

        tempAim = pm.aimConstraint(self.guidesList[-2].name,self.guidesList[-1].guideGrp,offset = [0,0,0],aimVector = [-1,0,0],upVector=[0,1,0],worldUpType='scene')
        pm.delete(tempAim)
Beispiel #26
0
    def test_assertAimingAt(self):
        a = pm.group(empty=1)
        b = pm.group(empty=1)
        pm.move(3, 3, 3, b, a=1)

        self.assertFalse(transforms.assertAimingAt(a, b, 'x'))
        pm.aimConstraint(b, a)
        self.assertFalse(transforms.assertAimingAt(a, b, 'y'))
        self.assertFalse(transforms.assertAimingAt(a, b, 'z'))

        self.assertTrue(transforms.assertAimingAt(a, b, 'x'))
    def test_assertAimingAt(self):
        a = pm.group(empty=1)
        b = pm.group(empty=1)
        pm.move(3, 3, 3, b, a=1)

        self.assertFalse(transforms.assertAimingAt(a, b, "x"))
        pm.aimConstraint(b, a)
        self.assertFalse(transforms.assertAimingAt(a, b, "y"))
        self.assertFalse(transforms.assertAimingAt(a, b, "z"))

        self.assertTrue(transforms.assertAimingAt(a, b, "x"))
Beispiel #28
0
def create_radian_trigger(prefix):
    prefix = ("%s_radianTrigger") %prefix

    display = pm.group(empty=True, name="%s_display" %prefix)
    display.overrideEnabled.set(1)
    display.overrideDisplayType.set(2)
        
    grp = pm.group(empty=True, name="%s_grp" %prefix)
    loc = pm.spaceLocator(name = "%s_target" %prefix)
    pm.addAttr(loc, at='double', ln="radical", k=True)
    pm.addAttr(loc, at='double', ln="angle", k=True)
    
    pos = pm.spaceLocator(name = "%s_pos" %prefix)
    
    loc.ty.set(1)
    loc.tz.set(1)
    pos.tz.set(1)    

    radical_exp = '%s.radical = rad_to_deg( atan2(  %s.translateY , %s.translateX ) )' %(loc.name(), loc.name(), loc.name())
    angle_exp = "%s.angle = rad_to_deg( acos( %s.translateZ / (sqrt( pow(%s.translateX, 2) + pow(%s.translateY, 2) + pow(%s.translateZ, 2) ) ) ) )" %(loc.name(), loc.name(), loc.name(), loc.name(), loc.name())
    pm.expression( o=loc, s= radical_exp, name="%s_radical_exp" %prefix)
    pm.expression( o=loc, s= angle_exp, name="%s_angle_exp" %prefix)
    
    planer_curve = "curve -d 1 -p 0 0 0 -p -1 0 0 -p -0.965926 0.258819 0 -p -0.765926 0.258819 0 -p -0.865926 0.258819 0 -p -0.865926 0.358819 0 -p -0.865926 0.158819 0 -p -0.865926 0.258819 0 -p -0.965926 0.258819 0 -p -0.866025 0.5 0 -p -0.707107 0.707107 0 -p -0.353553 0.353553 0 -p -0.707107 0.707107 0 -p -0.5 0.866025 0 -p -0.258819 0.965926 0 -p 0 1 0 -p 0 0.5 0 -p 0 1 0 -p 0.258819 0.965926 0 -p 0.5 0.866025 0 -p 0.707107 0.707107 0 -p 0.353553 0.353553 0 -p 0.707107 0.707107 0 -p 0.866025 0.5 0 -p 0.965926 0.258819 0 -p 1 0 0 -p 0.5 0 0 -p 1 0 0 -p 0.965926 -0.258819 0 -p 0.866025 -0.5 0 -p 0.707107 -0.707107 0 -p 0.353553 -0.353553 0 -p 0.707107 -0.707107 0 -p 0.5 -0.866025 0 -p 0.258819 -0.965926 0 -p 0 -1 0 -p 0 -0.5 0 -p 0 -1 0 -p -0.258819 -0.965926 0 -p -0.5 -0.866025 0 -p -0.707107 -0.707107 0 -p -0.353553 -0.353553 0 -p -0.707107 -0.707107 0 -p -0.866025 -0.5 0 -p -0.965926 -0.258819 0 -p -0.765926 -0.258819 0 -p -0.965926 -0.258819 0 -p -1 0 0 -k 0 -k 1 -k 2 -k 3 -k 4 -k 5 -k 6 -k 7 -k 8 -k 9 -k 10 -k 11 -k 12 -k 13 -k 14 -k 15 -k 16 -k 17 -k 18 -k 19 -k 20 -k 21 -k 22 -k 23 -k 24 -k 25 -k 26 -k 27 -k 28 -k 29 -k 30 -k 31 -k 32 -k 33 -k 34 -k 35 -k 36 -k 37 -k 38 -k 39 -k 40 -k 41 -k 42 -k 43 -k 44 -k 45 -k 46 -k 47"
    planer = pm.PyNode(pm.mel.eval(planer_curve))
    planer.rename("%s_planer" %prefix)

    arrow_curve = 'curve -d 1 -p 0 0 0 -p 0 0.377909 0 -p -0.0449662 0.378085 0 -p 0 0.460303 0 -p 0.0449662 0.378085 0 -p 0 0.377909 0 -k 0 -k 1 -k 2 -k 3 -k 4 -k 5 ;'
    arrow = pm.PyNode(pm.mel.eval(arrow_curve))
    pm.makeIdentity(arrow, apply=True, t=True, r=True, s=True)    
    arrow.rename("%s_arrow" %prefix)

    angle_curves = pm.circle(name="%s_angleCurve" %prefix, r=0.5)
    pm.aimConstraint(pos, angle_curves[0], mo=False, aimVector=[0,1,0], upVector=[-1,0,0], worldUpType='object', worldUpObject=loc)
    pm.parent(arrow, angle_curves)
    
    loc.angle >> angle_curves[-1].sweep

    posPointer = pm.curve(name='%s_posPointer'%prefix, d = 1, p = [(0,0,0), (0,0,1)])

    pointer = pm.curve(name='%s_targetPointer'%prefix, d = 1, p = [(0,0,0), (0,0,0)])
    pointer.inheritsTransform.set(0)
    
    cls1 = pm.cluster(pointer.cv[0], name='%s_pointerClusterStart' %prefix)
    cls2 = pm.cluster(pointer.cv[1], name='%s_pointerClusterEnd' %prefix)
    
    pm.parent(pos, planer, angle_curves[0], cls1, pointer, posPointer, display)
    pm.parent(display, loc, grp)
    pm.parent(cls2, loc, r=True)
    
    cls1[1].v.set(0)
    cls2[1].v.set(0)
    pos.v.set(0)
Beispiel #29
0
def follow_attribute(params):
    '''
    This function will add the follow function to the Pole Vector Controls on the IK/FK Legs
    '''

    # Declare the variables that will be used to create the follow attribute in the function
    root_ctl = params['ikRootControl'].name()
    goal_ctl = params['ikGoalControl'].name()
    pole_ctl = params['ikPoleControl'].name()
    pole_off = pole_ctl.replace('_ctl', '_off_exp')
    ik1_jnt = params['ikSkeleton'][0].name()
    #null_fp = cmds.createNode('transform', n='Auto_FollowBase' + '_' + root_ctl, p='rt_fk0_jnt')
    null_fp = cmds.createNode('transform',
                              n='Auto_FollowBase' + '_' + root_ctl,
                              p='noXform')
    null_ff = cmds.createNode('transform',
                              n='Auto_FollowGoal' + '_' + goal_ctl,
                              p=null_fp)

    # Parent the null groups under the noXform
    #cmds.parent(null_fp, 'noXform')

    # Create the Aim Constraints for the follow base
    pm.aimConstraint(goal_ctl,
                     null_fp,
                     weight=1,
                     upVector=(1, 0, 0),
                     worldUpObject=root_ctl,
                     worldUpType="objectrotation",
                     offset=(0, 0, 0),
                     aimVector=(0, -1, 0),
                     worldUpVector=(1, 0, 0))
    cmds.pointConstraint(ik1_jnt, null_fp, mo=True)

    # Create the Aim Constraints for the follow goal
    pm.aimConstraint(goal_ctl,
                     null_ff,
                     weight=1,
                     upVector=(0, 1, 0),
                     worldUpObject=goal_ctl,
                     worldUpType="objectrotation",
                     offset=(0, 0, 0),
                     aimVector=(0, -1, 0),
                     worldUpVector=(1, 0, 0))

    # Create the parent constraint for the pole vector control
    pole_vector_constraint = cmds.parentConstraint(null_ff, pole_off, mo=True)
    i = cmds.parentConstraint(pole_vector_constraint[0], wal=True, q=True)

    # Connect follow and pole vector control
    cmds.addAttr(goal_ctl, ln='poleVectorFollow', at='bool', k=True)
    cmds.connectAttr('{}.poleVectorFollow'.format(goal_ctl),
                     '{}.{}'.format(str(pole_vector_constraint[0]), str(i[0])))
Beispiel #30
0
    def create( self ):

        #
        # Create Kinect2 Joints
        #
        aimer = []
        for kjot in self.k2map:
            tag = self.k2map[kjot][0]
            aimid = self.k2map[kjot][2]
            aim = None if aimid is None else self.k2map[aimid][0]
            aimv = (1,0,0)

            t = pm.xform( tag, q=True, ws=True, t=True )
            pm.select( cl=True )
            pm.joint( p=t, n=kjot )

            if not aim is None:
                aimv = (-1,0,0) if pm.getAttr(aim+'.tx') < 0 else aimv
                aimer.append(pm.aimConstraint( aim, kjot, aim=aimv, wut='objectrotation', u=(0,1,0), wu=(0,1,0), wuo=tag ))
        pm.delete( aimer )

        #
        # Make Joints Hierarchy
        #
        for kjot in self.k2map:
            parent = self.k2map[kjot][1]
            aimid = self.k2map[kjot][2]
            if not parent is None:
                pm.parent( kjot, self.k2map[kjot][1] )
                if aimid is None:
                    pm.setAttr( kjot+'.jointOrient', (0,0,0) )

            # Freeze Transformations
            pm.makeIdentity( kjot, a=True, jo=False, t=False, r=True, s=False, n=0, pn=True )

        #
        # Make Constraint
        #
        for kjot in self.k2map:
            tag = self.k2map[kjot][0]
            aimid = self.k2map[kjot][2]
            aim = None if aimid is None else self.k2map[aimid][0]
            aimv = (1,0,0)

            # Aim Constraint
            pm.pointConstraint( tag, kjot )

            # Aim Constraint
            if not aim is None:
                aimv = (-1,0,0) if pm.getAttr(aim+'.tx') < 0 else aimv
                pm.aimConstraint( aim, kjot, aim=aimv, wut='objectrotation', u=(0,1,0), wu=(0,1,0), wuo=tag )

        return
Beispiel #31
0
def setTpose():
    selection = pm.ls(sl=1, type='joint')
    if selection:
        for jnt in selection:
            tempNull = pm.spaceLocator(name=jnt.name() + '_temp_loc')
            pm.delete(pm.pointConstraint(jnt, tempNull))
            tempNull.translateX.set(100)
            pm.aimConstraint(tempNull,
                             jnt,
                             aimVector=[1, 0, 0],
                             upVector=[0, 1, 0])
            pm.delete(tempNull)
            mirrorJntRot(jnt)
Beispiel #32
0
def quickSpineCtrl(side, base):
	""" from control joint selection creates controls for spine, 
	this function will build a quick spine control network """
	ctrlJoints = pm.selected()
	conName = nameNode(base, side)
	print(ctrlJoints)
	ctrlBase = createControl(side, base + "Tip", "circleX", sdk=1, con=1)
	ctrlMid = createControl(side, base + "Mid", "circleX", sdk=1, con=1)
	ctrlEnd = createControl(side, base + "End", "circleX", sdk=1, con=1)

	print(ctrlBase, ctrlMid, ctrlEnd)
	locs = []
	tangentLocs = []

	for i in range(len(ctrlJoints)):
		if i == 0:
			tParent = pm.parentConstraint( ctrlJoints[i], ctrlBase[0], mo =False)
			tangentLocs.append(pm.spaceLocator(n = conName + "base_tangent"))
			locs.append(pm.spaceLocator(n= conName + "base_upVec"))
		elif i == 1:
			tParent = pm.parentConstraint( ctrlJoints[i], ctrlMid[0] , mo =False)
			locs.append(pm.spaceLocator(n= conName + "mid_upVec"))
		else:
			tParent = pm.parentConstraint( ctrlJoints[i], ctrlEnd[0] , mo =False)
			tangentLocs.append(pm.spaceLocator(n = conName + "end_tangent"))
			tanEndParent = pm.parentConstraint(ctrlEnd[0], ctrlMid[0], tangentLocs[1], mo = False)
			tanBaseParent = pm.parentConstraint(ctrlBase[0], ctrlMid[0], tangentLocs[0], mo = False)
			locs.append(pm.spaceLocator(n= conName + "end_upVec"))
			pm.delete(tanEndParent, tanBaseParent)
			pm.parent(tangentLocs[1], ctrlEnd[3] )
			pm.parent(tangentLocs[0], ctrlBase[3] )
		pm.delete(tParent)


	for i in range(len(ctrlJoints)):
		lParent = pm.parentConstraint(ctrlJoints[i], locs[i], mo=False)
		pm.delete(lParent)
		pm.parent(locs[i], ctrlJoints[i])
		locs[i].translateY.set(15.0)
		if i == 0:
			pm.parent(ctrlJoints[i], ctrlBase[3])
		elif i == 1:
			pm.parent(ctrlJoints[i], ctrlMid[3])
			pm.parent(locs[i], w=True)
		else:
			pm.parent(ctrlJoints[i], ctrlEnd[3])

	pm.pointConstraint(locs[0], locs[2], locs[1], mo=True)
	pm.pointConstraint(tangentLocs[0], tangentLocs[1], ctrlMid[1], mo=True)
	#aimConstraint -mo -weight 1 -aimVector 1 0 0 -upVector 0 1 0 -worldUpType "object" -worldUpObject testmid_upVec;
	pm.aimConstraint(tangentLocs[0], ctrlMid[1], weight=True, aimVector=(1,0,0), upVector=(0,1,0), worldUpType="object", worldUpObject=locs[1], mo=True)
Beispiel #33
0
    def FKIK_query_orient(self, obj_list, *args):
        '''
        Create aim constraint setup to query properly planar-aligned xyz euler orientations.
            @Argument(s):
                obj_list : List of 3 objects to determine planar relationship
            @Return:
                [[xyz], [xyz], [xyz]]
        '''
        
        if not len(obj_list) == 3:
            raise RuntimeError('Must provide exactly 3 items in obj_list to query orientations correctly.')
        
        POS_list = self.query_translation(obj_list)
        
        # TODO:
        #     Replace all this code with something a little
        #     more elegant.
        
        #     Likely something with OpenMaya for querying the
        #     actual vectors and orientations of the objects
        #     in world space?
        
        #     Using cross products to determine the correct
        #     planar relationships between guide positions.

        A_LOC = pm.spaceLocator()
        B_LOC = pm.spaceLocator()
        C_LOC = pm.spaceLocator()
        
        if self.debugging: print 'Created:', A_LOC, B_LOC, C_LOC
        
        A_LOC.setTranslation(POS_list[0])
        B_LOC.setTranslation(POS_list[1])
        C_LOC.setTranslation(POS_list[2])
        
        A_orient = pm.aimConstraint(B_LOC, A_LOC, aimVector=[1,0,0], upVector=[0,1,0], worldUpType='object', worldUpObject=C_LOC)
        B_orient = pm.aimConstraint(C_LOC, B_LOC, aimVector=[1,0,0], upVector=[0,1,0], worldUpType='object', worldUpObject=A_LOC)
        C_orient = pm.aimConstraint(A_LOC, C_LOC, aimVector=[-1,0,0], upVector=[0,-1,0], worldUpType='object', worldUpObject=B_LOC)
        
        A_value = A_LOC.getRotation()
        B_value = B_LOC.getRotation()
        C_value = C_LOC.getRotation()
        
        if self.debugging:
            print ('Successfully completed the creation and query of guide orientation')
            print A_value, B_value, C_value
            
        # Add disposable items to the cleanup_queue
        self.cleanup_queue.extend([A_orient, B_orient, C_orient, A_LOC, B_LOC, C_LOC])
        
        return [A_value, B_value, C_value]    
Beispiel #34
0
def aimObject(toTarget, fromTarget):
    """
    Aim object to the target.
    :param toTarget: `PyNode` or `list` object or world position to aim to
    :param fromTarget: `PyNode` object to transform
    :return:
    """
    if isinstance(toTarget, list):
        targetObj = pm.createNode("transform")
        pm.xform(targetObj, t=toTarget, ws=1)
        pm.delete(pm.aimConstraint(targetObj, fromTarget, mo=0, wut=0))
        pm.delete(targetObj)
    else:
        pm.delete(pm.aimConstraint(toTarget, fromTarget, mo=0, wut=0))
Beispiel #35
0
def addTwistCard(jnt):
    '''
    Given a `BPJoint` to drive a twist, creates a card with sibling twist helper.
    '''
    names = jnt.card.nameList(usePrefix=False)
    name = names[jnt.cardCon.index()]
    # Strip off the suffix if one exists
    if util.isMirrored(jnt):
        mirrorCode = jnt.card.rigData.get(
            'mirrorCode',
            '')  # &&& Can I always get the mirror code and always set it?
        suffix = config.jointSideSuffix(mirrorCode)
        name = name[:-len(suffix)]
    else:
        mirrorCode = ''

    name += 'Twist'

    card = makeCard(jointCount=1, jointNames=[name], rigInfo=None, size=(1, 1))
    # &&& Can I prevent joints from being added to this card?

    # Keep the card scaled along the length of the bone.
    xform(card, piv=(0, .5, 0), ws=True)
    aimConstraint(jnt,
                  card,
                  aim=[0, -1, 0],
                  u=[1, 0, 0],
                  wut='objectrotation',
                  wuo=jnt.cardCon.node(),
                  wu=[0, 0, 1])
    pointConstraint(jnt.parent, card)

    dist, grp = pdil.dagObj.measure(jnt, jnt.parent)
    grp.setParent(card)
    dist.setParent(card)
    dist.distance >> card.sy

    # The twist needs to stay on axis.
    card.start().tz.lock()

    card.extraNode[0] = jnt
    if mirrorCode:
        card.suffix.set(mirrorCode)
    with card.rigData as data:
        data[enums.RigData.rigCmd] = 'TwistHelper'

    card.sz.set(max(card.sy.get() / 4.0, 1.0))

    card.start().setBPParent(jnt.parent)
    return card
Beispiel #36
0
 def createTwistJnt(self, jnt=None, nfJnt=None, ikHandle=None):
     ''' Setup twist joint to use as angular diff object from no_roll jnt '''
     twistJnt =pm.duplicate(jnt, n=jnt.name()+'_twistResult')[0]
     pm.delete(pm.listRelatives(twistJnt))
     nfEnd = [x for x in pm.listRelatives(nfJnt, children=True) if x.type()=='joint'][0] 
     pm.parent(twistJnt, nfJnt)
     pm.aimConstraint(nfEnd, twistJnt, 
                      aimVector=(1,0,0),
                      worldUpVector=(0,1,0),
                      wuo=jnt, wut='objectrotation')
     
     #--- Connect twist result to ikSpline twist
     pm.connectAttr('%s.rotateX'%twistJnt, '%s.twist'%ikHandle, f=True) 
     
     return twistJnt
Beispiel #37
0
	def bdRigEye(self):
		#create IK handles for the bind joints, for now getting the joints based on the name
		parts = []
		if self.templateSide == 'both':
			parts = ['left','right']
		else:
			parts = [self.templateSide]
		for side in parts:		
			eyeLidsJnt = pm.ls(side + '*eyelid_*_01_jnt')
			eyeJoint = pm.ls(side + "*eye*jnt")[0]
			eyeCorners = pm.ls(side + "*eye*corner*01_jnt")
			eyeAnim = pm.ls(side + '_eye_anim')
			pm.select(cl=True)
			eyeAnimGrp = pm.group(n=side + '_eyelids_anim_GRP')
			pm.select(cl=True)
			pm.aimConstraint(eyeAnim[0],eyeJoint,offset = [0, 0, 0] ,weight=1 , aimVector =[0 ,0 ,1] ,upVector=[0, 1, 0] ,worldUpType="vector" ,worldUpVector= [0,1,0])
		
			blinkUpJnt = pm.duplicate(eyeJoint,name = side + '_eyelid_upper_blink_jnt',po=True)
			blinkLowJnt = pm.duplicate(eyeJoint,name = side + '_eyelid_lower_blink_jnt',po=True)
			
			baseLidsJnt = pm.ls(side + '*lids*base')
			pm.parent([blinkUpJnt[0],blinkLowJnt[0]],baseLidsJnt[0])
			for joint in (eyeLidsJnt + eyeCorners):
				endJoint = pm.listRelatives(joint,c=True,type='joint')
				
				ikName = endJoint[0].name().replace('02_bnd_jnt','ikHandle')
				ctrlName = endJoint[0].name().replace('02_bnd_jnt','anim')
				
				bdRigUtils.bdAddIk(joint.name(),endJoint[0].name(),'ikSCsolver',ikName)
				eyelidAnim,eyelidAnimGrp = bdRigUtils.bdBuildSquareController(endJoint[0].name(),ctrlName,0.2)
				pm.parent(eyelidAnimGrp , eyeAnimGrp)
				#bdRigUtils.bdBuildBoxController(endJoint[0].name(),ctrlName,0.2)
				if 'corner' not in ctrlName:
					bdRigUtils.bdAddAttributeMinMax(ctrlName,['BlinkPosition'],'double',-5,5,1)
				pm.parent(ikName,ctrlName)
				self.bdBuildJointStructure(joint,ctrlName,ikName)
			
			'''
			allAnimsGrps = pm.ls(self.templateSide + '*eye*CON_??',type='transform')
			globalAnimGrp = pm.ls('controllers') 
			pm.parent(allAnimsGrps,globalAnimGrp[0])
			'''
			
			self.bdAddEyeAttr(eyeAnim[0])
			self.bdCreateVerticalFollow(side)
			self.bdCreateSideFollow(side)
			self.bdCreateBlink(side)
			self.bdCleanupGuides(side)
Beispiel #38
0
def orientXform(xform,
                aim_loc,
                aim_axis=(1, 0, 0),
                up_axis=(0, 1, 0),
                world_up=(0, 1, 0),
                freeze=False):

    xform = pm.ls(xform)[0]

    children = xform.listRelatives()

    if children:
        for child in children:
            child.setParent(None)

    target = pm.createNode('transform')
    target.setTranslation(aim_loc, ws=True)

    pm.delete(
        pm.aimConstraint(target,
                         xform,
                         aimVector=aim_axis,
                         upVector=up_axis,
                         worldUpVector=world_up))

    pm.delete(target)

    if freeze:
        pm.makeIdentity(xform, apply=True)

    if children:
        for child in children:
            child.setParent(xform)
Beispiel #39
0
def createBendDeformerOnCurve(curveTransforms, upDir=(1,0,0), aimDir=(0,1,0)):
	'''Creates bend deformers on every curve and aims them at the end
	Args:
		curveTransforms ([pm.nt.Transform]): list of transforms with nurbsCurve shapes
		upDir (float, float, float): up direction for aim to orient the bend deformer
	Returns:
		([pm.nt.nonLinear]): list of bend deformers
	Usage:
		createBendDeformerOnCurve(pm.ls(sl=True))
	'''
	bends=[]
	for curveTransform in curveTransforms:
		bendName = curveTransform.name().replace('CRV','BEND')
		bend = pm.nonLinear(curveTransform, type='bend', frontOfChain=True, curvature=0.0, lowBound=0, highBound=1)
		bend[0].rename(bendName.replace('BEND','BENDHDL'))
		bend[1].rename(bendName)
		startPosition = curveTransform.getShape().cv[0].getPosition(space='world')
		endPosition = curveTransform.getShape().cv[-1].getPosition(space='world')
		loc = pm.spaceLocator()
		
		pm.move(loc, endPosition, a=True)
		pm.move(bend[1], startPosition, a=True)
		
		aimConst = pm.aimConstraint( loc, bend[1], upVector=upDir, aimVector=aimDir )
		pm.delete([loc, aimConst])
		bends.append(bend)
	return bends
Beispiel #40
0
def orientJoint(joint,
                aim_loc,
                aim_axis=(1, 0, 0),
                up_axis=(0, 1, 0),
                world_up=(0, 1, 0)):

    joint = pm.ls(joint)[0]

    children = joint.listRelatives()

    if children:
        for child in children:
            child.setParent(None)

    target = pm.createNode('transform')
    target.setTranslation(aim_loc, ws=True)

    pm.delete(
        pm.aimConstraint(target,
                         joint,
                         aimVector=aim_axis,
                         upVector=up_axis,
                         worldUpVector=world_up))

    pm.delete(target)

    if children:
        for child in children:
            child.setParent(joint)

    pm.makeIdentity(joint, apply=True)
Beispiel #41
0
def alignToVector(xform, aim_x=(1, 0, 0), aim_y=(0, 1, 0), freeze=False):
    """
    Rotates transform so that axes align with specified world-space directions.

    Parameters
    ----------
    xform : pm.nt.Transform
        Transform to rotate.
    aim_x : tuple, optional
        World-space direction for the x-axis of `xform`.
    aim_y : tuple, optional
        World-space direction for the y-axis of `xform`.  If not orthogonal to `aim_x`,
        the y-axis will attempt to be as close as possible to this vector.
    freeze : bool, optional
        Freeze transformation if True. Default is False.

    """

    xform = pm.ls(xform)[0]

    xf_node = pm.createNode('transform')
    pm.move(xf_node, xform.getTranslation(ws=True))

    aim_node = pm.createNode('transform')
    pm.move(aim_node, xform.getTranslation(space='world') + aim_x)

    pm.delete(pm.aimConstraint(aim_node, xf_node, worldUpVector=aim_y),
              aim_node)

    xform.setRotation(xf_node.getRotation(ws=True), ws=True)
    pm.delete(xf_node)

    if freeze:
        pm.makeIdentity(xform, apply=True)
	def makeAim(self):
		"""Creates the aimConstraints joints for prevLoc to loc"""
		# each SPAN
		for i, jnt in enumerate(self.jnts):
			grp = self.grps[i]
			loc = self.locs[i]

			pmc.orientConstraint(loc, jnt, mo=False)
			
			if not i:
				# if root joint, pointConstrain(?) and move along -
				# next part is for each SPAN only
				continue

			prevJnt = self.jnts[i - 1]
			prevGrp = self.grps[i - 1]
			prevLoc = self.locs[i - 1]

			# if empty, getParent returns None, getChildren returns []
			if jnt not in prevJnt.getChildren():
				pmc.warning("It is recommended that joints be in a heirarchy,"
						" and be selected in heirarchical order.")
			
			# get one locator to aim at the other, which produces rotation
			# values which can be piped into joint rotation
			axis = jnt.translate.get().normal()
			arc = jnt.jointOrient.get().normal()
			wuo = prevGrp
			#if not i:
			#	wuo = self.ctrls[0]
			aim = pmc.aimConstraint(loc, prevLoc, aimVector=axis, upVector=arc, 
							worldUpVector=arc, worldUpObject=wuo, 
							wut="objectrotation")
Beispiel #43
0
def setNodeAxisVectors(node, oldA1="posY", oldA2="posX", newA1="posY", newA2="posX", orient=True):

    node = pm.PyNode(node)
    #these are world space vectors

    oldV1 = getNodeAxisVector(node, oldA1)
    oldV2 = getNodeAxisVector(node, oldA2)
    _logger.debug("%s vector: %s; %s vector: %s" % (oldA1, str(oldV1), oldA2, str(oldV2)))
    newV1 = g_vectorMap[newA1]
    newV2 = g_vectorMap[newA2]


    posL = pm.spaceLocator()
    aimL = pm.spaceLocator()
    upL = pm.spaceLocator()
    aimL.setParent(posL)
    upL.setParent(posL)
    pm.delete(pm.pointConstraint(node, posL, mo=False))

    aimL.translate.set(oldV1)
    upL.translate.set(oldV2)
    pm.delete(pm.aimConstraint(aimL, node, aimVector=newV1, upVector=newV2, worldUpType='object', worldUpObject=upL))
    pm.delete(posL)

    if orient:
        node.jox.set(node.jox.get() + node.rotateX.get())
        node.joy.set(node.joy.get() + node.rotateY.get())
        node.joz.set(node.joz.get() + node.rotateZ.get())
        node.rotate.set([0, 0, 0])
Beispiel #44
0
def strokePath(node, radius=.1):
    """
    Create a nurbs surface from a curve control
    """
    curveNodes = separateShapes(node)
    for curveNode in curveNodes:
        shape = curveNode.listRelatives(type='nurbsCurve')[0]
        t = pm.pointOnCurve(shape, p=0, nt=1)
        pos = pm.pointOnCurve(shape, p=0)
        cir = pm.circle(r=radius)[0]
        pm.xform(cir, t=pos, ws=1)

        #align the circule along the curve
        l = pm.spaceLocator()
        pm.xform(l, t=[pos[0]+t[0], pos[1]+t[1], pos[2]+t[2]], ws=1)
        pm.delete(pm.aimConstraint(l, cir, aimVector=[0,0,1]))
        pm.delete(l)

        newxf = pm.extrude(cir, curveNode, rn=False, po=0, et=2, ucp=1,
                            fpt=1, upn=1, scale=1, rsp=1, ch=1)[0]
        pm.delete(cir)
        pm.delete(curveNode.listRelatives(type='nurbsCurve'))
        parentShape(curveNode, newxf)
    if len(curveNodes) > 1:
        for i in range(1, len(curveNodes)):
            parentShape(curveNodes[0], curveNodes[i])
    return curveNodes[0]
Beispiel #45
0
    def orient_chain(self):
        """
        aim parent to get right orientation of Locs
        """

        pm.parent(*self, world=True)
        constraints = []
        for node_a, node_b in zip(self[1:], self[:-1]):

            # ainConstrain with UP orientation after node_a list
            cnst = pm.aimConstraint(node_a,
                                    node_b,
                                    worldUpObject=node_a,
                                    worldUpType="objectrotation",
                                    worldUpVector=(0, 1, 0))
            constraints.append(cnst)

        cnst = pm.orientConstraint(self[-2], self.list_of_joints[-1])
        constraints.append(cnst)

        pm.delete(constraints)

        pm.makeIdentity(self, rotate=True, apply=True)

        transform.parenting(self)
Beispiel #46
0
    def create(self):
        self.handle   = pm.group(em=True)
        self.result   = pm.group(em=True)
        self.aim      = pm.group(em=True)
        self.up       = pm.group(em=True)
        
        pm.parent(self.result, self.aim, self.up, self.handle )
        
        # 초기위치 조정
        mult = 20
        self.aim.t.set(self.aimVec * mult)
        self.up.t.set(self.upVec * mult)
        
        self.aimConstraint = pm.aimConstraint(self.aim, self.result, aim=self.aimVec, u=self.upVec, wut='object', wuo=self.up)
        
        # 시각화
        self.handle.displayHandle.set(True)
        #self.result.displayLocalAxis.set(True)
        
        # 어트리뷰트 잠금
        setAttrs( self.result, 'tx','ty','tz','sx','sy','sz','v' )
        setAttrs( self.aim,    'rx','ry','rz','sx','sy','sz','v' )
        setAttrs( self.up,     'rx','ry','rz','sx','sy','sz','v' )

        # 이름변경
        self.setPrefix( self.prefix )
Beispiel #47
0
    def poleVector(self, name='', mid='', posMultiplier=1):

        if name == '':
            name = self.name

        poleVector = rig_transform(0, name=name + 'PoleVector',
                                   type='locator').object
        pm.delete(pm.parentConstraint(self.start, self.end, poleVector))

        pm.delete(pm.aimConstraint(mid, poleVector, mo=False))

        startPos = pm.xform(self.start, translation=True, query=True, ws=True)
        midPos = pm.xform(self.end, translation=True, query=True, ws=True)
        poleVectorPos = pm.xform(poleVector,
                                 translation=True,
                                 query=True,
                                 ws=True)

        pvDistance = lengthVector(midPos, poleVectorPos)

        pm.xform(poleVector,
                 translation=[pvDistance * posMultiplier, 0, 0],
                 os=True,
                 r=True)

        pm.poleVectorConstraint(poleVector, self.handle)  # create pv

        return poleVector
Beispiel #48
0
def build(crv, name=''):
    '''
    creates a Marco Giordano style eyelid rig

    '''
    params = [curve.getClosestPointOnCurve(crv=crv, point = pmc.pointPosition(cv)) for cv in crv.cv[:]]

    mainGrp = pmc.group(empty=1, name='%s_grp' % name)
    baseGrp = pmc.group(empty=1, name='%s_base_grp' % name)
    baseGrp.setParent(mainGrp)

    mps = curve.nodesAlongCurve(crv=crv.name(), numNodes=len(params), name=name)

    for index in range(len(params)):
        mp = common.getPyNode(mps['mpNodes'][index])
        mp.uValue.set(params[index])
        mp.fractionMode.set(0)

        grp = common.getPyNode(mps['grps'][index])

        aimGrp = pmc.group(empty=1, name='%s_%s_aim_grp' % (name, str(index)))
        aimGrp.setParent(baseGrp)
        con = pmc.aimConstraint(grp, aimGrp, mo=0, wut=2, wuo=baseGrp.name())

        pmc.select(aimGrp, r=1)
        j = pmc.joint(name='%s_%s_jnt' % (name, str(index)))
        j.tx.set(10)
    def bdCreateDrvJnt(self,crv1,crv2):
        pm.select(cl=1)
        drv1 = self.startJnt.duplicate(po=1)[0]
        pm.parent(drv1,w=1)
        drv1.rename(self.nameRbn + '_DRV_1_JNT')
        radius = self.startJnt.radius.get()
        drv1.radius.set(radius*1.5)
        pm.parentConstraint(self.startJnt,drv1,mo=0)
        
        drv2 = drv1.duplicate(po=1)[0]
        drv2.rename(self.nameRbn + '_DRV_2_JNT')
        
        drv3 = drv1.duplicate(po=1)[0]
        drv3.rename(self.nameRbn + '_DRV_3_JNT')
        pm.parentConstraint(self.endJnt,drv3,mo=0)

        startPos,endPos = self.bdGetPos(0)
        drv1.setTranslation(startPos)
        drv3.setTranslation(endPos)

        drv2CtrlGrp = self.bdCreateJntCtrl(drv2,0.20)
        pm.pointConstraint(drv1,drv2CtrlGrp,mo=0 )
        pm.pointConstraint(drv3,drv2CtrlGrp,mo=0 )
        aimLocator = pm.spaceLocator(n=drv2CtrlGrp.name().replace('DRV_2_CTRL_GRP','AIM'))
        drv2CtrlGrpPos = drv2CtrlGrp.getTranslation(space='world')
        aimLocator.setPosition(drv2CtrlGrpPos)
        for axis in ['X','Y','Z']:
            aimLocator.attr('localScale'+axis).set(0.1)
        aimLocatorGrp = pm.group(aimLocator,n=aimLocator.name() + '_grp')
        aimLocatorGrp.centerPivots()
        if self.direction == 'hor':
            pm.move(0,0.5,0, aimLocatorGrp, r=1, os=1, wd=1)
        elif self.direction == 'vert':
            pm.move(0,0,0.5, aimLocatorGrp, r=1, os=1, wd=1)
        pm.parentConstraint(self.startJnt,aimLocatorGrp,mo=1)
        print aimLocator.getTranslation(space='world').x
        if aimLocator.getTranslation(space='world').x > 0:
            pm.aimConstraint(drv3,drv2CtrlGrp,mo=1,weight=1,aimVector=[1, 0, 0],upVector = [0, 1, 0],worldUpType="object" , worldUpObject = aimLocator)
        else:
            pm.aimConstraint(drv3,drv2CtrlGrp,mo=1,weight=1,aimVector=[-1, 0, 0],upVector = [0, 1, 0],worldUpType="object" , worldUpObject = aimLocator)
        drvGrp = pm.group([drv1,drv2CtrlGrp,drv3],n=self.nameRbn + '_DRV_GRP')
        crv1Skin = pm.skinCluster(drv1,drv2,drv3,crv1)
        crv1Skin = pm.skinCluster(drv1,drv2,drv3,crv2)
        pm.parent(aimLocatorGrp,drvGrp)
        return drvGrp
Beispiel #50
0
def addEyelashCollider(bnd, browCrv):
    '''
    browCrv = pm.PyNode(u'LT_eyeBrowCollide_crv')
    bnd = pm.PyNode('FACE:LT_eye_aimAt_bnd_16')
    '''
    childGrp = bnd.getChildren()[0]
    # create vertCrv
    vertCrv = pm.curve(p=((0,-10,0),(0,10,0)), n=bnd+'_vertCrv', d=1)
    # constrain to bnd
    pm.pointConstraint(bnd, vertCrv)
    # intersect
    crvInt = pm.createNode('curveIntersect', n=bnd+'_collider_int')
    browCrv.worldSpace >> crvInt.inputCurve1
    vertCrv.worldSpace >> crvInt.inputCurve2
    crvInt.useDirection.set(True)
    # calculate direction of bnd's x-axis
    mat = bnd.getMatrix(ws=True)
    dir = pm.dt.Vector(1,0,0) * mat
    crvInt.direction.set(dir)
    # get point on crv
    poci = pm.createNode('pointOnCurveInfo', n=bnd+'_collider_poci')
    browCrv.worldSpace >> poci.inputCurve
    crvInt.parameter1[0] >> poci.parameter
    # aim loc
    aimLoc = pm.spaceLocator(n=bnd+'_collide_aimLoc')
    aimLoc.localScale.set(0.1,0.1,0.1)
    poci.position >> aimLoc.t
    # limit null
    limitNull = pm.group(em=True, n=bnd+'_collider_limit')
    bnd | limitNull
    limitNull.setMatrix(pm.dt.Matrix())
    # aim to aimLoc
    pm.aimConstraint(aimLoc, limitNull, aim=(1,0,0), 
    wuo=bnd, wu=(0,1,0), u=(0,1,0), wut='objectrotation')
    # limit childGrp while keeping bnd's orientation
    limitNull | childGrp
    pm.orientConstraint(bnd, childGrp)
    childGrp.minRotZLimit.set(10)
    childGrp.minRotZLimitEnable.set(True)
    # cleanup
    grp = pm.group(vertCrv, aimLoc, n=bnd+'_collide_grp')
    grp.addAttr('minRotate', k=True, dv=10)
    grp.minRotate >> childGrp.minRotZLimit
    
    return grp
Beispiel #51
0
def aimAt(master, slave, upRotObject, orientation, flipUp=False):
    aimVec = orientation.getAxis('aim')
    upVec = orientation.getAxis('up')
    worldUpVec = upVec
    if flipUp:
        worldUpVec = [x*-1 for x in worldUpVec]
    cst = pm.aimConstraint(master, slave, aim=aimVec, u=upVec, wu=worldUpVec,
                     mo=False, wut='objectRotation')
    pm.delete(cst)
Beispiel #52
0
	def createManipulatorAndIkHandleConstraints(self):
		
		pm.select(cl = True)
		
		
		#manip_aim indicator aim grp
		pm.aimConstraint(self.manip_leg_complete, self.manip_aim_indicator_aim_grp, aim = (1,0,0), u = (0,1,0), wut = 'objectrotation' , wu = (0,1,0) ,mo = True)
		pm.select(cl = True)
		
		
		#manip_leg_ik
		pm.parentConstraint(self.manip_aim_indicator, self.manip_leg_ik_grp, mo = True)
		pm.scaleConstraint(self.manip_aim_indicator, self.manip_leg_ik_grp, mo = True)
		
		pm.pointConstraint(self.manip_leg_complete, self.manip_leg_ik_point_grp, mo = True)
		pm.select(cl = True)
		
		
		#poleVector
		pm.parentConstraint(self.manip_aim_indicator, self.leg_ik_pole_vector_locator_grp, mo = True)
		pm.scaleConstraint(self.manip_aim_indicator, self.leg_ik_pole_vector_locator_grp, mo = True)
		pm.select(cl = True)
		
		
		#poleVectorConstraint
		pm.poleVectorConstraint(self.leg_ik_pole_vector_locator, self.leg_ik_handle)
		pm.select(cl = True)
		
		
		#IkHandle
		pm.parentConstraint(self.manip_leg_ik, self.leg_ik_handle_grp, mo = True)
		pm.scaleConstraint(self.manip_leg_ik, self.leg_ik_handle_grp, mo = True)
		pm.select(cl = True)
		
		
		#ik_j_tip
		pm.orientConstraint(self.manip_leg_ik, self.leg_ik_j_tip, mo = True)
		pm.select(cl = True)
		
		
		#ik_j_grp
		pm.parentConstraint(self.manip_leg_base, self.leg_ik_j_grp, mo = True)
		pm.scaleConstraint(self.manip_leg_base, self.leg_ik_j_grp, mo = True)
		pm.select(cl = True)
    def constrainJoints(self, a=None, b=None, jnts=None):
	# Select two end joints, creates mid joint.
	# Constrains mid joint to follow and aim at second end joint.
	
	# Setup up locator
	loc = pm.spaceLocator(name='%s_upLoc' % a)
	pm.delete(pm.pointConstraint(b, loc, mo=0))
	
	# Adjust placement of Up object here
	moveAxis = pm.optionMenu(self.axisFld, q=1, value=1)
	if moveAxis == 'X': pm.move(20, loc, moveX=1)
	if moveAxis == 'Y': pm.move(20, loc, moveY=1)
	if moveAxis == 'Z': pm.move(20, loc, moveZ=1)
	pm.parent(loc, a)
	
	# Constrain joint
	for j in jnts:
	    pm.pointConstraint(a, b, j, mo=1)
	    pm.aimConstraint(b, j, wut='object', wuo=loc.name(), mo=1)
def rig_piston(head, rod, weight, crankshaft, rotatePattern, parent=False):
	rod_grp = pm.group(em=True,n=rod.replace('LOC','GRP'))
	head_grp = pm.group(em=True,n=head.replace('LOC','GRP'))
	head_pos = pm.spaceLocator(n=head.replace('LOC','pos_LOC'))
	pos.matchPos(head, [head_pos])
	pos.matchPos(rod, [rod_grp], type=1, ws=True, silent=True)
	rod.setParent(rod_grp)
	pos.matchPos(head, [head_grp])
	head.setParent(head_grp)
	pm.parentConstraint(weight, rod_grp, skipRotate=('x','y','z'),mo=True)
	pm.aimConstraint(head, rod, aimVector=(0,1,0), upVector=(0,1,0),
	                 worldUpType='vector',worldUpVector=(0,1,0),
	                 offset=(0,0,0),weight=1,skip=('y','z'), mo=True)
	dist=pm.shadingNode('distanceBetween',asUtility=True)
	head_pos.translate.connect(dist.point1)
	rod_grp.translate.connect(dist.point2)
	pma = pm.shadingNode('plusMinusAverage',asUtility=True)
	pma.input2D[1].input2Dx.set( dist.distance.get())
	dist.distance.connect( pma.input2D[0].input2Dx)
	pma.operation.set(2)
	md = pm.shadingNode("multiplyDivide", asUtility=True)
	pma.output2D.output2Dx.connect(md.input1.input1X)
	md.input2.input2X.set(-1)
	md.outputX.connect(head.ty)
	head_pos.visibility.set(0)
	
	if parent:
		rod_grp.setParent(parent)
		head_grp.setParent(parent)
		head_pos.setParent(parent)
		
	if rotatePattern:
		#Same direction if the input is 0
		crankshaft.rotateX.connect(weight.rotateX)
	else:
		#Reverse if the input is 0
		md = pm.shadingNode('multiplyDivide',asUtility=True)
		crankshaft.rotateX.connect(md.input1X)
		md.outputX.connect(weight.rotateX)
		md.input2X.set(-1)
Beispiel #55
0
    def build(self, extract_world_up, name=None, *args, **kwargs):
        super(NonRollJoint, self).build(name=name, *args, **kwargs)

        pymel.select(clear=True)
        self.start = pymel.joint()
        self.end = pymel.joint()
        self.end.setTranslation([1,0,0])
        pymel.makeIdentity((self.start, self.end), apply=True, r=True)

        self.ikHandle, ikEffector = pymel.ikHandle(
            solver='ikRPsolver',
            startJoint=self.start,
            endEffector=self.end)
        self.ikHandle.poleVectorX.set(0)
        self.ikHandle.poleVectorY.set(0)
        self.ikHandle.poleVectorZ.set(0)

        # Name stuff, if no nomenclature, cry, node will be named by the base class
        start_name = name + "_jntStart"
        end_name = name + "_jntEnd"
        ik_handle_name = name + "_ikHandle"
        ik_effector_name = name + "_ikEffector"
        twist_extract_name = name + "_twistExtractor"

        self.start.rename(start_name)
        self.end.rename(end_name)
        self.ikHandle.rename(ik_handle_name)
        ikEffector.rename(ik_effector_name)

        # Create the extract node for the twist information
        self.twist_extractor = pymel.createNode('transform')
        self.twist_extractor.rename(twist_extract_name)
        self.twist_extractor.setMatrix(self.start.getMatrix(worldSpace=True), worldSpace=True)
        self.twist_extractor.setParent(self.start)
        pymel.aimConstraint(self.end, self.twist_extractor, worldUpType=2, worldUpObject=extract_world_up)

        # Set Hierarchy
        self.start.setParent(self.node)
        self.ikHandle.setParent(self.node)
Beispiel #56
0
def centeredCtl(startJoint, endJoint, ctl, centerDown='posY'):
    """
    Setup a control to be 'centered' down a bone.
    @param startJoint: the joint the control should start at
    @param endJoint: the joint the control should end at
    @param ctl: the control node
    @param centerDown: the control axis to stretch to center the node
    """

    o = utils.Orientation()
    o.setAxis('aim', centerDown)

    pm.pointConstraint(startJoint, endJoint, ctl)
    pm.aimConstraint(endJoint, ctl,
                     aim=o.getAxis('aim'),
                     upVector=o.getAxis('up'),
                     wu=o.getAxis('up'), worldUpType='objectRotation',
                     worldUpObject=startJoint)

    #set up network to measure the distance

    mdn = MC.createNode('multiplyDivide', n='%s_centeredctl_mdn' % ctl)
    MC.select(cl=1)
    dd = MC.createNode('distanceBetween', n='%s_center_dd' % ctl)
    MC.connectAttr('%s.worldMatrix' % startJoint, "%s.im1" % dd)
    MC.connectAttr('%s.worldMatrix' % endJoint, "%s.im2" % dd)

    MC.connectAttr('%s.distance' % dd, '%s.input1X' % mdn)

    #find the amount we need to scale by. Ctls are generally built to a scale of 1
    #unit by default.
    scale = getInfo(ctl)['s']
    scale = scale[utils.indexFromVector(o.getAxis('aim'))]
    scale = (1.0/(scale*2))
    MC.setAttr("%s.input2X" % mdn, scale)

    scaleAttr = 'scale%s' % o.getAxis('aim', asString=True)[3]
    MC.connectAttr("%s.outputX" % mdn,
                   "%s.%s" % (ctl, scaleAttr))