def preBuild(self): self.controllers['cog'] = \ ctrl.control( name=user.prefs['cog-ctrl-name'], shape='circle', colour='pink', size=5.5) self.controllers['cogPivot'] = \ ctrl.control( name=user.prefs['pivot-ctrl-name'], shape='cog', colour='purple', size=5) self.controllers['cog'].rotateCtrlShapes(rotate=90, axis=[0, 0, 1]) self.controllers['cog'].makeAttr(name='Pivot_Visibility', at='bool', k=False) \ >> self.controllers['cogPivot'].shape.visibility self.controllers['cogPivot'].null.setParent( self.controllers['cog'].ctrl) pm.matchTransform(self.controllers['cog'].null, self.chain[1], pos=True, rot=True) # position on cog placement self.controllers['cog'].null.setParent(self.controllers['root2'])
def constrain_list(listA,listB): #iterate through listA by index, then match it to listB? source_list = targets[::2] target_list = targets[1::2] for index, object in enumerate(source_list): print(str(object)) object_target = target_list[index] #================== ----------- for index, source_object in enumerate(source_list): print(str(source_object)) target_name = str(source_object).replace('fat_male', target_string) target_object = pm.ls(target_name)[0] pm.matchTransform(source_object, target_object, pos = True, rot = True, scale = False) objectList = pm.ls (sl = 1) sourceObj = objectList[0] targetList = objectList[1:] for target in targetList: transformName = str(sourceObj) currentReplacement = pm.duplicate(sourceObj) pm.matchTransform(currentReplacement, target) #rename? if useTargetName == True: #transformName = str(item) pm.rename(currentReplacement,str(target)) else: print('using source name') #delete target targetParent = str(pm.listRelatives(target, parent = True)[0]) print(targetParent)
def __add_transform_actions(cls, root_menu, selection): pm.menuItem( p=root_menu, l="Create locator", rp="E", c=lambda *args: nodeFn.create_locator(at_object=selection[-1]), i="locator.png") # Match position sub menu match_position_menu = pm.subMenuItem(p=root_menu, l="Match", rp="N") pm.menuItem(p=match_position_menu, l="Position", rp="S", c=lambda *args: pm.matchTransform( selection[-1], selection[0], pos=True)) pm.menuItem(p=match_position_menu, l="Rotation", rp="SW", c=lambda *args: pm.matchTransform( selection[-1], selection[0], rot=True)) pm.menuItem(p=match_position_menu, l="Object center", rp="N", c=lambda *args: transformFn.snap_to_object_center( selection[0], selection[1:])) pm.menuItem(p=match_position_menu, l="Components center", rp="W", c=lambda *args: transformFn.snap_to_components_center( selection[:-1], selection[-1]))
def makeFkChain(jnts=None): """Select joints in an FK chain starting with the root. This creates a simple FK chain of controls for it.""" prev = None ctrls = [] if not jnts: jnts = pmc.selected(type="joint") for j in jnts: n = j.split("_") n[-1] = "{0}" n = "_".join(n) ctrl = pmc.circle(nr=(1, 0, 0), n=n.format("ctrl"), ch=0)[0] ctrls.append(ctrl) ctrlGrp = pmc.group(n=n.format("offset")) ctrlGrp.setParent(prev) prev = ctrl pmc.matchTransform(ctrlGrp, j) mm = pmc.nt.MultMatrix(n=n.format("fkMtx")) ctrl.wm >> mm.i[0] ctrlGrp.pim >> mm.i[1] dm = pmc.nt.DecomposeMatrix(n=n.format("fkXform")) mm.o >> dm.imat dm.outputTranslate >> j.t dm.outputRotate >> j.r # j.addAttr("control", at="message") ctrl.addAttr("joint", at="message") ctrl.joint >> j.control j.addAttr("fk_xforms", at="message") dm.message >> j.fk_xforms return ctrls
def create_ctl(): ''' create Facial Control and snap to bone Position ''' if pm.objExists('ctlGp'): pm.delete('ctlGp') rm.create_ctl() ul.get_node('ctlGp').setParent(ul.get_node('ROOT')) root = {} root['jaw'] = (ul.get_node('jaw_ctlGp'),ul.get_node('jawRoot_bon')) root['teethUpper'] = (ul.get_node('teethUpper_ctlGp'),ul.get_node('teethUpper_bon')) root['eye'] = (ul.get_node('eye_ctlGp'),ul.get_node('eyeLeftEnd_bon')) for v in string.ascii_uppercase[:4]: root['tongue%s'%v] = (ul.get_node('tongueCenter%sRoot_ctlGp'%v),ul.get_node('tongueCenter%s_bon'%v)) root['teethLower'] = (ul.get_node('teethLower_ctlGp'),ul.get_node('teethLower_bon')) for key,(ob,target) in root.items(): #print key, ob, target ob_pos = ob.getTranslation('world') target_pos = target.getTranslation('world') dest_pos = target_pos if key == 'eye': dest_pos = [ob_pos[0], target_pos[1], ob_pos[2]] ob.setTranslation(dest_pos,space='world') print 'set {} Position to {} postion'.format(ob, target) #ob.setPivots(dest_pos, worldSpace=True) if key != 'eye': pm.matchTransform(ob, target, pivots=True) pm.matchTransform(ob.getChildren()[0], target, pivots=True) print 'match', ob, target, ob.getChildren()[0], 'to', target pm.parentConstraint('CH_Head', 'facialRig_Gp', mo=True) print 'Parent constraint facialRig_Gp to head' pm.parentConstraint('CH_Head', 'eye_ctlGp', mo=True) print 'Parent constraint eye_ctlGp to head'
def shadow_primitive(): shadow_targets = pm.ls(sl=1) shadow_start = shadow_targets[0] shadow_start_location = pm.xform(shadow_start, q=True, ws=True, rotatePivot=True) if shadow_start.hasAttr('radius'): start_radius_attr = str(shadow_start) + '.radius' shadow_radius = shadow_start.radius.get() else: shadow_radius = 5 #shadow_sphere = pm.sphere(radius = shadow_start_radius) shadow_cylinder = pm.cylinder(radius=shadow_radius, heightRatio=2, axis=[1, 0, 0], sections=12, constructionHistory=1) if len(shadow_targets) > 1: shadow_end = shadow_targets[-1] shadow_end_location = pm.xform(shadow_end, q=True, ws=True, rotatePivot=True) shadow_height_ratio = get_distance(shadow_start_location, shadow_end_location) 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) else: pass pm.matchTransform(shadow_cylinder, shadow_start, scale=False)
def addInput(self, node, name=None): name = name or node.name() input_grp = pmc.group(empty=True, name=name + '_IN') pmc.matchTransform(input_grp, node) pmc.parent(input_grp, self.input_group) pmc.parentConstraint(node, input_grp, mo=True) self.__dict__[name] = input_grp
def createLocs(subject): loc_align = pm.spaceLocator() pm.matchTransform(loc_align,subject, rot=True, pos=True) loc_align.sx.set(scale) loc_align.sy.set(scale) loc_align.sz.set(scale) return loc_align
def create_ctrl(node=None): tgt = "NAME" if node: tgt = node.name() else: sel = pm.selected(type="transform") if sel: ctrls = [] for node in sel: ctrls.append(create_ctrl(node)) return ctrls ctrl_name = get_unique_name(tgt + "_CTRL") ctrl = pm.circle(normal=[1, 0, 0], name=ctrl_name)[0] offset_grp = pm.group(empty=True, name=ctrl_name + "_offsetGrp") spaces_grp = pm.group(empty=True, name=ctrl_name + "_spacesGrp") spaces_grp.setParent(offset_grp) ctrl.setParent(spaces_grp) if node: pm.matchTransform(offset_grp, tgt) pm.parentConstraint(ctrl, tgt) ctrl.setAttr("scaleX", lock=True, keyable=False) ctrl.setAttr("scaleY", lock=True, keyable=False) ctrl.setAttr("scaleZ", lock=True, keyable=False) ctrl.setAttr("visibility", lock=True, keyable=False) return ctrl
def addOutput(self, node, name=None): name = name or node.name() output_grp = pmc.group(empty=True, name=name + '_OUT') pmc.matchTransform(output_grp, node) pmc.parent(output_grp, self.output_group) pmc.parentConstraint(node, output_grp, mo=True) self.__dict__[name] = output_grp
def create_bones_between_points(self, initial_point, final_point, number_of_bones, align_object=None): direction_vector = final_point - initial_point total_length = direction_vector.length() step = total_length / number_of_bones step_vector = direction_vector.normal() * step locators_list = [] for count in range(0, number_of_bones + 1): Locator = pm.spaceLocator() if align_object: if self.name_convention.is_name_in_format(align_object): self.name_convention.rename_based_on_base_name( align_object, Locator, name='TwistJoint') locators_list.append(Locator) pm.xform(Locator, translation=list(initial_point + (step_vector * count)), worldSpace=True) pm.matchTransform(Locator, align_object, position=False, rotation=True, scale=False) reset_joints, joints = self.create.joint.point_base(*locators_list, name='twist') self.reset_joints.append(reset_joints) self.reset_joints[-1].setParent(self.rig_system.joints) self.joints.extend(joints) pm.delete(locators_list) return self.reset_joints, self.joints
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 match_micro(source, flip = 'none'): if source.hasAttr('microController'): try: joint_target = uf.meta_traverse(source = source, relation = 'child', tag = 'jointSkin')[0] control_grp = pm.ls(str(source).replace('_CTL','_GRP'))[0] except: pm.warning('problem finding joint_target or control_grp') try: pm.delete(control_grp, constraints = 1) pm.matchTransform(control_grp, joint_target, pos = True, rot = True, scale = False) except: pm.warning('failed to matchTransform') try: tr_constraint = pm.parentConstraint (source,joint_target, mo = 1, weight = 1) tr_constraint.setAttr('interpType', 2) sc_constraint = pm.scaleConstraint(source,joint_target, mo = 1, weight = 1) except: pm.warning('failed to constrain') if 'x' in flip: pm.xform(source, euler = True, rotation = [180,0,0]) elif 'y' in flip: pm.xform(source, euler = True, rotation = [0,180,0]) elif 'z' in flip: pm.xform(source, euler = True, rotation = [0,0,180]) else: pm.warning('controller attr present ') pass elif source.hasAttr('controller'): pm.warning("make sure this doesn't f**k anything!") try: joint_target = uf.meta_traverse(source = source, relation = 'child', tag = 'jointSkin')[0] control_grp = pm.ls(str(source).replace('_CTL','_GRP'))[0] except: pm.warning('problem finding joint_target or control_grp') try: pm.delete(control_grp, constraints = 1) pm.matchTransform(control_grp, joint_target, pos = True, rot = True, scale = False) except: pm.warning('failed to matchTransform') try: tr_constraint = pm.parentConstraint (source,joint_target, mo = 1, weight = 1) tr_constraint.setAttr('interpType', 2) sc_constraint = pm.scaleConstraint(source,joint_target, mo = 1, weight = 1) except: pm.warning('failed to constrain') if 'x' in flip: pm.xform(source, euler = True, rotation = [180,0,0]) elif 'y' in flip: pm.xform(source, euler = True, rotation = [0,180,0]) elif 'z' in flip: pm.xform(source, euler = True, rotation = [0,0,180]) else: pm.warning('controller attr present ') pass pass else: pm.warning('no controller or microController attr') pass pass
def replaceShape(self, old_ctrl=pm.selected(), new_ctrl=None): """ Replacing shape function @param old_ctrl: The controller that you want to change the shape @param new_ctrl: The new shape you want to give to your old controller """ original_ctl = old_ctrl colorSolver = pm.PyNode(original_ctl).overrideRGBColors.get() if colorSolver: color = pm.PyNode(original_ctl).overrideColorRGB.get() else: color = pm.PyNode(original_ctl).overrideColor.get() @propScale def createCtl(): ctl = new_ctrl() pm.PyNode(ctl).overrideEnabled.set(1) pm.PyNode(ctl).overrideRGBColors.set(colorSolver) if isinstance(color, int): pm.PyNode(ctl).overrideColor.set(color) else: pm.PyNode(ctl).overrideColorRGB.set(color) return ctl new_ctrl = createCtl() new_shape = new_ctrl # Duplicate source and move to target location new_shape_dup = pm.duplicate(new_shape, rc=True)[0] pm.matchTransform(new_shape_dup, original_ctl, pos=True, rot=True) # Parent source to target's parent pm.parent(new_shape_dup, original_ctl.getTransform()) pm.makeIdentity(new_shape_dup, apply=True, t=1, r=1, s=1) # Get transforms and shapes of source and target self.new_shape_getShape = pm.PyNode(new_shape_dup).getShapes() original_ctl_getShapes = pm.PyNode(original_ctl).getShapes() for original, new in zip(original_ctl_getShapes, self.new_shape_getShape): pm.rename(new, original.name()) # Parent shapes of source to target for srcShapes in self.new_shape_getShape: pm.parent(srcShapes, original_ctl, add=True, s=True) # Clean up pm.delete(new_shape_dup) pm.delete(original_ctl_getShapes) pm.delete(new_ctrl) return original_ctl
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
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
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 preBuild(self): super(SimpleFk, self).preBuild() ctrl_num = len(self.chain) - (1 - self.includeEndJoint) for i in range(ctrl_num): self.controllers[i] = (ctrl.control(name='{}_{:02d}'.format( self.name, i + 1), size=2)) pm.matchTransform(self.controllers[i].null, self.chain[i]) if i: pm.parent(self.controllers[i].null, self.controllers[i - 1].ctrl) pm.parent(self.controllers[0].null, self.modGlobals['modCtrls'])
def match_to_geo(): """ Helper function to match the first selected object to the second selected mesh object. """ user_sel = pm.ls(sl=True) _, temp_cluster = pm.cluster(user_sel[-1]) pm.matchTransform(user_sel[0], temp_cluster, position=True, rotation=False, scale=False) pm.delete(temp_cluster)
def placeHolderLoc(ctx=0): ''' create locator at position of each selected object @param ctx: 0- just snap, 1-constrain selection to loc, 2-constrain loc to selection @return: ''' sel = pm.selected() for s in sel: l = pm.spaceLocator(n=s.nodeName() + '_placeholderLoc') if ctx == 1: pm.parentConstraint(s, l, mo=0) elif ctx == 2: pm.parentConstraint(l, s, mo=0) else: pm.matchTransform(l, s)
def findClosestUVCoordinate(geo, obj): closestPointOnMesh = pm.createNode("closestPointOnMesh") geoShape = geo.getShape() pm.connectAttr(geoShape.worldMesh, closestPointOnMesh.inMesh) pm.connectAttr(geoShape.worldMatrix, closestPointOnMesh.inputMatrix) loc = pm.spaceLocator(n=name.removeSuffix(geo.name()) + '_LOC') pm.matchTransform(loc, obj) pm.connectAttr(loc.translate, closestPointOnMesh.inPosition) u = closestPointOnMesh.result.parameterU.get() v = closestPointOnMesh.result.parameterV.get() pm.delete(closestPointOnMesh, loc) return u, v
def createPiston(parent, child, control): """ createPiston('joint1', 'joint2', 'Control') """ try: pm.parent(child, parent) except RuntimeError: pass ikNode, effector = pm.ikHandle(n='{}_IkHandle'.format(control), sj=parent, ee=child) ik_group = adb.makeroot_func(ikNode, forceNameConvention=False) pm.matchTransform(ik_group, control, pos=1, rot=0) pm.parent(ik_group, control) ikNode.v.set(0)
def CreateCircles(): CurveColl = [] for joint in listJoint: myname = '{}'.format(joint) new_name = myname.split('__jnt__')[0] + '__ctrl__' curve = mc.circle(nr=self.Normalsctrl, n=new_name, r=self.RadiusCtrl)[0] CurveColl.append(curve) for oJoint, oCurve in zip(listJoint, CurveColl): pm.matchTransform(oCurve, oJoint, pos=True, rot=True) pm.parentConstraint(oCurve, oJoint, mo=True) return CurveColl
def createDoublePiston( lowRootjnt, lowEndjnt, topRootjnt, topEndjnt, low_ctrl, top_ctrl, ): """ Creates a piston system import adb_rig.Func__Piston as adbPiston reload (adbPiston) test = ['joint1', 'joint2', 'joint3', 'joint4', 'joint5__LOC', 'joint6__LOC'] """ ## create a root group over the controller rootGrp_low = adb.makeroot_func(low_ctrl) rootGrp_top = adb.makeroot_func(top_ctrl) pm.parent(lowRootjnt, low_ctrl) pm.parent(topRootjnt, top_ctrl) ## creating the Ik handles lowIk = pm.ikHandle( n='{}_IkHandle'.format(lowRootjnt), sj=lowRootjnt, ee=lowEndjnt, ) topIk = pm.ikHandle( n='{}_IkHandle'.format(topRootjnt), sj=topRootjnt, ee=topEndjnt, ) pm.parent(lowIk[0], top_ctrl) pm.parent(topIk[0], low_ctrl) pm.matchTransform(lowIk[0], topRootjnt, pos=True) pm.matchTransform(topIk[0], lowRootjnt, pos=True) ## hiding the Ik handles pm.PyNode(topIk[1]).v.set(0) pm.PyNode(lowIk[1]).v.set(0) pm.PyNode(topIk[0]).v.set(0) pm.PyNode(lowIk[0]).v.set(0)
def Mcon(src, tg, **op): if op.get('pos'): pm.matchTransform(tg, src, pos=1, rot=1, scl=0) mm = pm.createNode('multMatrix', n='%sMM' % tg) dm = pm.createNode('decomposeMatrix', n='%sDM' % tg) rtn = [None, None] if op.get('pvtCalc'): #tgRotatePivot=tg.getRotatePivot(space='transform') #tg.setScalePivot(tgRotatePivot,space='transform') tgScalePivotMtx = dt.Matrix() tgScalePivotMtx[3] = tg.getScalePivot(space='transform') mm.i[0].set(tgScalePivotMtx) mm.i[1].set(tg.getMatrix(worldSpace=1)) mm.i[2].set(src.getMatrix(worldSpace=1).inverse()) src.wm >> mm.i[3] tg.pim >> mm.i[4] tgTMRPM = dt.Matrix() tgTMRPM[3] = tg.transMinusRotatePivot.get() mm.i[5].set(tgTMRPM) else: mm.i[0].set(tg.getMatrix(worldSpace=1)) mm.i[1].set(src.getMatrix(worldSpace=1).inverse()) src.wm >> mm.i[2] tg.pim >> mm.i[3] mm.o >> dm.imat if op.get('t'): dm.ot >> tg.t if op.get('r'): if tg.nodeType() == 'joint': eq = pm.createNode('eulerToQuat', n='%sEQ' % tg) qi = pm.createNode('quatInvert', n='%sQI' % tg) qp = pm.createNode('quatProd', n='%sQP' % tg) qe = pm.createNode('quatToEuler', n='%sQE' % tg) tg.jo >> eq.irt eq.oq >> qi.iq dm.oq >> qp.iq1 qi.oq >> qp.iq2 qp.oq >> qe.iq qe.ort >> tg.r else: dm.attr('or') >> tg.r if op.get('s'): dm.os >> tg.s if op.get('sh'): dm.osh >> tg.sh
def nurbPlaneBetweenObjects(self, Object01, Object02): VP1 = om.MVector(pm.xform(Object01, a=True, ws=True, q=True, rp=True)) print VP1 VP2 = om.MVector(pm.xform(Object02, a=True, ws=True, q=True, rp=True)) print VP2 longitud = VP1 - VP2 plano = pm.nurbsPlane(ax=[0, 1, 0], p=[(longitud.length()) / 2, 0, 0], w=longitud.length(), lr=.05, d=3, u=8, v=1, ch=0, name="bendyPlane") self.name_conv.rename_name_in_format(plano, useName=True) pm.matchTransform(plano[0], Object01) return plano[0]
def nurb_plane_between_objects(self, object_a, object_b): vector_a = om.MVector( pm.xform(object_a, a=True, ws=True, q=True, rp=True)) vector_b = om.MVector( pm.xform(object_b, a=True, ws=True, q=True, rp=True)) length = vector_a - vector_b plano = pm.nurbsPlane(ax=[0, 1, 0], p=[(length.length()) / 2, 0, 0], w=length.length(), lr=.05, d=3, u=8, v=1, ch=0, name="bendyPlane") self.name_convention.rename_name_in_format(plano[0], useName=True) pm.matchTransform(plano[0], object_a) return plano[0]
def duplicateTransformHierarchyRec(origNode, parentToNode, geoProxy=False): origChildren = origNode.getChildren(type='transform') if len(origChildren) == 0: return 'Finished' for origChild in origChildren: origShape = origChild.getShape() if origShape is not None: # shape if geoProxy is not False: print 'duplicating mesh' proxySphere = pm.polySphere(name='temp', sx=4, sy=6)[0] pm.matchTransform(proxySphere, origChild) pm.parent(proxySphere, parentToNode) proxySphere.rename(origChild) else: dup = origChild.duplicate(n='temp', po=1)[0] pm.parent(dup, parentToNode) dup.rename(origChild) duplicateTransformHierarchyRec(origChild, dup, geoProxy)
def createloc(self): """Creates locator at the Pivot of the object selected """ if pm.selected(): try: loc = adb.LocOnVertex() except AttributeError: locs = [] for sel in pm.selected(): try: _name = sel.name().split('__')[1] except: _name = sel.name() loc_align = pm.spaceLocator(n=_name + '__loc__') locs.append(loc_align) pm.matchTransform(loc_align, sel, rot=True, pos=True) pm.select(locs, add=True) return locs else: locs = pm.spaceLocator(n='Locator1') return locs
def make_ctrl_at_jnt(jnt=None, axis="x"): """ Create a nurbs circle at the given or selected joint. :param jnt: (optional) Joint to match xforms to. :param axis: (optional) Joint primary axis. :return: the nurbs control """ if not jnt: jnt = pmc.selected(type="joint")[0] n = jnt.name().split("_") n[-1] = "{}" n = "_".join(n) offset = pmc.group(em=True, n=n.format("offset")) axis = [1 if a == axis else 0 for a in "xyz"] ctrl = pmc.circle(n=n.format("ctrl"), nr=axis, r=1.0, s=12, d=1, ch=0)[0] ctrl.setParent(offset) ctrl.lineWidth.set(2) pmc.matchTransform(offset, jnt) return ctrl