예제 #1
0
def register_object(reg_node=None, attr_name=None,
                    obj=None, log=False):
    '''Register an object to a reg_node

    Attributes:
        reg_node -- Registration node. pm.nt.Transform
        attr_name -- Name for attr to be created on reg_node. Str
        obj -- Object to connect message attr to reg_node.attr. pm.nt.Transform
    '''
    general.check_type(reg_node, 'reg_node', [pm.nt.Transform])
    general.check_type(attr_name, 'attr_name', [str])
    general.check_type(obj, 'obj', [pm.nt.Transform])

    for attr in ['version', 'reg_node']:
        if not hasattr(reg_node, attr):
            raise errors.ObjectError(reg_node, 'Attr: %s' % attr, None)

    reg_node.addAttr(attr_name, at='message')
    pm.connectAttr('%s.message' % obj,
                   '%s.%s' % (reg_node, attr_name), f=1)

    if log:
        str_1 = 'Connected: %s.%s >> %s.message' % (reg_node,
                                                    attr_name,
                                                    obj)
        general.logging.debug(str_1)
예제 #2
0
def completeStretchySetup( expr, expressionNode, characterNode, curveInfoNodeBack ):
    
    pymelLogger.debug('Starting: completeStretchySetup()...') 
    # if stretchy back is selected
    # When scaling characterNode character breaks
    # because the backcurve is also scaling
    # applying two time scale
    # we need to edit ikcurve expression and change the scale to
    # $scale = (curveinfoName).normalizedScale/(characterNode).scaleY;
    
    endFirstLineExpr = expr.find('\n')
    slicedExpr = expr[endFirstLineExpr:]

   
    # Edit first line and add the old expression sliced
    newExpr = '$scale = ' + curveInfoNodeBack + '.normalizedScale/' + characterNode + '.scaleY;\n'
    newExpr += slicedExpr
    pm.expression(expressionNode, edit = True, string=newExpr)
    
    
    
    # To avoid scaling uniformally in x and z 
    # the scale Y attr will drive X and Z
    pm.connectAttr(characterNode+'.scaleY', characterNode+'.scaleX')
    pm.connectAttr(characterNode+'.scaleY', characterNode+'.scaleZ')
    
    # Now we can lock and hide scale X and Z
    hideLockAttr(characterNode, lockHideXZ)
    
    # Change attr name of Scale Y to name = globalScale
    # it allows us to still use the scale manipulator
    # instead of adding a new attr for that
    pm.aliasAttr('globalScale', characterNode + '.scaleY')
    
    pymelLogger.debug('End: completeStretchySetup()...') 
def patch_spaceswitch_dpspine_objects():
    """
    This function is not clean, but it can be used to generate spaceswitch object for certain module and after look at
    all space switch target information to replace to space switch object target that could used a ctrl to the new space
    switch object that will not be removed after an unbuild
    """

    # Get the rig instance in the scene (Now support only the first one found
    rig_net = libSerialization.get_networks_from_class('Rig')[0]
    rig_instance = libSerialization.import_network(rig_net)

    # Get all the module that we could need to patch
    to_patch = [module for module in rig_instance.modules if isinstance(module, rigDpSpine.DpSpine)]

    for module in to_patch:
        module_to_patch = module
        if isinstance(module_to_patch, rigDpSpine.DpSpine):
            # Find all connection that have from the ctrl ik down (COG) and replace it
            connected_to_fk_dwn = module_to_patch.ctrl_fk_dwn._network.message.outputs(s=False, d=True, p=True)

            for connection in connected_to_fk_dwn:
                attr_name = connection.shortName()
                if attr_name.find('targets') >= 0:
                    log.info('Reconnecting {0} from {1} to space switch node {2}'
                             .format(connection, module_to_patch.ctrl_ik_dwn, module_to_patch.ctrl_ik_dwn._network))
                    connection.disconnect()
                    pymel.connectAttr(module_to_patch.ctrl_ik_dwn._network.message, connection, force=True)
예제 #4
0
def create_dominant_color_shader(dag, tex_name_surfix=['co', 'color', 'diffuse', 'dif', 'base'],
                                 sample_rate=None, max_auto_sample=50,
                                 default_shader='aiStandardSurface', default_channel='baseColor'):
    """
    Create an auto average-color lambert shader and assign it to input object.
    Maybe does not work with TIFF texture ( cannot extract color ).
    """

    if type(dag) == pm.nodetypes.Transform:
        mesh = dag.getShape()
        if not type(mesh) == pm.nodetypes.Mesh:
            return None
    elif type(dag) == pm.nodetypes.Mesh:
        mesh = dag
    else:
        return None
    avg_color = _detect_dominant_color(mesh, tex_name_surfix, sample_rate,
                                       max_auto_sample, default_shader, default_channel)
    if not avg_color:
        return None

    color_shader, sg = pm.createSurfaceShader('lambert')
    color_shader.color.set(avg_color)
    pm.connectAttr(color_shader.color, sg.surfaceShader, f=1)
    pm.sets(sg, forceElement=mesh)

    return color_shader
예제 #5
0
def stretchyBack( ikHandleTorso, jntList ):
    pymelLogger.debug('Starting: stretchyBack()...')     
    #Stretchy process
    # ArcLen to create curveInfo
    curveInfoNodeBack = pm.arclen( ikHandleTorso[2], ch=True )
    # add attr to curveinfo Node (normalizedScale)
    # this will have a value coming from a multiply divide node that will be 
    # dividing the current length by the initial length of the curve
    # this will be used later to scale the joints
    pm.addAttr(curveInfoNodeBack, longName='normalizedScale', attributeType='double')
    # get initial length of the curve
    iniLen = pm.getAttr( curveInfoNodeBack + '.arcLength' )
    
    # create a node multiplydivide, operation set to division
    MDCurveBack = pm.shadingNode( 'multiplyDivide', asUtility=True )
    pm.setAttr( MDCurveBack+'.operation', 2 ) # divide
    
    # Connect curve arcLength to input1X
    pm.connectAttr( curveInfoNodeBack + '.arcLength', MDCurveBack + '.input1X', force=True )
    # Set input2X to initial length of the curve
    pm.setAttr(MDCurveBack+'.input2X', iniLen)
    # connect outpux x from multiplydivide to normalized scale of the curve info
    pm.connectAttr(MDCurveBack + '.outputX', curveInfoNodeBack + '.normalizedScale', force=True)
    
    returnList = [curveInfoNodeBack,MDCurveBack]
    
    
    pymelLogger.debug('End: stretchyBack()...')   
    return returnList
예제 #6
0
파일: ocd.py 프로젝트: duncanrudd/rooftops
    def addSegment(self, segment):
        '''
        expects an instance of Ocd_Segment passed as 'segmemnt'
        '''
        p = pmc.FabricCanvasInstPreset(m=self.cn.getName(), e='', p='Fabric.Core.Array.Push', x=len(self.pushes)*300+100, y=len(self.pushes)*100+100)

        # Create input port and connections
        port = pmc.FabricCanvasAddPort(m=self.cn.getName(), e='', d=segment.name, p='In', ui=opaqueDict, t='Vec3[]')
        pmc.FabricCanvasConnect(m=self.cn.getName(), e='', s=port, d='%s.element' % p)
        pmc.connectAttr('%s.result' % segment.name, '%s.%s' % (self.cn.getName(), port))
        pmc.FabricCanvasConnect(m=self.cn.getName(), e='', s='%s.array' % p, d='%s.positions' % self.chain)
        if self.pushes:
            pmc.FabricCanvasConnect(m=self.cn.getName(), e='', s='%s.array' % self.pushes[-1], d='%s.array' % p)

        self.pushes.append(p)
        self.segments.append(segment)

        # Create localMat for new joint
        # This allows a non-straight joint to be initialized with a zero value.
        # When bend is calculated, this local offset is applied to the space in which the bend is computed.
        p = pmc.FabricCanvasInstPreset(m=self.cn.getName(), e='', p='Fabric.Core.Array.Push', x=len(self.initMatPushes)*300+300, y=len(self.initMatPushes)*100+300)
        m = pmc.FabricCanvasInstPreset(m=self.cn.getName(), e='', p='Fabric.Exts.Math.Constants.Mat44', x=len(self.initMatPushes)*300+100, y=len(self.initMatPushes)*100+300)
        pmc.FabricCanvasConnect(m=self.cn.getName(), e='', s='%s.value' % m, d='%s.element' % p)
        pmc.FabricCanvasConnect(m=self.cn.getName(), e='', s='%s.array' % p, d='%s.initMats' % self.chain)
        if self.initMatPushes:
            pmc.FabricCanvasConnect(m=self.cn.getName(), e='', s='%s.array' % self.initMatPushes[-1], d='%s.array' % p)
        self.initMatPushes.append(p)
        self.initMats.append(m)
	def createBoundJointConstraintsAndConnectVisibility(self):
		
		pm.select(cl = True)
		
		#bound joint constraint list
		self.boundJointConstraintList = []
		
		#iterate bound joint list and create orient constraint for each
		for index in range(len(self.boundJointsList)):
			pm.select(cl = True)
			self.boundJointConstraintList.append(pm.orientConstraint(self.ikSplineJointsList[index], self.ikDynamicJointsList[index], self.boundJointsList[index], mo = True))
			pm.select(cl = True)
			
		
		#create reverse node
		self.orientConstraintWeight_reverse = pm.createNode('reverse')
		pm.select(cl = True)
		
		#connect to manip dynamic blend
		self.manip_dynamic.manualDynamicBlend >> self.orientConstraintWeight_reverse.inputX
		pm.select(cl = True)
			
		#Connect Constraints to manip_dynamic
		for index in range(len(self.boundJointConstraintList)):
			pm.select(cl = True)
			pm.connectAttr(self.orientConstraintWeight_reverse.outputX, self.boundJointConstraintList[index].name() +'.' +self.ikSplineJointsList[index].name() +'W0', f = True)
			pm.connectAttr(self.manip_dynamic.manualDynamicBlend, self.boundJointConstraintList[index].name() +'.' +self.ikDynamicJointsList[index].name() +'W1', f = True)
			pm.select(cl = True)
	
	
		
		
		#Visibility
		self.orientConstraintWeight_reverse.outputX >> self.manipIkSplineTopGrp.visibility
예제 #8
0
    def build(self):
        super(CurveDeformer, self).build()

        oCurve = next((o for o in self.input if any (s for s in o.getShapes() if isinstance(s, pymel.nodetypes.NurbsCurve))), None)
        oSurface = next((o for o in self.input if any (s for s in o.getShapes() if isinstance(s, pymel.nodetypes.NurbsSurface))), None)

        if self.type == self.kType_NurbsSurface:
            oSurface = _createNurbsSurfaceFromNurbsCurve(oCurve)
            oSurface.rename(self._pNameMapRig.Serialize()+'_nurbsSurface')
            oSurface.setParent(self.grp_rig)

            for i in range(oSurface.numKnotsInV()-1):
                cluster, clusterHandle = pymel.cluster(oSurface.cv[0:3][i])
                cluster.rename(self._pNameMapRig.Serialize('cluster', _iIter=i))
                clusterHandle.rename(self._pNameMapRig.Serialize('clusterHandle', _iIter=i))
                clusterHandle.setParent(self.grp_rig)

                uRef = pymel.createNode('transform')
                uRef.rename(self._pNameMapRig.Serialize('cvRef', _iIter=i))
                uRef.setParent(self.grp_rig)
                pymel.connectAttr(oCurve.controlPoints[i], uRef.t)
                #pymel.connectAttr(libRigging.CreateUtilityNode('pointOnCurveInfo', inputCurve=oCurve.worldSpace, parameter=((float(i)/(oSurface.numKnotsInV()-3)))).position, uRef.t)
                #pymel.tangentConstraint(oCurve, uRef)

                clusterHandle.setParent(uRef)

        assert(isinstance(oSurface, pymel.PyNode))
        self.aJnts = _createSurfaceJnts(oSurface, self.numJnts)
        for i, jnt in enumerate(self.aJnts):
            jnt.rename(self._pNameMapRig.Serialize(_iIter=i))
            jnt.setParent(self.grp_rig)
예제 #9
0
파일: aov.py 프로젝트: skarone/PipeL
def addAOV( aovName, aovType = None ):
	"""docstring for addAov"""
	if aovType is None:
		aovType = aovs.getAOVTypeMap().get(aovName, 'rgba')
	if not isinstance(aovType, int):
		aovType = dict(aovs.TYPES)[aovType]
	aovNode = pm.createNode('aiAOV', name='aiAOV_' + aovName, skipSelect=True)
	out = aovNode.attr('outputs')[0]

	pm.connectAttr('defaultArnoldDriver.message', out.driver)
	filter = aovs.defaultFiltersByName.get(aovName, None)
	if filter:
		node = pm.createNode('aiAOVFilter', skipSelect=True)
		node.aiTranslator.set(filter)
		filterAttr = node.attr('message')
		import mtoa.hooks as hooks
		hooks.setupFilter(filter, aovName)
	else:
		filterAttr = 'defaultArnoldFilter.message'
	pm.connectAttr(filterAttr, out.filter)

	aovNode.attr('name').set(aovName)
	aovNode.attr('type').set(aovType)
	base = pm.PyNode('defaultArnoldRenderOptions')
	aovAttr = base.aovs
	nextPlug = aovAttr.elementByLogicalIndex(aovAttr.numElements())
	aovNode.message.connect(nextPlug)
	aov = aovs.SceneAOV(aovNode, nextPlug)
	return aov
    def swap_mesh(self, new_mesh, calibrate=True):
        """
        Change the mesh that the follicle is attached to.
        This is made to be used on a build InteractiveCtrlModel.
        :param new_mesh: A pymel.nodetypes.Mesh or pymel.nodetypes.Transform containing a mesh.
        """
        # Resolve the node driven by the follicle.
        # This node contain the bindPose of the ctrl and is linked via a parentConstraint which we'll want to re-create.
        # todo: how do we update the constraint again?
        constraint = next(
            obj for obj in self.follicle.translate.outputs() if isinstance(obj, pymel.nodetypes.ParentConstraint))
        target = constraint.getParent()
        pymel.delete(constraint)
        pos = target.getTranslation(space='world')

        # Get the new uv coordinates and apply them
        _, new_u, new_v = libRigging.get_closest_point_on_mesh(new_mesh, pos)
        pymel.connectAttr(new_mesh.outMesh, self.follicle.inputMesh, force=True)
        self.follicle.attr('parameterU').set(new_u)
        self.follicle.attr('parameterV').set(new_v)

        # Recreate the constraint
        pymel.parentConstraint(self.follicle, target, maintainOffset=True)

        if calibrate:
            self.calibrate()
예제 #11
0
 def fetch_attr(self, source, target):
     if source is None:
         return
     elif isinstance(source, pymel.Attribute):
         pymel.connectAttr(source, target)
     else:
         target.set(source)
예제 #12
0
def jointsOnCurve(crv=None, num=None, name=None):
    if not crv: return
    if not num: return
    if not name: return
    if num < 1: return

    param_increment = 1.0/float(num)
    param = 0
    curveShape = pm.PyNode(crv).getShape()
    prnt = []
    for i in range(num):
        pm.select(clear=1)
        # Create joint
        jnt = pm.joint(n=name+'_'+str(i).zfill(2))
        # Attach to curve
        poci = pm.createNode('pointOnCurveInfo')
        pm.connectAttr('%s.ws'%curveShape,'%s.inputCurve'%poci,f=1)
        pm.connectAttr('%s.position'%poci,'%s.translate'%jnt,f=1)
        pm.setAttr('%s.parameter'%poci,param)
        pm.setAttr('%s.turnOnPercentage'%poci,1)

        pm.disconnectAttr('%s.position'%poci,'%s.translate'%jnt)
        pm.delete(poci)

        if len(prnt):
            pm.parent(jnt,prnt[-1])

        prnt.append(jnt)
        param += param_increment
예제 #13
0
파일: utils.py 프로젝트: mkolar/Tapp
def Connect(src, dst):

    pm.undoInfo(openChunk=True)

    alembics = src
    if not isinstance(src, list):
        alembics = pm.ls(src, dagObjects=True, type='transform')

    targets = dst
    if not isinstance(dst, list):
        targets = pm.ls(dst, dagObjects=True, type='transform')

    attrs = ['translate', 'rotate', 'scale', 'visibility']
    for node in targets:
        for abc in alembics:
            if node.longName().split(':')[-1] == abc.longName().split(':')[-1]:
                for attr in attrs:
                    pm.connectAttr('%s.%s' % (abc, attr),
                                   '%s.%s' % (node, attr),
                                   force=True)

                # securing primary shape is connected
                pm.connectAttr('%s.worldMesh[0]' % abc.getShape(),
                               '%s.inMesh' % node.getShape(),
                               force=True)

    pm.undoInfo(closeChunk=True)
def FTV_multiConnectAutoKeyableNonLocked(src, dest, attsExcept):
	'''connect every keyable and non locked attribute of src to dest (basically connect parameters from control)'''
	atts = pm.listAttr(src, k=True, u=True)
	for a in atts:
		if a in attsExcept:
			continue
		pm.connectAttr(src+'.'+a, dest+'.'+a)
예제 #15
0
파일: aovs.py 프로젝트: Quazo/breakingpoint
    def addAOV(self, aovName, aovType=None):
        '''
        add an AOV to the active list for this AOV node

        returns the created AOV node
        '''
        if aovType is None:
            aovType = getAOVTypeMap().get(aovName, 'rgba')
        if not isinstance(aovType, int):
            aovType = dict(TYPES)[aovType]
        aovNode = pm.createNode('aiAOV', name='aiAOV_' + aovName, skipSelect=True)
        out = aovNode.attr('outputs')[0]

        pm.connectAttr('defaultArnoldDriver.message', out.driver)
        filter = defaultFiltersByName.get(aovName, None)
        if filter:
            node = pm.createNode('aiAOVFilter', skipSelect=True)
            node.aiTranslator.set(filter)
            filterAttr = node.attr('message')
            import mtoa.hooks as hooks
            hooks.setupFilter(filter, aovName)
        else:
            filterAttr = 'defaultArnoldFilter.message'
        pm.connectAttr(filterAttr, out.filter)

        aovNode.attr('name').set(aovName)
        aovNode.attr('type').set(aovType)
        nextPlug = self.nextAvailableAttr()
        aovNode.message.connect(nextPlug)
        aov = SceneAOV(aovNode, nextPlug)
        addAliases([aov])
        return aov
예제 #16
0
def rigConnectAttrsFromChannelbox( ):
    attrs = getAttrsFromChannelbox()
    num = len(attrs)/2

    for a,b in zip( attrs[num:], attrs[:num] ):
        pm.connectAttr( a, b )
        print a, '-->', b
예제 #17
0
	def CreateFKControl(self, _joint, _parent, _moduleContainer):
		jointName = utils.StripAllNamespaces(_joint)[1]
		containedNodes = []
		name = "%s_fkControl" %jointName
		
		controlObjectInstance = controlObject.ControlObject()
		
		fkControlInfo = controlObjectInstance.Create(name, "sphere.ma", self, _lod = 1, _translation = False, _rotation = True, _globalScale = False, _spaceSwitching = False)
		fkControl = fkControlInfo[0]
		
		pm.connectAttr("%s.rotateOrder" %_joint, "%s.rotateOrder" %fkControl)
		
		orientGrp = pm.group(name = "%s_orientGrp", empty = True, parent = _parent)
		containedNodes.append(orientGrp)
		
		pm.delete(pm.parentConstraint(_joint, orientGrp, maintainOffset = False))
		
		jointParent = pm.listRelatives(_joint, parent = True)[0]
		
		orientGrp_parentConstraint = pm.parentConstraint(jointParent, orientGrp, maintainOffset = True, name = "%s_parentConstraint" %orientGrp)
		orientGrp_scaleConstraint = pm.scaleConstraint(jointParent, orientGrp, maintainOffset = True, name = "%s_scaleConstraint" %orientGrp)
		
		pm.parent(fkControl, orientGrp, relative = True)
		
		orientConstraint = pm.orientConstraint(fkControl, _joint, maintainOffset = False, name = "%s_orientConstraint" %_joint)
		
		containedNodes.extend([orientGrp_parentConstraint, orientGrp_scaleConstraint, orientConstraint])
		
		utils.AddNodeToContainer(_moduleContainer, containedNodes)
		
		return fkControl
예제 #18
0
파일: ui.py 프로젝트: kudiaborm/mkScripts
    def assignToSelected(self, layerIndex, channelIndex):
        for obj in pm.selected():
            materialChannelList = [".diffuse", ".diffuse_weight", ".transparency", ".reflectivity", ".refl_gloss",
                                   ".cutout_opacity", ".bump", ".normal"]
            shapeNode = pm.listRelatives(obj, c=True, s=True)
            shadingGrp = pm.listConnections(shapeNode, type="shadingEngine")[0]
            mat = list(set(
                pm.listConnections(shadingGrp, type=['mia_material_x', 'mia_material_x_passes', 'lambert', 'phong'])))[
                0]
            try:
                currentItem = self.layeredTextureTreeModel.itemFromIndex(layerIndex[0]).node
            except:
                pm.cmds.warning("Please select a texture from the list.")
            try:
                if channelIndex < 6:
                    outAttr = ".outColor"
                    if channelIndex != 0:
                        outAttr = ".outAlpha"

                    currentItemOutColor = currentItem + outAttr
                    materialInput = mat + materialChannelList[channelIndex]
                    pm.connectAttr(currentItemOutColor, materialInput, f=True)
                elif channelIndex == 6:
                    createBump(currentItem, mat)
                else:
                    createBump(currentItem, mat, normal=True)
            except:
                pm.cmds.warning("Could not connect materials to " + obj)
예제 #19
0
    def connect(self):
        # Connect internal influence to network
        attr_out = self._get_attr_out_world_tm()
        pymel.connectAttr(self.obj.worldMatrix, attr_out)

        # Connect network to external influence
        _connect_matrix_to_trs(attr_out, self.obj_external)
def importAbcFile():
    importFilePath=pm.textField('path_ABC2', q=True, text=True)
    #.abc를 없애준다
    filePathDeletAbc = importFilePath.replace('.abc','')

    pm.importFile( filePathDeletAbc+'.ma' )
    importAbc( filePathDeletAbc+'.abc' )
    connectionsTxtFile_open = open(filePathDeletAbc+'.txt')
    import pickle
    lst = pickle.load(connectionsTxtFile_open)
    print lst
    for geo, shd, aiShd,disShd in lst:
        cmds.select( geo )
        cmds.hyperShade( assign=shd )
        node=pm.ls(geo)[0]
        shape = node.getShape()
        shadingGrps = shape.outputs( type='shadingEngine' )
        print shadingGrps[0]
        shader=pm.ls(aiShd)[0]
        print shader
        try:
            print 'good'
            pm.connectAttr(shader.outColor,shadingGrps[0].aiSurfaceShader) 
        except:
            print 'false'
        try:
            disShader=pm.ls(disShd)[0]
            pm.connectAttr(disShader.outColor,shadingGrps[0]..displacementShader) 
        except:
            print 'no dis'
예제 #21
0
    def _get_follicle_absolute_uv_attr(self, mult_u=1.0, mult_v=1.0):
        """
        Resolve the absolute parameterU and parameterV that will be sent to the follicles.
        :param mult_u: Custom multiplier
        :param mult_v:
        :return: A tuple containing two pymel.Attribute: the absolute parameterU and relative parameterV.
        """
        # TODO: Move attribute definition outside this function.
        attr_u_inn = libAttr.addAttr(self.grp_rig, longName=self._ATTR_NAME_U)
        attr_v_inn = libAttr.addAttr(self.grp_rig, longName=self._ATTR_NAME_V)

        attr_u_relative, attr_v_relative = self._get_follicle_relative_uv_attr(mult_u=mult_u, mult_v=mult_v)

        # Add base parameterU & parameterV
        attr_u_cur = libRigging.create_utility_node(
            'addDoubleLinear',
            input1=self._attr_u_base,
            input2=attr_u_relative
        ).output

        attr_v_cur = libRigging.create_utility_node(
            'addDoubleLinear',
            input1=self._attr_v_base,
            input2=attr_v_relative
        ).output

        # TODO: Move attribute connection outside of this function.
        pymel.connectAttr(attr_u_cur, attr_u_inn)
        pymel.connectAttr(attr_v_cur, attr_v_inn)

        return attr_u_inn, attr_v_inn
예제 #22
0
    def createJoints(self, name=None, curve=None, num=None):
        ''' Create groups on curve. '''
        num = float(num)
        joints = []
        param_increment = 1.0/num
        param = 0
        curveshape = curve.getShape()
        prnt = []
        for i in range(int(num)):
            pm.select(clear=1)

            # create joint
            jnt = pm.joint(name='%s%s_jnt' % (name, i))
            joints.append(jnt)

            # attach to curve
            poci = pm.createNode('pointOnCurveInfo')
            pm.connectAttr('%s.ws' % curveshape, '%s.inputCurve' % poci, f=1)
            pm.connectAttr('%s.position' % poci, '%s.translate' % jnt, f=1)
            pm.setAttr('%s.turnOnPercentage' % poci, 1)
            pm.setAttr('%s.parameter' % poci, param)

            pm.disconnectAttr('%s.position' % poci, '%s.translate' % jnt)
            pm.delete(poci)

            if len(prnt):
                pm.parent(jnt, prnt[-1])

            prnt.append(jnt)
            param += param_increment

        return joints
예제 #23
0
파일: libRigging.py 프로젝트: renaudll/omtk
def connect_or_set_attr(_attr, _val):
    if isinstance(_val, list) or isinstance(_val, tuple):

        # Note: List attribute and compound attribute don't have the same way of iterating.
        if _attr.isArray():
            for i, val in enumerate(_val):
                connect_or_set_attr(_attr.elementByLogicalIndex(i), val)
        elif _attr.isCompound():
            children = _attr.getChildren()
            for child, val in zip(children, _val):
                connect_or_set_attr(child, val)
        else:
            raise Exception("Can't apply value {0} on attribute {1}, need an array or compound".format(_val, _attr))

        '''
        for i, pSubValue in enumerate(_val):
            ConnectOrSetAttr(_attr.elementByLogicalIndex(i), pSubValue)
        '''
    else:
        if isinstance(_val, pymel.Attribute):
            pymel.connectAttr(_val, _attr, force=True)
        elif is_basic_type(_val):
            _attr.set(_val)
        else:
            logging.error(
                '[ConnectOrSetAttr] Invalid value for attribute {0} of type {1} and value {2}'.format(_attr.name(),
                                                                                                      type(_val),
                                                                                                      _val))
            raise TypeError
예제 #24
0
def create_render_cam(name="RENDER_CAM", exposure=True):
    """
    Creates a camera and renames it 
    
    str name: name of the camera
    bool exposure: connect a mia_exposure_photographic node to the camera     
    """
    if not pm.objExists(name):
        cam = pm.camera()[0]
        pm.rename(cam, name)
        [cam.renderable.set(cam.name().startswith(name)) for cam in pm.ls(cameras=True)]
    cam = pm.PyNode(name)
    
    if exposure:
        if not cam.miLensShader.isConnected():
            node = pm.createNode("mia_exposure_photographic")
            node.film_iso.set(800)
            node.f_number.set(1.2)
            node.gamma.set(1)
            pm.connectAttr(node.message, cam.miLensShader, force=True)
    
    cam.getShape().setDisplayResolution(True)
    pm.lookThru(name)
    
    pm.select(cam)
예제 #25
0
파일: libRigging.py 프로젝트: renaudll/omtk
def connectAttr_withLinearDrivenKeys(attr_src, attr_dst, type='animCurveUU', force=True, kt=(-1.0,0.0,1.0), kv=(-1.0,0.0,1.0), kit=(4,2,4), kot=(4,2,4), pre='linear', pst='linear'):
    # Skip if a connection already exist
    for node in getAttrOutput(attr_src, plugs=False, skipBlendWeighted=True):
        if 'animCurveU' in node.type():
            drivenkey_outplugs = getAttrOutput(node.output, plugs=True, skipBlendWeighted=True)
            for drivenkey_outplug in drivenkey_outplugs:
                if drivenkey_outplug == attr_dst:
                    if force:
                        pymel.disconnectAttr(node.input)
                        pymel.disconnectAttr(node.output)
                        pymel.delete(node)
                    else:
                        print("Can't connect. Attribute {0} is already connected to {1} via {2}".format(
                            attr_src.longName(),
                            attr_dst.longName(),
                            drivenkey_outplug.node().longName()
                        ))
                        return

    animCurve = create_animCurveU('animCurveUU',
                                  kt=kt,
                                  kv=kv,
                                  kit=kit, # Spline/Linear/Spline
                                  kot=kot, # Spline/Linear/Spline
                                  pre=pre,
                                  pst=pst
                                  )
    animCurve.rename('{0}_{1}'.format(attr_src.node().name(), attr_src.longName()))
    pymel.connectAttr(attr_src, animCurve.input)
    return connectAttr_withBlendWeighted(animCurve.output, attr_dst)
예제 #26
0
def createSubdivApproxNode():
    '''
    copy of createApproxNode from mentalrayApproxEditor.mel
    node will be named "mathildaSubdivApprox"
    '''
    # delete existing node if exists
    nodeName = 'mathildaSubdivApprox'
    
    # make sure mental ray is loaded first
    if not pm.pluginInfo('Mayatomr', q=True, loaded=True):
        pm.loadPlugin('Mayatomr', qt=True)
    
    # create approx node
    approxNode = pm.createNode('mentalraySubdivApprox', n=nodeName)
    
    # get listNode
    try:
        mrItemsListNode = pm.ls(type='mentalrayItemsList')[0]
    except IndexError:
        mrItemsListNode = pm.createNode('mentalrayItemsList', n='mentalrayItemsList')
    
    # connect approx to list
    pm.connectAttr(approxNode.message, mrItemsListNode.subdivApproxs, na=True)
    
    return approxNode
    def create_compound_ctrl(self, cls, inst, suffix, attr_inn_name, attr_out_name, **kwargs):
        """
        Initialize and build and connect a controller used in the Compound.
        :param cls: The desired class for the controller.
        :param inst: The current instance.
        :param suffix: A str that identify this controller.
        :param attr_inn_name: The name of the network attribute that receive the controller local matrix.
        :param attr_out_name: The name of the network attribute that will drive the controller offset world matrix.
        :param kwargs: Any keyword argument will be passed to the controller .build() method.
        :return: A controller instance of the desired type.
        """
        attr_inn = self.grp_inn.attr(attr_inn_name)
        attr_out = self.grp_out.attr(attr_out_name)
        nomenclature_anm = self.get_nomenclature_anm()

        inst = self.init_ctrl(cls, inst)
        ref_tm = attr_out.get()

        inst.build(
            name=nomenclature_anm.resolve(suffix),
            geometries=self.rig.get_meshes(),
            refs=[ref_tm],
            **kwargs
        )
        inst.setParent(self.grp_anm)

        pymel.connectAttr(inst.matrix, attr_inn)
        _connect_matrix_attr_to_transform(attr_out, inst.offset)
        return inst
예제 #28
0
def main():
	prefRun()
	
	center = pm.ikHandle(name="centerIK", startJoint="center1", endEffector="center13",  sol="ikSplineSolver",ns=3)
	left = pm.ikHandle(name="leftIK", startJoint="left1", endEffector="left13",  sol="ikSplineSolver",ns=3)
	right = pm.ikHandle(name="rightIK", startJoint="right1", endEffector="right13",  sol="ikSplineSolver",ns=3)
	
	pm.rename(center[2], "center_crv")
	pm.rename(left[2], "left_crv")
	pm.rename(right[2], "right_crv")
	
	clusterGrp_center = clusterCurve("center_crv")
	clusterGrp_left = clusterCurve("left_crv")
	clusterGrp_right = clusterCurve("right_crv")
	
	
	pm.connectAttr("jacketRight1.rz", clusterGrp_right+".rz")
	pm.connectAttr("jacketLeft1.rz", clusterGrp_left+".rz")
	
	pm.parent("center_crv", "rig")
	pm.parent("left_crv", "rig")
	pm.parent("right_crv", "rig")
	
	pm.parent(clusterGrp_center, "world_ctrl")
	pm.parent(clusterGrp_left, "world_ctrl")
	pm.parent(clusterGrp_right, "world_ctrl")
	
	for i in ["centerIK", "leftIK", "rightIK"]:
		pm.setAttr(i+".visibility", 0)
		pm.parent(i, "rig")
	
	for i in ['center_crv','left_crv','right_crv','center_crv_cv0_loc', 'left_crv_cv0_loc', 'right_crv_cv0_loc', 'pageTargets_grp', 'pages_grp', 'jacket_grp']:
		pm.setAttr(i+".visibility", 0)
예제 #29
0
def create_ibl(* args):
    '''
    # creates an ibl
    '''
    
    my_ibl = pm.shadingNode('mentalrayIblShape', asLight= True)
    pm.connectAttr('%s.message' % (my_ibl),
                   'mentalrayGlobals.imageBasedLighting', force= True)
    pm.setAttr('%s.primaryVisibility' % (my_ibl), 1)
    pm.setAttr('%s.visibleInReflections' % (my_ibl), 1)
    pm.setAttr('%s.visibleInRefractions' % (my_ibl), 1)
    pm.setAttr('%s.visibleInEnvironment' % (my_ibl), 1)
    pm.setAttr('%s.visibleInFinalGather' % (my_ibl), 1)
    
    scene_objects = pm.ls(type= ['mesh', 'nurbsSurface', 'volumeLight',
                                'spotLight', 'directionalLight','areaLight',
                                    'pointLight', 'ambientLight'])

    bounding_box = pm.exactWorldBoundingBox(scene_objects)
    bounding_box.sort()
    
    ibl_size = bounding_box[-1]

    pm.setAttr('%s.scaleX' % (my_ibl), ibl_size)
    pm.setAttr('%s.scaleY' % (my_ibl), ibl_size)
    pm.setAttr('%s.scaleZ' % (my_ibl), ibl_size)
    
    return my_ibl
예제 #30
0
    def build(self, refs=None, line_target=True, *args, **kwargs):
        """
        Will create the ctrl node and it's line target if needed
        :param refs: The reference used to attach the line target
        :param line_target: Bool to tell if we want a line target
        :param args: More args passed to the super class
        :param kwargs: More kwargs passed to the super class
        :return:
        """
        super(CtrlIkSwivel, self).build(*args, **kwargs)
        assert (self.node is not None)

        ref = next(iter(refs), None) if isinstance(refs, collections.Iterable) else refs

        # Create line
        if line_target is True and ref is not None:
            # Create a spaceLocator so the annotation can hook itself to it.
            self._line_locator = pymel.spaceLocator()
            locator_shape = self._line_locator.getShape()
            pymel.pointConstraint(ref, self._line_locator)
            self._line_locator.setParent(self.node)
            self._line_locator.hide()

            self._line_annotation = pymel.createNode('annotationShape')
            annotation_transform = self._line_annotation.getParent()
            self._line_annotation.setParent(self.node, relative=True, shape=True)
            pymel.connectAttr(locator_shape.worldMatrix, self._line_annotation.dagObjectMatrix[0], force=True)
            pymel.delete(annotation_transform)

        return self.node
예제 #31
0
def facialLocalWorldControllers(module, parent, ctrlSize=1):

    ctrlSizeHalf = [ctrlSize / 2.0, ctrlSize / 2.0, ctrlSize / 2.0]
    ctrlSizeQuarter = [ctrlSize / 4.0, ctrlSize / 4.0, ctrlSize / 4.0]
    ctrlSize = [ctrlSize, ctrlSize, ctrlSize]

    transLocs = cmds.ls("*_sdk2_LOC", type="transform")

    for loc in transLocs:
        locName = loc.replace('_sdk2', '')

        side = rig_nameGetSide(locName)
        base = locName
        #if side:
        base = rig_nameGetBase(locName)

        print 'side = ' + side
        print 'base = ' + base

        name = loc.replace('_sdk2_LOC', '')

        print 'name = ' + name

        localOffset = rig_transform(0,
                                    name=name + 'LocalOffset',
                                    parent=module.parts,
                                    target=loc).object
        localCon = rig_transform(0,
                                 name=name + 'LocalCon',
                                 parent=localOffset,
                                 target=localOffset).object

        pm.parentConstraint(loc, localCon, mo=True)

        ctrlName = base + 'Twk'
        if 'Tweak' in base:
            ctrlName = base.replace('Tweak', 'Twker')

        print 'ctrlName = ' + ctrlName

        ctrl = rig_control(side=side,
                           name=ctrlName,
                           shape='circle',
                           modify=1,
                           scale=ctrlSize,
                           directCon=1,
                           parentOffset=module.controlsSec,
                           secColour=1,
                           directConAttrs=('tx', 'ty', 'tz', 'rx', 'ry', 'rz'))

        pm.rotate(ctrl.ctrl.cv, 0, 0, 90, r=True, os=True)
        if side == 'r':
            pm.move(ctrl.ctrl.cv, -0.2, 0, 0, r=True, os=True)
        else:
            pm.move(ctrl.ctrl.cv, 0.2, 0, 0, r=True, os=True)

        jnt = pm.listRelatives(loc, type='joint', c=True)[0]

        pm.delete(pm.parentConstraint(loc, ctrl.offset))
        pm.parent(ctrl.offset, parent)
        for at in ('tx', 'ty', 'tz', 'rx', 'ry', 'rz'):
            pm.connectAttr(localCon + '.' + at, ctrl.modify + '.' + at)
            pm.connectAttr(ctrl.ctrl + '.' + at, jnt + '.' + at)
예제 #32
0
## Book Set Up ##
import pymel.core as pm
import tak_misc
reload(tak_misc)

# Page
bulgeClsts = []
selLs = pm.ls(sl=True)
for sel in selLs:
	pm.select(sel, r=True)
	ffdNodes = pm.lattice(sel, divisions=[2,5,2], objectCentered=True, ldv=[2,2,2], n=sel+"_ffd")
	ffdNodes[0].setAttr("local", 0)
	clst = pm.cluster("%s.pt[0:1][1][0]" %(ffdNodes[1]), "%s.pt[0:1][1][1]" %(ffdNodes[1]), n=sel+"_ffd_clst")
	
	pm.addAttr(sel.split("_")[0]+"_ctrl", ln="bulge", at="float", keyable=True)
	pm.connectAttr(sel.split("_")[0]+"_ctrl"+".bulge", clst[0]+"Handle.translateX")

# Page1~5
selLs = pm.ls(sl=True)
for sel in selLs:
	pm.select(sel, r=True)
	ffdNodes = pm.lattice(sel, divisions=[2,5,2], objectCentered=True, ldv=[2,2,2], n=sel+"_ffd")
	ffdNodes[0].setAttr("local", 0)
	clst = pm.cluster("%s.pt[0:1][1][0]" %(ffdNodes[1]), "%s.pt[0:1][1][1]" %(ffdNodes[1]), n=sel+"_ffd_clst")
	
	pm.addAttr(sel.rsplit("_", 1)[0] + "_ctrl", ln="bulge", at="float", keyable=True)
	pm.connectAttr(sel.rsplit("_", 1)[0]+"_ctrl"+".bulge", clst[0]+"Handle.translateX")
	
	groupName = sel.split("_", 1)[0] + "_bulge_system_grp"
	if groupName:
		pm.parent(ffdNodes[1:], clst[1], groupName)
예제 #33
0
 def connect_fresnel(self, file_node, slot_name):
     file_node.alphaIsLuminance.set(True)
     pm.connectAttr(file_node.outAlpha, '%s.%s' % (self.shader, slot_name))
예제 #34
0
 def connect_color_texture(self, file_node, slot_name):
     pm.connectAttr(file_node.outColor, '%s.%s' % (self.shader, slot_name))
예제 #35
0
def gear_rollsplinekine_op(out, controlers=[], u=.5, subdiv=10):
    """Apply a sn_rollsplinekine_op operator

    Arguments:
        out (dagNode): onstrained Object.
        controlers (list of dagNodes): Objects that will act as controler of
            the bezier curve. Objects must have a parent that will be used as
            an input for the operator.
        u (float): Position of the object on the bezier curve (from 0 to 1).
        subdiv (int): spline subdivision precision.

    Returns:
        pyNode: The newly created operator.
    """
    node = pm.createNode("mgear_rollSplineKine")

    # Inputs
    pm.setAttr(node + ".u", u)
    pm.setAttr(node + ".subdiv", subdiv)

    dm_node = pm.createNode("decomposeMatrix")

    pm.connectAttr(node + ".output", dm_node + ".inputMatrix")
    pm.connectAttr(dm_node + ".outputTranslate", out + ".translate")
    pm.connectAttr(dm_node + ".outputRotate", out + ".rotate")
    # connectAttr(dm_node+".outputScale", out+".scale")

    pm.connectAttr(out + ".parentMatrix", node + ".outputParent")

    for i, obj in enumerate(controlers):
        pm.connectAttr(obj + ".parentMatrix", node + ".ctlParent[%s]" % i)

        pm.connectAttr(obj + ".worldMatrix", node + ".inputs[%s]" % i)
        pm.connectAttr(obj + ".rx", node + ".inputsRoll[%s]" % i)

    return node
예제 #36
0
def gear_ikfk2bone_op(out=[],
                      root=None,
                      eff=None,
                      upv=None,
                      fk0=None,
                      fk1=None,
                      fk2=None,
                      lengthA=5,
                      lengthB=3,
                      negate=False,
                      blend=0):
    """Apply a sn_ikfk2bone_op operator

    Arguments:
        out (list of dagNodes): The constrained outputs order must be respected
            (BoneA, BoneB,  Center, CenterN, Eff), set it to None if you don't
            want one of the output.
        root (dagNode): Object that will act as the root of the chain.
        eff (dagNode): Object that will act as the eff controler of the chain.
        upv (dagNode): Object that will act as the up vector of the chain.
        fk0 (dagNode): Object that will act as the first fk controler of the
            chain.
        fk1 (dagNode): Object that will act as the second fk controler of the
            chain.
        fk2 (dagNode): Object that will act as the fk effector controler of the
            chain.
        lengthA (float): Length of first bone.
        lengthB (float): Length of second bone.
        negate (bool):  Use with negative Scale.
        blend (float): Default blend value (0 for full ik, 1 for full fk).

    Returns:
        pyNode: The newly created operator.

    """
    node = pm.createNode("mgear_ikfk2Bone")

    # Inputs
    pm.setAttr(node + ".lengthA", lengthA)
    pm.setAttr(node + ".lengthB", lengthB)
    pm.setAttr(node + ".negate", negate)
    pm.setAttr(node + ".blend", blend)

    pm.connectAttr(root + ".worldMatrix", node + ".root")
    pm.connectAttr(eff + ".worldMatrix", node + ".ikref")
    pm.connectAttr(upv + ".worldMatrix", node + ".upv")
    pm.connectAttr(fk0 + ".worldMatrix", node + ".fk0")
    pm.connectAttr(fk1 + ".worldMatrix", node + ".fk1")
    pm.connectAttr(fk2 + ".worldMatrix", node + ".fk2")

    # Outputs
    if out[0] is not None:
        pm.connectAttr(out[0] + ".parentMatrix", node + ".inAparent")

        dm_node = pm.createNode("decomposeMatrix")
        pm.connectAttr(node + ".outA", dm_node + ".inputMatrix")
        pm.connectAttr(dm_node + ".outputTranslate", out[0] + ".translate")
        pm.connectAttr(dm_node + ".outputRotate", out[0] + ".rotate")
        pm.connectAttr(dm_node + ".outputScale", out[0] + ".scale")

    if out[1] is not None:
        pm.connectAttr(out[1] + ".parentMatrix", node + ".inBparent")

        dm_node = pm.createNode("decomposeMatrix")
        pm.connectAttr(node + ".outB", dm_node + ".inputMatrix")
        pm.connectAttr(dm_node + ".outputTranslate", out[1] + ".translate")
        pm.connectAttr(dm_node + ".outputRotate", out[1] + ".rotate")
        pm.connectAttr(dm_node + ".outputScale", out[1] + ".scale")

    if out[2] is not None:
        pm.connectAttr(out[2] + ".parentMatrix", node + ".inCenterparent")

        dm_node = pm.createNode("decomposeMatrix")
        pm.connectAttr(node + ".outCenter", dm_node + ".inputMatrix")
        pm.connectAttr(dm_node + ".outputTranslate", out[2] + ".translate")
        pm.connectAttr(dm_node + ".outputRotate", out[2] + ".rotate")
        # connectAttr(dm_node+".outputScale", out[2]+".scale") # the scaling
        # is not working with FK blended to 1.
        # The output is from the solver I need to review the c++ solver

    if out[3] is not None:
        pm.connectAttr(out[3] + ".parentMatrix", node + ".inEffparent")

        dm_node = pm.createNode("decomposeMatrix")
        pm.connectAttr(node + ".outEff", dm_node + ".inputMatrix")
        pm.connectAttr(dm_node + ".outputTranslate", out[3] + ".translate")
        pm.connectAttr(dm_node + ".outputRotate", out[3] + ".rotate")
        pm.connectAttr(dm_node + ".outputScale", out[3] + ".scale")

    return node
예제 #37
0
def gear_spring_op(in_obj, goal=False):
    """Apply mGear spring node.

    Arguments:
        in_obj (dagNode): Constrained object.
        goal (dagNode): By default is False.

    Returns:
        pyNode: Newly created node
    """
    if not goal:
        goal = in_obj

    node = pm.createNode("mgear_springNode")

    pm.connectAttr("time1.outTime", node + ".time")
    dm_node = pm.createNode("decomposeMatrix")
    pm.connectAttr(goal + ".parentMatrix", dm_node + ".inputMatrix")
    pm.connectAttr(dm_node + ".outputTranslate", node + ".goal")

    cm_node = pm.createNode("composeMatrix")
    pm.connectAttr(node + ".output", cm_node + ".inputTranslate")

    mm_node = pm.createNode("mgear_mulMatrix")

    pm.connectAttr(cm_node + ".outputMatrix", mm_node + ".matrixA")
    pm.connectAttr(in_obj + ".parentInverseMatrix", mm_node + ".matrixB")

    dm_node2 = pm.createNode("decomposeMatrix")
    pm.connectAttr(mm_node + ".output", dm_node2 + ".inputMatrix")
    pm.connectAttr(dm_node2 + ".outputTranslate", in_obj + ".translate")

    pm.setAttr(node + ".stiffness", 0.5)
    pm.setAttr(node + ".damping", 0.5)

    return node
예제 #38
0
place2d_node.outUvFilterSize >> file_node.uvFilterSize
place2d_node.repeatUV >> file_node.repeatUV
place2d_node.rotateFrame >> file_node.rotateFrame
place2d_node.rotateUV >> file_node.rotateUV
place2d_node.stagger >> file_node.stagger
place2d_node.translateFrame >> file_node.translateFrame
place2d_node.vertexCameraOne >> file_node.vertexCameraOne
place2d_node.vertexUvOne >> file_node.vertexUvOne
place2d_node.vertexUvThree >> file_node.vertexUvThree
place2d_node.vertexUvTwo >> file_node.vertexUvTwo
place2d_node.wrapU >> file_node.wrapU
place2d_node.wrapV >> file_node.wrapV
pm.select(cl = True)

#connect shader to shading group
pm.connectAttr( shader_node.name() + ".outColor", shading_group_node.name() + ".surfaceShader", force = True)
pm.select(cl = True)

#connect file to ocio node
file_node.outColor >> ocio_node.input_color
pm.select(cl = True)

#connect ocio node to shader
ocio_node.output_color >> shader_node.outColor
pm.select(cl = True)

#set texture file
file_node.fileTextureName.set(texture_dir +'/' +texture_name)

#polyplane_transform_node, polyplane_shape_node
polyplane_transform_node, polyplane_shape_node = pm.polyPlane(n = 'ocio_test_polyplane', sx = 10, sy = 10, axis = (0,1,0), width = 12.8, height = 7.8)
예제 #39
0
def load_to_maya(positions,
                 names=None,
                 parents=None,
                 color=None,
                 radius=0.1,
                 thickness=5.0):

    import pymel.core as pm
    import maya.mel as mel

    if names is None:
        names = ['joint_%i' % i for i in xrange(positions.shape[1])]

    if color is None:
        color = (0.5, 0.5, 0.5)

    mpoints = []
    frames = range(1, len(positions) + 1)
    for i, name in enumerate(names):

        #try:
        #    point = pm.PyNode(name)
        #except pm.MayaNodeError:
        #    point = pm.sphere(p=(0,0,0), n=name, radius=radius)[0]
        point = pm.sphere(p=(0, 0, 0), n=name, radius=radius)[0]

        jpositions = positions[:, i]

        for j, attr, attr_name in zip(
                xrange(3), [point.tx, point.ty, point.tz],
            ["_translateX", "_translateY", "_translateZ"]):
            conn = attr.listConnections()
            if len(conn) == 0:
                curve = pm.nodetypes.AnimCurveTU(n=name + attr_name)
                pm.connectAttr(curve.output, attr)
            else:
                curve = conn[0]
            curve.addKeys(frames, jpositions[:, j])

        mpoints.append(point)

    if parents != None:

        for i, p in enumerate(parents):
            if p == -1: continue
            pointname = names[i]
            parntname = names[p]
            conn = pm.PyNode(pointname).t.listConnections()
            if len(conn) != 0: continue

            curve = pm.curve(p=[[0, 0, 0], [0, 1, 0]],
                             d=1,
                             n=names[i] + '_curve')
            pm.connectAttr(pointname + '.t', names[i] + '_curve.cv[0]')
            pm.connectAttr(parntname + '.t', names[i] + '_curve.cv[1]')
            pm.select(curve)
            pm.runtime.AttachBrushToCurves()
            stroke = pm.selected()[0]
            brush = pm.listConnections(stroke.getChildren()[0] + '.brush')[0]
            pm.setAttr(brush + '.color1', color)
            pm.setAttr(brush + '.globalScale', thickness)
            pm.setAttr(brush + '.endCaps', 1)
            pm.setAttr(brush + '.tubeSections', 20)
            mel.eval('doPaintEffectsToPoly(1,0,0,1,100000);')
            mpoints += [stroke, curve]

    return pm.group(mpoints, n='AnimationPositions'), mpoints
    def makeUIConnections(self):
        """
        Connects the facial UI to the blendShapes.
        Returns:

        """
        print 'Making connections for the shapes to the UI...'
        bmNode = pm.PyNode('BM_nodes')
        if not bmNode.objExists():
            pm.error('Missing %s, Please check and try again.' % bmNode)
            return False
        if not bmNode.guiimport.get():
            facialFile = self.facialUI_cb.currentText()
            if not facialFile:
                pm.error('Please select a proper facial file.')
                return False
            facialFilePath = os.path.join(self.facialFileLocation,
                                          str(facialFile)).replace('\\', '/')
            pm.importFile(facialFilePath)
            bmNode.guiimport.set(1)

        # get blendshape list from the blendShapeNode.
        blendShapeNode = pm.PyNode('%s_blendShapeNode' %
                                   self.baseMeshShapeNode)
        shapeList = pm.listAttr(blendShapeNode + '*.w', m=1, k=1)

        # Now read the config and make the connections...
        configFile = self.facialConfig_cb.currentText().replace('.py', '')
        importStatement = "pcgiShapeManager.config.%s" % configFile
        baseConfig = importlib.import_module(importStatement)
        reload(baseConfig)

        mainController = pm.PyNode('face_facial_ctl')
        usedShapes = list()
        for key, val in baseConfig.facialConnectionsDict.iteritems():
            if val:
                # shapeToConnect = None
                for eachShape in shapeList:
                    if val in eachShape:
                        usedShapes.append(eachShape)
                        pm.connectAttr(
                            '%s.%s' % (str(mainController), key),
                            '%s.%s' % (self.blendShapeNode, eachShape))

        extraShapes = set(shapeList) - set(usedShapes)
        for eachExtraShape in extraShapes:
            if 'pupil' in eachExtraShape:
                ret = blendShapeUtils.decompileNames(
                    eachExtraShape, str(self.mainfileter_le.text()))
                pm.connectAttr('face_r_pupil_fac_ctl.%s' % (ret['#shape']),
                               '%s.%s' % (self.blendShapeNode, eachExtraShape))
            else:
                attrName = '_'.join(eachExtraShape.split('_')[-2:])
                extraShapeCtl = pm.PyNode('face_extrashapes_fac_ctl')
                extraShapeCtl.addAttr(attrName,
                                      at='float',
                                      min=0,
                                      max=1,
                                      dv=0,
                                      k=1)
                pm.connectAttr('%s.%s' % (extraShapeCtl, attrName),
                               '%s.%s' % (self.blendShapeNode, eachExtraShape))
예제 #41
0
    def __init__(self, ikHandle, ikCtrl, doFlexyplane=True):
        ikHandle = pm.ls(ikHandle)[0]
        ikCtrl = pm.ls(ikCtrl)[0]

        prefix = name.removeSuffix(ikHandle.name())

        jointList = pm.ikHandle(ikHandle, jointList=True, q=True)
        endJoint = pm.listRelatives(jointList[-1], c=True, type='joint')[0]
        jointList.append(endJoint)

        distanceDimensionShape = pm.distanceDimension(
            sp=jointList[0].getTranslation(space='world'),
            ep=jointList[-1].getTranslation(space='world'))

        locators = pm.listConnections(distanceDimensionShape, s=True)
        startLoc = pm.rename(locators[0], prefix + 'DistanceStart_LOC')
        endLoc = pm.rename(locators[1], prefix + 'DistanceEnd_LOC')

        pm.pointConstraint(jointList[0], startLoc)
        pm.pointConstraint(ikCtrl, endLoc)

        # multiplyDivide Node
        multiplyDivideNode = pm.shadingNode('multiplyDivide',
                                            asUtility=True,
                                            n=prefix + '_multiplyDivide')
        multiplyDivideNode.input2X.set(1)
        multiplyDivideNode.operation.set(2)
        pm.connectAttr(distanceDimensionShape.distance,
                       multiplyDivideNode.input1X,
                       f=True)
        distance = 0
        for i in range(0, len(jointList[:-1])):
            distance = distance + util.get_distance(jointList[i],
                                                    jointList[i + 1])
        multiplyDivideNode.input2X.set(distance)

        # condition Node
        conditionNode = pm.shadingNode('condition',
                                       asUtility=True,
                                       n=prefix + '_condition')
        conditionNode.operation.set(2)
        pm.connectAttr(distanceDimensionShape.distance,
                       conditionNode.firstTerm,
                       f=True)
        pm.connectAttr(multiplyDivideNode.input2X,
                       conditionNode.secondTerm,
                       f=True)
        pm.connectAttr(multiplyDivideNode.outputX,
                       conditionNode.colorIfTrueR,
                       f=True)

        for jnt in jointList[:-1]:
            pm.connectAttr(conditionNode.outColorR, jnt.scaleX, f=True)

        self.stretchyGrp = pm.group(startLoc,
                                    endLoc,
                                    distanceDimensionShape.getParent(),
                                    n=prefix + 'Stretchy_GRP')
        self.stretchyGrp.visibility.set(0)

        # save attributes
        self.prefix = prefix
        self.jointList = jointList

        if doFlexyplane:
            self.doFlexyPlane(prefix)
예제 #42
0
    'face_A_fac_ctl', 'face_r_brow_wor_fac_ctl', 'face_l_brow_wor_fac_ctl',
    'face_r_half_eye_squint_fac_ctl', 'face_l_upper_eyelid_fac_ctl',
    'face_Smileright_fac_ctl', 'face_l_lower_eyelid_fac_ctl',
    'face_r_sneerup_fac_ctl', 'face_CDGK_fac_ctl', 'face_l_brow_agr_fac_ctl',
    'face_l_brow_sad_fac_ctl', 'face_l_sneerup_fac_ctl', 'face_U_fac_ctl',
    'face_l_sneerdown_fac_ctl', 'face_lwr_teeth_clench_fac_ctl',
    'face_upr_teeth_clench_fac_ctl', 'face_l_cheek_puff_fac_ctl',
    'face_mouthopen_fac_ctl', 'face_Smile1_fac_ctl', 'face_Smile2_fac_ctl',
    'face_r_cheek_puff_fac_ctl'
]

for eachConnection in directConnections:
    connectionName = (eachConnection.replace('face_',
                                             '')).replace('_fac_ctl', '')
    mainController.addAttr(connectionName, at='double', min=0, max=1, dv=1)
    pm.connectAttr('%s.ty' % eachConnection,
                   '%s.%s' % (mainController, connectionName))

biDirectionConectionsY = [
    'face_l_eyesquint_fac_ctl', 'face_r_eyesquint_fac_ctl',
    'face_l_brow_fac_ctl', 'face_r_brow_fac_ctl', 'face_jaw_fac_ctl',
    'face_mouth_slide_fac_ctl', 'face_r_cnr_fac_ctl', 'face_l_cnr_fac_ctl'
]

directionalList = [('Y', 0, 1), ('Y', 0, 0), ('X', 1, 1), ('X', 1, 0)]
yPlus = 1
yMin = 1
xPlus = 0
xMin = 0

for idx, each in enumerate(['yPlus', 'yMin']):  # , xPlus, xMin]):
    for eachConnection in biDirectionConectionsY:
예제 #43
0
def genMat(*args):
    selected = pm.ls(sl=1, long=1)

    matName = 'master_attr_mat'
    proxyName = 'proxy_attr_mat'
    existAttrMat = pm.ls((matName), materials=True)
    masterMat = False

    if (len(existAttrMat) == 0):
        rn1 = rand.uniform(0, 1)
        rn2 = rand.uniform(0, 1)
        rn3 = rand.uniform(0, 1)
        # create master material andol 5
        masterMat = pm.shadingNode('aiStandardSurface',
                                   name=matName,
                                   asShader=True)
        pm.setAttr((masterMat + '.baseColor'), randCol(), type='double3')
        proxyMat = pm.shadingNode('lambert', name=proxyName, asShader=True)

        #create vrtx col hook and boolean
        diffVrtx = pm.shadingNode('aiUserDataColor',
                                  name='diffVrtxAttr',
                                  asTexture=True)
        pm.setAttr((diffVrtx + '.colorAttrName'), 'colorSet1', type='string')
        pm.setAttr((diffVrtx + '.defaultValue'), (rand.uniform(0, 1)),
                   (rand.uniform(0, 1)), (rand.uniform(0, 1)),
                   type='double3')
        # create diff col attr
        diffCol = pm.shadingNode('aiUserDataColor',
                                 name='diffColAttr',
                                 asTexture=True)
        pm.setAttr((diffCol + '.colorAttrName'), 'diffCol', type='string')
        pm.setAttr((diffCol + '.defaultValue'), (rand.uniform(0, 1)),
                   (rand.uniform(0, 1)), (rand.uniform(0, 1)),
                   type='double3')
        # bool attribute for vrtx diff
        diffVrtxBool = pm.shadingNode('aiUserDataBool',
                                      name='diffVrtxBool',
                                      asUtility=True)
        pm.setAttr((diffVrtxBool + '.boolAttrName'),
                   'diffVrtxTog',
                   type='string')
        pm.setAttr((diffVrtxBool + '.defaultValue'), False)
        # switch between diff col and dif vrtx
        diffColSwitch = pm.shadingNode('colorCondition',
                                       name='useDiffVrtx',
                                       asUtility=True)
        pm.connectAttr((diffVrtx + '.outColor'), (diffColSwitch + '.colorA'))
        pm.connectAttr((diffVrtx + '.outTransparencyR'),
                       (diffColSwitch + '.alphaA'))
        pm.connectAttr((diffCol + '.outColor'), (diffColSwitch + '.colorB'))
        pm.connectAttr((diffCol + '.outTransparencyR'),
                       (diffColSwitch + '.alphaB'))
        pm.connectAttr((diffVrtxBool + '.outValue'),
                       (diffColSwitch + '.condition'))

        #create difftex attribute and empty texture file and udim attr
        diffTexStr = pm.shadingNode('aiUserDataString',
                                    name='diffTexAttr',
                                    asUtility=True)
        pm.setAttr((diffTexStr + '.stringAttrName'), 'diffTex', type='string')
        # diff tex udim
        diffUdimBool = pm.shadingNode('aiUserDataBool',
                                      name='diffUdimBool',
                                      asUtility=True)
        pm.setAttr((diffUdimBool + '.boolAttrName'), 'diffUdim', type='string')
        pm.setAttr((diffUdimBool + '.defaultValue'), False)
        #diff file
        diffTexFile = pm.shadingNode('file',
                                     name='diffTexFile',
                                     asTexture=True)
        pm.connectAttr((diffTexStr + '.outValue'),
                       (diffTexFile + '.fileTextureName'))
        #diff file udimm
        diffTexFileUdim = pm.shadingNode('file',
                                         name='diffTexFileUdim',
                                         asTexture=True)
        pm.setAttr((diffTexFileUdim + '.uvTilingMode'), 3)
        pm.connectAttr((diffTexStr + '.outValue'),
                       (diffTexFileUdim + '.fileTextureName'))
        #switch between tex and udim tex
        diffTexUdimSwitch = pm.shadingNode('colorCondition',
                                           name='useDiffUdimTex',
                                           asUtility=True)
        pm.connectAttr((diffTexFile + '.outColor'),
                       (diffTexUdimSwitch + '.colorA'))
        pm.connectAttr((diffTexFile + '.outAlpha'),
                       (diffTexUdimSwitch + '.alphaA'))
        pm.connectAttr((diffTexFileUdim + '.outColor'),
                       (diffTexUdimSwitch + '.colorB'))
        pm.connectAttr((diffTexFileUdim + '.outAlpha'),
                       (diffTexUdimSwitch + '.alphaB'))
        pm.connectAttr((diffUdimBool + '.outValue'),
                       (diffTexUdimSwitch + '.condition'))
        # bool for diff tex
        diffTexBool = pm.shadingNode('aiUserDataBool',
                                     name='diffTexBool',
                                     asUtility=True)
        pm.setAttr((diffTexBool + '.boolAttrName'),
                   'diffTexTog',
                   type='string')
        pm.setAttr((diffTexBool + '.defaultValue'), False)
        # switch between diff atr branch and dif file
        diffTexSwitch = pm.shadingNode('colorCondition',
                                       name='useDiffTex',
                                       asUtility=True)
        pm.connectAttr((diffTexUdimSwitch + '.outColor'),
                       (diffTexSwitch + '.colorA'))
        pm.connectAttr((diffTexUdimSwitch + '.outAlpha'),
                       (diffTexSwitch + '.alphaA'))
        pm.connectAttr((diffColSwitch + '.outColor'),
                       (diffTexSwitch + '.colorB'))
        pm.connectAttr((diffColSwitch + '.outAlpha'),
                       (diffTexSwitch + '.alphaB'))
        pm.connectAttr((diffTexBool + '.outValue'),
                       (diffTexSwitch + '.condition'))

        pm.connectAttr((diffTexSwitch + '.outColor'),
                       (masterMat + '.baseColor'))
        pm.connectAttr((diffTexSwitch + '.outAlpha'),
                       (masterMat + '.opacityR'))
        pm.connectAttr((diffTexSwitch + '.outAlpha'),
                       (masterMat + '.opacityG'))
        pm.connectAttr((diffTexSwitch + '.outAlpha'),
                       (masterMat + '.opacityB'))

        pm.connectAttr((diffTexSwitch + '.outColor'), (proxyMat + '.color'))
        #pm.connectAttr((diffTexSwitch +'.outAlpha'), (proxyMat +'.transparencyR'))
        #pm.connectAttr((diffTexSwitch +'.outAlpha'), (proxyMat +'.transparencyG'))
        #pm.connectAttr((diffTexSwitch +'.outAlpha'), (proxyMat +'.transparencyB'))

        masterMatShadingGroup = pm.shadingNode('shadingEngine',
                                               name=(masterMat + '_SG'),
                                               asShader=True)
        #addMember
        pm.connectAttr((proxyMat + '.outColor'),
                       (masterMatShadingGroup + '.surfaceShader'))
        pm.connectAttr((masterMat + '.outColor'),
                       (masterMatShadingGroup + '.aiSurfaceShader'))
    else:
        masterMat = existAttrMat[0]
    for member in selected:
        pm.select(member)
        pm.hyperShade(member, assign=masterMat)

    pm.select(selected)
예제 #44
0
def rotations_load_to_maya(rotations, positions, names=None):
    """
    Load Rotations into Maya
    
    Loads a Quaternions array into the scene
    via the representation of axis
    
    Parameters
    ----------
    
    rotations : (F, J) Quaternions 
        array of rotations to load
        into the scene where
            F = number of frames
            J = number of joints
    
    positions : (F, J, 3) ndarray 
        array of positions to load
        rotation axis at where:
            F = number of frames
            J = number of joints
            
    names : [str]
        List of joint names
    
    Returns
    -------
    
    maxies : Group
        Grouped Maya Node of all Axis nodes
    """

    import pymel.core as pm

    if names is None:
        names = ["joint_" + str(i) for i in range(rotations.shape[1])]

    maxis = []
    frames = range(1, len(positions) + 1)
    for i, name in enumerate(names):
        name = name + "_axis"
        axis = pm.group(pm.curve(p=[(0, 0, 0), (1, 0, 0)],
                                 d=1,
                                 n=name + '_axis_x'),
                        pm.curve(p=[(0, 0, 0), (0, 1, 0)],
                                 d=1,
                                 n=name + '_axis_y'),
                        pm.curve(p=[(0, 0, 0), (0, 0, 1)],
                                 d=1,
                                 n=name + '_axis_z'),
                        n=name)

        axis.rotatePivot.set((0, 0, 0))
        axis.scalePivot.set((0, 0, 0))
        axis.childAtIndex(0).overrideEnabled.set(1)
        axis.childAtIndex(0).overrideColor.set(13)
        axis.childAtIndex(1).overrideEnabled.set(1)
        axis.childAtIndex(1).overrideColor.set(14)
        axis.childAtIndex(2).overrideEnabled.set(1)
        axis.childAtIndex(2).overrideColor.set(15)

        curvex = pm.nodetypes.AnimCurveTA(n=name + "_rotateX")
        curvey = pm.nodetypes.AnimCurveTA(n=name + "_rotateY")
        curvez = pm.nodetypes.AnimCurveTA(n=name + "_rotateZ")

        arotations = rotations[:, i].euler()
        curvex.addKeys(frames, arotations[:, 0])
        curvey.addKeys(frames, arotations[:, 1])
        curvez.addKeys(frames, arotations[:, 2])

        pm.connectAttr(curvex.output, axis.rotateX)
        pm.connectAttr(curvey.output, axis.rotateY)
        pm.connectAttr(curvez.output, axis.rotateZ)

        offsetx = pm.nodetypes.AnimCurveTU(n=name + "_translateX")
        offsety = pm.nodetypes.AnimCurveTU(n=name + "_translateY")
        offsetz = pm.nodetypes.AnimCurveTU(n=name + "_translateZ")

        offsetx.addKeys(frames, positions[:, i, 0])
        offsety.addKeys(frames, positions[:, i, 1])
        offsetz.addKeys(frames, positions[:, i, 2])

        pm.connectAttr(offsetx.output, axis.translateX)
        pm.connectAttr(offsety.output, axis.translateY)
        pm.connectAttr(offsetz.output, axis.translateZ)

        maxis.append(axis)

    return pm.group(*maxis, n='RotationAnimation')
예제 #45
0
        pm.connectAttr(ctrlAttrA,'%s.input1D[0]'%pmaNode,f=1)

    if scaleB:
        scaleB_node = pm.shadingNode('multiplyDivide',n='%s_ScaleB'%sumCtrl, asUtility=1)
        pm.setAttr('%s.input1X'%scaleB_node,scaleB)
        pm.connectAttr(ctrlAttrB,'%s.input2X'%scaleB_node,f=1)
        pm.connectAttr('%s.outputX'%scaleB_node,'%s.input1D[1]'%pmaNode,f=1)
    else:
        pm.connectAttr(ctrlAttrB,'%s.input1D[1]'%pmaNode,f=1)

    try:
        pm.addAttr(sumCtrl, ln=ctrlAttrResult.split('.')[1], k=1)
    except Exception, e:
        raise( e )

    pm.connectAttr('%s.output1D'%pmaNode, ctrlAttrResult, f=1)

sumCtrl = 'FaceGui'
cntrl = 'JawSyncDistLoc'
attrA = 'JawSyncDistA.distance'
attrB = 'JawSyncDistB.distance'
sumAttrName = 'JawSync_L_Wide_Sum'
sumAttr(sumCtrl=sumCtrl,
        ctrlAttrA='%s' % (attrA),
        ctrlAttrB='%s' % (attrB),
        ctrlAttrResult='%s.%s' % (sumCtrl, sumAttrName),
        scaleA=None, scaleB=None)

#------------------------------------
# Give BS's and controls, create attributes that drive each blendshape on control.
import pymel.core as pm
예제 #46
0
    def add_target(self, aNewParent, firstSetup=False):
        """
        Add a new target to the space switch system
        """
        iNbTgt = len(self.nSwConst.getWeightAliasList())
        aExistTgt = self.nSwConst.getTargetList()

        for nParent in aNewParent:
            #Ensure that the parent doesn't already exist in the drivers list
            if not nParent in aExistTgt:
                #First, calculate the offset between the parent and the driven node
                vTrans = self._get_tm_offset(nParent, type="t")
                vRot = self._get_tm_offset(nParent, type="r")

                #Connect the new target manually in the parent constraint
                if (iNbTgt == 0):
                    self.nSwConst.addAttr(nParent.name() + "W" + str(iNbTgt),
                                          at="double",
                                          min=0,
                                          max=1,
                                          dv=1,
                                          k=True,
                                          h=False)
                else:
                    self.nSwConst.addAttr(nParent.name() + "W" + str(iNbTgt),
                                          at="double",
                                          min=0,
                                          max=1,
                                          dv=0,
                                          k=True,
                                          h=False)

                pymel.connectAttr(
                    nParent.parentMatrix,
                    self.nSwConst.target[iNbTgt].targetParentMatrix)
                pymel.connectAttr(nParent.scale,
                                  self.nSwConst.target[iNbTgt].targetScale)
                pymel.connectAttr(
                    nParent.rotateOrder,
                    self.nSwConst.target[iNbTgt].targetRotateOrder)
                pymel.connectAttr(nParent.rotate,
                                  self.nSwConst.target[iNbTgt].targetRotate)
                pymel.connectAttr(
                    nParent.rotatePivotTranslate,
                    self.nSwConst.target[iNbTgt].targetRotateTranslate)
                pymel.connectAttr(
                    nParent.rotatePivot,
                    self.nSwConst.target[iNbTgt].targetRotatePivot)
                pymel.connectAttr(nParent.translate,
                                  self.nSwConst.target[iNbTgt].targetTranslate)
                #Link the created attributes to the weight value of the target
                nConstTgtWeight = pymel.Attribute(self.nSwConst.name() + "." +
                                                  nParent.name() + "W" +
                                                  str(iNbTgt))
                pymel.connectAttr(nConstTgtWeight,
                                  self.nSwConst.target[iNbTgt].targetWeight)

                #Set the offset information
                self.nSwConst.target[
                    iNbTgt].targetOffsetTranslate.targetOffsetTranslateX.set(
                        vTrans[0])
                self.nSwConst.target[
                    iNbTgt].targetOffsetTranslate.targetOffsetTranslateY.set(
                        vTrans[1])
                self.nSwConst.target[
                    iNbTgt].targetOffsetTranslate.targetOffsetTranslateZ.set(
                        vTrans[2])
                self.nSwConst.target[
                    iNbTgt].targetOffsetRotate.targetOffsetRotateX.set(vRot[0])
                self.nSwConst.target[
                    iNbTgt].targetOffsetRotate.targetOffsetRotateY.set(vRot[1])
                self.nSwConst.target[
                    iNbTgt].targetOffsetRotate.targetOffsetRotateZ.set(vRot[2])

                pymel.setKeyframe(nConstTgtWeight, t=0, ott="step")
                pymel.setKeyframe(
                    self.nSwConst.target[iNbTgt].targetOffsetTranslate,
                    t=0,
                    ott="step")
                pymel.setKeyframe(
                    self.nSwConst.target[iNbTgt].targetOffsetRotate,
                    t=0,
                    ott="step")
                self.aDrivers.append(nParent)
                self.aDriversSubName.append(nParent.name())
                iNbTgt += 1
            else:
                print("Warning: " + nParent.name() +
                      " is already a driver for " + self.nDriven)
예제 #47
0
    def addOperators(self):
        """Create operators and set the relations for the component rig

        Apply operators, constraints, expressions to the hierarchy.
        In order to keep the code clean and easier to debug,
        we shouldn't create any new object in this method.

        """
        dm_node_scl = node.createDecomposeMatrixNode(self.root.worldMatrix)
        if self.settings["keepLength"]:
            arclen_node = pm.arclen(self.mst_crv, ch=True)
            alAttr = pm.getAttr(arclen_node + ".arcLength")

            pm.addAttr(self.mst_crv, ln="length_ratio", k=True, w=True)
            node.createDivNode(arclen_node.arcLength, alAttr,
                               self.mst_crv.length_ratio)

            div_node_scl = node.createDivNode(self.mst_crv.length_ratio,
                                              dm_node_scl.outputScaleX)

        step = 1.000 / (self.def_number - 1)
        u = 0.000
        for i in range(self.def_number):
            cnsUpv = applyop.pathCns(self.upv_cns[i],
                                     self.upv_crv,
                                     cnsType=False,
                                     u=u,
                                     tangent=False)

            cns = applyop.pathCns(self.div_cns[i], self.mst_crv, False, u,
                                  True)

            # Connectiong the scale for scaling compensation
            for axis, AX in zip("xyz", "XYZ"):
                pm.connectAttr(dm_node_scl.attr("outputScale{}".format(AX)),
                               self.div_cns[i].attr("s{}".format(axis)))

            if self.settings["keepLength"]:

                div_node2 = node.createDivNode(u, div_node_scl.outputX)

                cond_node = node.createConditionNode(div_node2.input1X,
                                                     div_node2.outputX, 4,
                                                     div_node2.input1X,
                                                     div_node2.outputX)

                pm.connectAttr(cond_node + ".outColorR", cnsUpv + ".uValue")
                pm.connectAttr(cond_node + ".outColorR", cns + ".uValue")

            cns.setAttr("worldUpType", 1)
            cns.setAttr("frontAxis", 0)
            cns.setAttr("upAxis", 1)

            pm.connectAttr(self.upv_cns[i].attr("worldMatrix[0]"),
                           cns.attr("worldUpMatrix"))
            u += step

        if self.settings["keepLength"]:
            # add the safty distance offset
            self.tweakTip_npo.attr("tx").set(self.off_dist)
            # connect vis line ref
            for shp in self.line_ref.getShapes():
                pm.connectAttr(self.ikVis_att, shp.attr("visibility"))

        for ctl in self.tweak_ctl:
            for shp in ctl.getShapes():
                pm.connectAttr(self.ikVis_att, shp.attr("visibility"))
        for ctl in self.fk_ctl:
            for shp in ctl.getShapes():
                pm.connectAttr(self.fkVis_att, shp.attr("visibility"))
예제 #48
0
def sumAttr(sumCtrl=None,
            ctrlAttrA=None, ctrlAttrB=None,
            ctrlAttrResult=None,
            scaleA=None, scaleB=None):

    pmaNode = pm.shadingNode('plusMinusAverage',n='%s_Sum'%sumCtrl, asUtility=1)
    if scaleA:
        scaleA_node = pm.shadingNode('multiplyDivide',n='%s_ScaleA'%sumCtrl, asUtility=1)
        pm.setAttr('%s.input1X'%scaleA_node,scaleA)
        pm.connectAttr(ctrlAttrA,'%s.input2X'%scaleA_node,f=1)
        pm.connectAttr('%s.outputX'%scaleA_node,'%s.input1D[0]'%pmaNode,f=1)
    else:
        pm.connectAttr(ctrlAttrA,'%s.input1D[0]'%pmaNode,f=1)

    if scaleB:
        scaleB_node = pm.shadingNode('multiplyDivide',n='%s_ScaleB'%sumCtrl, asUtility=1)
        pm.setAttr('%s.input1X'%scaleB_node,scaleB)
        pm.connectAttr(ctrlAttrB,'%s.input2X'%scaleB_node,f=1)
        pm.connectAttr('%s.outputX'%scaleB_node,'%s.input1D[1]'%pmaNode,f=1)
    else:
        pm.connectAttr(ctrlAttrB,'%s.input1D[1]'%pmaNode,f=1)

    try:
        pm.addAttr(sumCtrl, ln=ctrlAttrResult.split('.')[1], k=1)
    except Exception, e:
        raise( e )
예제 #49
0
    def addOperators(self):

        if self.settings["ikSolver"]:
            self.ikSolver = "ikRPsolver"
        else:
            pm.mel.eval("ikSpringSolver;")
            self.ikSolver = "ikSpringSolver"

        # 1 bone chain Upv ref =====================================================================================
        self.ikHandleUpvRef = pri.addIkHandle(self.root, self.getName("ikHandleLegChainUpvRef"), self.legChainUpvRef, "ikSCsolver")
        pm.pointConstraint(self.ik_ctl, self.ikHandleUpvRef)
        pm.parentConstraint( self.legChainUpvRef[0], self.upv_cns, mo=True)

        # mid joints =====================================================================================
        for xjnt, midJ in zip(self.legBones[1:3], [self.mid1_jnt, self.mid2_jnt]):
            nod.createPairBlend(None, xjnt, .5, 1, midJ)
            pm.connectAttr(xjnt+".translate", midJ+".translate", f=True)
            
        pm.parentConstraint(self.mid1_jnt, self.knee_lvl)
        pm.parentConstraint(self.mid2_jnt, self.ankle_lvl)

        #joint length multiply
        multJnt1_node = nod.createMulNode(self.boneALenght_attr, self.boneALenghtMult_attr)
        multJnt2_node = nod.createMulNode(self.boneBLenght_attr, self.boneBLenghtMult_attr)
        multJnt3_node = nod.createMulNode(self.boneCLenght_attr, self.boneCLenghtMult_attr)

        # # IK 3 bones ======================================================================================================
        
        self.ikHandle = pri.addIkHandle(self.softblendLoc, self.getName("ik3BonesHandle"), self.chain3bones, self.ikSolver, self.upv_ctl)
        
        # TwistTest
        if [round(elem, 4) for elem in tra.getTranslation(self.chain3bones[1])] != [round(elem, 4) for elem in  self.guide.apos[1]]:
            add_nodeTwist = nod.createAddNode(180.0, self.roll_att)
            pm.connectAttr(add_nodeTwist+".output", self.ikHandle.attr("twist"))
        else:
            pm.connectAttr(self.roll_att, self.ikHandle.attr("twist"))
        
        # stable spring solver doble rotation 
        pm.pointConstraint(self.root_ctl, self.chain3bones[0])

        # softIK 3 bones operators
        aop.aimCns(self.aim_tra, self.ik_ref, axis="zx", wupType=4, wupVector=[1,0,0], wupObject=self.root_ctl, maintainOffset=False)

        plusTotalLength_node = nod.createPlusMinusAverage1D([multJnt1_node.attr("outputX"), multJnt2_node.attr("outputX"), multJnt3_node.attr("outputX")])
        subtract1_node = nod.createPlusMinusAverage1D([plusTotalLength_node.attr("output1D"), self.soft_attr],2)

        distance1_node = nod.createDistNode(self.ik_ref, self.aim_tra)
        div1_node = nod.createDivNode(1.0, self.rig.global_ctl+".sx")      
        mult1_node = nod.createMulNode(distance1_node+".distance", div1_node+".outputX")
        subtract2_node = nod.createPlusMinusAverage1D([mult1_node.attr("outputX"), subtract1_node.attr("output1D")],2)
        div2_node = nod.createDivNode(subtract2_node+".output1D", self.soft_attr)
        mult2_node = nod.createMulNode(-1, div2_node+".outputX")
        power_node = nod.createPowNode( self.softSpeed_attr, mult2_node+".outputX")
        mult3_node = nod.createMulNode(self.soft_attr, power_node+".outputX")
        subtract3_node = nod.createPlusMinusAverage1D([plusTotalLength_node.attr("output1D"), mult3_node.attr("outputX")],2)

        cond1_node = nod.createConditionNode(self.soft_attr, 0, 2,subtract3_node+".output1D", plusTotalLength_node+".output1D")
        cond2_node = nod.createConditionNode(mult1_node+".outputX", subtract1_node+".output1D", 2,cond1_node+".outColorR", mult1_node+".outputX")

        pm.connectAttr(cond2_node+".outColorR", self.wristSoftIK+".tz")

        #soft blend
        pc_node = pm.pointConstraint( self.wristSoftIK, self.ik_ref, self.softblendLoc)
        nod.createReverseNode(self.stretch_attr, pc_node+".target[0].targetWeight")
        pm.connectAttr(self.stretch_attr, pc_node+".target[1].targetWeight", f=True)

        #Stretch
        distance2_node = nod.createDistNode(self.softblendLoc, self.wristSoftIK)
        mult4_node = nod.createMulNode(distance2_node+".distance", div1_node+".outputX")
     
        #bones
        for i, mulNode in enumerate([multJnt1_node, multJnt2_node, multJnt3_node]):
            div3_node = nod.createDivNode(mulNode+".outputX", plusTotalLength_node+".output1D")
            mult5_node = nod.createMulNode(mult4_node+".outputX", div3_node+".outputX")
            mult6_node = nod.createMulNode(self.stretch_attr, mult5_node+".outputX")
            plus1_node = nod.createPlusMinusAverage1D([mulNode.attr("outputX"), mult6_node.attr("outputX")],1, self.chain3bones[i+1]+".tx")



        # IK 2 bones ======================================================================================================

        self.ikHandle2 = pri.addIkHandle(self.softblendLoc2, self.getName("ik2BonesHandle"), self.chain2bones, self.ikSolver, self.upv_ctl)
        pm.connectAttr(self.roll_att, self.ikHandle2.attr("twist"))

        # stable spring solver doble rotation 
        pm.pointConstraint(self.root_ctl, self.chain2bones[0])
 
        parentc_node = pm.parentConstraint( self.ik2b_ikCtl_ref, self.ik2b_bone_ref, self.ik2b_blend)
        reverse_node = nod.createReverseNode(self.fullIK_attr,  parentc_node+".target[0].targetWeight")
        pm.connectAttr(self.fullIK_attr, parentc_node+".target[1].targetWeight", f=True)

        # softIK 2 bones operators
        aop.aimCns(self.aim_tra2, self.ik2b_ik_ref, axis="zx", wupType=4, wupVector=[1,0,0], wupObject=self.root_ctl, maintainOffset=False)

        plusTotalLength_node = nod.createPlusMinusAverage1D([multJnt1_node.attr("outputX"), multJnt2_node.attr("outputX")])
        subtract1_node = nod.createPlusMinusAverage1D([plusTotalLength_node.attr("output1D"), self.soft_attr], 2)
        distance1_node = nod.createDistNode(self.ik2b_ik_ref, self.aim_tra2)
        div1_node = nod.createDivNode(1, self.rig.global_ctl+".sx")

        mult1_node = nod.createMulNode(distance1_node+".distance", div1_node+".outputX")
        subtract2_node = nod.createPlusMinusAverage1D([mult1_node.attr("outputX"), subtract1_node.attr("output1D")], 2)
        div2_node =  nod.createDivNode(subtract2_node+".output1D", self.soft_attr)
        mult2_node = nod.createMulNode(-1, div2_node+".outputX")
        power_node = nod.createPowNode(self.softSpeed_attr, mult2_node+".outputX")
        mult3_node = nod.createMulNode(self.soft_attr, power_node+".outputX" )
        subtract3_node = nod.createPlusMinusAverage1D([plusTotalLength_node.attr("output1D"),mult3_node.attr("outputX")], 2)

        cond1_node = nod.createConditionNode(self.soft_attr, 0, 2,subtract3_node+".output1D", plusTotalLength_node+".output1D")
        cond2_node = nod.createConditionNode(mult1_node+".outputX", subtract1_node+".output1D", 2,cond1_node+".outColorR", mult1_node+".outputX")

        pm.connectAttr(cond2_node+".outColorR", self.ankleSoftIK+".tz")

        #soft blend
        pc_node = pm.pointConstraint( self.ankleSoftIK, self.ik2b_ik_ref, self.softblendLoc2)
        nod.createReverseNode(self.stretch_attr, pc_node+".target[0].targetWeight")
        pm.connectAttr(self.stretch_attr, pc_node+".target[1].targetWeight", f=True)

        #Stretch
        distance2_node = nod.createDistNode(self.softblendLoc2, self.ankleSoftIK)
        mult4_node = nod.createMulNode(distance2_node+".distance", div1_node+".outputX")


        for i, mulNode in enumerate([multJnt1_node, multJnt2_node]):
            div3_node = nod.createDivNode(mulNode+".outputX", plusTotalLength_node+".output1D")
            mult5_node = nod.createMulNode(mult4_node+".outputX", div3_node+".outputX")
            mult6_node = nod.createMulNode(self.stretch_attr, mult5_node+".outputX")
            plus1_node = nod.createPlusMinusAverage1D([mulNode.attr("outputX"), mult6_node.attr("outputX")],1, self.chain2bones[i+1]+".tx")



        ###  IK/FK connections 

        for i, x in enumerate(self.fk_ctl):
            pm.parentConstraint( x, self.legBonesFK[i], mo=True)

        for i, x in enumerate([self.chain2bones[0],self.chain2bones[1]] ):
            pm.parentConstraint( x, self.legBonesIK[i], mo=True)

        pm.pointConstraint(self.ik2b_ik_ref, self.legBonesIK[2])
        aop.aimCns(self.legBonesIK[2], self.roll_ctl, axis="xy", wupType=4, wupVector=[0,1,0], wupObject=self.legBonesIK[1], maintainOffset=False)
        pm.connectAttr( self.chain3bones[-1].attr("tx"), self.legBonesIK[-1].attr("tx"))
        # foot twist roll
        pm.orientConstraint(self.ik_ref, self.legBonesIK[-1], mo=True)

        multInvert_node = nod.createMulNode(-1, self.chain3bones[-1].attr("tx"), self.ik2b_ik_ref.attr("tx"))

        for i, x in enumerate(self.legBones):
            blend_node = nod.createPairBlend(self.legBonesFK[i], self.legBonesIK[i], self.blend_att, 1, x)


        # Twist references ----------------------------------------

        self.ikhArmRef, self.tmpCrv = aop.splineIK(self.getName("legRollRef"), self.rollRef, parent=self.root, cParent=self.legBones[0] )

        if self.negate:
            initRound = -.001
            multVal = -1
        else:
            initRound = .001
            multVal = 1

        multTangent_node = nod.createMulNode(self.roundnessKnee_att, multVal)
        add_node = nod.createAddNode(multTangent_node+".outputX", initRound)
        pm.connectAttr(add_node+".output", self.tws1_rot.attr("sx"))
        for x in ["translate", "rotate"]:
            pm.connectAttr(self.knee_ctl.attr(x), self.tws1_loc.attr(x))

        multTangent_node = nod.createMulNode(self.roundnessAnkle_att, multVal)
        add_node = nod.createAddNode(multTangent_node+".outputX", initRound)
        pm.connectAttr(add_node+".output", self.tws2_rot.attr("sx"))
        # for x in ["translate"]:
        for x in ["translate", "rotate"]:
            pm.connectAttr(self.ankle_ctl.attr(x), self.tws2_loc.attr(x))


        # Volume -------------------------------------------
        distA_node = nod.createDistNode(self.tws0_loc, self.tws1_loc)
        distB_node = nod.createDistNode(self.tws1_loc, self.tws2_loc)
        distC_node = nod.createDistNode(self.tws2_loc, self.tws3_loc)
        add_node = nod.createAddNode(distA_node+".distance", distB_node+".distance")
        add_node2 = nod.createAddNode(distC_node+".distance", add_node+".output")
        div_node = nod.createDivNode(add_node2+".output", self.root_ctl.attr("sx"))

        #comp scaling
        dm_node = nod.createDecomposeMatrixNode(self.root.attr("worldMatrix"))

        div_node2 = nod.createDivNode(div_node+".outputX", dm_node+".outputScaleX")


        self.volDriver_att = div_node2+".outputX"

        # Flip Offset ----------------------------------------
        pm.connectAttr(self.ankleFlipOffset_att, self.tws2_loc.attr("rz"))
        pm.connectAttr(self.kneeFlipOffset_att, self.tws1_loc.attr("rz"))
        # Divisions ----------------------------------------        
        # at 0 or 1 the division will follow exactly the rotation of the controler.. and we wont have this nice tangent + roll
        for i, div_cns in enumerate(self.div_cns):
            subdiv = False
            if i == len(self.div_cns)-1 or i == 0:
                subdiv = 45
            else:
                subdiv = 45

            if i < (self.settings["div0"]+1):
                perc = i*.333 / (self.settings["div0"]+1.0)

            elif i < (self.settings["div0"] + self.settings["div1"]+2):
                perc = i*.333 / (self.settings["div0"]+1.0)
            else:
                perc = .5 + (i-self.settings["div0"]-3.0)*.5 / (self.settings["div1"]+1.0)

            if i < (self.settings["div0"]+2):        
                perc = i*.333 / (self.settings["div0"]+1.0)

            elif i < (self.settings["div0"] + self.settings["div1"]+3):
                perc = .333 + (i-self.settings["div0"]-1)*.333 / (self.settings["div1"]+1.0)
            else:
                perc = .666 + (i-self.settings["div1"]-self.settings["div0"]-2.0)*.333 / (self.settings["div2"]+1.0)

            # we neet to offset the ankle and knee point to force the bone orientation to the nex bone span
            if perc == .333:
                perc = .3338
            elif perc == .666:
                perc = .6669

            perc = max(.001, min(.999, perc))

            # Roll
            if self.negate:
                node = aop.gear_rollsplinekine_op(div_cns, [self.tws3_rot, self.tws2_rot, self.tws1_rot, self.tws0_rot], 1-perc, subdiv)
            else:
                node = aop.gear_rollsplinekine_op(div_cns, [self.tws0_rot, self.tws1_rot, self.tws2_rot, self.tws3_rot], perc, subdiv)

            pm.connectAttr(self.resample_att, node+".resample")
            pm.connectAttr(self.absolute_att, node+".absolute")

            # Squash n Stretch
            node = aop.gear_squashstretch2_op(div_cns, None, pm.getAttr(self.volDriver_att), "x")
            pm.connectAttr(self.volume_att, node+".blend")
            pm.connectAttr(self.volDriver_att, node+".driver")
            pm.connectAttr(self.st_att[i], node+".stretch")
            pm.connectAttr(self.sq_att[i], node+".squash")


        # Visibilities -------------------------------------
        # fk
        fkvis_node = nod.createReverseNode(self.blend_att)
        for ctrl in self.fk_ctl:
            for shp in ctrl.getShapes():
                pm.connectAttr(fkvis_node+".outputX", shp.attr("visibility"))
        # ik
        for ctrl in [self.ik_ctl, self.roll_ctl]:
            for shp in ctrl.getShapes():
                pm.connectAttr(self.blend_att, shp.attr("visibility"))

        # setup leg node scale compensate
        pm.connectAttr(self.rig.global_ctl+".scale", self.setup+".scale")


        return
예제 #50
0
파일: util.py 프로젝트: Aiacos/DevPyLib
def matrixConstrain(driver,
                    driven,
                    parent=None,
                    translate=True,
                    rotate=True,
                    scale=False):
    driver = pm.ls(driver)[0]
    driven = pm.ls(driven)[0]

    if not parent:
        parent = driven.getParent()

    mulMatrix = pm.shadingNode('multMatrix', asUtility=True)
    decomposeMatrix = pm.shadingNode('decomposeMatrix', asUtility=True)

    pm.connectAttr(mulMatrix.matrixSum, decomposeMatrix.inputMatrix)
    pm.connectAttr(driver.worldMatrix[0], mulMatrix.matrixIn[0])
    pm.connectAttr(parent.worldInverseMatrix[0], mulMatrix.matrixIn[1])

    if translate:
        pm.connectAttr(decomposeMatrix.outputTranslate, driven.translate)
    if rotate:
        pm.connectAttr(decomposeMatrix.outputRotate, driven.rotate)
    if scale:
        pm.connectAttr(decomposeMatrix.outputScale, driven.scale)
예제 #51
0
파일: curve.py 프로젝트: theomission/anima
 def curveInfo(self, infoNode):
     self._curveInfo = infoNode
     pm.connectAttr(self.curveNode.worldSpace, infoNode.inputCurve)
예제 #52
0
    def rig_joints_base(self):
        total_distance = self.bone_chain_lenght()
        self._model.start_point = pm.spaceLocator(
            name="StretchyIkHandleStartPoint")
        self.name_convention.rename_name_in_format(self.start_point,
                                                   useName=True)
        self._model.end_point = pm.spaceLocator(
            name="StretchyIkHandleEndPoint")
        self.name_convention.rename_name_in_format(self.end_point,
                                                   useName=True)
        self.start_point.setParent(self.rig_system.kinematics)
        self.end_point.setParent(self.rig_system.kinematics)

        if self.reset_joints:
            pm.parent(self.start_point, self.reset_joints)
            pm.parent(self.end_point, self.reset_joints)

        pm.pointConstraint(self.joints[0], self.start_point)
        pm.pointConstraint(self.ik_handle, self.end_point)

        distance_node = pm.shadingNode(
            "distanceBetween",
            asUtility=True,
            name="IKDistance" +
            self.name_convention.get_a_short_name(self.joints[-1]))
        self.name_convention.rename_based_on_base_name(self.joints[2],
                                                       distance_node,
                                                       name=distance_node)

        pm.connectAttr(self.start_point.worldPosition[0],
                       distance_node.point1,
                       f=True)
        pm.connectAttr(self.end_point.worldPosition[0],
                       distance_node.point2,
                       f=True)

        condition_node = pm.shadingNode(
            "condition",
            asUtility=True,
            name="IkCondition" +
            self.name_convention.get_a_short_name(self.joints[2]))
        condition_node = self.name_convention.rename_based_on_base_name(
            self.joints[2], condition_node, name=condition_node)
        pm.connectAttr(distance_node + ".distance",
                       condition_node + ".colorIfFalseR",
                       f=True)
        pm.connectAttr(distance_node + ".distance",
                       condition_node + ".secondTerm",
                       f=True)
        pm.setAttr(condition_node + ".operation", 3)
        pm.setAttr(condition_node + ".firstTerm", total_distance)
        pm.setAttr(condition_node + ".colorIfTrueR", total_distance)
        multiply_divide = pm.shadingNode(
            "multiplyDivide",
            asUtility=True,
            name="IKStretchMultiply" +
            self.name_convention.get_a_short_name(self.joints[2]))
        self.name_convention.rename_based_on_base_name(self.joints[2],
                                                       multiply_divide,
                                                       name=multiply_divide)

        pm.connectAttr(condition_node + ".outColorR",
                       multiply_divide + ".input1X",
                       f=True)
        pm.setAttr(multiply_divide + ".input2X", total_distance)
        pm.setAttr(multiply_divide + ".operation", 2)

        # self.rig_space_switch.AddNumericParameter(self.controls_dict['ikHandle'], Name="StretchyIK")
        pm.addAttr(self.ik_handle,
                   ln="stretchyIK",
                   at='float',
                   min=0,
                   max=10,
                   k=True)
        ik_switch_divide = pm.shadingNode(
            "multiplyDivide",
            asUtility=True,
            name="IkSwitchDivide" +
            self.name_convention.get_a_short_name(self.joints[2]))
        self.name_convention.rename_based_on_base_name(self.joints[2],
                                                       ik_switch_divide,
                                                       name=ik_switch_divide)
        pm.connectAttr("%s.stretchyIK" % self.ik_handle,
                       ik_switch_divide + ".input1X")
        pm.setAttr(ik_switch_divide + ".input2X", 10)
        pm.setAttr(ik_switch_divide + ".operation", 2)

        ik_switchblend_two_attr = pm.shadingNode(
            "blendTwoAttr",
            asUtility=True,
            name="IkSwitchBlendTwoAttr{}".format(
                self.name_convention.get_a_short_name(self.joints[2])))
        self.name_convention.rename_based_on_base_name(
            self.joints[2],
            ik_switchblend_two_attr,
            name=ik_switchblend_two_attr)

        pm.connectAttr(multiply_divide.outputX,
                       ik_switchblend_two_attr.input[1],
                       force=True)
        ik_switchblend_two_attr.input[0].set(1)
        pm.connectAttr(ik_switch_divide.outputX,
                       ik_switchblend_two_attr.attributesBlender,
                       force=True)

        for joints in self.joints[:-1]:
            pm.connectAttr(ik_switchblend_two_attr.output,
                           '{}.scaleX'.format(joints))
예제 #53
0
    def addOperators(self):
        """Create operators and set the relations for the component rig

        Apply operators, constraints, expressions to the hierarchy.
        In order to keep the code clean and easier to debug,
        we shouldn't create any new object in this method.

        """
        # 1 bone chain Upv ref ==============================================
        self.ikHandleUpvRef = primitive.addIkHandle(
            self.root,
            self.getName("ikHandleArmChainUpvRef"),
            self.armChainUpvRef,
            "ikSCsolver",
        )
        pm.pointConstraint(self.ik_ctl, self.ikHandleUpvRef)
        p_cns = pm.parentConstraint(self.armChainUpvRef[0],
                                    self.upv_cns,
                                    mo=True)
        p_cns.interpType.set(0)

        # Visibilities -------------------------------------
        # fk
        fkvis_node = node.createReverseNode(self.blend_att)
        try:
            for shp in self.fk0_ctl.getShapes():
                pm.connectAttr(fkvis_node.outputX, shp.attr("visibility"))
            for shp in self.fk1_ctl.getShapes():
                pm.connectAttr(fkvis_node.outputX, shp.attr("visibility"))
            for shp in self.fk2_ctl.getShapes():
                pm.connectAttr(fkvis_node.outputX, shp.attr("visibility"))
        except RuntimeError:
            pm.displayInfo("Visibility already connected")

        # ik
        for shp in self.upv_ctl.getShapes():
            pm.connectAttr(self.blend_att, shp.attr("visibility"))
        for shp in self.ikcns_ctl.getShapes():
            pm.connectAttr(self.blend_att, shp.attr("visibility"))
        for shp in self.ik_ctl.getShapes():
            pm.connectAttr(self.blend_att, shp.attr("visibility"))
        for shp in self.line_ref.getShapes():
            pm.connectAttr(self.blend_att, shp.attr("visibility"))
        if self.settings["ikTR"]:
            for shp in self.ikRot_ctl.getShapes():
                pm.connectAttr(self.blend_att, shp.attr("visibility"))
        for shp in self.roll_ctl.getShapes():
            pm.connectAttr(self.blend_att, shp.attr("visibility"))

        # Controls ROT order -----------------------------------
        attribute.setRotOrder(self.fk0_ctl, "XZY")
        attribute.setRotOrder(self.fk1_ctl, "XYZ")
        attribute.setRotOrder(self.fk2_ctl, "YZX")
        attribute.setRotOrder(self.ik_ctl, "XYZ")

        # IK Solver -----------------------------------------
        out = [self.bone0, self.bone1, self.ctrn_loc, self.eff_loc]
        o_node = applyop.gear_ikfk2bone_op(
            out,
            self.root,
            self.ik_ref,
            self.upv_ctl,
            self.fk_ctl[0],
            self.fk_ctl[1],
            self.fk_ref,
            self.length0,
            self.length1,
            self.negate,
        )

        # NOTE: Ideally we should not change hierarchy or move object after
        # object generation method. But is much easier this way since every
        # part is in the final and correct position
        # after the  ctrn_loc is in the correct position with the ikfk2bone op

        # point constrain tip reference
        pm.pointConstraint(self.ik_ctl, self.tip_ref, mo=False)

        # interpolate transform  mid point locator
        int_matrix = applyop.gear_intmatrix_op(
            self.armChainUpvRef[0].attr("worldMatrix"),
            self.tip_ref.attr("worldMatrix"),
            0.5,
        )
        applyop.gear_mulmatrix_op(
            int_matrix.attr("output"),
            self.interpolate_lvl.attr("parentInverseMatrix[0]"),
            self.interpolate_lvl,
        )

        # match roll ctl npo to ctrn_loc current transform (so correct orient)
        transform.matchWorldTransform(self.ctrn_loc, self.roll_ctl_npo)

        # match roll ctl npo to interpolate transform current position
        pos = self.interpolate_lvl.getTranslation(space="world")
        self.roll_ctl_npo.setTranslation(pos, space="world")

        # parent constraint roll control npo to interpolate trans
        pm.parentConstraint(self.interpolate_lvl, self.roll_ctl_npo, mo=True)

        if self.settings["ikTR"]:
            # connect the control inputs
            outEff_dm = o_node.listConnections(c=True)[-1][1]

            inAttr = self.ikRot_npo.attr("translate")
            outEff_dm.attr("outputTranslate") >> inAttr

            outEff_dm.attr("outputScale") >> self.ikRot_npo.attr("scale")
            dm_node = node.createDecomposeMatrixNode(o_node.attr("outB"))
            dm_node.attr("outputRotate") >> self.ikRot_npo.attr("rotate")

            # rotation
            mulM_node = applyop.gear_mulmatrix_op(
                self.ikRot_ctl.attr("worldMatrix"),
                self.eff_loc.attr("parentInverseMatrix"),
            )
            intM_node = applyop.gear_intmatrix_op(
                o_node.attr("outEff"),
                mulM_node.attr("output"),
                o_node.attr("blend"),
            )
            dm_node = node.createDecomposeMatrixNode(intM_node.attr("output"))
            dm_node.attr("outputRotate") >> self.eff_loc.attr("rotate")
            transform.matchWorldTransform(self.fk2_ctl, self.ikRot_cns)

        # scale: this fix the scalin popping issue
        intM_node = applyop.gear_intmatrix_op(
            self.fk2_ctl.attr("worldMatrix"),
            self.ik_ctl_ref.attr("worldMatrix"),
            o_node.attr("blend"),
        )
        mulM_node = applyop.gear_mulmatrix_op(
            intM_node.attr("output"), self.eff_loc.attr("parentInverseMatrix"))
        dm_node = node.createDecomposeMatrixNode(mulM_node.attr("output"))
        dm_node.attr("outputScale") >> self.eff_loc.attr("scale")

        pm.connectAttr(self.blend_att, o_node + ".blend")
        if self.negate:
            mulVal = -1
            rollMulVal = 1
        else:
            mulVal = 1
            rollMulVal = -1
        roll_m_node = node.createMulNode(self.roll_att, mulVal)
        roll_m_node2 = node.createMulNode(self.roll_ctl.attr("rx"), rollMulVal)
        node.createPlusMinusAverage1D(
            [roll_m_node.outputX, roll_m_node2.outputX],
            operation=1,
            output=o_node + ".roll",
        )
        pm.connectAttr(self.scale_att, o_node + ".scaleA")
        pm.connectAttr(self.scale_att, o_node + ".scaleB")
        pm.connectAttr(self.maxstretch_att, o_node + ".maxstretch")
        pm.connectAttr(self.slide_att, o_node + ".slide")
        pm.connectAttr(self.softness_att, o_node + ".softness")
        pm.connectAttr(self.reverse_att, o_node + ".reverse")

        # Twist references ---------------------------------

        pm.pointConstraint(self.mid_ctl_twst_ref,
                           self.tws1_npo,
                           maintainOffset=False)
        pm.connectAttr(self.mid_ctl.scaleX, self.tws1_loc.scaleX)
        pm.orientConstraint(self.mid_ctl_twst_ref,
                            self.tws1_npo,
                            maintainOffset=False)

        o_node = applyop.gear_mulmatrix_op(
            self.eff_loc.attr("worldMatrix"),
            self.root.attr("worldInverseMatrix"),
        )
        dm_node = pm.createNode("decomposeMatrix")
        pm.connectAttr(o_node + ".output", dm_node + ".inputMatrix")
        pm.connectAttr(dm_node + ".outputTranslate",
                       self.tws2_npo.attr("translate"))

        dm_node = pm.createNode("decomposeMatrix")
        pm.connectAttr(o_node + ".output", dm_node + ".inputMatrix")
        pm.connectAttr(dm_node + ".outputRotate", self.tws2_npo.attr("rotate"))

        o_node = applyop.gear_mulmatrix_op(
            self.eff_loc.attr("worldMatrix"),
            self.tws2_rot.attr("parentInverseMatrix"),
        )
        dm_node = pm.createNode("decomposeMatrix")
        pm.connectAttr(o_node + ".output", dm_node + ".inputMatrix")
        attribute.setRotOrder(self.tws2_rot, "XYZ")
        pm.connectAttr(dm_node + ".outputRotate", self.tws2_rot + ".rotate")

        if self.settings["div0"]:
            ori_ref = self.rollRef[0]
        else:
            ori_ref = self.bone0

        applyop.oriCns(ori_ref, self.tws0_loc, maintainOffset=True)

        self.tws0_rot.setAttr("sx", 0.001)
        self.tws2_rot.setAttr("sx", 0.001)

        add_node = node.createAddNode(self.roundness_att, 0.0)
        pm.connectAttr(add_node + ".output", self.tws1_rot.attr("sx"))

        pm.connectAttr(self.armpit_roll_att, self.tws0_rot + ".rotateX")

        # Roll Shoulder
        applyop.splineIK(
            self.getName("rollRef"),
            self.rollRef,
            parent=self.root,
            cParent=self.bone0,
        )

        # Volume -------------------------------------------
        distA_node = node.createDistNode(self.tws0_loc, self.tws1_loc)
        distB_node = node.createDistNode(self.tws1_loc, self.tws2_loc)
        add_node = node.createAddNode(distA_node + ".distance",
                                      distB_node + ".distance")
        div_node = node.createDivNode(add_node + ".output",
                                      self.root.attr("sx"))

        dm_node = pm.createNode("decomposeMatrix")
        pm.connectAttr(self.root.attr("worldMatrix"), dm_node + ".inputMatrix")

        div_node2 = node.createDivNode(div_node + ".outputX",
                                       dm_node + ".outputScaleX")
        self.volDriver_att = div_node2 + ".outputX"

        if self.settings["extraTweak"]:
            for tweak_ctl in self.tweak_ctl:
                for shp in tweak_ctl.getShapes():
                    pm.connectAttr(self.tweakVis_att, shp.attr("visibility"))

        # Divisions ----------------------------------------
        # at 0 or 1 the division will follow exactly the rotation of the
        # controler.. and we wont have this nice tangent + roll
        for i, div_cns in enumerate(self.div_cns):

            if i < (self.settings["div0"] + 1):
                perc = i * 0.5 / (self.settings["div0"] + 1.0)
            elif i < (self.settings["div0"] + 2):
                perc = 0.501
            else:
                perc = 0.5 + (i - self.settings["div0"] -
                              1.0) * 0.5 / (self.settings["div1"] + 1.0)

            perc = max(0.001, min(0.999, perc))

            # Roll
            if self.negate:
                o_node = applyop.gear_rollsplinekine_op(
                    div_cns,
                    [self.tws2_rot, self.tws1_rot, self.tws0_rot],
                    1.0 - perc,
                    40,
                )
            else:
                o_node = applyop.gear_rollsplinekine_op(
                    div_cns,
                    [self.tws0_rot, self.tws1_rot, self.tws2_rot],
                    perc,
                    40,
                )

            pm.connectAttr(self.resample_att, o_node + ".resample")
            pm.connectAttr(self.absolute_att, o_node + ".absolute")

            # Squash n Stretch
            o_node = applyop.gear_squashstretch2_op(
                div_cns, None, pm.getAttr(self.volDriver_att), "x")
            pm.connectAttr(self.volume_att, o_node + ".blend")
            pm.connectAttr(self.volDriver_att, o_node + ".driver")
            pm.connectAttr(self.st_att[i], o_node + ".stretch")
            pm.connectAttr(self.sq_att[i], o_node + ".squash")

        # match IK/FK ref
        pm.parentConstraint(self.bone0, self.match_fk0_off, mo=True)
        pm.parentConstraint(self.bone1, self.match_fk1_off, mo=True)
        if self.settings["ikTR"]:
            transform.matchWorldTransform(self.ikRot_ctl, self.match_ikRot)
            transform.matchWorldTransform(self.fk_ctl[2], self.match_fk2)

        # recover hand offset transform
        if self.settings["use_blade"]:
            self.eff_jnt_off.setMatrix(self.off_t, worldSpace=True)
예제 #54
0
파일: curve.py 프로젝트: theomission/anima
 def _create_curveInfo(self):
     #create a new CurveInfo Node
     self._curveInfo = pm.createNode("curveInfo",
                                     n=self._curveNode + "_curveInfo")
     pm.connectAttr(self._curveNode.worldSpace, self._curveInfo.inputCurve)
     return self._curveInfo
예제 #55
0
    def __init__(self, objName, jointsNumber, groupJnts, curve, startJoint):

        self.objName = objName
        self.jointsNumber = jointsNumber
        self.groupJnts = groupJnts
        self.curve = curve
        self.startJoint = startJoint

        motionPathList = []
        #curveSpans = pm.getAttr(self.curve + 'Shape.spans')
        if (self.curve == '') or (pm.objExists(self.curve) == False):
            childStartJoint = pm.listRelatives(self.startJoint)
            posStart = pm.xform(self.startJoint, q=True, t=True, ws=True)
            posEnd = pm.xform(childStartJoint, q=True, t=True, ws=True)
            autoGenCv = pm.curve(n=self.startJoint + '_twistJointsChain_CRV',
                                 d=1,
                                 p=[posStart, posEnd])
            self.curve = autoGenCv
            pm.rebuildCurve(self.curve,
                            ch=True,
                            rt=0,
                            rpo=True,
                            end=1,
                            kr=0,
                            kep=True,
                            kt=0,
                            d=3,
                            s=10)
        else:
            pm.rebuildCurve(self.curve,
                            ch=True,
                            rt=0,
                            rpo=True,
                            end=1,
                            kr=0,
                            kep=True,
                            kt=0,
                            d=3,
                            s=10)

        pm.skinCluster(self.startJoint, childStartJoint, self.curve)
        pm.select(cl=True)

        groupTwistJoints = pm.group(n=self.groupJnts)

        nameTwistJoint = self.startJoint[0:len(self.startJoint) - 4]

        for i in range(0, self.jointsNumber):
            newJnt = pm.joint(n=nameTwistJoint + '_twist_' + str(i + 1) +
                              '_JNT',
                              radius=0.25)
            pm.setAttr(newJnt + '.overrideEnabled', 1)
            pm.setAttr(newJnt + '.overrideColor', 13)

            pm.parent(newJnt, groupTwistJoints)

            # motionPath = pm.pathAnimation(newJnt, c=self.curve, fractionMode = 0, eu = 1)
            motionPath = pm.createNode('motionPath')
            motionPathList.append(motionPath)
            pm.connectAttr(self.curve + 'Shape.worldSpace[0]',
                           motionPath + '.geometryPath')
            pm.connectAttr(motionPath + '.xCoordinate', newJnt + '.tx', f=True)
            pm.connectAttr(motionPath + '.yCoordinate', newJnt + '.ty', f=True)
            pm.connectAttr(motionPath + '.zCoordinate', newJnt + '.tz', f=True)
            pm.connectAttr(motionPath + '.message',
                           newJnt + '.specifiedManipLocation',
                           f=True)
            maxValueCurve = pm.getAttr(self.curve + '.maxValue')
            print maxValueCurve
            # pm.cutKey(motionPath+'.u')
            pm.setAttr(motionPath + '.u',
                       i * (maxValueCurve / (self.jointsNumber - 1)))
            pm.disconnectAttr(newJnt + '.tx')
            pm.disconnectAttr(newJnt + '.ty')
            pm.disconnectAttr(newJnt + '.tz')

        jointlist = pm.listRelatives(self.groupJnts, c=True)
        #print list
        for i in range(0, len(jointlist)):
            if i == 0:
                continue
            else:
                pm.parent(jointlist[i], jointlist[i - 1])

        pm.joint(jointlist[0],
                 e=True,
                 oj='yxz',
                 secondaryAxisOrient='zup',
                 ch=True,
                 zso=True)
        pm.joint(jointlist[len(jointlist) - 1],
                 e=True,
                 oj='none',
                 ch=True,
                 zso=True)

        for i in range(1, len(jointlist)):
            pm.parent(jointlist[i], groupTwistJoints)

        for i in range(0, len(motionPathList)):
            pm.connectAttr(motionPathList[i] + '.xCoordinate',
                           jointlist[i] + '.tx',
                           f=True)
            pm.connectAttr(motionPathList[i] + '.yCoordinate',
                           jointlist[i] + '.ty',
                           f=True)
            pm.connectAttr(motionPathList[i] + '.zCoordinate',
                           jointlist[i] + '.tz',
                           f=True)
예제 #56
0
    def addOperators(self):

        # Tangent position ---------------------------------
        # common part
        d = vec.getDistance(self.guide.pos["root"], self.guide.pos["neck"])
        dist_node = nod.createDistNode(self.root, self.ik_ctl)
        rootWorld_node = nod.createDecomposeMatrixNode(self.root.attr("worldMatrix"))
        div_node = nod.createDivNode(dist_node+".distance", rootWorld_node+".outputScaleX")
        div_node = nod.createDivNode(div_node+".outputX", d)

        # tan0
        mul_node = nod.createMulNode(self.tan0_att, self.tan0_loc.getAttr("ty"))
        res_node = nod.createMulNode(mul_node+".outputX", div_node+".outputX")
        pm.connectAttr( res_node+".outputX", self.tan0_loc+".ty")

        # tan1
        mul_node = nod.createMulNode(self.tan1_att, self.tan1_loc.getAttr("ty"))
        res_node = nod.createMulNode(mul_node+".outputX", div_node+".outputX")
        pm.connectAttr( res_node+".outputX", self.tan1_loc.attr("ty"))

        # Curves -------------------------------------------
        op = aop.gear_curveslide2_op(self.slv_crv, self.mst_crv, 0, 1.5, .5, .5)
        pm.connectAttr(self.maxstretch_att, op+".maxstretch")
        pm.connectAttr(self.maxsquash_att, op+".maxsquash")
        pm.connectAttr(self.softness_att, op+".softness")

        # Volume driver ------------------------------------
        crv_node = nod.createCurveInfoNode(self.slv_crv)

        # Division -----------------------------------------
        for i in range(self.settings["division"]):

            # References
            u = i / (self.settings["division"] - 1.0)

            cns = aop.pathCns(self.div_cns[i], self.slv_crv, False, u, True)
            cns.setAttr("frontAxis", 1)# front axis is 'Y'
            cns.setAttr("upAxis", 2)# front axis is 'Z'

            # Roll
            intMatrix = aop.gear_intmatrix_op(self.intMRef+".worldMatrix", self.ik_ctl+".worldMatrix", u)
            dm_node = nod.createDecomposeMatrixNode(intMatrix+".output")
            pm.connectAttr(dm_node+".outputRotate", self.twister[i].attr("rotate"))

            pm.parentConstraint(self.twister[i], self.ref_twist[i], maintainOffset=True)


            pm.connectAttr(self.ref_twist[i]+".translate", cns+".worldUpVector")




            # Squash n Stretch
            op = aop.gear_squashstretch2_op(self.fk_npo[i], self.root, pm.arclen(self.slv_crv), "y")
            pm.connectAttr(self.volume_att, op+".blend")
            pm.connectAttr(crv_node+".arcLength", op+".driver")
            pm.connectAttr(self.st_att[i], op+".stretch")
            pm.connectAttr(self.sq_att[i], op+".squash")
            op.setAttr("driver_min", .1)

            # scl compas
            if i != 0:
                div_node = nod.createDivNode([1,1,1], [self.fk_npo[i-1]+".sx", self.fk_npo[i-1]+".sy", self.fk_npo[i-1]+".sz"])
                pm.connectAttr(div_node+".output", self.scl_npo[i]+".scale")

            # Controlers
            if i == 0:
                mulmat_node = aop.gear_mulmatrix_op(self.div_cns[i].attr("worldMatrix"),
                                                    self.root.attr("worldInverseMatrix"))
            else:
                mulmat_node = aop.gear_mulmatrix_op(self.div_cns[i].attr("worldMatrix"),
                                                    self.div_cns[i - 1].attr("worldInverseMatrix"))

            dm_node = nod.createDecomposeMatrixNode(mulmat_node+".output")
            pm.connectAttr(dm_node+".outputTranslate", self.fk_npo[i].attr("t"))
            pm.connectAttr(dm_node+".outputRotate", self.fk_npo[i].attr("r"))

            # Orientation Lock
            if i == self.settings["division"] - 1 :
                dm_node = nod.createDecomposeMatrixNode(self.ik_ctl+".worldMatrix")
                blend_node = nod.createBlendNode([dm_node+".outputRotate%s"%s for s in "XYZ"], [cns+".rotate%s"%s for s in "XYZ"], self.lock_ori_att)
                self.div_cns[i].attr("rotate").disconnect()
                pm.connectAttr(blend_node+".output", self.div_cns[i]+".rotate")


        # Head ---------------------------------------------
        self.fk_ctl[-1].addChild(self.head_cns)

        #scale compensation
        dm_node = nod.createDecomposeMatrixNode(self.scl_npo[0]+".parentInverseMatrix")
        pm.connectAttr(dm_node+".outputScale", self.scl_npo[0]+".scale")
예제 #57
0
파일: paper.py 프로젝트: ckod3/LiqueTool
def paperbloc_gen(sel=None,
                  w=21.0,
                  d=29.7,
                  h=2,
                  num_sheets=10,
                  max_xz=0.5,
                  max_rot=10.0,
                  name='paperbloc'):

    sel = paperbloc_base(w, d, h, name)

    if not sel:
        # Get Current selection
        sel = pmc.ls(sl=True)

    elif not isinstance(sel, list):
        sel = [sel]

    if len(sel) != 2:
        raise ValueError(
            'Select Two Objects please, the fill paper and the paper bloc.')

    sSel = sel

    bloc_paper = sel[-1]
    sel = sel[0]
    print(bloc_paper)
    # check if the name already is in the scene

    i = 0
    num = 1
    while i < num:
        chk = pmc.ls(name + '_' + str(i))
        if chk:
            num += 1
        i += 1
        if i == num:
            num -= 1

    name_grp = name + '_grp_' + str(num)
    name_fill = name + '_fill_' + str(num)
    name = name + '_' + str(num)
    bloc_paper = pmc.duplicate(bloc_paper, n=name)
    fill_sheets = [bloc_paper[0]]
    #raise ValueError('STOP DOGGIE')

    for i in range(num_sheets):

        r_seed_x = random() * max_xz
        r_seed_y = random() * h
        r_seed_z = random() * max_xz
        r_seed_rot = random() * max_rot

        coin = coin_toss()
        if coin == 1:
            r_seed_rot = -r_seed_rot
        coin = coin_toss()
        if coin_toss == 1:
            r_seed_z = -r_seed_z
        coin = coin_toss()
        if coin_toss == 1:
            r_seed_x = -r_seed_x

        base_y = pmc.getAttr(sel.translateY)
        y_val = r_seed_y + base_y
        n_paper = pmc.duplicate(sel, n=name_fill)
        n_paper = n_paper[0]

        coin = coin_toss()
        if coin == 1:

            r_pivotx = random() * 10.0
            r_pivotz = random() * 10.0

            coin = coin_toss()
            if coin == 1:
                r_pivotx = -r_pivotx
            coin = coin_toss()
            if coin == 1:
                r_pivotz = -r_pivotz
            pmc.move(n_paper.rotatePivot, r_pivotx, 0, r_pivotz)

        pmc.setAttr(n_paper.ty, y_val)
        pmc.setAttr(n_paper.tx, r_seed_x)
        pmc.setAttr(n_paper.tz, r_seed_z)
        pmc.setAttr(n_paper.ry, r_seed_rot)

        fill_sheets.append(n_paper)

    print('---------feuilles placees -----------')

    print(fill_sheets)

    bender = pmc.nonLinear(fill_sheets, type='bend')

    print('bend creation')

    pmc.rename(bender[0], name + '__bend')
    pmc.rename(bender[-1], name + '__bendHandle')

    print('---------bend done -----------')

    pmc.setAttr(bender[-1].rotateZ, 90)
    fill_sheets.append(bender[0])
    fill_sheets.append(bender[-1])
    grp = pmc.group(em=True, n=name_grp)
    pmc.setAttr(grp.ty, base_y)
    pmc.parent(fill_sheets, grp)
    ar.zero_out(mc.ls(str(bender[-1])))

    pmc.addAttr(grp, ln='bend_me', at='float', k=True)
    pmc.addAttr(grp, ln='bend_shift', at='float', k=True)
    pmc.addAttr(grp, ln='bend_min', at='float', min=-10, dv=-1, max=0, k=True)
    pmc.addAttr(grp, ln='bend_max', at='float', min=0, dv=1, max=10, k=True)
    pmc.addAttr(grp, ln='pos_bendx', at='float', k=True)
    pmc.addAttr(grp, ln='pos_bendz', at='float', k=True)

    pmc.connectAttr(grp.bend_me, bender[0].curvature)
    pmc.connectAttr(grp.bend_shift, bender[-1].rx)
    pmc.connectAttr(grp.bend_min, bender[0].lowBound)
    pmc.connectAttr(grp.bend_max, bender[0].highBound)
    pmc.connectAttr(grp.pos_bendx, bender[-1].ty)
    pmc.connectAttr(grp.pos_bendz, bender[-1].tz)

    pmc.delete(sSel)
    pmc.select(pmc.ls(grp))
    return grp
예제 #58
0
파일: neck.py 프로젝트: dayelov/DevPyLib
    def __init__(
            self,
            neckJoints,
            headJnt,
            #neckCurve,
            prefix='neck',
            rigScale=1.0,
            baseRig=None):
        """
        :param neckJoints: list( str ), list of neck joints
        :param headJnt: str, head joint at the end of neck joint chain
        :param prefix: str, prefix to name new objects
        :param rigScale: float, scale factor for size of controls
        :param baseRig: instance of base.module.Base class
        :return: dictionary with rig module objects
        """
        # :param neckCurve: str, name of neck cubic curve with 5 CVs matching neck joints

        # make rig module
        self.rigmodule = module.Module(prefix=prefix, baseObj=baseRig)

        # make IK handle
        neckIk, effector, neckCurve = pm.ikHandle(n=prefix + '_IKH',
                                                  sol='ikSplineSolver',
                                                  sj=neckJoints[0],
                                                  ee=neckJoints[-1],
                                                  createCurve=True,
                                                  numSpans=2)

        # rename curve
        pm.rename(neckCurve, prefix + '_CRV')

        # make neck curve clusters
        neckCurveCVs = pm.ls(neckCurve + '.cv[*]', fl=1)
        numNeckCVs = len(neckCurveCVs)
        neckCurveClusters = []

        for i in range(numNeckCVs):
            cls = pm.cluster(neckCurveCVs[i],
                             n=prefix + 'Cluster%d' % (i + 1))[1]
            neckCurveClusters.append(cls)

        pm.hide(neckCurveClusters)

        # parent neck curve
        pm.parent(neckCurve, self.rigmodule.partsNoTransGrp)

        # make attach groups
        self.bodyAttachGrp = pm.group(n=prefix + 'BodyAttach_GRP',
                                      em=1,
                                      p=self.rigmodule.partsGrp)
        self.baseAttachGrp = pm.group(n=prefix + 'BaseAttach_GRP',
                                      em=1,
                                      p=self.rigmodule.partsGrp)

        pm.delete(pm.pointConstraint(neckJoints[0], self.baseAttachGrp))

        # make controls
        headMainCtrl = control.Control(prefix=prefix + 'HeadMain',
                                       translateTo=neckJoints[-1],
                                       rotateTo=headJnt,
                                       scale=rigScale * 5,
                                       parent=self.rigmodule.controlsGrp,
                                       shape='head')

        headLocalCtrl = control.Control(prefix=prefix + 'HeadLocal',
                                        translateTo=headJnt,
                                        rotateTo=headJnt,
                                        scale=rigScale * 4,
                                        parent=headMainCtrl.C,
                                        shape='circleX',
                                        lockChannels=['t'])

        middleCtrl = control.Control(prefix=prefix + 'Middle',
                                     translateTo=neckCurveClusters[2],
                                     rotateTo=neckJoints[2],
                                     scale=rigScale * 4,
                                     parent=self.rigmodule.controlsGrp,
                                     shape='circleX',
                                     lockChannels=['r'])

        # attach controls
        pm.parentConstraint(headMainCtrl.C,
                            self.baseAttachGrp,
                            middleCtrl.Off,
                            sr=['x', 'y', 'z'],
                            mo=1)
        pm.orientConstraint(self.baseAttachGrp, middleCtrl.Off, mo=1)
        pm.parentConstraint(self.bodyAttachGrp, headMainCtrl.Off, mo=1)

        # attach clusters
        pm.parent(neckCurveClusters[3:], headMainCtrl.C)
        pm.parent(neckCurveClusters[2], middleCtrl.C)
        pm.parent(neckCurveClusters[:2], self.baseAttachGrp)

        # attach joints
        pm.orientConstraint(headLocalCtrl.C, headJnt, mo=1)

        pm.hide(neckIk)
        pm.parent(neckIk, self.rigmodule.partsNoTransGrp)

        # setup IK twist
        pm.setAttr(neckIk + '.dTwistControlEnable', 1)
        pm.setAttr(neckIk + '.dWorldUpType', 4)
        pm.connectAttr(headMainCtrl.C + '.worldMatrix[0]',
                       neckIk + '.dWorldUpMatrixEnd')
        pm.connectAttr(self.baseAttachGrp + '.worldMatrix[0]',
                       neckIk + '.dWorldUpMatrix')
예제 #59
0
import pymel.core as pm

sel = pm.ls(sl=True)
ctrl = sel[1].replace('Ctrl', 'Master_ctrl')
closestPoint = pm.createNode('closestPointOnSurface',
                             n='closestPointonSurface_node')
arcLength = pm.createNode('arcLengthDimension', n='arcLengthDimension_node')

pos = pm.xform(sel[1], q=True, t=True, ws=True)
pm.connectAttr(sel[0] + '.local', closestPoint + '.inputSurface', f=1)
pm.setAttr(closestPoint + '.inPosition', pos[0], pos[1], pos[2])

pm.connectAttr(sel[0] + '.worldSpace', arcLength + '.nurbsGeometry')

pm.group(em=True, n='temp')
pm.connectAttr(closestPoint + '.parameterU', 'temp.tx')
pm.connectAttr(closestPoint + '.parameterV', 'temp.ty')
paraU = pm.getAttr('temp.tx')
paraV = pm.getAttr('temp.ty')
pm.setAttr(arcLength + '.uParamValue', paraU)
pm.setAttr(arcLength + '.vParamValue', paraV)
pm.connectAttr(arcLength + '.arcLength', 'temp.sx')
pm.connectAttr(arcLength + '.arcLengthInV', 'temp.sy')
arclenU = pm.getAttr('temp.sx')
arclenV = pm.getAttr('temp.sy')

pm.delete('temp', pm.listRelatives(arcLength, p=True), arcLength, closestPoint)

flc = pm.createNode('follicle', n=ctrl + '_follicleShape')
pm.connectAttr(sel[0] + '.local', flc + '.inputSurface')
pm.connectAttr(sel[0] + '.worldMatrix', flc + '.inputWorldMatrix')
예제 #60
0
    def addOperators(self):
        """Create operators and set the relations for the component rig

        Apply operators, constraints, expressions to the hierarchy.
        In order to keep the code clean and easier to debug,
        we shouldn't create any new object in this method.

        """
        # Visibilities -------------------------------------
        # fk
        fkvis_node = node.createReverseNode(self.blend_att)

        for shp in self.fk0_ctl.getShapes():
            pm.connectAttr(fkvis_node + ".outputX", shp.attr("visibility"))
        for shp in self.fk0_roll_ctl.getShapes():
            pm.connectAttr(fkvis_node + ".outputX", shp.attr("visibility"))
        for shp in self.fk1_ctl.getShapes():
            pm.connectAttr(fkvis_node + ".outputX", shp.attr("visibility"))
        for shp in self.fk1_roll_ctl.getShapes():
            pm.connectAttr(fkvis_node + ".outputX", shp.attr("visibility"))

        fkvis2_node = node.createReverseNode(self.blend2_att)
        for shp in self.fk2_ctl.getShapes():
            pm.connectAttr(fkvis2_node + ".outputX", shp.attr("visibility"))

        # ik
        for shp in self.upv_ctl.getShapes():
            pm.connectAttr(self.blend_att, shp.attr("visibility"))
        for shp in self.ikcns_ctl.getShapes():
            pm.connectAttr(self.blend_att, shp.attr("visibility"))
        for shp in self.ik_ctl.getShapes():
            pm.connectAttr(self.blend_att, shp.attr("visibility"))
        for shp in self.line_ref.getShapes():
            pm.connectAttr(self.blend_att, shp.attr("visibility"))

        # jnt ctl
        for ctl in (self.div_ctls):
            for shp in ctl.getShapes():
                pm.connectAttr(self.jntctl_vis_att, shp.attr("visibility"))

        # Controls ROT order -----------------------------------
        attribute.setRotOrder(self.ik_ctl, "XZY")

        # IK Solver -----------------------------------------
        out = [self.bone0, self.bone1, self.ctrn_loc, self.eff_npo]

        o_node = applyop.gear_ikfk2bone_op(out, self.root, self.ik_ref,
                                           self.upv_ctl, self.fk0_mtx,
                                           self.fk1_mtx, self.fk2_mtx,
                                           self.length0, self.length1,
                                           self.negate)

        pm.connectAttr(self.blend_att, o_node + ".blend")
        if self.negate:
            mulVal = -1
        else:
            mulVal = 1
        node.createMulNode(self.roll_att, mulVal, o_node + ".roll")
        pm.connectAttr(self.scale_att, o_node + ".scaleA")
        pm.connectAttr(self.scale_att, o_node + ".scaleB")
        pm.connectAttr(self.maxstretch_att, o_node + ".maxstretch")
        pm.connectAttr(self.slide_att, o_node + ".slide")
        pm.connectAttr(self.softness_att, o_node + ".softness")
        pm.connectAttr(self.reverse_att, o_node + ".reverse")
        # update issue on effector scale interpolation, disconnect
        # for stability
        pm.disconnectAttr(self.eff_npo.scale)

        # auto upvector -------------------------------------
        # leg aim
        o_node = applyop.aimCns(self.upv_auv,
                                self.ik_ctl,
                                axis="-yz",
                                wupType=1,
                                wupVector=[0, 1, 0],
                                wupObject=self.upv2_auv,
                                maintainOffset=False)

        # foot aim
        o_node = applyop.aimCns(self.upv1_auv,
                                self.root,
                                axis="yz",
                                wupType=4,
                                wupVector=[0, 1, 0],
                                wupObject=self.root,
                                maintainOffset=False)

        # auto upvector connection
        o_node = applyop.gear_mulmatrix_op(
            self.upv_auv.attr("worldMatrix"),
            self.upv_mtx.attr("parentInverseMatrix"))

        dm_node = pm.createNode("decomposeMatrix")
        pm.connectAttr(o_node + ".output", dm_node + ".inputMatrix")
        pb_node = pm.createNode("pairBlend")
        pb_node.attr("rotInterpolation").set(1)
        pm.connectAttr(dm_node + ".outputTranslate", pb_node + ".inTranslate2")
        pm.connectAttr(dm_node + ".outputRotate", pb_node + ".inRotate2")
        pm.connectAttr(pb_node + ".outRotate", self.upv_mtx.attr("rotate"))
        pm.connectAttr(pb_node + ".outTranslate",
                       self.upv_mtx.attr("translate"))
        pm.connectAttr(self.auv_att, pb_node + ".weight")

        # fk0 mtx parent constraint
        o_node = applyop.gear_mulmatrix_op(
            self.fk0_roll_ctl.attr("worldMatrix"),
            self.fk0_mtx.attr("parentInverseMatrix"))

        dm_node = pm.createNode("decomposeMatrix")
        pm.connectAttr(o_node + ".output", dm_node + ".inputMatrix")
        pm.connectAttr(dm_node + ".outputTranslate",
                       self.fk0_mtx.attr("translate"))

        pm.connectAttr(dm_node + ".outputRotate", self.fk0_mtx.attr("rotate"))
        # fk1 loc to fk1 ref parent constraint
        o_node = applyop.gear_mulmatrix_op(
            self.fk1_ref.attr("worldMatrix"),
            self.fk1_loc.attr("parentInverseMatrix"))

        dm_node = pm.createNode("decomposeMatrix")
        pm.connectAttr(o_node + ".output", dm_node + ".inputMatrix")
        pm.connectAttr(dm_node + ".outputTranslate",
                       self.fk1_loc.attr("translate"))

        pm.connectAttr(dm_node + ".outputRotate", self.fk1_loc.attr("rotate"))
        # fk1 mtx orient cns to fk1 roll
        pm.connectAttr(self.fk1_roll_ctl.attr("rotate"),
                       self.fk1_mtx.attr("rotate"))

        # fk2_loc position constraint to effector------------------------
        o_node = applyop.gear_mulmatrix_op(
            self.eff_npo.attr("worldMatrix"),
            self.fk2_loc.attr("parentInverseMatrix"))

        dm_node = pm.createNode("decomposeMatrix")
        pm.connectAttr(o_node + ".output", dm_node + ".inputMatrix")
        pm.connectAttr(dm_node + ".outputTranslate",
                       self.fk2_loc.attr("translate"))
        # fk2_loc rotation constraint to bone1 ------------------------

        o_node = applyop.gear_mulmatrix_op(
            self.bone1.attr("worldMatrix"),
            self.fk2_loc.attr("parentInverseMatrix"))

        dm_node = pm.createNode("decomposeMatrix")
        pm.connectAttr(o_node + ".output", dm_node + ".inputMatrix")
        pm.connectAttr(dm_node + ".outputRotate", self.fk2_loc.attr("rotate"))

        # foot ikfk blending from fk ref to ik ref (serious bugfix)----
        o_node = applyop.gear_mulmatrix_op(
            self.fk_ref.attr("worldMatrix"),
            self.eff_loc.attr("parentInverseMatrix"))

        dm_node = pm.createNode("decomposeMatrix")
        pb_node = pm.createNode("pairBlend")
        pb_node.attr("rotInterpolation").set(1)
        pm.connectAttr(o_node + ".output", dm_node + ".inputMatrix")
        pm.connectAttr(dm_node + ".outputRotate", pb_node + ".inRotate1")
        pm.connectAttr(self.blend2_att, pb_node + ".weight")
        pm.connectAttr(pb_node + ".outRotate", self.eff_loc.attr("rotate"))

        o_node = applyop.gear_mulmatrix_op(
            self.ik_ref.attr("worldMatrix"),
            self.eff_loc.attr("parentInverseMatrix"))

        dm_node1 = pm.createNode("decomposeMatrix")
        pm.connectAttr(o_node + ".output", dm_node1 + ".inputMatrix")
        pm.connectAttr(dm_node1 + ".outputRotate", pb_node + ".inRotate2")
        # use blendcolors to blend scale
        bc_node = pm.createNode("blendColors")
        pm.connectAttr(self.blend_att, bc_node + ".blender")
        pm.connectAttr(dm_node + ".outputScale", bc_node + ".color2")
        pm.connectAttr(dm_node1 + ".outputScale", bc_node + ".color1")
        pm.connectAttr(bc_node + ".output", self.eff_loc.attr("scale"))

        # Twist references ---------------------------------
        pm.connectAttr(self.mid_ctl.attr("translate"),
                       self.tws1_npo.attr("translate"))
        pm.connectAttr(self.mid_ctl.attr("rotate"),
                       self.tws1_npo.attr("rotate"))
        pm.connectAttr(self.mid_ctl.attr("scale"), self.tws1_npo.attr("scale"))

        o_node = applyop.gear_mulmatrix_op(
            self.eff_loc.attr("worldMatrix"),
            self.tws3_npo.attr("parentInverseMatrix"))

        dm_node = pm.createNode("decomposeMatrix")
        pm.connectAttr(o_node + ".output", dm_node + ".inputMatrix")

        pm.connectAttr(dm_node + ".outputTranslate",
                       self.tws3_npo.attr("translate"))

        o_node = applyop.gear_mulmatrix_op(
            self.bone1.attr("worldMatrix"),
            self.tws3_npo.attr("parentInverseMatrix"))

        dm_node = pm.createNode("decomposeMatrix")
        pm.connectAttr(o_node + ".output", dm_node + ".inputMatrix")
        pm.connectAttr(dm_node + ".outputRotate", self.tws3_npo.attr("rotate"))

        o_node = applyop.gear_mulmatrix_op(
            self.tws_ref.attr("worldMatrix"),
            self.tws3_rot.attr("parentInverseMatrix"))

        dm_node = pm.createNode("decomposeMatrix")
        pm.connectAttr(o_node + ".output", dm_node + ".inputMatrix")
        pm.connectAttr(dm_node + ".outputRotate", self.tws3_rot.attr("rotate"))

        # knee thickness connection
        if self.negate:
            o_node = node.createMulNode(
                [self.knee_thickness_att, self.knee_thickness_att],
                [0.5, -0.5, 0],
                [self.tws1_loc + ".translateX", self.tws2_loc + ".translateX"])
        else:
            o_node = node.createMulNode(
                [self.knee_thickness_att, self.knee_thickness_att],
                [-0.5, 0.5, 0],
                [self.tws1_loc + ".translateX", self.tws2_loc + ".translateX"])

        # connect both tws1 and tws2  (mid tws)
        self.tws0_rot.setAttr("sx", .001)
        self.tws3_rot.setAttr("sx", .001)

        add_node = node.createAddNode(self.roundness0_att, .001)
        pm.connectAttr(add_node + ".output", self.tws1_rot.attr("sx"))

        add_node = node.createAddNode(self.roundness1_att, .001)
        pm.connectAttr(add_node + ".output", self.tws2_rot.attr("sx"))

        # Roll Shoulder--use aimconstraint withour uovwctor to solve the
        # stable twist

        if self.negate:
            o_node = applyop.aimCns(self.tws0_loc,
                                    self.mid_ctl,
                                    axis="-xy",
                                    wupType=4,
                                    wupVector=[0, 1, 0],
                                    wupObject=self.tws0_npo,
                                    maintainOffset=False)
        else:
            o_node = applyop.aimCns(self.tws0_loc,
                                    self.mid_ctl,
                                    axis="xy",
                                    wupType=4,
                                    wupVector=[0, 1, 0],
                                    wupObject=self.tws0_npo,
                                    maintainOffset=False)

        # Volume -------------------------------------------
        distA_node = node.createDistNode(self.tws0_loc, self.tws1_npo)
        distB_node = node.createDistNode(self.tws1_npo, self.tws3_loc)
        add_node = node.createAddNode(distA_node + ".distance",
                                      distB_node + ".distance")
        div_node = node.createDivNode(add_node + ".output",
                                      self.root.attr("sx"))

        dm_node = pm.createNode("decomposeMatrix")
        pm.connectAttr(self.root.attr("worldMatrix"), dm_node + ".inputMatrix")

        div_node2 = node.createDivNode(div_node + ".outputX",
                                       dm_node + ".outputScaleX")
        self.volDriver_att = div_node2 + ".outputX"

        # Divisions ----------------------------------------
        # div mid constraint to mid ctl
        o_node = applyop.gear_mulmatrix_op(
            self.mid_ctl.attr("worldMatrix"),
            self.div_mid.attr("parentInverseMatrix"))

        dm_node = pm.createNode("decomposeMatrix")
        pm.connectAttr(o_node + ".output", dm_node + ".inputMatrix")

        pm.connectAttr(dm_node + ".outputTranslate",
                       self.div_mid.attr("translate"))

        pm.connectAttr(dm_node + ".outputRotate", self.div_mid.attr("rotate"))

        # at 0 or 1 the division will follow exactly the rotation of the
        # controler.. and we wont have this nice tangent + roll
        scl_1_perc = []
        scl_2_perc = []

        for i, div_cnsUp in enumerate(self.div_cnsUp):

            if i < (self.settings["div0"] + 1):
                perc = i / (self.settings["div0"] + 1.0)
            elif i < (self.settings["div0"] + 2):
                perc = .95

            perc = max(.001, min(.99, perc))

            # Roll
            if self.negate:
                o_node = applyop.gear_rollsplinekine_op(
                    div_cnsUp, [self.tws1_rot, self.tws0_rot], 1 - perc, 20)

            else:
                o_node = applyop.gear_rollsplinekine_op(
                    div_cnsUp, [self.tws0_rot, self.tws1_rot], perc, 20)
            pm.connectAttr(self.resample_att, o_node + ".resample")
            pm.connectAttr(self.absolute_att, o_node + ".absolute")

            scl_1_perc.append(perc / 2)
            scl_2_perc.append(perc)
        scl_1_perc.append(0.5)
        scl_2_perc.append(1)
        for i, div_cnsDn in enumerate(self.div_cnsDn):

            if i == (0):
                perc = .05
            elif i < (self.settings["div1"] + 1):
                perc = i / (self.settings["div1"] + 1.0)
            elif i < (self.settings["div1"] + 2):
                perc = .95

            perc = max(.001, min(.990, perc))

            # Roll
            if self.negate:
                o_node = applyop.gear_rollsplinekine_op(
                    div_cnsDn, [self.tws3_rot, self.tws2_rot], 1 - perc, 20)

            else:
                o_node = applyop.gear_rollsplinekine_op(
                    div_cnsDn, [self.tws2_rot, self.tws3_rot], perc, 20)
            pm.connectAttr(self.resample_att, o_node + ".resample")
            pm.connectAttr(self.absolute_att, o_node + ".absolute")

            scl_1_perc.append(perc / 2 + 0.5)
            scl_2_perc.append(1 - perc)
        # Squash n Stretch
        for i, div_cns in enumerate(self.div_cns):
            o_node = applyop.gear_squashstretch2_op(
                div_cns, None, pm.getAttr(self.volDriver_att), "x")
            pm.connectAttr(self.volume_att, o_node + ".blend")
            pm.connectAttr(self.volDriver_att, o_node + ".driver")
            pm.connectAttr(self.st_att[i], o_node + ".stretch")
            pm.connectAttr(self.sq_att[i], o_node + ".squash")
            # get the first mult_node after sq op
            mult_node = pm.listHistory(o_node, future=True)[1]
            # linear blend effector scale
            bc_node = pm.createNode("blendColors")
            bc_node.setAttr("color2R", 1)
            bc_node.setAttr("color2G", 1)
            bc_node.setAttr("blender", scl_1_perc[i])
            pm.connectAttr(self.eff_loc.attr("scale"), bc_node + ".color1")
            # linear blend mid scale
            bc_node2 = pm.createNode("blendColors")
            bc_node2.setAttr("color2R", 1)
            bc_node2.setAttr("color2G", 1)
            bc_node2.setAttr("blender", scl_2_perc[i])
            pm.connectAttr(self.mid_ctl.attr("scale"), bc_node2 + ".color1")
            # mid_ctl scale * effector scale
            mult_node2 = pm.createNode("multiplyDivide")
            pm.connectAttr(bc_node2 + ".output", mult_node2 + ".input1")
            pm.connectAttr(bc_node + ".output", mult_node2 + ".input2")
            # plug to sq scale
            pm.connectAttr(mult_node2 + ".output", mult_node + ".input2")

        # match IK/FK ref
        pm.connectAttr(self.bone0.attr("rotate"),
                       self.match_fk0.attr("rotate"))
        pm.connectAttr(self.bone0.attr("translate"),
                       self.match_fk0.attr("translate"))
        pm.connectAttr(self.bone1.attr("rotate"),
                       self.match_fk1.attr("rotate"))
        pm.connectAttr(self.bone1.attr("translate"),
                       self.match_fk1.attr("translate"))

        return