Example #1
0
 def makeCube():
     squareCrv = dtLib.makeSquare()
     squareCrv2 = dtLib.makeSquare()
     squareCrv2.setRotation([90, 0,0])
     squareCrv2.setTranslation([0,0.5,-0.5])
     pm.makeIdentity(apply=True, translate=True, rotate=True, scale=True, normal=1)
     
     crvs = squareCrv2.getShapes()
     
     for current in crvs:
         pm.parent(current, squareCrv, relative=True, shape=True)
     pm.delete(squareCrv2)
     
     pm.select(squareCrv)
     dupCrv = pm.duplicate()
     dupCrv[0].setRotation([180, 0, 0])
     dupCrv[0].setTranslation([0,0,-1])
     pm.makeIdentity(apply=True, translate=True, rotate=True, scale=True, normal=1)
     crvs = dupCrv[0].getShapes()
     for current in crvs:
         pm.parent(current, squareCrv, relative=True, shape=True)
         
     pm.delete(dupCrv)
     #中央にピポットを移動
     pm.select(squareCrv)
     pm.xform(cp=True)
     return pm.selected()
def add_text_shape(ctrl, text):
    text_curve = pm.PyNode( pm.textCurves(ch=False, font="Arial Black", text=text, name='text_curve')[0] )
    text_curve_length = text_curve.boundingBox()[1][0] #max X
    text_curve_height = text_curve.boundingBox()[1][1] #max Y
    
    shapes = pm.listRelatives(text_curve, ad=True, type="shape")
    
    pm.xform(text_curve, piv=[0,text_curve_height,0], ws=True)

    pm.move(text_curve, 0, -text_curve_height , 0)

    scale = 1 / text_curve_length
    pm.scale(text_curve, scale, scale, scale)
            
    pm.makeIdentity(text_curve, apply=True, t=True, r=True, s=True)

    display_attr = ("%s_text_display"%text)
    if not ctrl.hasAttr(display_attr):
        ctrl.addAttr(display_attr, at='bool', k=True, dv=1)

    for s in shapes:
        pm.parent(s, ctrl, s=True, r=True)
        s.rename('%sText'%text)
        pm.connectAttr("%s.%s" %(ctrl.name(), display_attr), s.visibility)

    pm.delete(text_curve)
Example #3
0
 def build_between_points(cls, start_xform, end_xform, num_joints, name={'name':'chain'}, freeze=True, chain=True, parent=None, offset=False):
     """ Create joints based on given 3D spatial positions/rotations e.g. [[[10,5.3,1.4],[0,90,0]],...,nPos]
     Args:
         start_xform [pm.nt.Transform]: starting position
         end_xform [pm.nt.Transform]: ending position
         name (str): base name for the chain
         chain (bool): whether or not to make a chain, or isolated joints
         offset (bool): whether or not to build in offset groups for the joints
         parent (pm.nt.Transform): final parent of the joints, empty if kept at root level
     Returns:
         [pm.nt.Joint]: list of joints
     Usage:
         Joint.build_between_points(pm.ls(sl=True)[0], pm.ls(sl=True)[1], 5, chain=True, offset=True, freeze=True)
     """
     xform_interps = transform.spatial_interpolate(pm.xform(start_xform, q=True, t=True, ws=True),
                                                   pm.xform(end_xform, q=True, t=True, ws=True),
                                                   num_joints)
     
     rotation_interps = transform.spatial_interpolate(pm.xform(start_xform, q=True, ro=True, ws=True),
                                                      pm.xform(end_xform, q=True, ro=True, ws=True),
                                                      num_joints)
     
     positions = [[xform_interp, rotation_interp] for xform_interp, rotation_interp in zip(xform_interps, rotation_interps)]
     
     return cls.build_from_points(positions, name=name, chain=chain, parent=parent, offset=offset, freeze=freeze)
Example #4
0
    def generate( self, radius = 10, iterations = 1 ):
        
        self.radius     = radius
        self.iterations = iterations
        
        print( "%s radius %f iterations %i" % ( self.__class__.__name__, self.radius, self.iterations ) )

        octahedronRadius = float(self.radius) / util.pow( float(2), float(self.iterations ) )
        octahedron       = self.mesh( radius = octahedronRadius )
        octahedra        = [ octahedron ]
        
        pm.polySoftEdge( angle = 0 )   

        octahedronHeight = octahedron[ 1 ].getSideLength() / util.sqrt( 2 )
    
        for i in range( iterations ):
            
            mesh = self.__generateMesh( octahedra[ 0 ], octahedronHeight, octahedronRadius, ( i + 1 ) )
            
            octahedronHeight *= 2            
            octahedronRadius *= 2            
            
            octahedra = [ mesh ]
        

        pm.xform( mesh[ 0 ], centerPivots = True )

        print( "Construction complete" )
        
        return mesh
Example #5
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
Example #6
0
def locatorGrid(width, height, depth, offset, centered=True):
	'''Create a grid of locators to test upon
	Args:
		width (int): Width of the grid
		height (int): Height of the grid
		offset (float): Adds an offset multiplier to the locator positions
		centered (bool): determines whether it's centered in world space
	Returns (pm.PyNode): The top group of the locator grid
	Usage: locatorGrid(5,5,5,2)
	'''
	if not pm.objExists('locatorGrid'):
		grp=pm.group(em=True,n='locatorGrid')
		for d in range(0,depth):
			for w in range(0,width):
				for h in range(0,height):
					loc = pm.polyCube(w=.5, h=.5, d=.5, ch=0)[0]
					pm.move(loc,(w*offset,h*offset,d*offset), rpr=True)
					loc.setParent(grp)
					if loc.getShape().type() == "locator":
						loc.localScale.set(.2,.2,.2)
		if centered:
			pm.xform(grp, cp=1)
			pm.move(grp, (0, 0, 0), rpr=1)
			pm.makeIdentity(grp, apply=True, r=1,s=1,t=1)
		return grp
Example #7
0
    def buildChains(self, *args):
        """
        Build joint chains based on locator positions.
        """
        self.jointChain = []
        self.ikChain = []
        self.fkChain = []

        loc1Pos = pm.xform(self.loc1, q=True, ws=True, t=True)
        loc2Pos = pm.xform(self.loc2, q=True, ws=True, t=True)
        loc3Pos = pm.xform(self.loc3, q=True, ws=True, t=True)

        jnt1='%s_shldrJnt'%self.prefix
        jnt2='%s_elbow1Jnt'%self.prefix
        jnt3='%s_wristJnt'%self.prefix

        self.jointChain.append(pm.PyNode(pm.joint(p=loc1Pos, n=jnt1))) 
        self.jointChain.append(pm.PyNode(pm.joint(p=loc2Pos, n=jnt2)))
        self.jointChain.append(pm.PyNode(pm.joint(p=loc3Pos, n=jnt3)))

        #--- Orient the chain
        self.orientChain()

        #--- Creating duplicate ik/fk joint chains
        for each in pm.duplicate(self.jointChain, rc=True):
            # Slice off number maya adds during duplication
            each.rename('%s_ik' % each[:-1])
            self.ikChain.append(pm.PyNode(each))

        for each in pm.duplicate(self.jointChain, rc=True):
            each.rename('%s_fk' % each[:-1])
            self.fkChain.append(pm.PyNode(each))
def transfer_shape(source, target, flip=True):
    """it will replace the shape of selected number 2 with the shapes of selected number 1"""

    target_shape = target.getShape(noIntermediate=True)
    target_shape_orig = get_orig_shape(target_shape)

    dup = pymel.duplicate(source, rc=1)[0]
    tmp = pymel.createNode('transform')
    pymel.parent(tmp, dup)
    pymel.xform(tmp, t=(0, 0, 0), ro=(0, 0, 0), scale=(1, 1, 1))
    pymel.parent(tmp, w=1)
    for sh in dup.getShapes(noIntermediate=True):
        pymel.parent(sh, tmp, r=1, s=1)

    pymel.delete(dup)
    temp_grp_negScale = pymel.createNode('transform')
    pymel.parent(tmp, temp_grp_negScale)
    if flip:
        temp_grp_negScale.scaleX.set(-1)

    pymel.parent(tmp, target)
    pymel.delete(temp_grp_negScale)

    pymel.makeIdentity(tmp, t=True)  # this brings translate values at 0 before scale freezing
    pymel.makeIdentity(tmp, apply=True, t=True, r=True, s=True)
    pymel.parent(tmp, w=1)

    color_info, vis_master = get_previous_controller_info(target)

    shapes_has_been_deleted = False
    for sh in tmp.getShapes():
        if target_shape_orig:
            adapt_to_orig_shape(sh, target.getShape())
        else:
            if not shapes_has_been_deleted:
                shapesDel = target.getShapes()
                if shapesDel: pymel.delete(shapesDel)
                shapes_has_been_deleted = True

            pymel.parent(sh, target, r=1, s=1)
            pymel.rename(sh.name(), target.name() + "Shape")

            if color_info[0]:
                if color_info[1]:
                    sh.overrideEnabled.set(True)
                    sh.overrideRGBColors.set(1)
                    sh.overrideColorRGB.set(color_info[2])

                else:
                    sh.overrideEnabled.set(True)
                    sh.overrideRGBColors.set(0)
                    sh.overrideColor.set(color_info[2])

            else:
                sh.overrideEnabled.set(False)

            if vis_master:
                vis_master.connect(sh.visibility)

    pymel.delete(tmp)
Example #9
0
def set_newPivot(*args):
    sel = pm.ls(sl=True)
    source = sel[-1]
    piv = pm.xform (source, piv=True, q=True, ws=True)
    
    for obj in sel[:-1]:
        pm.xform (obj, ws=True, piv=(piv[0], piv[1], piv[2]) )
Example #10
0
def setPosUv(vtxs,length,side,uvDistorted):
    startUv = pm.ls(pm.polyListComponentConversion(vtxs[0],fv=1,tuv=1),fl=1)

    if side == 'left':
        pm.polyEditUV(startUv,r=0,u=0,v=0)
    else:
        pm.polyEditUV(startUv,r=0,u=1,v=0)
    

    for i in range(1,len(vtxs)):
        vtx1Pos = pm.xform(vtxs[i-1],q=1,t=1,ws=1)
        vtx2Pos = pm.xform(vtxs[i],q=1,t=1,ws=1)
        vtx1PosVec = MVector(vtx1Pos[0],vtx1Pos[1],vtx1Pos[2])
        vtx2PosVec = MVector(vtx2Pos[0],vtx2Pos[1],vtx2Pos[2])
        dist = (vtx2PosVec  - vtx1PosVec).length()
        
        factor=0.0
        if uvDistorted:
            factor = dist / length
        else:
            factor = 1.0 / (len(vtxs) - 1)
            
                             
        uv1 = pm.ls(pm.polyListComponentConversion(vtxs[i-1],fv=1,tuv=1),fl=1)
        uv2 = pm.ls(pm.polyListComponentConversion(vtxs[i],fv=1,tuv=1),fl=1)
        uv1Pos = pm.polyEditUV(uv1,q=1)
        uv2Pos = uv1Pos[1] + factor
        if side == 'left':
            pm.polyEditUV(uv2,r=0,u=0,v=uv2Pos)
        else:
            pm.polyEditUV(uv2,r=0,u=1,v=uv2Pos)
    def generateShape(self, *args):
        sel = pm.ls(sl=1)
        if len(sel) != 4:
            pm.mel.warning('Must select: Neutral, TargetA, TargetB, TargetC meshes')
            return
        
        meshN = sel[0]
        meshA = sel[1]
        meshB = sel[2]
        meshC = sel[3]
        
        # Create new mesh
        new = pm.duplicate(meshN, n='Corrective')[0]
        
        # Per vertex, translate in world space: C-(A+B)
        for vtx in new.vtx:
            vert = vtx.split('.')[1]
            n_pos = pmd.Point(pm.xform( vtx, query=True, ws=True, t=True))
            a_pos = pmd.Point(pm.xform( meshA + '.' + vert, query=True, ws=True, t=True))
            b_pos = pmd.Point(pm.xform( meshB + '.' + vert, query=True, ws=True, t=True))
            c_pos = pmd.Point(pm.xform( meshC + '.' + vert, query=True, ws=True, t=True))
            
            aVec = a_pos - n_pos
            bVec = b_pos - n_pos
            cVec = c_pos - n_pos

            delta = cVec - (aVec + bVec)
            
            pm.move(vtx, delta, r=1)
Example #12
0
def create_bind_proxy(jnt):
    if jnt.getChildren():
        name=jnt.name() + "_bindProxy"
         
        distance = jnt.getChildren()[0].translateX.get()
        if not pm.objExists(name):
            proxy = pm.polyCylinder(r=0.25, h=0.5, sx=12, sy=4, sz=4, ax=[1,0,0], rcp=1, cuv=0, ch=0, name=name)[0]
            pm.xform(proxy, piv=[-0.5, 0, 0])
             
            pm.parent(proxy, 'bind_proxy')
             
            pm.delete(pm.parentConstraint(jnt, proxy, mo=False))
            proxy.scale.set(distance, distance, distance)
             
            try:
                jnt.addAttr('iterations', at='long', min=1, max=5, dv=3, k=True)
                jnt.addAttr('bind_proxy', at='message')
            except:
                pass            
                 
        else:
            proxy = pm.PyNode(name)

        
        pm.skinCluster( jnt, proxy, tsb=True)
        proxy.message >> jnt.bind_proxy            
Example #13
0
    def __areaSkin(self,*args):

        geo = pm.ls(sl = 1)[0]
        skinCluster = mel.eval('findRelatedSkinCluster ' + geo)
        vertex = pm.polyEvaluate(geo,v = 1)
        joints = pm.skinCluster(skinCluster,q = 1,inf = 1)
        skinList = {}

        for num in range(0,vertex):
            vertex = geo + '.vtx[' + str(num) + ']'
            vertPos = pm.xform(vertex,q = 1,t = 1,ws = 1)
            tempDict = {}
          
            for joint in joints:
                jntPos = pm.xform(joint,q = 1,t = 1,ws = 1)
                dist = math.sqrt(pow(vertPos[0] - jntPos[0],2) + pow(vertPos[1] - jntPos[1],2) + pow(vertPos[2] - jntPos[2],2))
                tempDict.setdefault(joint,dist)
                  
            minDistVal = min(distVal for distVal in tempDict.values())
          
            for joint in tempDict.keys(): 
                if minDistVal == tempDict[joint]:
                    if joint not in skinList:
                        skinList[joint] = []
                    skinList[joint].append(vertex)
                      
        for item in skinList.items():
            joint =  item[0]
            vertex = item[1]
            for vert in vertex:
                pm.skinPercent(skinCluster,vert,transformValue = (joint,1))        
Example #14
0
    def create_hook(cls, asset="asset", side="c",  part="part",
                    snap_to=None, in_out='in'):
        """
        Settings for generating hooks in the autorig.

        :parameters:
            asset: For naming convention.
            side: For naming convention. (l, r, c)
            part: For naming convention.
            snap_to: Object to snap to.
            in_out: default value.
        """
        hook_name = NameUtils.get_unique_name(asset, side, part, "loc")
        hook = pm.createNode(settings.HOOK_NODE_TYPE, n=hook_name)

        if settings.HOOK_NODE_TYPE == "locator":
            hook = hook.getParent()
            hook.rename(hook_name)

        digit_type = 0
        if in_out == 'out':
            digit_type = 1

        hook.addAttr('hookType', at='float', dv=digit_type)
        hook.attr('hookType').lock(1)
        if snap_to:
            pm.xform(hook, ws=1, matrix=snap_to.wm.get())
        return hook
Example #15
0
def load_position(obj):
	'''Finds all of the positions for the selected object and applies them
	Args:
		obj (pm.PyNode): the object to apply to
	Returns (dict): position
	Usage:
		get_positions(pm.ls(sl=True)[0])
	'''
	#Current version folder nonsense
	folder = os.path.join( environ.POSITIONS, obj )
	versionFolder = lib_env.folder_detectVersions( folder, versionUp = False )
	if versionFolder:
		folder = versionFolder
	else:
		pm.warning('Folder does not exist')
	
	#Handling shit
	if os.path.exists(folder):
		os.chdir(folder)
		positions = []
		for file in glob.glob("*.pos"):
			position = import_position(file)
			print position
			pm.xform(obj, t=position['translate'], ro=position['rotate'], s=position['scale'], ws=True)
	else:
		pm.warning('Object: %s does not have any deformers available in folder: %s'%(obj,folder))
Example #16
0
def Snap(target, source, translation=True, rotation=True):
    ''' Snaps source object to target object.
    If point is True, translation will snap.
    If orient is True, orientation will snap.
    If source is None, then it looks for lists for translation,rotation and scale
    '''

    #if source doesnt exists and passing in transform lists
    if not source:
        if isinstance(translation, list):
            pm.xform(target, ws=True, translation=translation)
        if isinstance(rotation, list):
            pm.xform(target, ws=True, rotation=rotation)

        return

    #translation
    if translation:
        trans = pm.xform(source, q=True, ws=True, translation=True)
        pm.xform(target, ws=True, translation=trans)

    #orientation
    if rotation:
        rot = pm.xform(source, q=True, ws=True, rotation=True)
        pm.xform(target, ws=True, rotation=rot)
Example #17
0
def autoPoleVector( baseJnt=None, endJnt=None, side='L' ):

	baseJntPos = pm.xform( baseJnt, q=True, t=True, ws=True )
	endJntPos = pm.xform( endJnt, q=True, t=True, ws=True )

	pm.select(clear=True)
	poleVectorJnt_one = pm.joint( p=baseJntPos )
	poleVectorJnt_two = pm.joint( p=endJntPos )
	poleVectorIKstuff = pm.ikHandle(  sj = poleVectorJnt_one, ee = poleVectorJnt_two, solver = "ikSCsolver"  )

	pv = pm.spaceLocator()
	pv.setParent( poleVectorJnt_two )
	pv.translate.set( 0,0,0 )
	pvZeros = ZeroGrp( pv )

	pm.pointConstraint( poleVectorIKstuff[0], pvZeros[0] )

	if side=='L':
		pv.translateX.set( 1 )
	elif side=='R':
		pv.translateX.set( -1 )


	pvZeros[0].setParent( poleVectorJnt_two )

	return ( pv, poleVectorIKstuff, (poleVectorJnt_one, poleVectorJnt_two) ) 
Example #18
0
def createCOG(*args):
   
    newCog = createCircle()[0]
    cvsToSelect = (newCOG.cv[::2])
    pm.select(cvsToSelect)
    pm.xform(s = [.5, .5, .5])
    return newCog
Example #19
0
def GuideCrv ( startGuider=None , endGuider=None ):

	if startGuider==None or endGuider==None:
		startGuider,endGuider = pm.ls(sl=True)
	
	pm.select(clear=True)
	
	startJnt = pm.joint ( n = startGuider.name()+"_guideCrvJnt")
	pm.parent (startJnt , startGuider)
	startJnt.translate.set (0,0,0)
	startJnt.visibility.set (0)
	pm.setAttr ( startJnt.visibility , lock=True  )
	
	
	endJnt = pm.joint (  n = endGuider.name()+"_guideCrvJnt" )
	pm.parent (endJnt , endGuider)
	endJnt.translate.set (0,0,0)
	endJnt.visibility.set (0)
	pm.setAttr ( endJnt.visibility , lock=True  )
	
	startJntPos = pm.xform ( startJnt , q=True , ws=True , t=True)
	endJntPos = pm.xform ( endJnt , q=True , ws=True , t=True)
	
	guideCrv = pm.curve ( degree=1 , p = (startJntPos ,endJntPos) , k=(1,2)  )
	
	pm.rename ( guideCrv , startGuider.name()+"_guideCrv")
	
	pm.skinCluster ( guideCrv , startJnt , endJnt  )
	
	guideCrv.inheritsTransform.set(0)
	guideCrv.template.set(1)
	
	pm.select(clear=True)
	
	return guideCrv
Example #20
0
    def mirrorPose(self):
        lf='lf_'
        rt='rt_'
        center = 'ctr_'
        sel = pm.ls(sl=1)
        pm.select(clear=True)
        commands = []
        for s in sel:

            mirrorObject = ""
            if str(s).startswith(lf):
                mirrorObject = rt + s[3:]
            elif str(s).startswith(rt):
                mirrorObject = lf + s[3:]
            elif str(s).startswith(center):
                mirrorObject = center + s[4:]

            pos = pm.xform(s, q=1, ws=1, rp=1)
            rot = pm.xform(s, q=1, ws=1, ro=1)
            scale = pm.xform(s, q=1, r=1, s=1)

            commands.append( 'move %s %s %s  -ws -rpr "%s"'%(-pos[0],pos[1],pos[2],mirrorObject) )
            commands.append( 'rotate -a %s %s %s -ws "%s" '%(rot[0],-rot[1],-rot[2],mirrorObject) )
            commands.append( 'scale %s %s %s "%s"'%(scale[0],scale[1],scale[2],mirrorObject) )

            pm.select(mirrorObject,add=True)

        for c in commands:
            pm.mel.eval(c)
Example #21
0
def FindPVposition( objs=pm.ls(sl=True) ):

	if not len(objs) == 3:
		pm.error( 'ehm_tools...findPVposition: objs arguments takes exactly 3 objects. %s was given.'%len(objs) )

	base = objs[0]
	mid  = objs[1]
	tip  = objs[2]

	A = dt.Vector( pm.xform( base, q=True, t=True, ws=True ) )
	B = dt.Vector( pm.xform( mid, q=True, t=True, ws=True ) )
	C = dt.Vector( pm.xform( tip, q=True, t=True, ws=True ) )

	AC = C - A
	AB = B - A

	D =  A + ( (dt.dot(AB,AC.normal()))  * AC.normal() ) # AB projected on AC

	position =  B + B - D
	
	if (position[0]  - B[0] < 0.001) and (position[1]  - B[1] < 0.001) and (position[2]  - B[2] < 0.001):
		pm.warning( 'ehm_tools...FindPVposition: Limbs were straight. None was returned!' )
		return None
	else:
		return position
	def change_distance(self):
		intervValue = self.interv_int.value()
		value = self.distance_float.value()

		pm.setAttr(rigLight+'.translateZ', value)
		pm.xform(vis_mainGrp, s=[value, value, value])
		vis_mainGrp
Example #23
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]
Example #24
0
def getXProductFromNodes(midObj, topObj, btmObj):
    """
    get a cross product based upon the position of the first three objects in objList
    Returns the cross product of two vectors: midObj to topObj and midObj to btmObj
    """

    #get the vectors
    midPos = pm.xform(midObj, q=True, worldSpace=True, translation=True)
    topPos = pm.xform(topObj, q=True, worldSpace=True, translation=True)
    btmPos = pm.xform(btmObj, q=True, worldSpace=True, translation=True)

    topVector = [topPos[0] - midPos[0], topPos[1] - midPos[1], topPos[2] - midPos[2]]
    btmVector = [btmPos[0] - midPos[0], btmPos[1] - midPos[1], btmPos[2] - midPos[2]]

    #create a temporary vectorProduct node
    vp = pm.createNode("vectorProduct")
    #set to cross product
    vp.operation.set(2)
    vp.input1.set(btmVector)
    vp.input2.set(topVector)

    #store the cross product
    cp = vp.output.get()

    #delete the vector node
    pm.delete(vp)
    return cp
Example #25
0
def getShapePos(*nodes, **kwargs):
    """
    @return: dictionary of {shapePyNode: [pointPositionList],...}
    """
    ws = kwargs.get('ws', False)
    if ws:
        space = 'world'
    else:
        space = 'preTransform'

    vertObjs, crvObjs, surfObjs = filterShapes(*nodes)
    result = {}

    for obj in vertObjs:
        assert isinstance(obj, pm.nodetypes.Mesh)
        result[obj] = obj.getPoints(space=space)

    for obj in crvObjs:
        assert (isinstance(obj, pm.nodetypes.NurbsCurve))
        result[obj] = []
        for i in range(obj.numCVs()):
            result[obj].append(pm.xform(obj.cv[i], q=True, ws=ws, t=True))
        #this might have a bug?
        #result[obj] = obj.getCVs(space='world')
        #result[obj].append(.getPosition(space='world'))
    for obj in surfObjs:
        assert(isinstance(obj, pm.nodetypes.NurbsSurface))
        result[obj] = []
        for u in range(obj.numCVsInU()):
            for v in range(obj.numCVsInV()):
                result[obj].append(pm.xform(obj.cv[u][v], q=True, ws=ws, t=True))
    return result
Example #26
0
	def ChangeNumberOfJoints(self, *args):
		self.blueprint_UI_instance.DeleteScriptJob()
		
		# Collect information from current spline module
		joints = self.GetJoints()
		numJoints = len(joints)
		
		newNumJoints = pm.intField(self.numberOfJointsField, query = True, value = True)
		
		startPos = pm.xform(self.GetTranslationControl(joints[0]), query = True, worldSpace = True, translation = True)
		endPos = pm.xform(self.GetTranslationControl(joints[numJoints - 1]), query = True, worldSpace = True, translation = True)
		
		hookObj = self.FindHookObjectForLock()
		
		rotateOrder = pm.getAttr("%s.rotateOrder" %joints[0])
		sao_local = pm.getAttr("%s:module_grp.sao_local" %self.moduleNamespace)
		sao_world = pm.getAttr("%s:module_grp.sao_world" %self.moduleNamespace)
		
		# Delete current spline module
		self.Delete()
		
		# Create new spline module with new joint count
		newInstance = Spline(self.userSpecifiedName, hookObj, newNumJoints, startPos, endPos)
		newInstance.Install()
		
		# Apply previous attribute values
		newJoints = newInstance.GetJoints()
		pm.setAttr("%s.rotateOrder" %newJoints[0], rotateOrder)
		pm.setAttr("%s:module_grp.sao_local" %newInstance.moduleNamespace, sao_local)
		pm.setAttr("%s:module_grp.sao_world" %newInstance.moduleNamespace, sao_world)
		
		self.blueprint_UI_instance.CreateScriptJob()
		
		pm.select("%s:module_transform" %newInstance.moduleNamespace, replace = True)
	def vis_orbits(self):
		global vis_orbGrp
		vis_orbGrp = pm.group(n='olp_visOrbits', em=True)

		intervValue = self.interv_int.value()
		distValue = self.distance_float.value()
		orbitValue = self.orbit_int.value()

		global all_orbitObjs
		all_orbitObjs = []
		for orbit in range(orbitValue):
			orbitRot = orbit * 360/float(orbitValue*2)
			
			orbit_visObject = pm.circle(n='olp_orbCircle{0}'.format(orbit+1), r=distValue, s=intervValue*2, nr=[1, 0, 0], ch=True)[0]
			pm.parent(orbit_visObject, vis_orbGrp)

			orbit_visObject.overrideEnabled.set(1)
			orbit_visObject.overrideColorRGB.set(0, 1, 1)
			orbit_visObject.overrideRGBColors.set(1)

			pm.xform(orbit_visObject, ro=[0, 0, orbitRot])

			all_orbitObjs.append(orbit_visObject)

		pm.xform(vis_orbGrp, a=True, t=sel_center)
		pm.parent(vis_orbGrp, vis_mainGrp)
		pm.select(sel_objects, r=True)
		return vis_orbGrp
Example #28
0
    def generate( self, size = 10, iterations = 1, grid = 3, holes = [ 4, 10, 12, 13, 14, 16, 22 ] ):

        self.size       = size
        self.iterations = iterations
        self.grid       = grid
        self.holes      = holes

        print( "%s radius %f iterations %i" % ( self.__class__.__name__, self.size, self.iterations ) )
    
        cubeSize = float(self.size) /  util.pow( float(self.grid), float(self.iterations) )
        cube     = self.mesh( width = cubeSize, height = cubeSize, depth = cubeSize )    
        cubes    = [ cube ]
        
        for i in range( iterations ):

            mesh     = self.__generateMesh( cubes[ 0 ], cubeSize, ( i + 1 ) )
            cubeSize = cubeSize * self.grid
            cubes    = [ mesh ]


        pm.xform( mesh[ 0 ], centerPivots = True )

        print( "Construction complete" )

        return mesh
	def createLight(self, position):
		value = self.distance_float.value()
		if self.lightType_menu.currentIndex() == 1:
			light = pm.shadingNode('areaLight', asLight=True)
			
			pm.setAttr(light + '.intensity', 500)
			pm.setAttr(light + '.decayRate', 2)
			pm.setAttr(light + '.areaLight', 1)

		elif self.lightType_menu.currentIndex() == 2:
			light = pm.shadingNode('spotLight', asLight=True)

			pm.setAttr(light + '.intensity', 500)
			pm.setAttr(light + '.decayRate', 2)

		elif self.lightType_menu.currentIndex() == 3:
			light = pm.shadingNode('directionalLight', asLight=True)

		elif self.lightType_menu.currentIndex() == 4:
			light = pm.shadingNode('pointLight', asLight=True)

			pm.setAttr(light + '.intensity', 500)
			pm.setAttr(light + '.decayRate', 2)

		pm.rename(light, light_name)
		pm.xform(light, a=True, t=position)
		pm.xform(light, r=True, t=(0, 0, value))

		return light
Example #30
0
def mirror_nurb(patches, negative_x=True, reverse=False):
    """
    Args:
        patches (pm.nt.Transform): nurbsies
        negative_x (bool): mirror from +x => -x or vice versa
    Usage:
        mirror_nurb(pm.ls(sl=True, type='transform'), negative_x=True, reverse=False)
    """
    for patch in patches:
        shape = patch.getShape()
        cvu, cvv = shape.numCVsInU(), shape.numCVsInV()
        if reverse:
            cvu, cvv = shape.numCVsInV(), shape.numCVsInU()
        
        for column in range(cvv):
            even_odd = cvu % 2
            
            for row in range(cvu/2):
                if negative_x:
                    row_mirrored = row
                    row = (row*-1) - 1
                else:
                    row_mirrored = (row*-1) - 1
                
                pos = pm.xform(shape.cv[row][column], q=True,ws=True,t=True)
                pos_mirrored = [a*b for a,b in zip(pos, [-1,1,1])]
                pm.xform(shape.cv[row_mirrored][column], t=pos_mirrored, ws=True)
                
Example #31
0
def matrixDisplay(o, ws=False):
    if isinstance(o, PyNode):
        m = xform(o, q=True, ws=ws, m=True)
    elif isinstance(o, dt.Matrix):
        m = list(o[0]) + list(o[1]) + list(o[2]) + list(o[3])
    else:
        m = o

    print('[' + ', '.join([numf(n) for n in m[0:4]]) + ']')
    print('[' + ', '.join([numf(n) for n in m[4:8]]) + ']')
    print('[' + ', '.join([numf(n) for n in m[8:12]]) + ']')
    print('[' + ', '.join([numf(n) for n in m[12:16]]) + ']')
Example #32
0
def joint_rotation(joints):
    '''
    Checks through given joints for rotation values. 
    Arguments:
        joints - list of joints to check.
    '''
    invalid_joints = []
    for joint in joints:
        rotation_values = pm.xform(joint, q=1, rotation=True)
        if rotation_values[0] != 0 or rotation_values[1] != 0 or rotation_values[2] != 0:
            invalid_joints.append(joint)
    return invalid_joints
Example #33
0
def locatorOnCurveCVs(size=1, crv=None, prefix="lid"):
	locs = []
	for i,cv in enumerate(crv.cv):
		pm.select( clear=1 )
		cvPose = pm.xform( cv, q=1, t=1, ws=1 )
		locs.append( pm.spaceLocator(name="%s_%s_loc"%(prefix,i)) )
		locs[i].translate.set( cvPose )		
		locs[i].localScale.set(size,size,size)
	pm.delete( (locs[1],locs[-2]) )
	locs.remove( locs[1] )
	locs.remove( locs[-2] )	
	return(locs)
Example #34
0
 def clicked_guess_joint_side(self):
     # Set the side of a joint based on its X position.
     #
     # This is a quick way to set the side of joints.  A good policy is
     # to label joints on the YZ plane as center joints, joints with mirrored
     # left and right counterparts as left and right, and joints that aren't
     # in the center but which aren't mirrored as having no side.  This
     # doesn't do any mirror matching and just looks at the X position.
     for joint in pm.ls(sl=True, type='joint'):
         pos = pm.xform(joint, q=True, ws=True, t=True)
         side = 2 if pos[0] < -0.1 else 1 if pos[0] > 0.1 else 0
         joint.side.set(side)
Example #35
0
def assertLocationIs(obj=None, pos=None):
    '''Assert obj is located at position pos

    Attributes:
        obj -- Object to check. (pm.nt.Transform, pm.nt.Joint)
        pos -- pm.dt.Point=(x, y, z)
    '''
    general.check_type(obj, 'obj', [pm.nt.Transform])
    general.check_type(pos, 'pos', [pm.dt.Point])

    return general.assertAlmostEquals(
        pm.dt.Point(pm.xform(obj, q=1, ws=1, t=1)), pos, 3)
Example #36
0
def rightFingerToLeft(mayaFalse):
    rFingers = pm.listRelatives('*Character1_Ctrl_RightHand', ad=True)
    lFingers = pm.listRelatives('*Character1_Ctrl_LeftHand', ad=True)
    counter = 0
    for i in rFingers:
        if i.find('Thumb') != -1:
            pm.xform(lFingers[counter],
                     rotation=[
                         -1 * pm.getAttr(i.rx),
                         pm.getAttr(i.ry), -1 * pm.getAttr(i.rz)
                     ])

        else:
            pm.xform(lFingers[counter],
                     rotation=[
                         -1 * pm.getAttr(i.rx), -1 * pm.getAttr(i.ry),
                         pm.getAttr(i.rz)
                     ])
        pm.setKeyframe(lFingers[counter],
                       attribute=['rotateX', 'rotateY', 'rotateZ'])
        counter += 1
Example #37
0
        def wrapper(self, *args, **kws):
            control = func(self, *args, **kws)

            self.setColor(control)
            control.setTranslation(self.offset, 'world')
            pm.makeIdentity(control, apply=True)
            log.info('Control of type:{} name {} created along {}'.format(
                func.__name__, control.name(), self._axis))
            if self.groupControl:
                Gp = pm.nt.Transform(name=self.name + 'Gp')
                control.setParent(Gp)
                self.controlGps.append(Gp)
            else:
                pm.xform(control,
                         pivots=(0, 0, 0),
                         ws=True,
                         dph=True,
                         ztp=True)
            if self.forceSetAxis:
                self.setAxis(control, self.axis)
            return control
Example #38
0
def sanity_check_eyes(joints):
    pos = [pm.xform(node, q=True, ws=True, t=True) for node in joints]
    # We expect the character to be in the standard orientation: Y-up, facing up Z.  Sanity check that
    # the eyes are somewhere up Y.
    if pos[0][1] <= 0 or pos[1][1] <= 0:
        log.error('The selected objects should be on positive Y.')
        return False
            
    # Check that the eyes are parallel on the X axis.
    if abs(pos[0][1] - pos[1][1]) > 0.001 or abs(pos[0][2] - pos[1][2]) > 0.001:
        log.warning('Warning: the selected objects aren\'t parallel on the X axis.')
    return True
Example #39
0
def jointOnCurveCVs(size=1, crv=None, prefix="lid"):
	jnts = []
	for i,cv in enumerate(crv.cv):
		pm.select( clear=1 )
		cvPose = pm.xform( cv, q=1, t=1, ws=1 )
		jnts.append( pm.joint(p=cvPose, name="%s_%s_jnt"%(prefix,i)) )
		jnts[i].radius.set( size )	
		pm.joint( jnts[i], e=True, oj="xyz", sao="yup", zso=1, ch=1 )
	pm.delete( (jnts[1],jnts[-2]) )
	jnts.remove( jnts[1] )
	jnts.remove( jnts[-2] )
	return jnts
Example #40
0
 def onAWire4(self, locs, crv):
     locs = pm.listRelatives(locs, children=True, type="transform")
     crv = crv
     for x in locs:
         pos = pm.xform(x, q=1, ws=1, t=1)
         u = getUParam(pos, crv)
         #create point on curve node. Make sure Locators have suffix of _LOX
         name = x.replace("_LOC", "_PCI")
         pci = pm.createNode("pointOnCurveInfo", n=name)
         pm.connectAttr(crv + ".worldSpace", pci + ".inputCurve")
         pm.setAttr(pci + ".parameter", u)
         pm.connectAttr(pci + ".position", x + ".t")
Example #41
0
def alignToMatcher(ctrl):
    try:
        matcher = getMatcher(ctrl)
        xform(ctrl, ws=True, t=xform(matcher, q=True, ws=True, t=True))
        xform(ctrl, ws=True, ro=xform(matcher, q=True, ws=True, ro=True))
    except Exception:
        warning('{0} does not have a matcher setup'.format(ctrl))
Example #42
0
 def alignToMatcher(ctrl):
     try:
         matcher = ctrl.matcher.listConnections()[0]
         xform(ctrl, ws=True, t=xform(matcher, q=True, ws=True, t=True))
         xform(ctrl, ws=True, ro=xform(matcher, q=True, ws=True, ro=True))
     except Exception:
         warning('{0} does not have a matcher setup'.format(ctrl))
Example #43
0
def rigMake(mayaFalse):
    #check
    if not pm.ls(
            'Locator_Pivot'
    ):  #first, perform a check to see if locatorMake() has been performed.
        pm.confirmDialog(title=u'SER 武器リグ', message=u'先ず、ピボット設定をしてください。')
        return

    #rest of rig start
    constrLoc = pm.spaceLocator(
        name="Locator_Constraint")  #creating locator to constraint the bone to

    weapJoint = pm.ls('*Joint_Weapon', type='joint')[0]
    pm.xform(
        constrLoc, ws=True, t=pm.xform(weapJoint, q=True, t=True, ws=True)
    )  #moving the newly created constraint locator to the translation position of the joint

    pm.parentConstraint(constrLoc, weapJoint, mo=False)
    contr1 = pm.circle(name='Controller_Weapon_Global', r=9, nr=[0, 1, 0])
    contr2 = pm.circle(name='Controller_Weapon_Local', r=7, nr=[0, 1, 0])

    pm.parent(contr2[0], contr1[0])
    pm.xform(contr1,
             ws=True,
             t=pm.xform('Locator_Pivot', q=True, t=True, ws=True),
             ro=pm.xform('Locator_Pivot', q=True, ro=True, ws=True))
    pm.delete(
        'Locator_Pivot'
    )  #deleting locator pivot after rig controllers have been created.
    pm.parent(constrLoc, contr2[0])

    R_Constr = pm.parentConstraint(
        pm.ls('*Helper_Weapon1')[0],
        contr1[0],
        name='Constraint_Weapon_Global')  #parent constraint to right hand
    L_Constr = pm.parentConstraint(pm.ls('*Helper_Weapon2')[0],
                                   contr1[0])  #parent constraint to left hand
    pm.setAttr(
        'Constraint_Weapon_Global.%s' %
        pm.listAttr('Constraint_Weapon_Global', k=True)[-1], 0)

    pm.setKeyframe('Controller_Weapon_Global')
    pm.setKeyframe('Controller_Weapon_Global',
                   v=1,
                   at='blendWeaponGlobal',
                   itt='auto',
                   ott='step')
    pm.setKeyframe('Constraint_Weapon_Global',
                   v=1,
                   at=pm.listAttr('Constraint_Weapon_Global',
                                  k=True)[-2])  #sets RH constraint to 1
    pm.setKeyframe('Constraint_Weapon_Global',
                   v=0,
                   at=pm.listAttr('Constraint_Weapon_Global',
                                  k=True)[-1])  #sets LH constraint to 0
Example #44
0
        def animSave(_):
            output = []
            for frame in range(int(animAPI.MAnimControl.maxTime().value() +
                                   1)):
                pm.currentTime(frame)
                line = ''
                for i in pm.listRelatives(
                        pm.ls(sl=True), ad=True, type='joint'
                ):  # remove ", type = 'joint'" for control rig version
                    if str(
                            pm.listRelatives(i, parent=True)
                    ) == "[nt.Joint(u'Character_Head')]" or str(
                            pm.listRelatives(i, parent=True)
                    ) == "[nt.Joint(u'Helper_Weapon2')]" or str(
                            pm.listRelatives(i, parent=True)
                    ) == "[nt.Joint(u'Helper_Weapon1')]" or i[:5] == 'Joint':
                        continue
                    if pm.objectType(i) == "locator":
                        continue
                    line = line + str(int(pm.currentTime(
                    ))) + ' ' + i + ' ' + str(
                        pm.xform(i, q=True, translation=True)) + ' ' + str(
                            pm.xform(i, q=True, rotation=True)) + ' ' + str(
                                pm.xform(i, q=True, scale=True, relative=True))
                    line = line.replace('[', '')
                    line = line.replace(']', '')
                    line = line.replace(',', '')
                    line
                    output.append(line)
                    line = ''

            # writing pose into data
            defPose = open(
                r'\\p.sv\Prism\project\SER\user\chew\ref\animPose\taiso.pose',
                'w')
            for i in output:
                defPose.write(i)
                defPose.write('\n')
            defPose.close()
            pass
Example #45
0
def handSetup(leftArm, numFingers, makeThumb):
    #hand = Container('Hand', meters(0.20, 0.20) )
    hand = makeCard(1, 'Hand', size=meters(0.20, 0.20))

    # It makes sense that the wrist is oriented to the hand
    leftArm.end().customUp = hand.getUpArrow()

    placeJoints(hand, [(0, -.7)])
    hand.joints[0].isHelper = True
    leftArm.end().orientTarget = hand.joints[0]
    hand.joints[0].setBPParent(leftArm.end())

    xform(hand, ws=True, t=xform(leftArm.end(), q=True, ws=True, t=True))
    moveCard.down(hand, meters(.1))
    #hand.setParent( leftArm.end() )
    xform(hand, ws=True, piv=xform(leftArm.end(), q=True, ws=True, t=True))

    pointConstraint(leftArm.end(), core.dagObj.zero(hand), mo=True)
    [hand.attr('t' + a).lock() for a in 'xyz']

    mod = 0.15 / (numFingers - 1) if numFingers > 1 else 0

    for i, finger in enumerate(['Index', 'Middle', 'Ring',
                                'Pinky'][:numFingers]):
        card = makeCard(4, finger + '*', suffix='L')
        moveCard.to(card, leftArm.end())
        moveCard.backward(card, meters(i * mod - 0.1))
        moveCard.down(card, meters(0.20))

        grp = group(card, n=finger + "_grp")
        card.setParent(grp)

        parentConstraint(hand, grp, mo=True)
        card.ry.set(90)

        card.joints[-1].isHelper = True

        #proxy.pointer( leftArm.end(), card.start() )
        card.start().setBPParent(leftArm.end())

        card.rigCommand = 'RotateChain'
        card.rigOptions = '-size 2 -visGroup fingers'

    if makeThumb:
        thumb = makeCard(4, 'Thumb*', suffix='L')
        moveCard.to(thumb, leftArm.end())
        thumb.ry.set(-90)

        moveCard.to(thumb, leftArm.end())
        moveCard.forward(thumb, meters(0.1))
        moveCard.down(thumb, meters(0.1))
        moveCard.closer(thumb, meters(0.05))
        thumb.end().isHelper = True
        grp = group(thumb, n="Thumb_grp")
        parentConstraint(hand, grp, mo=True)

        #proxy.pointer( leftArm.end(), thumb.start() )
        thumb.start().setBPParent(leftArm.end())
        thumb.rigCommand = 'RotateChain'
        thumb.rigOptions = '-size 2 -visGroup fingers'
Example #46
0
    def toggle_pivot_positions(obj_list):
        last_obj = obj_list[-1]  # selects last obj of list
        pivot = pm.xform(last_obj, q=True, rp=True, ws=True)

        state = next_pivot_state(
            last_obj)  # Gets the next state for last selected obj

        for obj in obj_list:
            bbox = pm.xform(obj, q=True, ws=True, bb=True)
            center = [(bbox[0] + bbox[3]) / 2, (bbox[1] + bbox[4]) / 2,
                      (bbox[2] + bbox[5]) / 2]
            bottom = [(bbox[0] + bbox[3]) / 2, bbox[1],
                      (bbox[2] + bbox[5]) / 2]

            for i in range(0, 3):
                pivot[i] = round(pivot[i], 4)
                center[i] = round(center[i], 4)
                bottom[i] = round(bottom[i], 4)

            # Setting the pivot to match whatever state the last selected obj has
            if state == "origo":
                new_sel = pm.ls(obj)
                pm.move(0,
                        0,
                        0, (new_sel[0] + ".scalePivot"),
                        (new_sel[0] + ".rotatePivot"),
                        absolute=True)  # Sets pivot to origo
            if state == "bottom":
                pm.xform(obj, piv=bottom, ws=True,
                         absolute=True)  # Sets pivot to bottom of Bounding Box
            if state == "center":
                pm.xform(obj, piv=center, ws=True,
                         absolute=True)  # Sets pivot to center

            pm.select(obj_list)
Example #47
0
def scaleCtrlShapes(*args, **kwargs):
    """
	Scale ctrl shapes and set line width

	:param args:  Transform nodes to change
	:param kwargs:  scale_mult | s: amount to scale ctrl curve, default 1
					line_width | lw: line width thickness, ignores if not specified
	"""
    scale_mult = kwargs.pop('scale_mult', kwargs.pop('s', 1))
    line_width = kwargs.pop('line_width', kwargs.pop('lw', None))

    if kwargs:
        raise ValueError('--Unknown argument: {}'.format(kwargs))

    ctrl_ls = makePyNodeList(args)

    for ctrl in ctrl_ls:
        shapes = ctrl.getChildren()
        if ctrl.nodeType() == 'nurbsCurve':
            shapes.append(ctrl)

        for shape in shapes:
            if 'nurbsCurve' in shape.nodeType():
                curv_type = pm.getAttr('%s.form' % shape)
                # if curve open get curve points
                if curv_type == 0:
                    num_cv = pm.getAttr('%s.cp' % shape, s=1)
                # else curve must be closed so get spans
                else:
                    num_cv = pm.getAttr('%s.spans' % shape)
                for i in xrange(num_cv):
                    cv_ws = pm.xform('{}.cv[{}]'.format(shape, i),
                                     t=True,
                                     q=True)
                    pm.xform('{}.cv[{}]'.format(shape, i),
                             t=[(cv_ws[0] * scale_mult),
                                (cv_ws[1] * scale_mult),
                                (cv_ws[2] * scale_mult)])
                if line_width:
                    shape.lineWidth.set(line_width)
Example #48
0
    def doRig(self):
        if not self.guideMoveall:
            self.doGuide()

        if pm.objExists(self.name + 'Moveall'):
            pm.delete(self.name + 'Moveall')

        self.drvGrp = pm.group(em=True, n=self.name + 'Sys_grp')
        self.drvGrp.visibility.set(False)
        self.cntrlGrp = pm.group(em=True, n=self.name + 'Ctrls_grp')
        self.moveall = pm.group(self.cntrlGrp, n=self.name + 'Constrained')

        self.cntrlList = []

        for i in range(self.num):
            pm.select(cl=True)
            jnt = pm.joint(n=self.name + str(i + 1) + self.jntPrefix)
            pos = pm.xform(self.guideList[i], q=True, ws=True, t=True)
            pm.xform(jnt, ws=True, t=pos)
            drvName = self.drvSetup['nameTempl'] + str(i + 1) + '_drv'
            drv = controlTools.cntrlCrv(name=drvName,
                                        obj=jnt,
                                        connType='parent',
                                        **self.drvSetup)
            cntrlName = self.ctrlSetup['nameTempl'] + str(i + 1)
            cntrl = controlTools.cntrlCrv(name=cntrlName,
                                          obj=drv,
                                          connType='connection',
                                          offsets=1,
                                          **self.ctrlSetup)

            if self.hasMulti:
                mlt = pm.createNode('multiplyDivide')
                mlt.input2.set([-1, -1, -1])
                cntrl.translate >> mlt.input1
                mlt.output >> cntrl.getParent().translate

            self.cntrlList.append(cntrl)
            cntrl.getParent(2).setParent(self.cntrlGrp)
            drv.getParent().setParent(self.drvGrp)
Example #49
0
    def active_splineChest(cls, chestCtrl):
        '''
        ..  todo::
            Implement even number of stomach joints
        '''
        cls.alignToMatcher(chestCtrl)

        midJnt = chestCtrl.subControl['mid'].listRelatives(type='joint')[0]

        skin = listConnections(midJnt, type='skinCluster')
        curveShape = skin[0].outputGeometry[0].listConnections(
            p=True)[0].node()
        ikHandle = curveShape.worldSpace.listConnections(type='ikHandle')[0]

        chain = getChainFromIk(ikHandle)

        boundJoints = getConstraineeChain(chain)

        if len(boundJoints) % 2 == 1:
            switch_logger.debug('Mid point ODD moved, # bound = {}'.format(
                len(boundJoints)))
            i = int(len(boundJoints) / 2) + 1
            xform(chestCtrl.subControl['mid'],
                  ws=True,
                  t=xform(boundJoints[i], q=True, ws=True, t=True))
        else:
            i = int(len(boundJoints) / 2)
            xform(chestCtrl.subControl['mid'],
                  ws=True,
                  t=xform(boundJoints[i], q=True, ws=True, t=True))
            switch_logger.debug('Mid point EVEN moved, # bound = {}'.format(
                len(boundJoints)))
Example #50
0
def vecViz(vector, startTranform=[0,0,0], name="vecViz"):
    '''
    Crates cone represenatation of vector between start and endpoint

    Args:
        vector:
        tfm:
        name:

    Returns:

    '''
    """Visual aid for Vectors"""
    startPoint = om.MVector(startTranform[0], startTranform[1], startTranform[2])
    endPoint = vector
    vec = vector


    loc = pm.spaceLocator(n=name)

    #cone for visulization
    height = vec.length()
    #pivot of cone is in center. for nicer look we shift it to base
    pointer = pm.polyCone(name=name+'_pointer', sx=4, r=0.25, h=height)[0]
    pm.xform(pointer,  piv=(0,(-1*height/2),0), t=(0,(height/2),0),ro=(0,0,-90), os=1)
    pm.makeIdentity(pointer, a=1)


    #move locator to vector and cone to tfm
    loc.setTranslation(endPoint)


    #aim constrain cone to look at locator
    pm.delete(pm.aimConstraint(loc,pointer,aimVector=(1,0,0), mo=0))

    # clean up
    pm.parent(loc,pointer)
    pointer.setTranslation(startPoint)

    return pointer
Example #51
0
    def set_pivot(cls, axis=0):
        """moves the object pivot to desired axis

        There are 7 options to move the pivot point to:
            c, -x, +x, -y, +y, -z, +z
            0,  1,  2,  3,  4,  5,  6

        :param int axis: One of [0-6] showing the desired axis to get the
          pivot point to
        """
        from maya.OpenMaya import MBoundingBox, MPoint
        if not 0 <= axis <= 6:
            return

        for node in pm.ls(sl=1):
            # check if the node has children
            children = pm.ls(sl=1)[0].getChildren(ad=1, type='transform')
            # get the bounding box points
            # bbox = node.boundingBox()
            bbox = pm.xform(node, q=1, ws=1, boundingBox=1)
            bbox = MBoundingBox(
                MPoint(bbox[0], bbox[1], bbox[2]),
                MPoint(bbox[3], bbox[4], bbox[5])
            )

            if len(children):
                # get all the bounding boxes
                for child in children:
                    if child.getShape() is not None:
                        # child_bbox = child.boundingBox()
                        child_bbox = pm.xform(child, q=1, ws=1, boundingBox=1)
                        child_bbox = MBoundingBox(
                            MPoint(child_bbox[0], child_bbox[1], child_bbox[2]),
                            MPoint(child_bbox[3], child_bbox[4], child_bbox[5])
                        )
                        bbox.expand(child_bbox.min())
                        bbox.expand(child_bbox.max())

            piv = bbox.center()
            if axis == 1:
                # -x
                piv.x = bbox.min().x
            elif axis == 2:
                # +x
                piv.x = bbox.max().x
            elif axis == 3:
                # -y
                piv.y = bbox.min().y
            elif axis == 4:
                # +y
                piv.y = bbox.max().y
            elif axis == 5:
                # -z
                piv.z = bbox.min().z
            elif axis == 6:
                # +z
                piv.z = bbox.max().z

            pm.xform(node, ws=1, rp=piv)
            pm.xform(node, ws=1, sp=piv)
Example #52
0
    def placement(self):
        grp2 = pm.ls("*offSet*")
        fols = pm.ls("*_fol")
        for num, fol in enumerate(fols):
            pos = pm.xform(fol, q=1, ws=1, t=True)
            oldName = fol.split("_")
            newName = oldName[0] + "_" + oldName[1] + "_"
            ctl = self.fControl(newName, num)
            pm.xform(grp2, ws=1, t=pos)
            loc = pm.spaceLocator(n="loc_{}".format(num))
            pm.setAttr(loc + ".visibility", 0)
            pm.xform(loc, ws=1, t=pos)
            pm.pointConstraint(fol, loc)
            pm.orientConstraint(fol, loc)

        ctls = pm.ls("*fCTL", type="transform")
        for x in ctls:
            pm.transformLimits(x, tx=(-1, 1), etx=(1, 0))
            pm.transformLimits(x, tx=(-1, 1), etx=(1, 1))
            pm.transformLimits(x, ty=(-1, 1), ety=(1, 0))
            pm.transformLimits(x, ty=(-1, 1), ety=(1, 1))
            #if:
            #pm.transformLimits(x, ty=(-1,1), ety=(1,0))
            #pm.transformLimits(x, ty=(-1,1), ety=(1,1))

        grp3 = pm.ls("*woldSpace*", type="transform")
        locs = pm.ls("loc_?", "loc_??", type="transform")
        for x, y in sorted(zip(grp3, locs)):
            pm.parent(y, x)
        grp2 = pm.ls("*offSet*")
        for x, y in sorted(zip(grp2, locs)):
            pm.connectAttr(y + ".translate", x + ".translate", force=True)
            pm.connectAttr(y + ".rotate", x + ".rotate", force=True)
        #for x in grp2:
        #pm.delete(pm.normalConstraint("C_body_PLY", x,  weight=1, aimVector=[0,0,1], upVector=[0,1,0], worldUpType="vector", worldUpVector=[0,1,0]))

        #grp =
        #for x in grp:
        #pm.orientConstraint("C_body_PLY", x, mo=True)
        pm.group(grp3, name="bsMan_faceRig_low_control_GRP")
Example #53
0
def create_ik_fk_arm():
    result_joints = pm.ls(sl=True)
    appendage_name = pm.textField("appendage_name_input", q=True, text=True)
    name_prefixes = get_name_prefixes(result_joints)

    # Create FK Joints and Controls
    fk_icon = pm.optionMenu("fk_icon_menu", query=True, value=True)
    fk_color = pm.optionMenu("fk_color_menu", query=True, value=True)
    fk_scale_list = []
    for fk_curve in pm.listRelatives("FK_Icons_DO_NOT_DELETE_GRP"):
        fk_scale_list.append(
            pm.xform(fk_curve, query=True, worldSpace=True, scale=True))
    fk_joints = attach_fk_to_joints(result_joints, fk_icon, fk_color,
                                    fk_scale_list)

    # Create IK Joints and Controls
    ik_icon = pm.optionMenu("ik_icon_menu", query=True, value=True)
    ik_color = pm.optionMenu("ik_color_menu", query=True, value=True)
    ik_icon_scale = pm.xform("IK_Test_CRV",
                             query=True,
                             worldSpace=True,
                             scale=True)
    pv_icon = pm.optionMenu("pv_icon_menu", query=True, value=True)
    pv_pos = pm.xform("PV_Test_CRV",
                      query=True,
                      worldSpace=True,
                      translation=True)
    pv_icon_scale = pm.xform("PV_Test_CRV",
                             query=True,
                             worldSpace=True,
                             scale=True)
    ik_joints = attach_ik_to_joints(result_joints, appendage_name,
                                    name_prefixes[1], ik_icon, pv_icon,
                                    ik_color, pv_pos, ik_icon_scale,
                                    pv_icon_scale)

    blend_nodes = attach_fk_ik_to_blend_to_result(fk_joints, ik_joints,
                                                  result_joints, name_prefixes)
    settings_icon = pm.optionMenu("settings_icon_menu", query=True, value=True)
    settings_color = pm.optionMenu("settings_color_menu",
                                   query=True,
                                   value=True)
    settings_pos = pm.xform("Settings_Test_CRV",
                            query=True,
                            worldSpace=True,
                            translation=True)
    settings_icon_scale = pm.xform("Settings_Test_CRV",
                                   query=True,
                                   worldSpace=True,
                                   scale=True)
    settings_control = create_fk_ik_settings_control(
        appendage_name, name_prefixes[1], result_joints, blend_nodes,
        fk_joints, settings_icon, settings_color, settings_pos,
        settings_icon_scale)

    parent_joints_to_groups(appendage_name, name_prefixes, result_joints,
                            fk_joints, ik_joints, settings_control)

    pm.delete("Test_Icons_DO_NOT_DELETE_GRP")
    pm.deleteUI(new_window)
Example #54
0
    def duplicate_selected_reference(cls):
        """duplicates the selected referenced object as reference
        """
        all_selected_refs = []
        for sel_node in pm.ls(sl=1):
            ref = sel_node.referenceFile()
            if ref not in all_selected_refs:
                all_selected_refs.append(ref)

        select_list = []
        for ref in all_selected_refs:
            # get the highest parent ref
            if ref.parent():
                while ref.parent():
                    ref = ref.parent()

            namespace = ref.namespace
            dup_ref = pm.createReference(
                ref.path,
                gl=True,
                namespace=namespace,
                options='v=0'
            )

            top_parent = cls.get_no_parent_transform(ref)
            if top_parent:
                node = top_parent
                tra = pm.xform(node, q=1, ws=1, t=1)
                rot = pm.xform(node, q=1, ws=1, ro=1)
                sca = pm.xform(node, q=1, ws=1, s=1)

                new_top_parent_node = cls.get_no_parent_transform(dup_ref)
                pm.xform(new_top_parent_node, ws=1, t=tra)
                pm.xform(new_top_parent_node, ws=1, ro=rot)
                pm.xform(new_top_parent_node, ws=1, s=sca)

                # parent to the same group
                group = node.getParent()
                if group:
                    pm.parent(new_top_parent_node, group)

                # select the top node
                select_list.append(new_top_parent_node)
        pm.select(select_list)
        return select_list
Example #55
0
def connectStereoCameras(camera, stereo_cams, base_percent=0.7, interactive=False, threshod=0.001):
    if not pm.objExists(camera):
        print 'The given center camera does not exists: '+str(camera)
        return
    else:
        camera = pm.PyNode(camera)

    if not isinstance(stereo_cams, type([])):
        stereo_cams = [stereo_cams]

    stereoCameras = {}

    for s in stereo_cams:
        s = pm.PyNode(s)

        # constrain stereo camera to main camera
        pm.pointConstraint(camera, s, offset=(0,0,0), weight=1)
        pm.orientConstraint(camera, s, offset=(0,0,0), weight=1)

        # local pivot alignment
        rot_local = pm.xform(camera, query=True, os=True, rp=True)
        scale_local = pm.xform(camera, query=True, os=True, sp=True)
        local_pivot_bool = False
        for v in rot_local:
            if math.fabs(v) >= threshod:
                local_pivot_bool = True
                pm.xform(s, os=True, rp=tuple(rot_local))
                break
        for v in scale_local:
            if math.fabs(v) >= threshod:
                local_pivot_bool = True
                pm.xform(s, os=True, sp=tuple(scale_local))
                break

        if interactive and local_pivot_bool:
            pm.confirmDialog(title='Warning', message='Found non-zero value on local pivot attribute of camera!', button='OK', defaultButton='OK', cancelButton='OK', dismissString='OK')

        # connect attributes of cameras
        for a in ['focalLength', 'horizontalFilmAperture', 'verticalFilmAperture']:
            camera.attr(a) >> s.attr(a)

        try:
            filmFit = camera.attr('filmFit').get()
            if filmFit==0:
                filmFit = 1
                camera.attr('filmFit').set(filmFit)
            s.attr('filmFit').set(filmFit)
            s.getShape().attr('stereo').set(2)
            s.getShape().attr('displayResolution').set(0)
        except:
            print traceback.format_exc()

        # create safe plane
        planes = createStereoSafePlanes(s)
        # add roundness ratio
        addRoundnessRatio(planes['safePlane'], planes['convergePlane'])

        stereoCameras.update( {s:{'camera':camera, 'safePlane':planes['safePlane'], 'convergePlane':planes['convergePlane'], 'node':s}} )

    return stereoCameras
Example #56
0
 def _setValuesFromGuideData(cls, guide, data, idMap=None):
     pm.xform(guide.transform,
              translation=data["translation"],
              worldSpace=True)
     pm.xform(guide.transform, rotation=data["rotation"], worldSpace=True)
     pm.xform(guide.transform, scale=data["scale"], worldSpace=True)
     guide.setHandleColor(data.get("handleColor", (0.0, 0.0, 0.0)))
Example #57
0
def resetDynamicPivot(pivot_control, key=True, rest=False):
    """
    Resets the position of the dynamic pivot. Maintains world position of control driven by pivot.

    Args:
        pivot_control (pm.nodetypes.Transform): Pivot control that needs to be reset to zero position.

        key (boolean): If True, will key the pivot and parent control on the previous frame.

        rest (boolean): If True, will move pivot to the rest position.
    """
    parent = pivot_control.getParent()
    matrix = parent.worldMatrix.get()
    rest_matrix = pm.PyNode(pivot_control.attr(
        pcfg.dynamic_pivot_rest).get()).worldMatrix.get()

    if key:
        current_frame = pm.currentTime(q=True)
        pm.setKeyframe(pivot_control, time=current_frame - 1)
        pm.setKeyframe(parent, time=current_frame - 1)

    pm.xform(pivot_control, ws=True,
             m=rest_matrix) if rest else mayamath.zeroOut(pivot_control)
    pm.xform(parent, ws=True, m=matrix)
    pm.xform(parent, ws=True, m=matrix)  # called twice because Maya is stupid
Example #58
0
def match_macro(source):
    if source.hasAttr('controller'):
        try:
            #joint_target = uf.meta_traverse(source = source, relation = 'child', tag = 'jointSkin')[0]
            control_grp = pm.ls(str(source).replace('_CTL','_GRP'))[0]
            child_controls = uf.meta_traverse(source = source, relation = 'child', tag = 'jointSkin')[0]
            target_locator = uf.nest_transform(name = str(source)+ '_target_position', action = 'child', target = source, transformObj = 'locator', transformRadius = 1.0)
            pm.parent(target_locator, world = True)
            brow_position = uf.average_position(*brow_controls)
            offset_joint = pm.joint(name = str(brow_main_control)+ '_offset_thing', relative = False, radius = 2, position = brow_position)
            pm.parent(offset_joint, world = True)
            offset_joint | target_locator
        except:
            pm.warning('problem finding target location')
        try:
            for micro_controller in brow_controls:
                joint_target_list = joint_target_list+ [uf.meta_traverse(source = control_object, relation = 'child', tag = 'jointSkin')[0]]
            final_position = uf.average_position(*joint_target_list)
            pm.xform(offset_joint, translation = final_position, worldSpace = True)
            pm.matchTransform(brow_main_grp, target_position, pos = True, rot = False, scale = False)
            pm.delete(offset_joint)
            pass
        except:
            pm.warning('problem finding target location')
        try:
            pm.delete(source, constraints = 1)
            pm.matchTransform(control_grp, joint_target, pos = True, rot = True, scale = False)
        except:
            pm.warning('failed to matchTransform')

        if '_R_' in str(control_object):
            pm.xform(control_object, euler = True, rotation = [0,0,180])
        else:
            pass
    elif source.hasAttr('controller'):
        pass
    else:
        pm.warning('no controller or microController attr')
        pass
    pass
Example #59
0
    def hookJntsOnCurve(self, jntList, upList, jntCrv, upCrv):
        jntNPoC = pm.createNode('nearestPointOnCurve', n=self.name+'NPCjnt')
        jntGrpA = pm.group(empty=True, n=self.name + 'jntGrp')
        jntCrv.worldSpace[0] >> jntNPoC.inputCurve

        jntGrpA.translate >> jntNPoC.inPosition

        upNPoC = pm.createNode('nearestPointOnCurve', n=self.name+'NPCup')
        upGrpA = pm.group(empty=True, n=self.name + 'upGrpA')
        upCrv.worldSpace[0] >> upNPoC.inputCurve
        upGrpA.translate >> upNPoC.inPosition

        for jnt, up in zip(jntList, upList):
            wp = pm.xform(jnt, t=True, ws=True, q=True)
            pm.xform(jntGrpA, t=wp, ws=True)
            hookPoci = pm.createNode('pointOnCurveInfo', n=self.name+'CurveInfoA')
            jntCrv.worldSpace[0] >> hookPoci.inputCurve
            hookPoci.position >> jnt.translate
            hookPar = jntNPoC.parameter.get()
            hookPoci.parameter.set(hookPar)
            pm.tangentConstraint(jntCrv, jnt, aimVector=(-1, 0, 0), upVector=(0, 1, 0), worldUpType="object",
                                 worldUpObject=up)

            wp = pm.xform(up, t=True, ws=True, q=True)
            pm.xform(upGrpA, t=wp, ws=True)
            hookPoci = pm.createNode('pointOnCurveInfo', n=self.name+'CurveInfoB')
            upCrv.worldSpace[0] >> hookPoci.inputCurve
            hookPoci.position >> up.translate
            hookPar = upNPoC.parameter.get()
            hookPoci.parameter.set(hookPar)

        pm.delete(upNPoC, upGrpA, jntNPoC, jntGrpA)
Example #60
0
    def getDict(self):
        try:
            guideName = self.moveallGuideSetup['nameTempl'] + self.guideSulfix
            self.guideMoveall = pm.PyNode(guideName)

            jsonDict = self.guideMoveall.spineDict.get()
            dictRestored = json.loads(jsonDict)
            self.__dict__.update(**dictRestored)

            self.guideDict['moveall'][0] = self.guideMoveall.getTranslation(
                space='world').get()
            self.guideDict['moveall'][1] = tuple(
                self.guideMoveall.getRotation(space='object'))
            self.guideDict['moveall'][2] = tuple(
                pm.xform(self.guideMoveall, q=True, s=True, ws=True))

            guideName = self.startGuideSetup['nameTempl'] + self.guideSulfix
            self.startGuide = pm.PyNode(guideName)
            self.guideDict['start'][0] = self.startGuide.getTranslation(
                space='object').get()
            self.guideDict['start'][1] = tuple(
                self.startGuide.getRotation(space='object'))

            guideName = self.midGuideSetup['nameTempl'] + self.guideSulfix
            self.midGuide = pm.PyNode(guideName)
            self.guideDict['mid'][0] = self.midGuide.getTranslation(
                space='object').get()
            self.guideDict['mid'][1] = tuple(
                self.midGuide.getRotation(space='object'))

            guideName = self.endGuideSetup['nameTempl'] + self.guideSulfix
            self.endGuide = pm.PyNode(guideName)
            self.guideDict['end'][0] = self.endGuide.getTranslation(
                space='object').get()
            self.guideDict['end'][1] = tuple(
                self.endGuide.getRotation(space='object'))

            guideName = self.endTipGuideSetup['nameTempl'] + self.guideSulfix
            self.endTipGuide = pm.PyNode(guideName)
            self.guideDict['endTip'][0] = self.endTipGuide.getTranslation(
                space='object').get()
            self.guideDict['endTip'][1] = tuple(
                self.endTipGuide.getRotation(space='object'))

            guideName = self.startTipGuideSetup['nameTempl'] + self.guideSulfix
            self.startTipGuide = pm.PyNode(guideName)
            self.guideDict['startTip'][0] = self.startTipGuide.getTranslation(
                space='object').get()
            self.guideDict['startTip'][1] = tuple(
                self.startTipGuide.getRotation(space='object'))
        except:
            pass