def addLockKneeElbow(): ''' add lock knee/elbow feature ''' ikCtrls = {'FL':('IK_ARM_FL_CTRL', 'ElbowLock', 'PVC_ARM_FL_CTRL' , 'jIKArmFL', 'jIKClavL02'), 'FR':('IK_ARM_FR_CTRL', 'ElbowLock', 'PVC_ARM_FR_CTRL' , 'jIKArmFR', 'jIKClavR02'), 'BL':('IK_LEG_BL_CTRL', 'KneeLock', 'PVC_LEG_BL_CTRL', 'jIKLegBL', 'jIKHipBL02'), 'BR':('IK_LEG_BR_CTRL', 'KneeLock', 'PVC_LEG_BR_CTRL', 'jIKLegBR', 'jIKHipBR02')} for side in ikCtrls: pm.addAttr(ikCtrls[side][0], sn=ikCtrls[side][1], at='bool') lockAttr = pm.PyNode('%s.%s'%(ikCtrls[side][0], ikCtrls[side][1])) lockAttr.set(0, keyable=True, lock=False) pt1 = pm.PyNode(ikCtrls[side][4]) pt2 = pm.PyNode(ikCtrls[side][2]) pt3 = pm.PyNode(ikCtrls[side][0]) pt1pos = pm.xform(pt1, q=True, ws=True, rp=True) pt2pos = pm.xform(pt2, q=True, ws=True, rp=True) pt3pos = pm.xform(pt3, q=True, ws=True, rp=True) dim1 = pm.distanceDimension(startPoint=pt1pos, endPoint=pt2pos) dim1Parent = dim1.listRelatives(parent=True)[0] dim1Parent.rename('%s_lockPos_01'%side) dim2 = pm.distanceDimension(startPoint=pt3pos, endPoint=pt2pos) dim2Parent = dim2.listRelatives(parent=True)[0] dim2Parent.rename('%s_lockPos_02'%side) loc = dim1.endPoint.listConnections()[0] loc.rename('loc_%s_%s'%(side,ikCtrls[side][1])) pm.parentConstraint(ikCtrls[side][2], loc, mo=True) pm.scaleConstraint('CONSTRAIN', loc, mo=True) pm.parent((dim1, dim2, loc), 'misc') cond = pm.createNode('condition', name='cond_adjust_%s_%s'%(side,ikCtrls[side][1])) jnt01 = pm.PyNode('%s02'%ikCtrls[side][3]) jnt02 = pm.PyNode('%s03'%ikCtrls[side][3]) lockAttr >> cond.firstTerm cond.secondTerm.set(1) dim1.distance >> cond.colorIfTrueR dim2.distance >> cond.colorIfTrueG cond.colorIfFalseR.set( jnt01.tx.get() ) cond.colorIfFalseG.set( jnt02.tx.get() ) cond.outColorR >> jnt01.tx cond.outColorG >> jnt02.tx
def focusRig(): currentSelection = pmc.selected() warningMsg = "Please make a valid selection, first camera and then focus geometry!" if len(currentSelection) != 2: return pmc.displayWarning(warningMsg) cameraTransform, focusTransform = currentSelection cameraShape = cameraTransform.getShape() if cameraShape.type() != "camera": return pmc.displayWarning(warningMsg) distance = pmc.distanceDimension(sp=focusTransform.getRotatePivot(space='world'), ep=cameraTransform.getRotatePivot(space='world')) distance.rename('lsFocusRigShape') distance.getParent().rename('lsFocusRig') focusLocator, nodalLocator = distance.listConnections() focusLocator.rename('lsFocusPoint') nodalLocator.rename('lsCameraNodal') pmc.parent(nodalLocator, cameraTransform) pmc.parent(distance.getParent(), cameraTransform) # Needs to only continue if arnold is valid if Renderer.isArnold: cameraShape.aiEnableDOF.set(1) cameraShape.aiApertureSize.set(1) distance.distance >> cameraShape.aiFocusDistance else: cameraShape.depthOfField.set(1) distance.distance >> cameraShape.focusDistance
def create_scale_distance(self): self._MODEL.getScaleGrp = [adb.makeroot_func(grp, suff='scale', forceNameConvention=True) for grp in self.jointList] for grp in self._MODEL.getScaleGrp: self.MOD_GRP.sx >> grp.sx self.MOD_GRP.sy >> grp.sy self.MOD_GRP.sz >> grp.sz distObjs_LIST_QDT = self.ribbon_ctrl distanceNode_shape = pm.distanceDimension(sp=(1, 1, 1), ep=(2, 2, 2)) pm.rename(distanceNode_shape, 'bendy_scale_distDimShape') pm.rename(pm.PyNode(distanceNode_shape).getParent(), 'bendy_scale_distDim') distanceNode = (pm.PyNode(distanceNode_shape).getParent()) end_point_loc = pm.listConnections(str(distanceNode_shape) + '.endPoint', source=True)[0] start_point_loc = pm.listConnections(str(distanceNode_shape) + '.startPoint', source=True)[0] pm.rename(start_point_loc, '{}_Dist__{}'.format(distObjs_LIST_QDT[0], NC.LOC)) pm.rename(end_point_loc, '{}_Dist__{}'.format(distObjs_LIST_QDT[1], NC.LOC)) pm.matchTransform(start_point_loc, distObjs_LIST_QDT[0]) pm.matchTransform(end_point_loc, distObjs_LIST_QDT[1]) [loc.v.set(0) for loc in [end_point_loc, start_point_loc]] self.scale_grp = pm.group(n='{}_scale__{}'.format(self.NAME, NC.GRP), w=True, em=True) pm.parent(distanceNode, start_point_loc, end_point_loc, self.scale_grp) self.scale_grp.v.set(0) return distanceNode_shape
def directPlacementMode(card): assert len(card.joints) == 3 grp = group(em=True, n='DirectPlacement_Deletable') ctrls = [] for bpj in card.joints: ctrl = tempWidget() pdil.dagObj.matchTo(ctrl, bpj) ctrls.append(ctrl) ctrl.setParent(grp) base, up, aim = ctrls aimLoc = spaceLocator() aimLoc.setParent(aim) aimLoc.t.set(0, 0, 0) baseLoc = spaceLocator() baseLoc.setParent(base) baseLoc.t.set(0, 0, 0) dist = distanceDimension(baseLoc, aimLoc) dist.getParent().setParent(grp) hide(dist) pointConstraint(base, card, mo=True) aimConstraint(aim, card, wut='object', wuo=up, aim=[0, -1, 0], u=[0, 0, -1], mo=True) # save base dimension # current dimesion / base dimension # multiply x, z by card's existing scale dist.addAttr('baseDist', at='double', dv=dist.distance.get()) scaled = pdil.math.divide(dist.distance, dist.baseDist) mult = createNode('multiplyDivide') scaled >> mult.input1X scaled >> mult.input1Y scaled >> mult.input1Z mult.input2Y.set(card.sy.get()) mult.input2Z.set(card.sz.get()) mult.outputY >> card.sy mult.outputZ >> card.sz pointConstraint(up, card.joints[1], sk='x')
def createDistanceTool(objA=None, objB=None): """ A better version of Maya's Distance Tool """ if objA == None and objB == None: objA, objB = getSelection(2) elif objA == None or objB == None: raise SelectionError("Incorrect Selection!") spPos = getPosition(objA) epPos = getPosition(objB) distanceNode = pm.distanceDimension(sp=spPos, ep=epPos) locSp = pm.listConnections(str(distanceNode) + ".startPoint")[0] locEp = pm.listConnections(str(distanceNode) + ".endPoint")[0] return [locSp, locEp]
def create_height_measure( feet=0, inches=0, scale=.1, name=False ): ''' usage: create_height_measure( feet=5, inches=11, name='maleRunnerB' ) ''' pm.select(cl=True) in_to_cm = 2.54 inches += feet * 12 height = (inches * in_to_cm) * scale distance_nodes = pm.distanceDimension( sp=[0,0,0], ep=[0, height, 0] ) return pm.group(distance_nodes, name=name)
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)
def creatDist(): sel = pm.ls(sl=True) print sel distNodeShape = pm.distanceDimension(sp=[0, 0, 0], ep=[0, 50, 0]) distNode = pm.listRelatives(distNodeShape, fullPath=True, parent=True) print distNode locs = pm.listConnections(distNodeShape, s=True) print locs pm.rename(locs[0], (sel[0].name() + "_dist_loc1")) pm.rename(locs[1], (sel[1].name() + "_dist_loc2")) pm.rename(distNode, (sel[0].name() + "_dist")) pm.pointConstraint(sel[1], locs[1], w=True) pm.pointConstraint(sel[0], locs[0], w=True)
def creatDist(): sel = pm.ls(sl = True) print sel distNodeShape = pm.distanceDimension(sp = [0,0,0], ep = [0,50,0]) distNode = pm.listRelatives(distNodeShape, fullPath = True, parent = True) print distNode locs = pm.listConnections(distNodeShape, s = True) print locs pm.rename(locs[0], (sel[0].name() + "_dist_loc1")) pm.rename(locs[1], (sel[1].name() + "_dist_loc2")) pm.rename(distNode, (sel[0].name() + "_dist")) pm.pointConstraint(sel[1], locs[1], w = True) pm.pointConstraint(sel[0], locs[0], w = True)
def rollingWheel(forwardAxis="translateZ", rotationAxis="rotateX", centerPosObj='', bottomPosObj='', rollingObject='', controller='', suffix="roll"): """ gets radius from bottom and center, uses the translate of controller to move forward, attaching rotation to rollingObject bug: can only move in a single direction. """ if not centerPosObj and bottomPosObj and rollingObject and controller: logger.info('Arguments not satisfied') return #create nodes piNode = pm.shadingNode('multiplyDivide', asUtility=True, n=suffix + '_pi_md') distanceNode = pm.shadingNode('multiplyDivide', asUtility=True, n=suffix + '_distance_md') fwdNode = pm.shadingNode('multiplyDivide', asUtility=True, n=suffix + '_fwd_md') degreeRotNode = pm.shadingNode('multiplyDivide', asUtility=True, n=suffix + '_degreeRot_md') distanceDimensionNode = pm.distanceDimension( sp=(centerPosObj.getTranslation()), ep=(bottomPosObj.getTranslation())) #set initial inputs degreeRotNode.setAttr('input2X', -360) piNode.setAttr('input2X', 3.14) distanceNode.setAttr('input2X', 2) fwdNode.setAttr('operation', 2) #connectInputs distanceDimensionNode.connectAttr('distance', distanceNode.input1X) distanceNode.connectAttr('outputX', piNode.input1X) piNode.connectAttr('outputX', fwdNode.input2X) fwdNode.connectAttr('outputX', degreeRotNode.input1X) controller.connectAttr(forwardAxis, fwdNode.input1X) degreeRotNode.connectAttr('outputX', rollingObject + '.' + rotationAxis)
def creatDist(sel = None): if not sel: sel = pm.ls(sl = True) if len(sel) == 2: distNodeShape = pm.distanceDimension(sp = [0,0,0], ep = [0,50,0]) distNode = pm.listRelatives(distNodeShape, fullPath = True, parent = True) locs = pm.listConnections(distNodeShape, s = True) pm.rename(locs[0], (sel[0].name() + "_dist_loc1")) pm.rename(locs[1], (sel[1].name() + "_dist_loc2")) pm.rename(distNode, (sel[0].name() + "_dist")) pm.pointConstraint(sel[1], locs[1], w = True) pm.pointConstraint(sel[0], locs[0], w = True) return distNodeShape, locs else: om.MGlobal_displayError('non conform selection')
def measure(start, end, name='measureLocs'): ''' Given 2 objects, makes and point constrains locators to them and measures. ''' a = spaceLocator() pointConstraint(start, a) b = spaceLocator() pointConstraint(end, b) dist = distanceDimension(a, b) hide(a, b, dist) grp = group(em=True, name=name) grp.inheritsTransform.set(False) a.setParent(grp) b.setParent(grp) return dist.getParent(), grp
def measure(start, end, name='measureLocs'): ''' Given 2 objects, makes and point constrains locators to them and measures. .. todo:: Should this be combined with `distanceBetween`? #--# was skeleton.util.measure ''' a = spaceLocator() pointConstraint(start, a) b = spaceLocator() pointConstraint(end, b) dist = distanceDimension(a, b) #a.setParent( dist.getParent() ) #b.setParent( dist.getParent() ) hide(a, b, dist) return dist.getParent(), group(a, b, name=name)
def stretchyIKSetUp(self): """ Creates a stretch system for an arm or leg """ # ----------------------------------- # FUNCTION # ----------------------------------- def createloc(sub=pm.selected()): """Creates locator at the Pivot of the object selected """ locs = [] for sel in sub: loc_align = pm.spaceLocator(n='{}_Distance__{}'.format( NC.getNameNoSuffix(sel), NC.LOC)) locs.append(loc_align) pm.matchTransform(loc_align, sel, rot=True, pos=True) pm.select(locs, add=True) return locs self.posLoc = createloc([self.startJnt, self.endJnt]) sp = (pm.PyNode(self.posLoc[0]).translateX.get(), pm.PyNode(self.posLoc[0]).translateY.get(), pm.PyNode(self.posLoc[0]).translateZ.get()) ep = (pm.PyNode(self.posLoc[1]).translateX.get(), pm.PyNode(self.posLoc[1]).translateY.get(), pm.PyNode(self.posLoc[1]).translateZ.get()) # ----------------------------------- # IK STRETCH BUILD # ----------------------------------- # create Nodes self.distanceLoc = pm.distanceDimension(sp=sp, ep=ep) self.orig_distance = self.distanceLoc.distance.get() # getMaxdistance def getMaxDistance(): oriTranslate = self.ik_ctrl.getTranslation() pm.move(self.ik_ctrl, -1000, -1000, 0) _max_distance = self.distanceLoc.distance.get() self.ik_ctrl.setTranslation(oriTranslate) return _max_distance max_distance = getMaxDistance() + 0.2 # condition node self.cond_node = pm.shadingNode('condition', asUtility=1, n='{}_cond_{}'.format( self.NAME, NC.CONDITION_SUFFIX)) self.cond_node.operation.set(3) self.cond_node.colorIfFalseR.set(1) self.cond_node.secondTerm.set(1) # blendColor node Toggle self.toggle_node = pm.shadingNode('blendColors', asUtility=1, n='{}_Toggle__{}'.format( self.NAME, NC.BLENDCOLOR_SUFFIX)) self.toggle_node.blender.set(1) # multiply Divide strech self.md_strech_node = pm.shadingNode('multiplyDivide', asUtility=1, n='{}_strech__MD'.format( self.NAME, NC.MULTIPLY_DIVIDE_SUFFIX)) self.md_strech_node.operation.set(1) # multiply Divide Scale Factor self.md_scale_node = pm.shadingNode('multiplyDivide', asUtility=1, n='{}_scaleFactor__{}'.format( self.NAME, NC.MULTIPLY_DIVIDE_SUFFIX)) self.md_scale_node.operation.set(1) self.md_scale_node.input2X.set(max_distance) self.MOD_GRP.sx >> self.md_scale_node.input1X # multiply Divide proportion self.md_prp_node = pm.shadingNode('multiplyDivide', asUtility=1, n='{}_proportion__{}'.format( self.NAME, NC.MULTIPLY_DIVIDE_SUFFIX)) self.md_prp_node.operation.set(2) adb.makeroot_func(self.posLoc[1], suff='OFFSET', forceNameConvention=1) # connections self.distanceLoc.distance >> self.toggle_node.color1R self.toggle_node.outputR >> self.md_prp_node.input1X self.md_prp_node.outputX >> self.cond_node.firstTerm self.md_prp_node.outputX >> self.cond_node.colorIfTrueR self.md_scale_node.outputX >> self.md_prp_node.input2X self.cond_node.outColorR >> self.md_strech_node.input1X self.cond_node.outColorR >> self.md_strech_node.input1Y self.md_strech_node.outputX >> pm.PyNode( self.startJnt) + '.scale' + str(self.stretchAxis) for joint in self.hingeJnts: self.md_strech_node.outputX >> pm.PyNode(joint) + '.scale' + str( self.stretchAxis) # Clean up self.posLoc[0].v.set(0) self.posLoc[1].v.set(0) self.distanceLoc.getParent().v.set(0)
def MakeIkStretchy( ikh=None, elbowLock=True ): if ikh==None: ikh = pm.ls(sl=True)[0] locs = [] dists = [] # find joints connected to ikh mustStrechJnts = ikh.getJointList() endEffector = ikh.getEndEffector() if len(mustStrechJnts) > 1 : # more than one joint, meaning RPSolver # positions uplegPos = WorldPos(mustStrechJnts[0]) kneePos = WorldPos(mustStrechJnts[1]) kneeEndPos = WorldPos(endEffector) # create locators and distance nodes uplegLoc = pm.spaceLocator() pm.rename( uplegLoc, "%s_stretch_start_loc"% ikh.name() ) uplegLoc.translate.set( uplegPos ) kneeLoc = pm.spaceLocator() pm.rename( uplegLoc, "%s_stretch_mid_loc"% ikh.name() ) kneeLoc.translate.set( kneePos ) kneeEndLoc = pm.spaceLocator() kneeEndLoc.translate.set( kneeEndPos ) pm.rename( uplegLoc, "%s_stretch_end_loc"% ikh.name() ) locs.append(uplegLoc) locs.append(kneeLoc) locs.append(kneeEndLoc) pm.select(uplegLoc, kneeLoc) uplegDistShape = pm.distanceDimension () pm.select(kneeLoc, kneeEndLoc) kneeDistShape = pm.distanceDimension () pm.select(uplegLoc, kneeEndLoc) legDistShape = pm.distanceDimension () uplegDist = uplegDistShape.getParent() kneeDist = kneeDistShape.getParent() legDist = legDistShape.getParent() dists.append(uplegDist) dists.append(kneeDist) dists.append(legDist) pm.parent ( ikh , kneeEndLoc ) # make ik joints stretchy defaultIKLegLen = uplegDistShape.distance.get() + kneeDistShape.distance.get() stretch_mdn = pm.createNode ("multiplyDivide" , n = "%s_stretch_mdn" % ( ikh.name() ) ) stretch_mdn.input2X.set( defaultIKLegLen ) legDistShape.distance >> stretch_mdn.input1X stretch_mdn.operation.set(2) stretch_cnd = pm.createNode ("condition" , n = "%s_stretch_cnd"% ( ikh.name() ) ) legDistShape.distance >> stretch_cnd.firstTerm stretch_cnd.secondTerm.set(defaultIKLegLen) stretch_cnd.operation.set(2) stretch_mdn.outputX >> stretch_cnd.colorIfTrueR # stretch switch stretchSwitch_bln = pm.createNode ("blendColors" , n = "%s_stretchSwitch_bln" % ( ikh.name() ) ) stretch_cnd.outColorR >> stretchSwitch_bln.color1R stretchSwitch_bln.color2R.set(1) # conncet result for jnt in mustStrechJnts: stretchSwitch_bln.outputR >> jnt.scaleX # create swtich attribute on last locator pm.addAttr(kneeEndLoc, keyable=True, attributeType="double", min=0, max=1, defaultValue=1, longName="stretchable") kneeEndLoc.stretchable >> stretchSwitch_bln.blender #================================================================================ # Elbow Lock if elbowLock==True: pm.addAttr ( kneeLoc ,dv = 0 ,min=0 ,max=10 , keyable = True , ln = "elbowLock" , at = "double") defaultIKUpArmLen = pm.getAttr ( uplegDist.distance ) elbowLock_mdn = pm.createNode ("multiplyDivide" , n = ikh.name() + "_elbowLock_mdn" ) pm.setAttr ( elbowLock_mdn.input2X, defaultIKUpArmLen ) uplegDist.distance >> elbowLock_mdn.input1X pm.setAttr ( elbowLock_mdn.operation, 2 ) defaultIKElbowLen = pm.getAttr ( kneeDist.distance ) IKelbowLock_mdn = pm.createNode ("multiplyDivide" , n = ikh.name() + "_elbowLock_mdn" ) pm.setAttr ( IKelbowLock_mdn.input2X, defaultIKElbowLen ) kneeDist.distance >> IKelbowLock_mdn.input1X pm.setAttr ( IKelbowLock_mdn.operation, 2 ) #================================================================================ # make elbowLock more animation friendly by dividing it by 10 elbowLockAnimFriend_mdn = pm.createNode ("multiplyDivide" , n = ikh.name() + "_elbowLockAnimFriend_mdn" ) pm.setAttr ( elbowLockAnimFriend_mdn.input2X, 10 ) pm.setAttr ( elbowLockAnimFriend_mdn.operation, 2 ) kneeLoc.attr ( "elbowLock" ) >> elbowLockAnimFriend_mdn.input1X #================================================================================ # conncet result of stretch and elbow lock to joint with a blend switch on the elbow locator stretchUparmLock_bta = pm.createNode ("blendTwoAttr" , n = ikh.name() + "_stretchUparmLock_bta" ) elbowLockAnimFriend_mdn.outputX >> stretchUparmLock_bta.attributesBlender stretchSwitch_bln.outputR >> stretchUparmLock_bta.input[0] elbowLock_mdn.outputX >> stretchUparmLock_bta.input[1] stretchUparmLock_bta.output >> mustStrechJnts[0].scaleX stretchElbowLock_bta = pm.createNode ("blendTwoAttr" , n = ikh.name() + "_stretchElbowLock_bta" ) elbowLockAnimFriend_mdn.outputX >> stretchElbowLock_bta.attributesBlender stretchSwitch_bln.outputR >> stretchElbowLock_bta.input[0] IKelbowLock_mdn.outputX >> stretchElbowLock_bta.input[1] stretchElbowLock_bta.output >> mustStrechJnts[1].scaleX elif len(mustStrechJnts) == 1 : # one jnt meaning SCSolver # positions uplegPos = WorldPos(mustStrechJnts[0]) kneeEndPos = WorldPos(endEffector) # create locators and distance nodes uplegLoc = pm.spaceLocator() uplegLoc.translate.set( uplegPos ) kneeEndLoc = pm.spaceLocator() kneeEndLoc.translate.set( kneeEndPos ) locs.append(uplegLoc) locs.append(kneeEndLoc) pm.select(uplegLoc, kneeEndLoc) legDistShape = pm.distanceDimension () legDist = legDistShape.getParent() dists.append(legDist) pm.parent ( ikh , kneeEndLoc ) # make ik joints stretchy defaultIKLegLen = legDistShape.distance.get() stretch_mdn = pm.createNode ("multiplyDivide" , n = "%s_stretch_mdn" % ( ikh.name() ) ) stretch_mdn.input2X.set( defaultIKLegLen ) legDistShape.distance >> stretch_mdn.input1X stretch_mdn.operation.set(2) # stretch switch stretchSwitch_bln = pm.createNode ("blendColors" , n = "%s_stretchSwitch_bln" % ( ikh.name() ) ) stretch_mdn.outputX >> stretchSwitch_bln.color1R stretchSwitch_bln.color2R.set(1) # conncet result for jnt in mustStrechJnts: stretchSwitch_bln.outputR >> jnt.scaleX # create swtich attribute on last locator pm.addAttr(kneeEndLoc, keyable=True, attributeType="double", min=0, max=1, defaultValue=1, longName="stretchable") kneeEndLoc.stretchable >> stretchSwitch_bln.blender return ( locs, dists)
def IK_Stretch(*args): joint_selected = pm.ls(sl=True) joint_start = joint_selected[0] joint_end = joint_selected[1] textFieldData_ik_suffix = pm.textField(textFieldEntry_ik_suffix, editable=True, query=True, text=True) ik_suffix = textFieldData_ik_suffix num_name_delete = pm.intField(intFieldEntry_num_name_delete, editable=True, query=True, value=True) newname = joint_start.split('_') print newname number_name = len(newname) new_name_first = newname[0] + '_' for i in range(0, number_name): if i > number_name - num_name_delete - 1 or i == number_name - num_name_delete - 1: new_name_ik = new_name_first print 'naming error' break else: if i < number_name - num_name_delete - 1: new_name_second = newname[i + 1] + '_' new_name_ik = new_name_first + new_name_second new_name_first = new_name_ik else: break pm.ikHandle(sj=joint_start, ee=joint_end, n='{0}ik_handle'.format(new_name_ik)) if pm.objExists('dist_loc_01'): print 'dist_loc_01 exists' else: dist_loc_01 = pm.spaceLocator(n='dist_loc_01') for i in range(0, 20): if i == 0: pm.select(joint_start) joint_parent = pm.listRelatives(p=True, type='joint') elif i > 0: pm.select(joint_parent) joint_first = pm.ls(sl=True) joint_parent = pm.listRelatives(p=True, type='joint') if joint_parent == []: pm.select(joint_first) joint_first_select = pm.ls(sl=True) break else: continue pm.select(joint_first_select, hi=True) all_hierachy = pm.ls(sl=True) pm.select(joint_start) joint_mid = pm.listRelatives(c=True) pm.select(dist_loc_01, joint_start) snapping() pm.select(dist_loc_01, joint_mid) snapping() pm.select(dist_loc_01, joint_end) snapping() pm.select(joint_start, joint_mid, joint_end) ik_joint_loc = pm.ls(sl=True) pm.select(d=True) for n in ik_joint_loc: newname = n.split('_') print newname number_name = len(newname) new_name_first = newname[0] + '_' for i in range(0, number_name): if i > number_name - num_name_delete - 1 or i == number_name - num_name_delete - 1: new_name = new_name_first print 'naming error' break else: if i < number_name - num_name_delete - 1: new_name_second = newname[i + 1] + '_' new_name = new_name_first + new_name_second new_name_first = new_name else: break print new_name pm.select('{0}{1}'.format(new_name, ik_suffix), add=True) dist_loc_all = pm.ls(sl=True) dist_loc_start = dist_loc_all[0] dist_loc_mid = dist_loc_all[1] dist_loc_end = dist_loc_all[2] pm.pointConstraint('{0}'.format(dist_loc_start), joint_start, mo=True, w=1) pm.pointConstraint(joint_mid, '{0}_pad'.format(dist_loc_mid), mo=True, w=1) pm.pointConstraint('{0}'.format(dist_loc_end), '{0}ik_handle'.format(new_name_ik), mo=True, w=1) dist_loc_start_tx = pm.getAttr('{0}_pad.tx'.format(dist_loc_start)) dist_loc_start_ty = pm.getAttr('{0}_pad.ty'.format(dist_loc_start)) dist_loc_start_tz = pm.getAttr('{0}_pad.tz'.format(dist_loc_start)) dist_loc_mid_tx = pm.getAttr('{0}_pad.tx'.format(dist_loc_mid)) dist_loc_mid_ty = pm.getAttr('{0}_pad.ty'.format(dist_loc_mid)) dist_loc_mid_tz = pm.getAttr('{0}_pad.tz'.format(dist_loc_mid)) dist_loc_end_tx = pm.getAttr('{0}_pad.tx'.format(dist_loc_end)) dist_loc_end_ty = pm.getAttr('{0}_pad.ty'.format(dist_loc_end)) dist_loc_end_tz = pm.getAttr('{0}_pad.tz'.format(dist_loc_end)) dist_dimension_name() pm.distanceDimension(sp=(dist_loc_start_tx, dist_loc_start_ty, dist_loc_start_tz), ep=(dist_loc_mid_tx, dist_loc_mid_ty, dist_loc_mid_tz)) newname = dist_loc_start.split('_') print newname number_name = len(newname) new_name_first = newname[0] + '_' for i in range(0, number_name): if i > number_name - num_name_delete - 2 or i == number_name - num_name_delete - 2: new_name = new_name_first print 'naming error' break else: if i < number_name - num_name_delete - 2: new_name_second = newname[i + 1] + '_' new_name = new_name_first + new_name_second new_name_first = new_name else: break dist_measure_01 = pm.rename(dist_dimension_created, '{0}01_dist'.format(new_name)) dist_dimension_name() pm.distanceDimension(sp=(dist_loc_mid_tx, dist_loc_mid_ty, dist_loc_mid_tz), ep=(dist_loc_end_tx, dist_loc_end_ty, dist_loc_end_tz)) dist_measure_02 = pm.rename(dist_dimension_created, '{0}02_dist'.format(new_name)) dist_dimension_name() pm.distanceDimension(sp=(dist_loc_start_tx, dist_loc_start_ty, dist_loc_start_tz), ep=(dist_loc_end_tx, dist_loc_end_ty, dist_loc_end_tz)) actual_length_ik = pm.rename(dist_dimension_created, '{0}dist'.format(new_name)) first_length_ik = pm.getAttr('{0}.distance'.format(dist_measure_01)) second_length_ik = pm.getAttr('{0}.distance'.format(dist_measure_02)) max_length_ik = first_length_ik + second_length_ik ratio_ik_stretch = pm.createNode('multiplyDivide', n='{0}ratio_ik_stretch'.format(new_name)) pm.setAttr('{0}.operation'.format(ratio_ik_stretch), 2) pm.connectAttr('{0}.distance'.format(actual_length_ik), '{0}.input1X'.format(ratio_ik_stretch)) pm.setAttr('{0}.input2X'.format(ratio_ik_stretch), max_length_ik) ratio_ik_stretch_cond = pm.createNode( 'condition', n='{0}ratio_ik_stretch_cond'.format(new_name)) pm.connectAttr('{0}.outputX'.format(ratio_ik_stretch), '{0}.firstTerm'.format(ratio_ik_stretch_cond)) pm.connectAttr('{0}.outputX'.format(ratio_ik_stretch), '{0}.colorIfTrueR'.format(ratio_ik_stretch_cond)) pm.setAttr('{0}.operation'.format(ratio_ik_stretch_cond), 3) pm.setAttr('{0}.secondTerm'.format(ratio_ik_stretch_cond), 1) pm.setAttr('{0}.colorIfFalseR'.format(ratio_ik_stretch_cond), 1) pm.connectAttr('{0}.outColorR'.format(ratio_ik_stretch_cond), '{0}.scaleX'.format(joint_start)) pm.connectAttr('{0}.outColorR'.format(ratio_ik_stretch_cond), '{0}.scaleX'.format(joint_mid[0])) pm.connectAttr('{0}.outColorR'.format(ratio_ik_stretch_cond), '{0}.scaleX'.format(joint_end)) pm.delete(dist_loc_01)
q=True, ws=True, rotatePivot=True) shadow_height_ratio = get_distance(shadow_start_location, shadow_end_location) print shadow_height_ratio shadow_cylinder[0].rotatePivot.set([-0.5 * shadow_height_ratio, 0, 0]) shadow_cylinder[0].scalePivot.set([-0.5 * shadow_height_ratio, 0, 0]) shadow_cylinder[1].heightRatio.set(shadow_height_ratio / shadow_radius) else: pass pm.matchTransform(shadow_cylinder, shadow_start, scale=False) aim_object(aimer, target, axis='+x') #pm.move(shadow_cylinder, [-1.15381, 1.627506, 0.141238], relative = True, rotatePivotRelative = 1, scalePivotRelative = 1) print( pm.distanceDimension(startPoint=shadow_start_location, endPoint=shadow_end_location)) #set shadow_length import math def get_distance(startPoint, endPoint): dx = startPoint[0] - endPoint[0] dy = startPoint[1] - endPoint[1] dz = startPoint[2] - endPoint[2] return math.sqrt(dx * dx + dy * dy + dz * dz)
def CreateNodes(self): """Creation et settings de mes nodes""" def createloc(sub): """Creates locator at the Pivot of the object selected """ locs = [] for sel in sub: loc_align = pm.spaceLocator(n='{}__pos_loc__'.format(sel)) locs.append(loc_align) pm.matchTransform(loc_align, sel, rot=True, pos=True) pm.select(locs, add=True) return locs self.CurveInfoNode = None posLocs = [] if self.usingCurve: self.spineLenghtCurve = adb.createCurveFrom(self.jointList, curve_name='{}_lenght__CRV'.format(self.NAME)) pm.parent(self.spineLenghtCurve, self.RIG_GRP) self.CurveInfoNode = pm.shadingNode('curveInfo', asUtility=1, n='{}_CurveInfo'.format(self.NAME)) else: posLocs = createloc([self.jointList[0], self.jointList[-1]]) sp = (pm.PyNode(posLocs[0]).translateX.get(), pm.PyNode(posLocs[0]).translateY.get(), pm.PyNode(posLocs[0]).translateZ.get()) ep = (pm.PyNode(posLocs[1]).translateX.get(), pm.PyNode(posLocs[1]).translateY.get(), pm.PyNode(posLocs[1]).translateZ.get()) # create Distances Nodes self.DistanceLoc = pm.distanceDimension(sp=sp, ep=ep) pm.rename(self.DistanceLoc, 'bendy_distDimShape') pm.rename(pm.PyNode(self.DistanceLoc).getParent(), 'bendy_distDim') distance = self.DistanceLoc.distance.get() pm.parent(self.DistanceLoc.getParent(), self.RIG_GRP) pm.parent(posLocs[0], self.ribbon_ctrl[0]) pm.parent(posLocs[1], self.ribbon_ctrl[1]) pm.rename(posLocs[0], 'distance_depart__{}'.format(NC.LOC)) pm.rename(posLocs[1], 'distance_end__{}'.format(NC.LOC)) posLocs[0].v.set(0) posLocs[1].v.set(0) self.DistanceLoc.getParent().v.set(0) # Creation des nodes Multiply Divide self.Stretch_MD = pm.shadingNode('multiplyDivide', asUtility=1, n="StretchMult") self.Squash_MD = pm.shadingNode('multiplyDivide', asUtility=1, n="SquashMult") self.expA_MD = pm.shadingNode('multiplyDivide', asUtility=1, n="{}_ExpA".format(self.NAME)) self.expB_MD = pm.shadingNode('multiplyDivide', asUtility=1, n="{}_ExpB".format(self.NAME)) self.expC_MD = pm.shadingNode('multiplyDivide', asUtility=1, n="{}_ExpC".format(self.NAME)) # blendColor node Toggle self.toggle_node = pm.shadingNode('blendColors', asUtility=1, n='{}_Toggle__{}'.format(self.NAME, NC.BLENDCOLOR_SUFFIX)) self.toggle_node.blender.set(1) # Settings des nodes Multiply Divide self.Stretch_MD.operation.set(2) self.Squash_MD.operation.set(2) self.expA_MD.operation.set(3) self.expA_MD.input1X.set(1) self.expB_MD.operation.set(3) self.expB_MD.input1X.set(1) self.expC_MD.operation.set(3) self.expC_MD.input1X.set(1) return self.expA_MD, self.expB_MD, self.expC_MD, self.Squash_MD, self.Stretch_MD, self.CurveInfoNode, posLocs
def __init__(self, **kwds): self.name = defaultReturn('rig_measure', 'name', param=kwds) self.start = defaultReturn(None, 'start', param=kwds) self.end = defaultReturn(None, 'end', param=kwds) self.parent = defaultReturn(None, 'parent', param=kwds) startConstrainer = self.start endConstrainer = self.end self.start = rig_transform( 0, name=self.name+'Start', type='locator', target=self.start ).object self.end = rig_transform( 0, name=self.name+'End', type='locator', target=self.end ).object pm.move(self.end, 0, 10, 0, r=True, os=True) #startAttr = pm.getAttr( self.start+'.translate' ) startAttr = pm.xform(self.start, translation=True, query=True, ws=True) #endAttr = pm.getAttr( self.end+'.translate' ) endAttr = pm.xform(self.end, translation=True, query=True, ws=True) self.shape = pm.distanceDimension(sp=startAttr, ep=endAttr) pm.move(self.end, 0, -10, 0, r=True, os=True) pm.rename(self.shape, self.name+'_distanceShape') self.distance = pm.rename(pm.listRelatives(self.shape, p=True)[0], self.name+'_distance') pm.pointConstraint( startConstrainer , self.start ) pm.pointConstraint( endConstrainer , self.end ) self.distanceVal = pm.getAttr(self.distance.distance) pm.addAttr(self.distance, longName='originalLength', at='float', k=True, dv=self.distanceVal ) self.distance.originalLength.set(cb=True) pm.addAttr(self.distance, longName='globalOriginalLength', at='float', k=True, dv=self.distanceVal) self.distance.globalOriginalLength.set(cb=True) pm.addAttr(self.distance, longName='originalPercent', at='float', k=True, dv=1) self.distance.originalPercent.set(cb=True) pm.addAttr(self.distance, longName='globalOriginalPercent', at='float', k=True, dv=1) self.distance.globalOriginalPercent.set(cb=True) ''' measurePnct = multiplyDivideNode(self.name + '_measurepcnt', 'divide', input1=[self.distance.distance,self.distance.distance, 1], input2=[self.distance.originalLength,self.distance.globalOriginalLength, 1], output=[self.distance.originalPercent, self.distance.globalOriginalPercent]) ''' measurePnct = multiplyDivideNode(self.name + '_measurepcnt', 'divide', input1=[self.distance.distance, self.distance.distance, 1], input2=[1, 1, 1], output=[self.distance.originalPercent, self.distance.globalOriginalPercent]) # make 0.001 the minimum originalMin_con = conditionNode(self.name + '_origZeroMin', 'equal', (self.distance, 'originalLength' ), ('', 0 ), ( '', 0.001 ), ( self.distance, 'originalLength' )) globalOriginalMin_con = conditionNode(self.name + '_globalOrigZeroMin', 'equal', (self.distance, 'globalOriginalLength' ), ('', 0 ), ( '', 0.001 ), ( self.distance, 'globalOriginalLength' )) pm.connectAttr( originalMin_con+'.outColorR', measurePnct+'.input2X' ) pm.connectAttr( globalOriginalMin_con + '.outColorR', measurePnct + '.input2Y') if pm.objExists('rig_GRP'): multiplyDivideNode(self.name + '_globalOriginalLength', 'multiply', input1=[self.distance.originalLength, 0, 0], input2=['rig_GRP.worldScale', 0, 0], output=[self.distance.globalOriginalLength]) if pm.objExists(self.parent): pm.parent( self.distance, self.start, self.end ,self.parent )
def setup_ik_stretch_leg(jnts, RL='L'): ### TODO: consider global scale, stretch attribute on/off on ik Ctlr ### TODO: split up upper and lower leg stretch amound (as seen in AM steward) # distance measure. 2 locators, parent foot and up_leg dd = pm.distanceDimension( sp=jnts['L_leg01']['ikJnt'].t.get(), ep=jnts['L_foot01']['ctrlJnt'].t.get(), ) pm.rename(dd.getParent(), '%s_leg_ik_dist' % RL) start_loc = pm.spaceLocator(n='%s_leg_ik_startDist' % RL) end_loc = pm.spaceLocator(n='%s_leg_ik_endDist' % RL) pm.pointConstraint(jnts['L_leg01']['ikJnt'], start_loc) pm.pointConstraint('%s_leg_ikHandle' % RL, end_loc) # connect loc to distanceNode start_loc.t >> dd.startPoint end_loc.t >> dd.endPoint riggUtils.grpIn('L_legikJnt_distGrp', [start_loc, end_loc]) log_debug('dist create done') # sum_leg_tx to compare. ADD UP UP LOW DISTANCfE leg02_tx_orig = pm.createNode('plusMinusAverage', n='%s_leg02StrOrig_plsMns') leg02_tx_orig.input1D[0].set(jnts['L_leg02']['ikJnt'].tx.get()) leg03_tx_orig = pm.createNode('plusMinusAverage', n='%s_leg03StrOrig_plsMns') leg03_tx_orig.input1D[1].set(jnts['L_leg03']['ikJnt'].tx.get()) leg_tx_orig = pm.createNode('plusMinusAverage', n='%s_legStrOrig_plsMns') leg02_tx_orig.output1D >> leg_tx_orig.input1D[0] leg03_tx_orig.output1D >> leg_tx_orig.input1D[1] log_debug('summing up tx to compare done') # divide dist node by summed stretch_factor_mult = pm.createNode('multiplyDivide', n='%s_legStrFactor_mult') leg_tx_orig.output1D >> stretch_factor_mult.input2X dd.distance >> stretch_factor_mult.input1X stretch_factor_mult.operation.set(2) log_debug('figure out distance multiplyer done') # clamp output 1 to max stretch (don't want to go below 1, squash..) clamp_stretch = pm.createNode('clamp', n='%s_legStr_clamp' % RL) clamp_stretch.minR.set(1) clamp_stretch.maxR.set(3) # TODO: max stretch sett a attribute for it animator can adjust stretch_factor_mult.outputX >> clamp_stretch.inputR log_debug('clamp done') # multiply tx fo leg02 and 03 with stretch stretch_mult = pm.createNode('multiplyDivide', n='%s_legStr_mult') clamp_stretch.outputR >> stretch_mult.input2X clamp_stretch.outputR >> stretch_mult.input2Y leg02_tx_orig.output1D >> stretch_mult.input1X leg03_tx_orig.output1D >> stretch_mult.input1Y log_debug('mult tx to leg 02/03 stretch done') # now connect that to actual ikJnt TX stretch_mult.outputX >> jnts['L_leg02']['ikJnt'].tx stretch_mult.outputY >> jnts['L_leg03']['ikJnt'].tx log_debug('connecting done')
def ikLimb( self, *args ): print 'ehm_leg........................ikLimb' #=============================================================================== # duplicate main leg joints and rename IK joints self.IKJnts = pm.duplicate (self.upLegJnt ) pm.select (self.IKJnts[0]) self.IKJnts = SearchReplaceNames ( "jnt", "IK_jnt", self.IKJnts[0] ) #=============================================================================== # create ik handles self.legIKStuff = pm.ikHandle( sj = self.IKJnts[0], ee = self.IKJnts[2], solver = "ikRPsolver" ) pm.rename (self.legIKStuff[0] , (self.side + "_leg_ikh") ) #=============================================================================== # distance nodes for stretching purpose self.IKLegDist = pm.distanceDimension ( sp = self.upLegPos , ep = self.anklePos ) self.IKupLegDist = pm.distanceDimension ( sp = self.upLegPos , ep = self.kneePos ) self.IKKneeDist = pm.distanceDimension ( sp = self.kneePos , ep = self.anklePos ) self.IKLegDistT = pm.listRelatives ( self.IKLegDist , p=True)[0] self.IKupLegDistT = pm.listRelatives ( self.IKupLegDist , p=True)[0] self.IKKneeDistT = pm.listRelatives ( self.IKKneeDist , p=True)[0] #=============================================================================== # find the leg locs from distance shape node self.IKlegDistLocs = pm.listConnections (self.IKLegDist , plugs=False) self.IKKneeDistLocs = pm.listConnections (self.IKKneeDist , plugs=False) pm.rename (self.IKlegDistLocs[0] , self.side + "_upLeg_dist_loc" ) pm.rename (self.IKlegDistLocs[1] , self.side + "_ankle_dist_loc" ) pm.rename (self.IKKneeDistLocs[0] , self.side + "_knee_dist_loc" ) #=============================================================================== # parent ikHandle to ankle loc pm.parent ( self.legIKStuff[0] , self.IKKneeDistLocs[1] ) #=============================================================================== # make ik joints stretchy defaultIKLegLen = pm.getAttr ( self.IKupLegDist.distance ) + pm.getAttr ( self.IKKneeDist.distance ) self.IKLeg_stretch_mdn = pm.createNode ("multiplyDivide" , n = self.side + "_IKLeg_stretch_mdn" ) pm.setAttr ( self.IKLeg_stretch_mdn.input2X, defaultIKLegLen ) self.IKLegDist.distance >> self.IKLeg_stretch_mdn.input1X pm.setAttr ( self.IKLeg_stretch_mdn.operation, 2 ) self.IKLeg_stretch_cnd = pm.createNode ("condition" , n = self.side + "_IKLeg_stretch_cnd") self.IKLegDist.distance >> self.IKLeg_stretch_cnd.firstTerm pm.setAttr ( self.IKLeg_stretch_cnd.secondTerm , defaultIKLegLen ) pm.setAttr ( self.IKLeg_stretch_cnd.operation , 2 ) self.IKLeg_stretch_mdn.outputX >> self.IKLeg_stretch_cnd.colorIfTrueR #================================================================================ # Knee Lock pm.addAttr ( self.IKKneeDistLocs[0] ,dv = 0 ,min=0 ,max=10 , keyable = True , ln = "kneeLock" , at = "double") defaultIKupLegLen = pm.getAttr ( self.IKupLegDist.distance ) self.IKupLeg_kneeLock_mdn = pm.createNode ("multiplyDivide" , n = self.side + "_IKupLeg_kneeLock_mdn" ) pm.setAttr ( self.IKupLeg_kneeLock_mdn.input2X, defaultIKupLegLen ) self.IKupLegDist.distance >> self.IKupLeg_kneeLock_mdn.input1X pm.setAttr ( self.IKupLeg_kneeLock_mdn.operation, 2 ) defaultIKKneeLen = pm.getAttr ( self.IKKneeDist.distance ) self.IKKnee_kneeLock_mdn = pm.createNode ("multiplyDivide" , n = self.side + "_IKKnee_kneeLock_mdn" ) pm.setAttr ( self.IKKnee_kneeLock_mdn.input2X, defaultIKKneeLen ) self.IKKneeDist.distance >> self.IKKnee_kneeLock_mdn.input1X pm.setAttr ( self.IKKnee_kneeLock_mdn.operation, 2 ) #================================================================================ # make kneeLock more animation friendly by dividing it by 10 self.IKLeg_kneeLockAnimFriend_mdn = pm.createNode ("multiplyDivide" , n = self.side + "_IKLeg_kneeLockAnimFriend_mdn" ) pm.setAttr ( self.IKLeg_kneeLockAnimFriend_mdn.input2X, 10 ) pm.setAttr ( self.IKLeg_kneeLockAnimFriend_mdn.operation, 2 ) self.IKKneeDistLocs[0].attr ( "kneeLock" ) >> self.IKLeg_kneeLockAnimFriend_mdn.input1X #================================================================================ # conncet result of stretch and knee lock to joint with a blend switch on the knee locator self.upLeg_stretchKneeLock_bta = pm.createNode ("blendTwoAttr" , n = self.side + "_upLeg_stretchKneeLock_bta" ) self.IKLeg_kneeLockAnimFriend_mdn.outputX >> self.upLeg_stretchKneeLock_bta.attributesBlender self.IKLeg_stretch_cnd.outColorR >> self.upLeg_stretchKneeLock_bta.input[0] self.IKupLeg_kneeLock_mdn.outputX >> self.upLeg_stretchKneeLock_bta.input[1] self.knee_stretchKneeLock_bta = pm.createNode ("blendTwoAttr" , n = self.side + "_knee_stretchKneeLock_bta" ) self.IKLeg_kneeLockAnimFriend_mdn.outputX >> self.knee_stretchKneeLock_bta.attributesBlender self.IKLeg_stretch_cnd.outColorR >> self.knee_stretchKneeLock_bta.input[0] self.IKKnee_kneeLock_mdn.outputX >> self.knee_stretchKneeLock_bta.input[1] self.upLeg_stretchKneeLock_bta.output >> self.IKJnts[0].scaleX self.knee_stretchKneeLock_bta.output >> self.IKJnts[1].scaleX #================================================================================ # force leg distance dimentions to be scalable by mainCtrl DistGlobalScale (mainCtrl=self.mainCtrl , dist=self.IKLegDist) DistGlobalScale (mainCtrl=self.mainCtrl , dist=self.IKupLegDist) DistGlobalScale (mainCtrl=self.mainCtrl , dist=self.IKKneeDist) # create IK ankle control curve with transforms of the ankle joint self.ankleIKCtrl = CubeCrv( self.legSize*1.5 , self.side + "_ankle_IK_ctrl" ) pm.select ( self.ankleIKCtrl ) self.ankleIKCtrlZero = ZeroGrp()[0] pm.parent ( self.ankleIKCtrlZero , self.IKJnts[2] ) self.ankleIKCtrlZero.translate.set( 0,0,0 ) # self.ankleIKCtrlZero.rotate.set( 0,0,0 ) pm.parent ( self.ankleIKCtrlZero , w=True ) pm.parent ( self.IKlegDistLocs[1] , self.ankleIKCtrl ) #============================================================================ # add attributes to leg_ctrl pm.addAttr ( self.ankleIKCtrl , ln = "stretch_off_on" , at = "double" , min = 0 , max = 1 , dv = 1 , k = True ) pm.addAttr ( self.ankleIKCtrl , ln = "roll" , at = "double" , min = -10 , max = 10 , dv = 0 , k = True ) pm.addAttr ( self.ankleIKCtrl , ln = "toe" , at = "double" , min = -10 , max = 10 , dv = 0 , k = True ) pm.addAttr ( self.ankleIKCtrl , ln = "side_to_side" , at = "double" , min = -10 , max = 10 , dv = 0 , k = True ) #============================================================================ # create foot ik handles self.toeIKStuff = pm.ikHandle( sj = self.IKJnts[2], ee = self.IKJnts[3], solver = "ikSCsolver" ) pm.rename(self.toeIKStuff[0], self.side + "_toe_ikh") self.toeEndIKStuff = pm.ikHandle( sj = self.IKJnts[3], ee = self.IKJnts[4], solver = "ikSCsolver" ) pm.rename(self.toeEndIKStuff[0], "_toe_end_ikh") #============================================================================ # foot ik groups and set driven keys self.heelUpSdk = pm.group ( self.toeIKStuff[0] , self.IKlegDistLocs[1] , n = self.side + "_heel_up_sdk" ) pm.xform ( os= True , piv = self.toePos ) self.toeSdk = pm.group( self.toeEndIKStuff[0] , n = self.side + "_toe_sdk" ) pm.xform ( os= True , piv = self.toePos ) self.tipSdk = pm.group ( self.heelUpSdk , self.toeSdk , n = self.side + "_tip_sdk" ) pm.xform ( os= True , piv = ( self.toeEndPos[0] , 0 , self.toeEndPos[2] ) ) self.heelSdk = pm.group ( self.tipSdk , n = self.side + "_heel_sdk" ) pm.xform ( os= True , piv = ( self.heelPos[0] , 0 , self.heelPos[2] ) ) self.inFootSdk = pm.group ( self.heelSdk, n = self.side + "_in_foot_sdk" ) pm.xform ( os= True , piv = ( self.inPivPos[0] , 0 , self.inPivPos[2] ) ) self.outFootSdk = pm.group ( self.inFootSdk , n = self.side + "_out_foot_sdk" ) pm.xform ( os= True , piv = ( self.outPivPos[0] , 0 , self.outPivPos[2] ) ) pm.parent ( self.outFootSdk , self.ankleIKCtrl ) #============================================================================ # foot set driven keys # toe set driven keys pm.setDrivenKeyframe ( self.toeSdk.rotateX , currentDriver = self.ankleIKCtrl.toe , dv = 0 , v = 0 ) pm.setDrivenKeyframe ( self.toeSdk.rotateX , currentDriver = self.ankleIKCtrl.toe , dv = 10 , v = -45 ) pm.setDrivenKeyframe ( self.toeSdk.rotateX , currentDriver = self.ankleIKCtrl.toe , dv = -10 , v = 70 ) # roll set driven keys pm.setDrivenKeyframe ( self.heelSdk.rotateX , currentDriver = self.ankleIKCtrl.roll , dv = 0 , v = 0 ) pm.setDrivenKeyframe ( self.tipSdk.rotateX , currentDriver = self.ankleIKCtrl.roll , dv = 0 , v = 0 ) pm.setDrivenKeyframe ( self.heelUpSdk.rotateX , currentDriver = self.ankleIKCtrl.roll , dv = 0 , v = 0 ) pm.setDrivenKeyframe ( self.heelSdk.rotateX , currentDriver = self.ankleIKCtrl.roll , dv = 10 , v = -30 ) pm.setDrivenKeyframe ( self.tipSdk.rotateX , currentDriver = self.ankleIKCtrl.roll , dv = -10 , v = 45 ) pm.setDrivenKeyframe ( self.heelUpSdk.rotateX , currentDriver = self.ankleIKCtrl.roll , dv = -10 , v = 0 ) pm.setDrivenKeyframe ( self.tipSdk.rotateX , currentDriver = self.ankleIKCtrl.roll , dv = -5 , v = 0 ) pm.setDrivenKeyframe ( self.heelUpSdk.rotateX , currentDriver = self.ankleIKCtrl.roll , dv = -5 , v = 30 ) #================================================================================ # create IK knee control curve self.kneeIKCtrl = SoftSpiralCrv( self.legSize , self.side + "_knee_IK_ctrl" ) if self.side == "R" : self.kneeIKCtrl.scale.scaleY.set (-1) pm.makeIdentity (self.kneeIKCtrl , apply = True , t = 1 , r = 1 , s = 1 , n = 0) pm.select ( self.kneeIKCtrl ) self.kneeIKCtrlZO = ZeroGrp() pm.parent ( self.kneeIKCtrlZO[0] , self.IKJnts[1] ) self.kneeIKCtrlZO[0].translate.set( 0,0,0 ) #self.kneeIKCtrlZO[0].rotate.set( 0,0,0 ) pm.parent ( self.kneeIKCtrlZO[0] , w=True ) pm.parent ( self.IKKneeDistLocs[0] , self.kneeIKCtrl ) # direction of the knee ctrl is defined here. ???????????????????????????????? self.kneeIKCtrlZO[1].translate.set (0,0, self.legSize*3) pm.poleVectorConstraint( self.IKKneeDistLocs[0] , self.legIKStuff[0] ) #=========== # pv guide curve self.PVGuideCrv = pm.curve ( d = 1 , p = ( (self.kneePos) , (0,0,0 ) ) , k = (1,2) , name = self.side + "_PV_guide_crv" ) self.PVGuideStartJnt =pm.joint ( p = (self.kneePos) , name = ( self.side + "_PV_guide_start_jnt" ) ) pm.select (cl=True) self.PVGuideEndJnt =pm.joint ( p = (0,0,0) , name = ( self.side + "_PV_guide_end_jnt" ) ) pm.skinCluster( self.PVGuideCrv , self.PVGuideStartJnt , self.PVGuideEndJnt , toSelectedBones = True ) pm.parent (self.PVGuideEndJnt , self.kneeIKCtrl) self.PVGuideEndJnt.translate.set(0,0,0) pm.setAttr ( self.PVGuideCrv.overrideEnabled , True) pm.setAttr ( self.PVGuideCrv.overrideDisplayType , True) pm.setAttr ( self.PVGuideCrv.inheritsTransform , False) LockHideAttr ( objs=self.PVGuideStartJnt , attrs="vv") LockHideAttr ( objs=self.PVGuideEndJnt , attrs="vv") #================================================================================ # if just ik leg is needed then delete leg joints and us ik joints as leg joints # this way we won't have extra result joint, just ik joints will remain in the scene if self.FKIKMode == "IK" : pm.delete (self.upLegJnt) self.upLegJnt = self.IKJnts[0] self.kneeJnt = self.IKJnts[1] self.ankleJnt = self.IKJnts[2] self.toeJnt = self.IKJnts[3]
def cardIk(card): #ctrl = mel.eval( 'curve -d 1 -p -0.5 1 -0.866026 -p -0.5 1 0.866025 -p 1 1 0 -p -0.5 1 -0.866026 -p 0 0 0 -p -0.5 -1 -0.866026 -p -0.5 -1 0.866025 -p 0 0 0 -p -0.5 1 0.866025 -p 1 1 0 -p 0 0 0 -p 1 -1 0 -p -0.5 -1 -0.866026 -p -0.5 -1 0.866025 -p 1 -1 0 -k 0 -k 1 -k 2 -k 3 -k 4 -k 5 -k 6 -k 7 -k 8 -k 9 -k 10 -k 11 -k 12 -k 13 -k 14 ;' ) ctrl = tempWidget() ctrl.rename(card.name() + "_target") upCtrl = duplicate(ctrl)[0] upCtrl.rename(card.name() + "_up") aim = spaceLocator() aim.setParent(ctrl) aim.t.set(0, 0, 0) hide(aim) up = spaceLocator() up.setParent(upCtrl) hide(up) base = spaceLocator() base.rename('cardIkBase') hide(base) pointConstraint(card, base) pdil.dagObj.moveTo(ctrl, card.joints[-1]) #pdil.dagObj.moveTo( upCtrl, card.vtx[1] ) pdil.dagObj.moveTo(upCtrl, card.cv[1][0]) aimConstraint(aim, card, wut='object', wuo=up, aim=[0, -1, 0], u=[0, 0, -1]) dist = distanceDimension(base, aim) dist.getParent().setParent(ctrl) hide(dist) pdil.math.divide(dist.distance, dist.distance.get() / card.sy.get()) >> card.sy follower = spaceLocator() follower.rename('cardIkFollower') follower.setParent(card) follower.t.set(0, 0, 0) hide(follower) pointConstraint(up, follower, skip=['x', 'z']) sideDist = distanceDimension(follower, up) sideDist.getParent().setParent(ctrl) hide(sideDist) pdil.math.divide(sideDist.distance, sideDist.distance.get() / card.sz.get()) >> card.sz # Orient controls with the card so moving in local space initially preserves orientation. upCtrl.setRotation(card.getRotation(space='world'), space='world') ctrl.setRotation(card.getRotation(space='world'), space='world') distBetweenCtrls = (ctrl.getTranslation(space='world') - upCtrl.getTranslation(space='world')).length() if distBetweenCtrls < 8.0: upCtrl.s.set([distBetweenCtrls / 8.0] * 3) ctrl.s.set([distBetweenCtrls / 8.0] * 3) select(ctrl)
def cardIk(card): #ctrl = mel.eval( 'curve -d 1 -p -0.5 1 -0.866026 -p -0.5 1 0.866025 -p 1 1 0 -p -0.5 1 -0.866026 -p 0 0 0 -p -0.5 -1 -0.866026 -p -0.5 -1 0.866025 -p 0 0 0 -p -0.5 1 0.866025 -p 1 1 0 -p 0 0 0 -p 1 -1 0 -p -0.5 -1 -0.866026 -p -0.5 -1 0.866025 -p 1 -1 0 -k 0 -k 1 -k 2 -k 3 -k 4 -k 5 -k 6 -k 7 -k 8 -k 9 -k 10 -k 11 -k 12 -k 13 -k 14 ;' ) ctrl = PyNode( mel.eval( 'curve -d 1 -p 0 4 0 -p -2.828427 2.828427 -2.47269e-007 -p -4 0 -3.49691e-007 -p -2.828427 -2.828427 -2.47269e-007 -p 0 -4 0 -p 2.828427 -2.828427 0 -p 4 0 0 -p 2.828427 2.828427 0 -p 0 4 0 -p -1.23634e-007 2.828427 2.828427 -p -1.74846e-007 0 4 -p -1.23634e-007 -2.828427 2.828427 -p 0 -4 0 -p 3.70903e-007 -2.828427 -2.828427 -p 5.24537e-007 0 -4 -p 3.70903e-007 2.828427 -2.828427 -p 0 4 0 -p 0 0 0 -p 0 -4 0 -p 0 0 0 -p -4 0 0 -p 4 0 0 -p 0 0 -4 -p 0 0 4 -k 0 -k 1 -k 2 -k 3 -k 4 -k 5 -k 6 -k 7 -k 8 -k 9 -k 10 -k 11 -k 12 -k 13 -k 14 -k 15 -k 16 -k 17 -k 18 -k 19 -k 20 -k 21 -k 22 -k 23 ;' )) ctrl.rename(card.name() + "_target") upCtrl = duplicate(ctrl)[0] upCtrl.rename(card.name() + "_up") aim = spaceLocator() aim.setParent(ctrl) aim.t.set(0, 0, 0) hide(aim) up = spaceLocator() up.setParent(upCtrl) hide(up) base = spaceLocator() base.rename('cardIkBase') hide(base) pointConstraint(card, base) util.moveTo(ctrl, card.joints[-1]) util.moveTo(upCtrl, card.vtx[1]) aimConstraint(aim, card, wut='object', wuo=up, aim=[0, -1, 0], u=[0, 0, -1]) dist = distanceDimension(base, aim) dist.getParent().setParent(ctrl) hide(dist) core.math.divide(dist.distance, dist.distance.get() / card.sy.get()) >> card.sy follower = spaceLocator() follower.rename('cardIkFollower') follower.setParent(card) follower.t.set(0, 0, 0) hide(follower) pointConstraint(up, follower, skip=['x', 'z']) sideDist = distanceDimension(follower, up) sideDist.getParent().setParent(ctrl) hide(sideDist) core.math.divide(sideDist.distance, sideDist.distance.get() / card.sz.get()) >> card.sz # Orient controls with the card so moving in local space initially preserves orientation. upCtrl.setRotation(card.getRotation(space='world'), space='world') ctrl.setRotation(card.getRotation(space='world'), space='world') distBetweenCtrls = (ctrl.getTranslation(space='world') - upCtrl.getTranslation(space='world')).length() if distBetweenCtrls < 8.0: upCtrl.s.set([distBetweenCtrls / 8.0] * 3) ctrl.s.set([distBetweenCtrls / 8.0] * 3) select(ctrl)