Ejemplo n.º 1
0
    def setup_VisibilityGRP(self):
        visGrp = adbAttr.NodeAttr([self.RIG.VISIBILITY_GRP])
        visGrp.AddSeparator(self.RIG.VISIBILITY_GRP, 'Joints')
        visGrp.addAttr(
            '{Side}_{Basename}_Clavicule_JNT'.format(**self.nameStructure),
            True)
        visGrp.addAttr('{Side}_{Basename}_IK_JNT'.format(**self.nameStructure),
                       False)

        visGrp.AddSeparator(self.RIG.VISIBILITY_GRP, 'Controls')
        visGrp.addAttr(
            '{Side}_{Basename}_Clavicule_CTRL'.format(**self.nameStructure),
            True)

        for attr in visGrp.allAttrs.keys():
            for module in self.BUILD_MODULES:
                for grp in module.VISRULE_GRP.getChildren():
                    shortName = NC.getBasename(grp).split(
                        '{Basename}_'.format(**self.nameStructure))[-1]
                    if shortName.lower() in attr.lower():
                        try:
                            pm.connectAttr(
                                '{}.{}'.format(visGrp.subject, attr),
                                '{}.vis'.format(grp))
                        except:
                            pass
Ejemplo n.º 2
0
    def mirror(self, axis='X'):
        """
        Mirror a transform according to given axis.
        """
        for subject in self.transform:
            # get the name
            if (pm.PyNode(subject).name()).startswith('r__'):
                _name = '{}'.format(str(subject).replace('r__', 'l__'))

            elif (pm.PyNode(subject).name()).startswith('l__'):
                _name = '{}'.format(
                    str(pm.PyNode(subject)).replace('l__', 'r__'))

            else:
                _name = None

            # temp unlock all user defined attributes
            locks_attr_list = adbAttr.NodeAttr(self.transform).getLock_attr()
            # Unlock all
            att_to_unlock = [
                'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'
            ]
            for att in att_to_unlock:
                pm.PyNode(subject).setAttr(att, lock=False, keyable=True)

            # mirror function
            dup = pm.duplicate(subject, rr=True, name=_name)[0]
            offset_grp = pm.group(name='dup_grp', em=True)
            pm.makeIdentity(dup, n=0, s=1, r=1, t=1, apply=True, pn=1)
            pm.parent(dup, offset_grp)

            if axis == 'x':
                pm.PyNode(offset_grp).scaleX.set(-1)
            elif axis == 'y':
                pm.PyNode(offset_grp).scaleY.set(-1)
            elif axis == 'z':
                pm.PyNode(offset_grp).scaleZ.set(-1)
            elif axis == 'X':
                pm.PyNode(offset_grp).scaleX.set(-1)
            elif axis == 'Y':
                pm.PyNode(offset_grp).scaleY.set(-1)
            elif axis == 'Z':
                pm.PyNode(offset_grp).scaleZ.set(-1)

            pm.parent(dup, world=True)
            pm.makeIdentity(dup, n=0, s=1, r=1, t=1, apply=True, pn=1)
            pm.delete(offset_grp)

            # relock attribute
            for attrs in locks_attr_list:
                if attrs:
                    for att in attrs:
                        pm.PyNode(subject).setAttr(att,
                                                   lock=True,
                                                   channelBox=True,
                                                   keyable=False)
                        pm.PyNode(dup).setAttr(att,
                                               lock=True,
                                               channelBox=True,
                                               keyable=False)
Ejemplo n.º 3
0
    def createVariableFkSystem(self):
        """
        Create an Fk Variable system based on a Bend Attribute
        Returns:
            Module - Class object of the FkVariable Class
        """
        resultOffset_grp = [
            adb.makeroot_func(subject=x,
                              suff='OFFSET',
                              forceNameConvention=True)
            for x in self.spine_chain_joints
        ]

        settingsGrpAttr = adbAttr.NodeAttr([self.RIG.SETTINGS_GRP])
        settingsGrpAttr.addAttr('Bend', 0)
        fkV = Slide.FkVariable(module_name='Bend',
                               joint_chain=self.spine_chain_joints,
                               driver=[self.RIG.SETTINGS_GRP],
                               range=2,
                               driver_axis='Bend',
                               target_axis='rx',
                               useMinus=False)
        fkV.start()
        fkV.build()

        pm.parent(fkV.metaData_GRP, self.RIG.SETTINGS_GRP)
        return fkV
Ejemplo n.º 4
0
    def createNetworkNode(self, _metaDataNode):
        spaceAttrNode = moduleBase.ModuleBase.createMetaDataGrp('{}_attribute'.format(self.NAME), type ='transform')
        spaceAttr = adbAttr.NodeAttr(spaceAttrNode)
        spaceAttr.addAttr(self.NAME,  'enum',  eName = str(':'.join(self.attrNames)))

        pm.PyNode('{}.{}'.format(spaceAttrNode , spaceAttr.attrName)) >> self.choiceNode.selector

        return spaceAttrNode
Ejemplo n.º 5
0
 def setup_SettingGRP(self):
     setting_ctrl = adbAttr.NodeAttr([self.RIG.SETTINGS_GRP])
     setting_ctrl.AddSeparator([self.RIG.SETTINGS_GRP],
                               'VolumePreservation')
     adbAttr.NodeAttr.copyAttr(
         self.spine_squash_stretch.metaData_GRP, [self.RIG.SETTINGS_GRP],
         nicename='{Side}_{Basename}'.format(**self.nameStructure),
         forceConnection=True)
Ejemplo n.º 6
0
def createSticky(stickyName = 'Deformer', scale = 0.2):   
    """
    Sticky : Creates a rivet with a softmod deformer 
    Returns the sticky locator   
    """  
    rivetData = buildRivet()
    rivet_trans = rivetData[0]
    curveFromMeshEdgeList = rivetData[1]
    MeshName = rivetData[2]                     
    pm.PyNode(rivet_trans).v.set(0) 
        
    ## master and offset grp
    deformer__sys__ = pm.createNode('transform', n = '{}_{}__{}'.format(stickyName, NC.SYSTEM, NC.GRP))
    deformer_offset_grp__ = pm.createNode('transform', n = '{}__offset__{}'.format(stickyName, NC.GRP))
    pm.parent(deformer_offset_grp__, deformer__sys__)
        
    ## create locator
    sticky_locator = pm.spaceLocator(name = '{}_sticky'.format(MeshName))
    adb.changeColor_func(sticky_locator, 'index', col = 18)    
    pm.PyNode(sticky_locator).localScaleX.set(scale)
    pm.PyNode(sticky_locator).localScaleY.set(scale)
    pm.PyNode(sticky_locator).localScaleZ.set(scale)    
    pm.parent(sticky_locator, deformer_offset_grp__)
    pm.matchTransform(deformer_offset_grp__, rivet_trans.getParent(), rot = True, pos=True)    
    
    ## create softmod
    softModName = '{}__softMod__'.format(stickyName)
    softModDeformer = pm.softMod(MeshName,n=softModName)
    pm.softMod(softModDeformer[0], edit = True, wn=(sticky_locator,sticky_locator), fas=False, fm=False )
    pm.PyNode('{}HandleShape'.format(softModDeformer[0])).v.set(0)

    ## connect falloff Center
    adb.connect_axesAttr(deformer_offset_grp__, softModDeformer[0], outputs = ['translate'], inputs = ['falloffCenter'])  
    deformer_offset_grp__.inverseMatrix >> softModDeformer[0].bindPreMatrix
            
    _sticky_Attr = adbAttr.NodeAttr([sticky_locator])  
    _sticky_Attr.addAttr('Softmod_Falloff_Radius', 0.75, min = 0, max = 100 )  
    sticky_locator.Softmod_Falloff_Radius >> softModDeformer[0].falloffRadius
    
    ##giving new input geo to curveFromMeshEdges    
    groupPartsNodeName = pm.listConnections(softModName, t='groupParts') 
    
    for index in range(len(curveFromMeshEdgeList)):
        pm.PyNode('{}GroupParts.outputGeometry'.format(softModName)) >> curveFromMeshEdgeList[index].inputMesh        
    adb.connect_axesAttr(rivet_trans.getParent(), deformer_offset_grp__, outputs = ['translate', 'rotate'], inputs = [])  

    ## clean scene
    pm.delete(softModDeformer[1])
    pm.parent(rivet_trans.getParent(),deformer__sys__)
    pm.select(clear=True)
    
    sys.stdout.write('// Result: Sticky created // \n ')
    return sticky_locator
def wrapSetUp(_HiRez = pm.selected(), _LoRez=pm.selected()):
    """
    Custom wrapDeformer Setup
    Select target - HiRez first, then the source - LoRez
    The script will create a duplicate of the HiRez with a blenshape and add a DeltaMush on the HiRez

    @param Hirez: Target which will receive the wrap 
    @param Lorez: Source     
    
    ## EXTERIOR CLASS BUILD
    #------------------------
    import adb_utils.Script__WrapDeformer_Setup as adbWrapSetUp
    reload(adbWrapSetUp)

    #or
    from adb_utils.Script__WrapDeformer_Setup import wrapSetUp             
    """

    ## Define Variable type
    if isinstance(_HiRez, str) and isinstance(_LoRez, str):
        hi = _HiRez
        lo = _LoRez       
    elif len(_HiRez) == 2:    
        hi = _HiRez[0]
        lo = _LoRez[1]
    
    
    dup = pm.duplicate(hi, n='{}__{}__'.format(hi,'duplicate_wrap'), ic=1, rr=1)[0]
   
    wrapData = adbWrap.wrapDeformer(str(dup),str(lo))

    ## add custom attribute on wrap node
    wrap_node = adbAttr.NodeAttr([wrapData])
    wrap_node.addAttr('mushEnveloppe', 1)
    wrap_node.addAttr('smoothingIterations', 10)
    wrap_node.addAttr('smoothingStep', 0.5)

    ## blendShape
    blendShape = pm.blendShape(dup, hi, exclusive="deformPartition#", o = "world", w = [(0, 1.0)], ib=1, n = '{}__{}__'.format(hi, 'BLS'))[0]

    ## Mush
    mush = pm.deltaMush(hi, smoothingIterations=10, envelope=1, smoothingStep=0.5, pinBorderVertices=1,  n = '{}_{}'.format(hi, 'mush'))

    pm.PyNode(wrapData).mushEnveloppe >> pm.PyNode(mush).envelope
    pm.PyNode(wrapData).smoothingIterations >> pm.PyNode(mush).smoothingIterations
    pm.PyNode(wrapData).smoothingStep >> pm.PyNode(mush).smoothingStep

    ## Clean Up
    pm.PyNode(dup).v.set(0)
Ejemplo n.º 8
0
    def setupVisRule(self,
                     tansformList,
                     parent,
                     name=False,
                     defaultValue=True):
        """
            Edit : for setting up the visrule for Fk shapes ctrl
            Original one from ModuleBase
            """
        if name:
            visRuleGrp = pm.group(n=name, em=1, parent=parent)
        else:
            visRuleGrp = pm.group(n='{}_{}__{}'.format(
                NC.getNameNoSuffix(tansformList[0]),
                NC.getSuffix(tansformList[0]), NC.VISRULE),
                                  em=1,
                                  parent=parent)
        visRuleGrp.v.set(0)
        visRuleAttr = adbAttr.NodeAttr([visRuleGrp])
        visRuleAttr.addAttr('vis', 'enum', eName="2:0")

        self.nameStructure['Suffix'] = NC.ADDLINEAR_SUFFIX
        addDouble = pm.shadingNode(
            'addDoubleLinear',
            asUtility=1,
            n='{Side}__{Basename}_visrule__{Suffix}'.format(
                **self.nameStructure))
        self.nameStructure['Suffix'] = NC.REVERSE_SUFFIX
        reverse = pm.shadingNode(
            'reverse',
            asUtility=1,
            n='{Side}__{Basename}_visrule__{Suffix}'.format(
                **self.nameStructure))
        addDouble.input2.set(1)
        pm.connectAttr('{}.{}'.format(visRuleGrp, visRuleAttr.name),
                       '{}.inputX'.format(reverse),
                       f=1)
        pm.connectAttr('{}.outputX'.format(reverse),
                       '{}.input1'.format(addDouble),
                       f=1)
        for transform in tansformList:
            pm.connectAttr('{}.output'.format(addDouble),
                           '{}.drawStyle'.format(transform))
        adb.lockAttr_func(
            visRuleGrp,
            ['tx', 'ty', 'tz', 'rx', 'ry', 'rx', 'rz', 'sx', 'sy', 'sz', 'v'])
        return visRuleGrp, visRuleAttr.name
Ejemplo n.º 9
0
    def setup_VisibilityGRP(self):
        visGrp = adbAttr.NodeAttr([self.RIG.VISIBILITY_GRP])
        visGrp.AddSeparator(self.RIG.VISIBILITY_GRP, 'Joints')
        visGrp.addAttr('{Side}_{Basename}_FK_JNT'.format(**self.nameStructure),
                       self.config['VISRULES']['FK_Reg_JNT'])
        visGrp.addAttr(
            '{Side}_{Basename}_FK_Reverse_JNT'.format(**self.nameStructure),
            self.config['VISRULES']['FK_Rev_JNT'])
        visGrp.addAttr('{Side}_{Basename}_IK_JNT'.format(**self.nameStructure),
                       self.config['VISRULES']['IK_JNT'])
        visGrp.addAttr(
            '{Side}_{Basename}_MACRO_JNT'.format(**self.nameStructure),
            self.config['VISRULES']['Macro_JNT'])

        visGrp.AddSeparator(self.RIG.VISIBILITY_GRP, 'Controls')
        visGrp.addAttr(
            '{Side}_{Basename}_FK_CTRL'.format(**self.nameStructure),
            self.config['VISRULES']['FK_Reg_CTRL'])
        visGrp.addAttr(
            '{Side}_{Basename}_FK_Reverse_CTRL'.format(**self.nameStructure),
            self.config['VISRULES']['FK_Rev_CTRL'])
        visGrp.addAttr(
            '{Side}_{Basename}_IK_CTRL'.format(**self.nameStructure),
            self.config['VISRULES']['IK_CTRL'])
        visGrp.addAttr(
            '{Side}_{Basename}_CHEST_CTRL'.format(**self.nameStructure),
            self.config['VISRULES']['Chest_CTRL'])
        visGrp.addAttr(
            '{Side}_{Basename}_HIPS_CTRL'.format(**self.nameStructure),
            self.config['VISRULES']['Hips_CTRL'])

        for attr in visGrp.allAttrs.keys():
            for module in self.BUILD_MODULES:
                for grp in module.VISRULE_GRP.getChildren():
                    shortName = NC.getBasename(grp).split(
                        '{Basename}_'.format(**self.nameStructure))[-1]
                    if shortName.lower() in attr.lower():
                        try:
                            pm.connectAttr(
                                '{}.{}'.format(visGrp.subject, attr),
                                '{}.vis'.format(grp))
                        except:
                            pass
Ejemplo n.º 10
0
    def setupVisRule(tansformList, parent, name=False, defaultValue=True):
        """
        setup VisRule group for a tansform. Connect the tansform visibility to the visRule group

        Arguments:
            tansform {List} -- Control to connect
            parent {transform} -- parent of the VisRule group
        """
        if name:
            visRuleGrp = pm.group(n=name, em=1, parent=parent)
        else:
            visRuleGrp = pm.group(n='{}_{}__{}'.format(NC.getNameNoSuffix(tansformList[0]), NC.getSuffix(tansformList[0]), NC.VISRULE),  em=1, parent=parent)
        visRuleGrp.v.set(0)
        visRuleAttr = adbAttr.NodeAttr([visRuleGrp])
        visRuleAttr.addAttr('vis', defaultValue)

        for transform in tansformList:
            pm.connectAttr('{}.{}'.format(visRuleGrp, visRuleAttr.name), '{}.v'.format(transform))
        adb.lockAttr_func(visRuleGrp, ['tx', 'ty', 'tz', 'rx', 'ry', 'rx', 'rz', 'sx', 'sy', 'sz','v'])
        return visRuleGrp, visRuleAttr.name
Ejemplo n.º 11
0
 def setup_SpaceGRP(self, transform, Ik_FK_attributeName=[]):
     switch_ctrl = adbAttr.NodeAttr([transform])
     for name in Ik_FK_attributeName:
         switch_ctrl.addAttr(name, 'enum', eName="IK:FK:")
     return Ik_FK_attributeName
Ejemplo n.º 12
0
    def footGroupSetup(self):
        ## Create Attributes
        footAttr = adbAttr.NodeAttr([self.Foot_MOD.metaData_GRP])
        footAttr.addAttr('heelRoll', 0)
        footAttr.addAttr('heelSide', 0)
        footAttr.addAttr('heelTwist', 0)
        footAttr.addAttr('ballRoll', 0)
        footAttr.addAttr('toeRoll', 0)
        footAttr.addAttr('toeSide', 0)
        footAttr.addAttr('toeBend', 0)

        @changeColor('index', 2)
        def createJoints():
            points = [
                pm.PyNode(guide).getRotatePivot(space='world')
                for guide in self.starter_Foot
            ]
            self.foot_chain = Joint.Joint.point_base(
                *points,
                name='{Side}__{Basename}'.format(**self.nameStructure),
                chain=True,
                padding=2)
            self.footAnkle_joint, self.footBall_joint, self.footToes_joint, self.footHeel_joint, = self.foot_chain.joints

            # Parenting the joints
            pm.parent(self.footHeel_joint, self.footAnkle_joint)
            pm.PyNode(self.footAnkle_joint).rename(
                '{Side}__{Basename}_{Parts[0]}_END'.format(
                    **self.nameStructure))
            pm.PyNode(self.footBall_joint).rename(
                '{Side}__{Basename}_{Parts[1]}_END'.format(
                    **self.nameStructure))
            pm.PyNode(self.footToes_joint).rename(
                '{Side}__{Basename}_{Parts[2]}_END'.format(
                    **self.nameStructure))
            pm.PyNode(self.footHeel_joint).rename(
                '{Side}__{Basename}_{Parts[3]}_END'.format(
                    **self.nameStructure))
            adb.AutoSuffix(self.foot_chain.joints)

            pm.parent(self.footAnkle_joint, self.Foot_MOD.OUTPUT_GRP)
            self.footOffsetGrp = self.createPivotGrps(
                self.footAnkle_joint,
                name='{Basename}_Offset'.format(**self.nameStructure))

            ## orient joint
            if self.side == NC.RIGTH_SIDE_PREFIX:
                mirror_chain_1 = pm.mirrorJoint(self.footAnkle_joint,
                                                mirrorYZ=1)
                mirror_chain_3 = pm.mirrorJoint(mirror_chain_1[0],
                                                mirrorBehavior=1,
                                                mirrorYZ=1)
                pm.delete(self.footAnkle_joint, mirror_chain_1)
                self.foot_chain = Joint.Joint(mirror_chain_3)
                self.footAnkle_joint, self.footBall_joint, self.footToes_joint, self.footHeel_joint = self.foot_chain.joints

                pm.PyNode(self.footAnkle_joint).rename(
                    '{Side}__{Basename}_{Parts[0]}_END'.format(
                        **self.nameStructure))
                pm.PyNode(self.footBall_joint).rename(
                    '{Side}__{Basename}_{Parts[1]}_END'.format(
                        **self.nameStructure))
                pm.PyNode(self.footToes_joint).rename(
                    '{Side}__{Basename}_{Parts[2]}_END'.format(
                        **self.nameStructure))
                pm.PyNode(self.footHeel_joint).rename(
                    '{Side}__{Basename}_{Parts[3]}_END'.format(
                        **self.nameStructure))
                adb.AutoSuffix(self.foot_chain.joints)

            pm.makeIdentity(self.footOffsetGrp.getChildren(),
                            n=0,
                            t=1,
                            apply=True,
                            pn=1)
            adb.makeroot_func(self.footOffsetGrp,
                              suff='Output',
                              forceNameConvention=1)
            Transform(self.footOffsetGrp).pivotPoint = Transform(
                self.footAnkle_joint).worldTrans

            self.foot_chain.radius = 1.0
            self.nameStructure['Suffix'] = NC.VISRULE
            moduleBase.ModuleBase.setupVisRule(
                [self.footAnkle_joint], self.Foot_MOD.VISRULE_GRP,
                '{Side}__{Basename}_JNT__{Suffix}'.format(
                    **self.nameStructure), True)
            return self.foot_chain.joints

        # ============
        # Build
        # ============
        createJoints()
Ejemplo n.º 13
0
    def autoClavicule(
        self,
        arm_ik_joints=[],
        poleVector_ctl=[],
        arm_ik_offset_ctrl=[],
    ):

        self.AUTO_CLAVICULE_MOD = moduleBase.ModuleBase()
        self.AUTO_CLAVICULE_MOD._start(
            '{Side}__AutoClavicule'.format(**self.nameStructure),
            _metaDataNode='transform')
        self.BUILD_MODULES += [self.AUTO_CLAVICULE_MOD]
        pm.parent(self.AUTO_CLAVICULE_MOD.metaData_GRP, self.RIG.SETTINGS_GRP)
        pm.parent(self.AUTO_CLAVICULE_MOD.MOD_GRP, self.RIG.MODULES_GRP)

        autoClaviculeGrp = adbAttr.NodeAttr(
            [self.AUTO_CLAVICULE_MOD.metaData_GRP])
        autoClaviculeGrp.addAttr('Toggle', True)
        autoClaviculeGrp.addAttr('RemapNode', 'message')

        def ik_chain_duplicate():
            self.ik_AutoShoulder_joint = [
                pm.duplicate(joint, parentOnly=True)[0]
                for joint in arm_ik_joints
            ]
            pm.parent(self.ik_AutoShoulder_joint[-1],
                      self.ik_AutoShoulder_joint[-2])
            pm.parent(self.ik_AutoShoulder_joint[-2],
                      self.ik_AutoShoulder_joint[0])

            pm.PyNode(self.ik_AutoShoulder_joint[0]).rename(
                '{Side}__Auto{Basename}_Ik_Shoulder'.format(
                    **self.nameStructure))
            pm.PyNode(self.ik_AutoShoulder_joint[1]).rename(
                '{Side}__Auto{Basename}_Ik_Elbow'.format(**self.nameStructure))
            pm.PyNode(self.ik_AutoShoulder_joint[2]).rename(
                '{Side}__Auto{Basename}_Ik_Wrist'.format(**self.nameStructure))
            adb.AutoSuffix(self.ik_AutoShoulder_joint)

            self.nameStructure['Suffix'] = NC.IKHANDLE_SUFFIX
            autoShoulder_IkHandle, autoShoulder_IkHandle_effector = pm.ikHandle(
                n='{Side}__Auto{Basename}__{Suffix}'.format(
                    **self.nameStructure),
                sj=self.ik_AutoShoulder_joint[0],
                ee=self.ik_AutoShoulder_joint[-1])
            autoShoulder_IkHandle.v.set(0)
            self.autoShoulder_IkHandle = autoShoulder_IkHandle
            adb.makeroot_func(self.autoShoulder_IkHandle)
            pm.poleVectorConstraint(poleVector_ctl,
                                    autoShoulder_IkHandle,
                                    weight=1)

            self.AUTO_CLAVICULE_MOD.setFinalHiearchy(
                RIG_GRP_LIST=[self.autoShoulder_IkHandle.getParent()],
                OUTPUT_GRP_LIST=[self.ik_AutoShoulder_joint[0]])

            adb.matrixConstraint(arm_ik_offset_ctrl,
                                 self.autoShoulder_IkHandle.getParent())
            pm.parent(self.AUTO_CLAVICULE_MOD.MOD_GRP, self.RIG.MODULES_GRP)
            self.nameStructure['Suffix'] = NC.VISRULE
            moduleBase.ModuleBase.setupVisRule(
                [self.ik_AutoShoulder_joint[0]],
                self.AUTO_CLAVICULE_MOD.VISRULE_GRP,
                name='{Side}__{Basename}_IK_JNT__{Suffix}'.format(
                    **self.nameStructure),
                defaultValue=False)

        def claviculeSetup():
            autoShoulder_grp = adb.makeroot_func(self.clavicule_ctrl,
                                                 suff='AutoClavicule',
                                                 forceNameConvention=True)
            self.nameStructure['Suffix'] = NC.MULTIPLY_DIVIDE_SUFFIX
            autoShoulder_toggle = pm.shadingNode(
                'multiplyDivide',
                au=True,
                n='{Side}__Auto{Basename}_toggle__{Suffix}'.format(
                    **self.nameStructure))
            self.nameStructure['Suffix'] = NC.REMAP_COLOR_SUFFIX
            autoShoulder_remapNode = pm.shadingNode(
                'remapColor',
                au=True,
                n='{Side}__Auto{Basename}__{Suffix}'.format(
                    **self.nameStructure))
            autoShoulder_remapNode.outColorR >> self.AUTO_CLAVICULE_MOD.metaData_GRP.RemapNode

            if self.side == 'L':
                autoShoulder_remapNode.inputMin.set(-90)
                autoShoulder_remapNode.inputMax.set(90)
                autoShoulder_remapNode.outputMin.set(-45)
                autoShoulder_remapNode.outputMax.set(45)
            elif self.side == 'R':
                autoShoulder_remapNode.inputMin.set(90)
                autoShoulder_remapNode.inputMax.set(-90)
                autoShoulder_remapNode.outputMin.set(-45)
                autoShoulder_remapNode.outputMax.set(45)

            for color in AUTO_CLAVICULE_CONFIG.keys():
                for points in AUTO_CLAVICULE_CONFIG[color].keys():
                    pm.PyNode('{}.{}[{}].{}_Interp'.format(
                        autoShoulder_remapNode, color, str(points),
                        color)).set(3)
                    pm.PyNode('{}.{}[{}].{}_Position'.format(
                        autoShoulder_remapNode, color, str(points),
                        color)).set(AUTO_CLAVICULE_CONFIG[color][points][0])
                    pm.PyNode('{}.{}[{}].{}_FloatValue'.format(
                        autoShoulder_remapNode, color, str(points),
                        color)).set(AUTO_CLAVICULE_CONFIG[color][points][1])

            ## Connection
            claviculePoseReader = PoseReader.poseReader(
                name='{Side}__Clavicule'.format(**self.nameStructure),
                driver=self.AUTO_CLAVICULE_MOD.OUTPUT_GRP,
                target=self.ik_AutoShoulder_joint[0],
                upPostion=(0, 10, 0),
                targetPosition=(10, 0, 0),
            )[0]

            claviculePoseReader[0].rx >> autoShoulder_toggle.input1X
            claviculePoseReader[0].ry >> autoShoulder_toggle.input1Y
            claviculePoseReader[0].rz >> autoShoulder_toggle.input1Z

            autoShoulder_toggle.outputX >> autoShoulder_remapNode.colorR
            autoShoulder_toggle.outputY >> autoShoulder_remapNode.colorG
            autoShoulder_toggle.outputZ >> autoShoulder_remapNode.colorB

            autoShoulder_remapNode.outColorR >> autoShoulder_grp.rx
            autoShoulder_remapNode.outColorG >> autoShoulder_grp.ry
            autoShoulder_remapNode.outColorB >> autoShoulder_grp.rz

            self.AUTO_CLAVICULE_MOD.metaData_GRP.Toggle >> autoShoulder_toggle.input2X
            self.AUTO_CLAVICULE_MOD.metaData_GRP.Toggle >> autoShoulder_toggle.input2Y
            self.AUTO_CLAVICULE_MOD.metaData_GRP.Toggle >> autoShoulder_toggle.input2Z

        # ============================
        # BUILD
        # ============================
        ik_chain_duplicate()
        claviculeSetup()
Ejemplo n.º 14
0
def poseReader(name = '', driver='joint1__CTRL', target = 'joint2__CTRL', upPostion = (0,10,0), targetPosition = (10,0,0), twistPosition = (0,0,10), twist=False):
    """
    Create a Pose Reader

    import adb_library.adb_utils.Script__PoseReader as PoseReader
    PoseReader.PoseReader()

    """
    poseReaderGrp = pm.createNode('transform', name='{}_PoseReader__{}'.format(name, NC.GRP))
    pm.matchTransform(poseReaderGrp, driver, pos=True, rot=False)
    mainPoseReader = Locator.Locator.create(name='{}_tempPoseReader__{}'.format(name, NC.LOC))
    mainPoseReaderOutput = Locator.Locator.create(name='{}_MainPoseReader__{}'.format(name, NC.LOC))
    upPoseReader = Locator.Locator.create(name='{}_UpPoseReader__{}'.format(name, NC.LOC))
    targetPoseReader = Locator.Locator.create(name='{}_TargetPoseReader__{}'.format(name, NC.LOC))

    poseReaderLocs = [mainPoseReader.locators, upPoseReader.locators, targetPoseReader.locators, mainPoseReaderOutput.locators]

    [pm.matchTransform(loc, target, pos=True, rot=False) for loc in poseReaderLocs]
    [pm.parent(loc, poseReaderGrp) for loc in poseReaderLocs]
    targetGrp = adb.makeroot_func(targetPoseReader.locators)

    pm.move(upPoseReader.locators[0], upPostion, r=1, os=1, wd=1)
    pm.move(targetPoseReader.locators[0], targetPosition, r=1, os=1, wd=1)

    pm.aimConstraint(targetPoseReader.locators[0], mainPoseReader.locators[0], weight=1, upVector=tuple(dt.Vector(upPostion).normal()), worldUpObject=upPoseReader.locators[0], worldUpType="object", offset=(0, 0, 0), aimVector=tuple(dt.Vector(targetPosition).normal()))

    pm.parent(poseReaderGrp, driver)
    adb.matrixConstraint(target, targetGrp)

    # add double Function
    adb.makeroot_func(mainPoseReader.locators)
    adb.makeroot_func(upPoseReader.locators)

    mainPoseReader.locators[0].tx.set(targetPosition[0]*-1)
    upPoseReader.locators[0].tx.set(targetPosition[0]*-1)
    
    mult = pm.shadingNode('multiplyDivide', asUtility=1, n='{}_PR_double__{}'.format(name, NC.MULTIPLY_DIVIDE_SUFFIX))
    mult.input2X.set(2)
    mult.input2Y.set(2)
    mult.input2Z.set(2)

    mainPoseReader.locators[0].rx >> mult.input1X
    mainPoseReader.locators[0].ry >> mult.input1Y
    mainPoseReader.locators[0].rz >> mult.input1Z

    mult.outputX >> mainPoseReaderOutput.locators[0].rx
    mult.outputY >> mainPoseReaderOutput.locators[0].ry
    mult.outputZ >> mainPoseReaderOutput.locators[0].rz

    ## add Twist
    if twist:
        twistPoseReaderGrp = pm.createNode('transform', name='{}_TwistPoseReader__{}'.format(name, NC.GRP))
        pm.matchTransform(twistPoseReaderGrp, driver, pos=True, rot=False)
        twistMainPoseReader = Locator.Locator.create(name='{}_TwistMainPoseReader__{}'.format(name, NC.LOC))
        twistTargetPoseReader = Locator.Locator.create(name='{}_TwistTargetPoseReader__{}'.format(name, NC.LOC))
        twistUpPoseReader = Locator.Locator.create(name='{}_TwistUpPoseReader__{}'.format(name, NC.LOC))

        twistPoseReaderLocs = [twistMainPoseReader.locators, twistUpPoseReader.locators, twistTargetPoseReader.locators]
        [pm.parent(loc, twistPoseReaderGrp) for loc in twistPoseReaderLocs]
        pm.parent(twistPoseReaderGrp, poseReaderGrp)

        [pm.matchTransform(loc, target, pos=True, rot=False) for loc in twistPoseReaderLocs]

        pm.move(twistUpPoseReader.locators[0], targetPosition, r=1, os=1, wd=1)
        pm.move(twistTargetPoseReader.locators[0], twistPosition, r=1, os=1, wd=1)

        pm.aimConstraint(twistTargetPoseReader.locators[0], twistMainPoseReader.locators[0], weight=1, upVector=tuple(dt.Vector(targetPosition).normal()), worldUpObject=twistUpPoseReader.locators[0], worldUpType="object", offset=(0, 0, 0), aimVector=tuple(dt.Vector(twistPosition).normal()))
        pm.parent(twistTargetPoseReader.locators[0], targetGrp)

        mult.outputY >> twistPoseReaderGrp.ry
        mult.outputZ >> twistPoseReaderGrp.rz

    ## add Extra Attributes
    mainLocAttr = adbAttr.NodeAttr(mainPoseReaderOutput.locators)
    mainLocAttr.addAttr('bend', 0)
    mainLocAttr.addAttr('twist', 0)
    mainLocAttr.addAttr('bendSide', 0)

    if twist:
        twistMainPoseReader.locators[0].rx >>mainPoseReaderOutput.locators[0].twist
    mainPoseReaderOutput.locators[0].ry >> mainPoseReaderOutput.locators[0].bendSide
    mainPoseReaderOutput.locators[0].rz >>mainPoseReaderOutput.locators[0].bend


    poseReaderGrp.v.set(0)
    return mainPoseReaderOutput.locators, upPoseReader.locators, targetPoseReader.locators



# poseReader()
Ejemplo n.º 15
0
def follicule_rivet(
    references_obj,
    target_mesh,
    visibility=True,
):
    """
    Method that creates a follicule rivet on the target mesh base on the position of the 
    reference object
    
    # NOTES: UV must be done on the target mesh in order to work properly
    
        @param obj            : (list) list of objects that is used as reference to get the closest point on the surface
        @param target_mesh    : (str) name of the transform of the mesh.
        @param visibility     : (bool) visibility of the locators

    Returns:
            (list) Follicules, follicule_locs

    """

    follicule_sys = adbFolli.Folli(1,
                                   len(references_obj),
                                   radius=0.5,
                                   sub=target_mesh)
    follicule_joint = follicule_sys.getJoints
    follicule_shape = follicule_sys.getFollicules
    follicules = [x.getParent() for x in follicule_shape]
    follicule_locs = []

    ## Set u_v values
    u_v_values = [
        Transform.get_closest_u_v_point_on_mesh(obj, target_mesh)
        for obj in references_obj
    ]
    for uv_values, joint in zip(u_v_values, follicule_joint):
        joint.u_param.set(uv_values[0] * 100)
        joint.v_param.set(uv_values[1] * 100)

    ## Replace follicules_joints by a locators
    for fol_jnt, fol in zip(follicule_joint, follicules):
        foll_loc = pm.spaceLocator()
        follicule_locs.append(foll_loc)
        pm.rename(foll_loc, fol_jnt.replace('jnt', 'loc'))
        pm.matchTransform(foll_loc, fol, pos=True, rot=True)
        pm.parent(foll_loc, fol_jnt.getParent())
        follicule_loc_attr = adbAttr.NodeAttr([foll_loc])
        follicule_loc_attr.addAttr('U_Param',
                                   fol_jnt.u_param.get(),
                                   min=-100,
                                   max=100)
        follicule_loc_attr.addAttr('V_Param',
                                   fol_jnt.v_param.get(),
                                   min=-100,
                                   max=100)
        foll_loc.U_Param >> fol.u_param
        foll_loc.V_Param >> fol.v_param

    ## Clean up
    pm.delete(fol_jnt)
    [x.v.set(0) for x in follicule_shape]  ## Hide the red follicule
    [x.v.set(visibility) for x in follicule_locs]

    return follicules, follicule_locs
Ejemplo n.º 16
0
def buildRivet(scale = 0.2):
    """ 
    Creates a Rivet Between 2 edges
    Returns : - Rivet locator, 
              - List of the 2 edge from curves nodes 
              - Mesh Name
    """
    
    if not (pm.pluginInfo('matrixNodes', q=True, loaded=True)):
        pm.loadPlugin( 'matrixNodes' )        
    _edges = pm.filterExpand(selectionMask = 32) ## Edge
    
    if len(_edges) < 2:
        pm.warning('n\Need 2 edges selected')
    
    elif len(_edges) > 2:
        pm.error('Too much edges selected! Only select 2!!')
        
    else:    
        objectFromEdge = _edges[0].split('.')[0]
        edgeMaxNumber = pm.polyEvaluate(objectFromEdge, edge = True)
        objectShape = pm.PyNode(objectFromEdge).getShape()
        edgeCount = len(_edges)
        edgeNumber = [(edge.split('.e[')[1]).split(']')[0] for edge in _edges]

        ## RIVET LOC AND GRP SET UP
        rivet_grp= pm.group(em=True, name = '{}_rivet__grp__'.format(objectFromEdge))
        rivet_locator = pm.spaceLocator(name = '{}_rivet'.format(objectFromEdge))
        adb.changeColor_func(rivet_locator, 'index', col = 17)
        
        pm.PyNode(rivet_locator).localScaleX.set(scale)
        pm.PyNode(rivet_locator).localScaleY.set(scale)
        pm.PyNode(rivet_locator).localScaleZ.set(scale)
        
        pm.parent(rivet_locator, rivet_grp)
        _rivet_Attr = adbAttr.NodeAttr([rivet_locator])
        _rivet_Attr.addAttr("edges_index", 'float2', nc=2)
        _rivet_Attr.addAttr("edge_index_0", int(edgeNumber[0]), min = 0, max = edgeMaxNumber, parent = "edges_index")
        _rivet_Attr.addAttr("edge_index_1", int(edgeNumber[1]), min = 0, max = edgeMaxNumber, parent = "edges_index")
        
        print _rivet_Attr
        _rivet_Attr.addAttr("UV", 'float2', nc=2)
        _rivet_Attr.addAttr("U_pos", 0.5, min = 0, max = 1, parent = "UV")
        _rivet_Attr.addAttr("V_pos", 0.5, min = 0, max = 1, parent = "UV")

        ## NODES CREATION
        curveFromEdge_nodes = [pm.createNode('curveFromMeshEdge', name = 'curveFromEdge_{}_{}'.format(objectFromEdge, x)) for x in edgeNumber]
        loft_node = pm.createNode('loft', name = 'rivet_loft__node__')
        pm.PyNode(loft_node).degree.set(1)

        pointOnSurface_node = pm.createNode('pointOnSurfaceInfo', name = 'pointOnSurface_node')
        pm.PyNode(pointOnSurface_node).turnOnPercentage.set(1)

        matrix_node = pm.createNode('fourByFourMatrix', name = 'mat__node__')
        decomposeMatrix_node = pm.createNode('decomposeMatrix', name = 'decompMat__node__')

        ## MAKING THE CONNECTIONS
        objectShape.worldMesh >> pm.PyNode(curveFromEdge_nodes[0]).inputMesh
        objectShape.worldMesh >> pm.PyNode(curveFromEdge_nodes[1]).inputMesh

        for index in range(0, edgeCount):
            pm.PyNode('{}.{}'.format(curveFromEdge_nodes[index], 'outputCurve')) >> pm.PyNode('{}.inputCurve[{}]'.format(loft_node, index))        
        loft_node.outputSurface >> pointOnSurface_node.inputSurface
        rivet_locator.U_pos >> pointOnSurface_node.parameterU
        rivet_locator.V_pos >> pointOnSurface_node.parameterV

        pos_node_attr = ['normal', 'tangentU.tangentU', 'tangentV.tangentV', 'position.position']
        xyz = 'XYZ'

        for i in range(len(pos_node_attr)):
            for j in range(3):
                axe =  xyz[j]
                if 'tU' in pos_node_attr[i]: axe = axe.lower()
                elif 'tV' in pos_node_attr[i]: axe = axe.lower()
                pm.PyNode('{}.{}{}'.format(pointOnSurface_node, pos_node_attr[i], axe)) >> pm.PyNode('{}.in{}{}'.format(matrix_node, i, j))                
        matrix_node.output >> decomposeMatrix_node.inputMatrix
        for i in range(3):
            axe =  xyz[i]
            pm.PyNode('{}.outputRotate{}'.format(decomposeMatrix_node, axe)) >> pm.PyNode('{}.rotate{}'.format(rivet_grp, axe))
            pm.PyNode('{}.outputTranslate{}'.format(decomposeMatrix_node, axe)) >> pm.PyNode('{}.translate{}'.format(rivet_grp, axe))

        rivet_locator.edge_index_0 >> curveFromEdge_nodes[0].edgeIndex[0]
        rivet_locator.edge_index_1 >> curveFromEdge_nodes[1].edgeIndex[0]

        sys.stdout.write('// Result: Rivet created! // \n')
        return rivet_locator, curveFromEdge_nodes, objectFromEdge
Ejemplo n.º 17
0
 def setup_SettingGRP(self):
     setting_ctrl = adbAttr.NodeAttr([self.RIG.SETTINGS_GRP])
     adbAttr.NodeAttr.copyAttr(
         self.AUTO_CLAVICULE_MOD.metaData_GRP, [self.RIG.SETTINGS_GRP],
         nicename='{Side}_AutoClavicule'.format(**self.nameStructure),
         forceConnection=True)
Ejemplo n.º 18
0
pm.skinCluster(folli_proxy, bind_joints)

adbWrap.wrapDeformer(ik_spline_curve, ik_curve_proxy)
wrap_ik_spline = adbWrap.wrapDeformer(geo, ik_spline_proxy)
wrap_folli = adbWrap.wrapDeformer(geo, folli_proxy)

wrap_ik_spline.rename('x__ik_spline__wrap__')
wrap_folli.rename('x__follicule__wrap__')

## Swith set up
rv_ik_spline = pm.shadingNode('remapValue', asUtility=1, n='ik_spline__rv__')
rev_ik_spline = pm.shadingNode('reverse', asUtility=1, n='ik_spline__rv__')

rv_ik_spline.inputMin.set(1)
rv_ik_spline.inputMax.set(10)

## add the swith attribute
ik_blend_ctrl = adbAttr.NodeAttr([attribute_ctrl])
ik_blend_ctrl.addAttr('IK_blend', 1, min=1, max=10)

ParamBlend = pm.PyNode(attribute_ctrl).name() + ".IK_blend"

pm.PyNode(ParamBlend) >> pm.PyNode(rv_ik_spline).inputValue

pm.PyNode(rv_ik_spline).outValue >> pm.PyNode(wrap_folli).envelope
pm.PyNode(rv_ik_spline).outValue >> pm.PyNode(rev_ik_spline).inputX
pm.PyNode(rev_ik_spline).outputX >> pm.PyNode(wrap_ik_spline).envelope

## Clean up
pm.PyNode(ik_spline_curve).v.set(False)
Ejemplo n.º 19
0
def wrapDeformer(_HiRez=pm.selected(), _LoRez=pm.selected()):
    """
    Custom wrapDeformer
    Select target - HiRez first, then the source - LoRez
    @param Hirez: Target which will receive the wrap : str or selection
    @param Lorez: Source : str of selection   
    
    ## EXTERIOR CLASS BUILD
    #------------------------
    import adb_utils.Script__WrapDeformer as adbWrap
    reload(adbWrap)

    #or
    from adb_utils.Script__WrapDeformer import wrapDeformer              
    """
    ## Define Variable type
    if isinstance(_HiRez, str) and isinstance(_LoRez, str):
        print('a')
        HiRez = _HiRez
        LoRez = _LoRez

    elif len(_HiRez) == 2:
        print('b')
        HiRez = _HiRez[0]
        LoRez = _LoRez[1]

    else:
        print('c')
        HiRez = _HiRez
        LoRez = _LoRez

    ## get Orig node
    orig_node = adb.getShapeOrig(LoRez)
    if orig_node == None:
        cls = pm.cluster(LoRez)
        pm.delete(cls)
        orig_node = adb.getShapeOrig(LoRez)
        # raise RuntimeError("No 'Orig' Node for: {}".format(LoRez))

    ## Wrap Node creation
    pm.select(HiRez, r=True)
    pm.select(LoRez, add=True)
    wrapData = pm.deformer(HiRez,
                           name='{}_{}'.format(HiRez, 'wrap'),
                           type='wrap')[0]

    pm.PyNode(wrapData).maxDistance.set(1)
    pm.PyNode(wrapData).autoWeightThreshold.set(1)
    pm.PyNode(wrapData).exclusiveBind.set(0)
    pm.PyNode(wrapData).falloffMode.set(0)

    ## add custom attribute on LoRez mesh
    if adb.attrExist(LoRez, 'dropoff'):
        pass
    else:
        LoRez_node = adbAttr.NodeAttr([LoRez])
        LoRez_node.addAttr('dropoff', 4)
        LoRez_node.addAttr('smoothness', 0)
        LoRez_node.addAttr('inflType', 2)

    ## Connections
    (pm.PyNode(LoRez).getShape()
     ).worldMesh[0] >> pm.PyNode(wrapData).driverPoints[0]
    (pm.PyNode(HiRez).getShape()
     ).worldMatrix[0] >> pm.PyNode(wrapData).geomMatrix
    pm.PyNode(LoRez).dropoff >> pm.PyNode(wrapData).dropoff[0]
    pm.PyNode(LoRez).inflType >> pm.PyNode(wrapData).inflType[0]
    pm.PyNode(LoRez).smoothness >> pm.PyNode(wrapData).smoothness[0]
    pm.PyNode(orig_node).worldMesh[0] >> pm.PyNode(wrapData).basePoints[0]

    ## Clean Up)
    pm.PyNode(LoRez).v.set(0)

    sys.stdout.write('custom wrap deformer created \n')

    return wrapData


# wrapDeformer()
Ejemplo n.º 20
0
def ik_fk_switch(
    ctrl_name='',
    blend_attribute='',
    result_joints=[],
    ik_joints=[],
    fk_joints=[],
    lenght_blend=1,
):
    """
    Function to create an Ik - Fk rotation based script
    
    @param ctrl_name            : (str) Name of the control having the switch attribute
    @param blend_attribute      : (sr)  Name of blend attribute
    @param result_joints        : (list) List of result joints
    @param ik_joints            : (list) List of ik joints
    @param fk_joints            : (list) List of fk joints
    
    example:
    ik_fk_switch(ctrl_name = 'locator1',
                blend_attribute = 'ik_fk_switch',
                result_joints = ['result_01', 'result_02', 'result_03'],
                ik_joints = ['ik_01', 'ik_02', 'ik_03'],
                fk_joints = ['fk_01', 'fk_02', 'fk_03'],
            )
    
    """

    ## add attribute message
    switch_ctrl = adbAttr.NodeAttr([ctrl_name])
    switch_ctrl.addAttr('lenght_blend', lenght_blend, keyable=False)

    ## Creation of the remaps values and blendColor nodes
    BlendColorColl_R = [
        pm.shadingNode('blendColors', asUtility=1, n="Rotate__BC")
        for x in result_joints
    ]
    RemapValueColl = [
        pm.shadingNode('remapValue', asUtility=1, n="Blend__RV")
        for x in result_joints
    ]

    ## Connect the FK in the Color 1
    for oFK, oBlendColor in zip(ik_joints, BlendColorColl_R):
        pm.PyNode(oFK).rx >> pm.PyNode(oBlendColor).color1R
        pm.PyNode(oFK).ry >> pm.PyNode(oBlendColor).color1G
        pm.PyNode(oFK).rz >> pm.PyNode(oBlendColor).color1B

    ## Connect the IK in the Color 2
    for oIK, oBlendColor in zip(fk_joints, BlendColorColl_R):
        pm.PyNode(oIK).rx >> pm.PyNode(oBlendColor).color2R
        pm.PyNode(oIK).ry >> pm.PyNode(oBlendColor).color2G
        pm.PyNode(oIK).rz >> pm.PyNode(oBlendColor).color2B

    ## Connect the BlendColor node in the Blend joint chain
    for oBlendColor, oBlendJoint in zip(BlendColorColl_R, result_joints):
        pm.PyNode(oBlendColor).outputR >> pm.PyNode(oBlendJoint).rx
        pm.PyNode(oBlendColor).outputG >> pm.PyNode(oBlendJoint).ry
        pm.PyNode(oBlendColor).outputB >> pm.PyNode(oBlendJoint).rz

    for oBlendColor in BlendColorColl_R:
        pm.PyNode(oBlendColor).blender.set(1)

    ## Connect the Remap Values to Blend Colors
    for oRemapValue, oBlendColor in zip(RemapValueColl, BlendColorColl_R):
        pm.PyNode(oRemapValue).outValue >> pm.PyNode(oBlendColor).blender

    ## Connect the IK -FK Control to Remap Value
    blend_switch = '{}.{}'.format(ctrl_name, blend_attribute)
    for each in RemapValueColl:
        pm.PyNode(blend_switch) >> pm.PyNode(each).inputValue
        pm.PyNode('{}.{}'.format(
            ctrl_name, switch_ctrl.attrName)) >> pm.PyNode(each).inputMax