def connect_leg_2jnt_01(self): """Connector for leg 2jnt""" # If the parent component hasn't been generated we skip the connection if self.parent_comp is None: return pm.connectAttr(self.parent_comp.blend_att, self.blend_att) pm.parent(self.root, self.parent_comp.ik_ctl) pm.parent(self.parent_comp.ik_ref, self.bk_loc[-1]) pm.parentConstraint(self.parent_comp.tws2_rot, self.fk_ref, maintainOffset=True) pm.parent(self.parent_comp.match_fk2, self.fk_ref) heel_t = transform.getTranslation(self.heel_ctl) ik_t = transform.getTranslation(self.parent_comp.ik_ctl) offset_y = heel_t.y - ik_t.y ik_shapes = self.parent_comp.ik_ctl.getShapes() for shape in ik_shapes: points = [] for cv in shape.getCVs(): x = cv[0] * 2. y = cv[1] * 0.4 + offset_y z = cv[2] * 3. points.append(datatypes.Point((x, y, z))) shape.setCVs(points) shape.updateCurve()
def gen2(crv, name, nbPoints, tobe_offset): t = getTransform(self.root) new_crv = curve.createCurveFromCurve(crv, self.getName(name), nbPoints=nbPoints, parent=crv_root, m=t) new_crv.attr("visibility").set(False) # double translation denial cvs = new_crv.getCVs(space="world") for i, cv in enumerate(cvs): x, y, z = transform.getTranslation(new_crv) offset = [cv[0] - x, cv[1] - y, cv[2] - z] new_crv.setCV(i, offset, space='world') if not tobe_offset: return new_crv cvs = new_crv.getCVs(space="world") for i, cv in enumerate(cvs): # we populate the closest vertext list here to skipt the first # and latest point offset = [cv[0], cv[1], cv[2] + self.FRONT_OFFSET] new_crv.setCV(i, offset, space='world') return new_crv
def addObjects(self): self.root = self.addRoot() vTemp = transform.getOffsetPosition(self.root, [0, 0, 1]) self.sizeRef = self.addLoc("sizeRef", self.root, vTemp) pm.delete(self.sizeRef.getShapes()) attribute.lockAttribute(self.sizeRef) self.lookat = self.addLoc("lookat", self.root, vTemp) v = transform.getTranslation(self.root) self.sliding_surface = self.addSliderSurface("sliding_surface", self.root, v)
def addObjects(self): """Add the Guide Root, blade and locators""" self.root = self.addRoot() self.uplocs = self.addLocMulti("#_uploc", self.root) v = transform.getOffsetPosition(self.root, [0., 1.0, 0.0]) self.upPos = self.addLoc("uploc", self.root, v) v = transform.getOffsetPosition(self.root, [0., -0.1, 0.0]) self.lowPos = self.addLoc("lowloc", self.root, v) v = transform.getOffsetPosition(self.root, [0, 0.0000001, 2.5]) self.tan = self.addLoc("tan", self.root, v) self.blade = self.addBlade("blade", self.root, self.tan) v = transform.getTranslation(self.root) self.sliding_surface = self.addSliderSurface("sliding_surface", self.root, v)
def addObjects(self): """Add the Guide Root, blade and locators""" self.root = self.addRoot() self.uplocs = self.addLocMulti("#_uploc", self.root) self.lowlocs = self.addLocMulti("#_lowloc", self.root) v = transform.getOffsetPosition(self.root, [-1, 0.0, 0.0]) self.inPos = self.addLoc("inloc", self.root, v) v = transform.getOffsetPosition(self.root, [1., 0.0, 0.0]) self.outPos = self.addLoc("outloc", self.root, v) v = transform.getOffsetPosition(self.root, [0., 1.0, 0.0]) self.upPos = self.addLoc("uploc", self.root, v) v = transform.getOffsetPosition(self.root, [0., -1.0, 0.0]) self.lowPos = self.addLoc("lowloc", self.root, v) centers = [self.inPos] centers.extend(self.uplocs) centers.append(self.outPos) self.dispcrv = self.addDispCurve("crv", centers) self.addDispCurve("crvRef", centers, 3) centers = [self.inPos] centers.extend(self.lowlocs) centers.append(self.outPos) self.dispcrv = self.addDispCurve("crv", centers) self.addDispCurve("crvRef", centers, 3) v = transform.getTranslation(self.root) self.eyeMesh = self.addEyeMesh("eyeMesh", self.root, v) v = transform.getOffsetPosition(self.root, [0, 0.0000001, 2.5]) self.tan = self.addLoc("tan", self.root, v) self.blade = self.addBlade("blade", self.root, self.tan)
def addObjects(self): """Add all the objects needed to create the component.""" self.WIP = self.options["mode"] self.normal = self.getNormalFromPos(self.guide.apos) self.binormal = self.getBiNormalFromPos(self.guide.apos) self.length0 = vector.getDistance(self.guide.apos[0], self.guide.apos[1]) self.length1 = vector.getDistance(self.guide.apos[1], self.guide.apos[2]) self.length2 = vector.getDistance(self.guide.apos[2], self.guide.apos[3]) # 1 bone chain for upv ref self.legChainUpvRef = primitive.add2DChain( self.root, self.getName("legUpvRef%s_jnt"), [self.guide.apos[0], self.guide.apos[2]], self.normal, False, self.WIP) self.legChainUpvRef[1].setAttr( "jointOrientZ", self.legChainUpvRef[1].getAttr("jointOrientZ") * -1) # extra neutral pose t = transform.getTransformFromPos(self.guide.apos[0]) self.root_npo = primitive.addTransform(self.root, self.getName("root_npo"), t) self.root_ctl = self.addCtl(self.root_npo, "root_ctl", t, self.color_fk, "circle", w=self.length0 / 6, tp=self.parentCtlTag) # FK Controlers ----------------------------------- t = transform.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, "xz", self.negate) self.fk0_npo = primitive.addTransform(self.root_ctl, self.getName("fk0_npo"), t) po_vec = datatypes.Vector(.5 * self.length0 * self.n_factor, 0, 0) self.fk0_ctl = self.addCtl(self.fk0_npo, "fk0_ctl", t, self.color_fk, "cube", w=self.length0, h=self.size * .1, d=self.size * .1, po=po_vec, tp=self.root_ctl) attribute.setKeyableAttributes( self.fk0_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) t = transform.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2], self.normal, "xz", self.negate) self.fk1_npo = primitive.addTransform(self.fk0_ctl, self.getName("fk1_npo"), t) po_vec = datatypes.Vector(.5 * self.length1 * self.n_factor, 0, 0) self.fk1_ctl = self.addCtl(self.fk1_npo, "fk1_ctl", t, self.color_fk, "cube", w=self.length1, h=self.size * .1, d=self.size * .1, po=po_vec, tp=self.fk0_ctl) attribute.setKeyableAttributes( self.fk1_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) t = transform.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3], self.normal, "xz", self.negate) self.fk2_npo = primitive.addTransform(self.fk1_ctl, self.getName("fk2_npo"), t) po_vec = datatypes.Vector(.5 * self.length2 * self.n_factor, 0, 0) self.fk2_ctl = self.addCtl(self.fk2_npo, "fk2_ctl", t, self.color_fk, "cube", w=self.length2, h=self.size * .1, d=self.size * .1, po=po_vec, tp=self.fk1_ctl) attribute.setKeyableAttributes(self.fk2_ctl) self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl] for x in self.fk_ctl: attribute.setInvertMirror(x, ["tx", "ty", "tz"]) # IK Controlers ----------------------------------- self.ik_cns = primitive.addTransformFromPos(self.root_ctl, self.getName("ik_cns"), self.guide.pos["ankle"]) self.ikcns_ctl = self.addCtl(self.ik_cns, "ikcns_ctl", transform.getTransformFromPos( self.guide.pos["ankle"]), self.color_ik, "null", w=self.size * .12, tp=self.root_ctl) attribute.setInvertMirror(self.ikcns_ctl, ["tx"]) m = transform.getTransformLookingAt(self.guide.pos["ankle"], self.guide.pos["eff"], self.x_axis, "zx", False) self.ik_ctl = self.addCtl(self.ikcns_ctl, "ik_ctl", transform.getTransformFromPos( self.guide.pos["ankle"]), self.color_ik, "cube", w=self.size * .12, h=self.size * .12, d=self.size * .12) attribute.setKeyableAttributes(self.ik_ctl) attribute.setRotOrder(self.ik_ctl, "XZY") attribute.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"]) # upv v = self.guide.apos[2] - self.guide.apos[0] v = self.normal ^ v v.normalize() v *= self.size * .5 v += self.guide.apos[1] self.upv_cns = primitive.addTransformFromPos(self.ik_ctl, self.getName("upv_cns"), v) self.upv_ctl = self.addCtl(self.upv_cns, "upv_ctl", transform.getTransform(self.upv_cns), self.color_ik, "diamond", w=self.size * .12, tp=self.root_ctl) self.add_controller_tag(self.ik_ctl, self.upv_ctl) if self.settings["mirrorMid"]: if self.negate: self.upv_cns.rz.set(180) self.upv_cns.sy.set(-1) else: attribute.setInvertMirror(self.upv_ctl, ["tx"]) attribute.setKeyableAttributes(self.upv_ctl, self.t_params) # References -------------------------------------- self.ik_ref = primitive.addTransform( self.ik_ctl, self.getName("ik_ref"), transform.getTransform(self.ik_ctl)) self.fk_ref = primitive.addTransform( self.fk_ctl[2], self.getName("fk_ref"), transform.getTransform(self.ik_ctl)) # Chain -------------------------------------------- # The outputs of the ikfk2bone solver self.bone0 = primitive.addLocator( self.root_ctl, self.getName("0_bone"), transform.getTransform(self.fk_ctl[0])) self.bone0_shp = self.bone0.getShape() self.bone0_shp.setAttr("localPositionX", self.n_factor * .5) self.bone0_shp.setAttr("localScale", .5, 0, 0) self.bone0.setAttr("sx", self.length0) self.bone0.setAttr("visibility", False) self.bone1 = primitive.addLocator( self.root_ctl, self.getName("1_bone"), transform.getTransform(self.fk_ctl[1])) self.bone1_shp = self.bone1.getShape() self.bone1_shp.setAttr("localPositionX", self.n_factor * .5) self.bone1_shp.setAttr("localScale", .5, 0, 0) self.bone1.setAttr("sx", self.length1) self.bone1.setAttr("visibility", False) self.ctrn_loc = primitive.addTransformFromPos(self.root_ctl, self.getName("ctrn_loc"), self.guide.apos[1]) self.eff_loc = primitive.addTransformFromPos(self.root_ctl, self.getName("eff_loc"), self.guide.apos[2]) # tws_ref t = transform.getRotationFromAxis(datatypes.Vector(0, -1, 0), self.normal, "xz", self.negate) t = transform.setMatrixPosition(t, self.guide.pos["ankle"]) # addind an npo parent transform to fix flip in Maya 2018.2 self.tws_npo = primitive.addTransform(self.eff_loc, self.getName("tws_npo"), t) self.tws_ref = primitive.addTransform(self.tws_npo, self.getName("tws_ref"), t) # Mid Controler ------------------------------------ t = transform.getTransform(self.ctrn_loc) self.mid_cns = primitive.addTransform(self.ctrn_loc, self.getName("mid_cns"), t) self.mid_ctl = self.addCtl(self.mid_cns, "mid_ctl", t, self.color_ik, "sphere", w=self.size * .2, tp=self.root_ctl) attribute.setKeyableAttributes( self.mid_ctl, params=["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) if self.settings["mirrorMid"]: if self.negate: self.mid_cns.rz.set(180) self.mid_cns.sz.set(-1) else: attribute.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"]) # Twist references --------------------------------- x = datatypes.Vector(0, -1, 0) x = x * transform.getTransform(self.eff_loc) z = datatypes.Vector(self.normal.x, self.normal.y, self.normal.z) z = z * transform.getTransform(self.eff_loc) m = transform.getRotationFromAxis(x, z, "xz", self.negate) m = transform.setMatrixPosition(m, transform.getTranslation(self.ik_ctl)) self.rollRef = primitive.add2DChain(self.root, self.getName("rollChain"), self.guide.apos[:2], self.normal, self.negate, self.WIP) self.tws0_loc = primitive.addTransform( self.rollRef[0], self.getName("tws0_loc"), transform.getTransform(self.fk_ctl[0])) self.tws0_rot = primitive.addTransform( self.tws0_loc, self.getName("tws0_rot"), transform.getTransform(self.fk_ctl[0])) self.tws1_loc = primitive.addTransform( self.ctrn_loc, self.getName("tws1_loc"), transform.getTransform(self.ctrn_loc)) self.tws1_rot = primitive.addTransform( self.tws1_loc, self.getName("tws1_rot"), transform.getTransform(self.ctrn_loc)) # thickness control self.thick_lvl = primitive.addTransform( self.mid_ctl, self.getName("thickness_lvl"), transform.getTransform(self.ctrn_loc)) self.thick_ctl = self.addCtl(self.thick_lvl, "thickness_ctl", transform.getTransform(self.mid_ctl), self.color_ik, "arrow", w=self.size * .1, ro=datatypes.Vector([0, 1.5708, 0]), tp=self.mid_ctl) if self.negate and not self.settings["mirrorMid"]: self.thick_ctl.rz.set(180) self.thick_ctl.sz.set(-1) attribute.setKeyableAttributes(self.thick_ctl, ["tx", "ty"]) self.tws1B_loc = primitive.addTransform( self.ctrn_loc, self.getName("tws1B_loc"), transform.getTransform(self.ctrn_loc)) self.tws1B_rot = primitive.addTransform( self.tws1B_loc, self.getName("tws1B_rot"), transform.getTransform(self.ctrn_loc)) self.tws2_loc = primitive.addTransform( self.root_ctl, self.getName("tws2_loc"), transform.getTransform(self.tws_ref)) self.tws2_rot = primitive.addTransform( self.tws2_loc, self.getName("tws2_rot"), transform.getTransform(self.tws_ref)) self.tws2_rot.setAttr("sx", .001) # angle reader ---------------------------------------- t = transform.getTransformLookingAt(self.guide.apos[1], self.guide.apos[0], self.binormal, "yz") self.readerA = primitive.addTransform(self.root, self.getName("readerA_loc"), t) self.readerB = primitive.addTransform(self.readerA, self.getName("readerB_loc"), t) self.readerB.rotateOrder.set(2) # Divisions ---------------------------------------- # We have at least one division at the start, the end and one for # the elbow. + 2 for knee angle control if self.settings["supportJoints"]: ej = 2 else: ej = 0 self.divisions = self.settings["div0"] + self.settings["div1"] + 3 + ej self.div_cns = [] if self.settings["extraTweak"]: tagP = self.parentCtlTag self.tweak_ctl = [] for i in range(self.divisions): div_cns = primitive.addTransform(self.root_ctl, self.getName("div%s_loc" % i)) self.div_cns.append(div_cns) if self.settings["extraTweak"]: t = transform.getTransform(div_cns) tweak_ctl = self.addCtl(div_cns, "tweak%s_ctl" % i, t, self.color_fk, "square", w=self.size * .15, d=self.size * .15, ro=datatypes.Vector([0, 0, 1.5708]), tp=tagP) attribute.setKeyableAttributes(tweak_ctl) tagP = tweak_ctl self.tweak_ctl.append(tweak_ctl) self.jnt_pos.append([tweak_ctl, i, None, False]) else: self.jnt_pos.append([div_cns, i]) # End reference ------------------------------------ # To help the deformation on the ankle self.end_ref = primitive.addTransform(self.tws2_rot, self.getName("end_ref"), m) self.jnt_pos.append([self.end_ref, 'end']) # match IK FK references self.match_fk0_off = self.add_match_ref(self.fk_ctl[1], self.root, "matchFk0_npo", False) self.match_fk0 = self.add_match_ref(self.fk_ctl[0], self.match_fk0_off, "fk0_mth") self.match_fk1_off = self.add_match_ref(self.fk_ctl[2], self.root, "matchFk1_npo", False) self.match_fk1 = self.add_match_ref(self.fk_ctl[1], self.match_fk1_off, "fk1_mth") self.match_fk2 = self.add_match_ref(self.fk_ctl[2], self.ik_ctl, "fk2_mth") self.match_ik = self.add_match_ref(self.ik_ctl, self.fk2_ctl, "ik_mth") self.match_ikUpv = self.add_match_ref(self.upv_ctl, self.fk0_ctl, "upv_mth") # add visual reference self.line_ref = icon.connection_display_curve( self.getName("visalRef"), [self.upv_ctl, self.mid_ctl])
def rig(edge_loop="", up_vertex="", low_vertex="", name_prefix="", thickness=0.3, do_skin=True, rigid_loops=5, falloff_loops=8, head_joint=None, jaw_joint=None, parent_node=None, control_name="ctl", upper_lip_ctl=None, lower_lip_ctl=None): ###### # Var ###### FRONT_OFFSET = .02 NB_ROPE = 15 ################## # Helper functions ################## def setName(name, side="C", idx=None): namesList = [name_prefix, side, name] if idx is not None: namesList[1] = side + str(idx) name = "_".join(namesList) return name ############### # Checkers ############## # Loop if edge_loop: try: edge_loop = [pm.PyNode(e) for e in edge_loop.split(",")] except pm.MayaNodeError: pm.displayWarning( "Some of the edges listed in edge loop can not be found") return else: pm.displayWarning("Please set the edge loop first") return # Vertex if up_vertex: try: up_vertex = pm.PyNode(up_vertex) except pm.MayaNodeError: pm.displayWarning("%s can not be found" % up_vertex) return else: pm.displayWarning("Please set the upper lip central vertex") return if low_vertex: try: low_vertex = pm.PyNode(low_vertex) except pm.MayaNodeError: pm.displayWarning("%s can not be found" % low_vertex) return else: pm.displayWarning("Please set the lower lip central vertex") return # skinnign data if do_skin: if not head_joint: pm.displayWarning("Please set the Head Jnt or unCheck Compute " "Topological Autoskin") return else: try: head_joint = pm.PyNode(head_joint) except pm.MayaNodeError: pm.displayWarning( "Head Joint: %s can not be found" % head_joint ) return if not jaw_joint: pm.displayWarning("Please set the Jaw Jnt or unCheck Compute " "Topological Autoskin") return else: try: jaw_joint = pm.PyNode(jaw_joint) except pm.MayaNodeError: pm.displayWarning("Jaw Joint: %s can not be found" % jaw_joint) return # check if the rig already exist in the current scene if pm.ls(setName("root")): pm.displayWarning("The object %s already exist in the scene. Please " "choose another name prefix" % setName("root")) return ##################### # Root creation ##################### lips_root = primitive.addTransform(None, setName("root")) lipsCrv_root = primitive.addTransform(lips_root, setName("crvs")) lipsRope_root = primitive.addTransform(lips_root, setName("rope")) ##################### # Geometry ##################### geo = pm.listRelatives(edge_loop[0], parent=True)[0] ##################### # Groups ##################### try: ctlSet = pm.PyNode("rig_controllers_grp") except pm.MayaNodeError: pm.sets(n="rig_controllers_grp", em=True) ctlSet = pm.PyNode("rig_controllers_grp") try: defset = pm.PyNode("rig_deformers_grp") except pm.MayaNodeError: pm.sets(n="rig_deformers_grp", em=True) defset = pm.PyNode("rig_deformers_grp") ##################### # Curves creation ##################### # get extreme position using the outer loop extr_v = meshNavigation.getExtremeVertexFromLoop(edge_loop) upPos = extr_v[0] lowPos = extr_v[1] inPos = extr_v[2] outPos = extr_v[3] edgeList = extr_v[4] vertexList = extr_v[5] upPos = up_vertex lowPos = low_vertex # upper crv upLip_edgeRange = meshNavigation.edgeRangeInLoopFromMid(edgeList, upPos, inPos, outPos) upCrv = curve.createCuveFromEdges(upLip_edgeRange, setName("upperLip"), parent=lipsCrv_root) # store the closest vertex by curv cv index. To be use fo the auto skining upLip_closestVtxList = [] # offset upper lip Curve cvs = upCrv.getCVs(space="world") for i, cv in enumerate(cvs): closestVtx = meshNavigation.getClosestVertexFromTransform(geo, cv) upLip_closestVtxList.append(closestVtx) if i == 0: # we know the curv starts from right to left offset = [cv[0] - thickness, cv[1], cv[2] - thickness] elif i == len(cvs) - 1: offset = [cv[0] + thickness, cv[1], cv[2] - thickness] else: offset = [cv[0], cv[1] + thickness, cv[2]] upCrv.setCV(i, offset, space='world') # lower crv lowLip_edgeRange = meshNavigation.edgeRangeInLoopFromMid(edgeList, lowPos, inPos, outPos) lowCrv = curve.createCuveFromEdges(lowLip_edgeRange, setName("lowerLip"), parent=lipsCrv_root) lowLip_closestVtxList = [] # offset lower lip Curve cvs = lowCrv.getCVs(space="world") for i, cv in enumerate(cvs): closestVtx = meshNavigation.getClosestVertexFromTransform(geo, cv) lowLip_closestVtxList.append(closestVtx) if i == 0: # we know the curv starts from right to left offset = [cv[0] - thickness, cv[1], cv[2] - thickness] elif i == len(cvs) - 1: offset = [cv[0] + thickness, cv[1], cv[2] - thickness] else: # we populate the closest vertext list here to skipt the first # and latest point offset = [cv[0], cv[1] - thickness, cv[2]] lowCrv.setCV(i, offset, space='world') upCrv_ctl = curve.createCurveFromCurve(upCrv, setName("upCtl_crv"), nbPoints=7, parent=lipsCrv_root) lowCrv_ctl = curve.createCurveFromCurve(lowCrv, setName("lowCtl_crv"), nbPoints=7, parent=lipsCrv_root) upRope = curve.createCurveFromCurve(upCrv, setName("upRope_crv"), nbPoints=NB_ROPE, parent=lipsCrv_root) lowRope = curve.createCurveFromCurve(lowCrv, setName("lowRope_crv"), nbPoints=NB_ROPE, parent=lipsCrv_root) upCrv_upv = curve.createCurveFromCurve(upCrv, setName("upCrv_upv"), nbPoints=7, parent=lipsCrv_root) lowCrv_upv = curve.createCurveFromCurve(lowCrv, setName("lowCrv_upv"), nbPoints=7, parent=lipsCrv_root) upRope_upv = curve.createCurveFromCurve(upCrv, setName("upRope_upv"), nbPoints=NB_ROPE, parent=lipsCrv_root) lowRope_upv = curve.createCurveFromCurve(lowCrv, setName("lowRope_upv"), nbPoints=NB_ROPE, parent=lipsCrv_root) # offset upv curves for crv in [upCrv_upv, lowCrv_upv, upRope_upv, lowRope_upv]: cvs = crv.getCVs(space="world") for i, cv in enumerate(cvs): # we populate the closest vertext list here to skipt the first # and latest point offset = [cv[0], cv[1], cv[2] + FRONT_OFFSET] crv.setCV(i, offset, space='world') rigCrvs = [upCrv, lowCrv, upCrv_ctl, lowCrv_ctl, upRope, lowRope, upCrv_upv, lowCrv_upv, upRope_upv, lowRope_upv] for crv in rigCrvs: crv.attr("visibility").set(False) ################## # Joints ################## lvlType = "transform" # upper joints upperJoints = [] cvs = upCrv.getCVs(space="world") pm.progressWindow(title='Creating Upper Joints', progress=0, max=len(cvs)) for i, cv in enumerate(cvs): pm.progressWindow(e=True, step=1, status='\nCreating Joint for %s' % cv) oTransUpV = pm.PyNode(pm.createNode( lvlType, n=setName("upLipRopeUpv", idx=str(i).zfill(3)), p=lipsRope_root, ss=True)) oTrans = pm.PyNode( pm.createNode(lvlType, n=setName("upLipRope", idx=str(i).zfill(3)), p=lipsRope_root, ss=True)) oParam, oLength = curve.getCurveParamAtPosition(upRope, cv) uLength = curve.findLenghtFromParam(upRope, oParam) u = uLength / oLength applyop.pathCns( oTransUpV, upRope_upv, cnsType=False, u=u, tangent=False) cns = applyop.pathCns( oTrans, upRope, cnsType=False, u=u, tangent=False) cns.setAttr("worldUpType", 1) cns.setAttr("frontAxis", 0) cns.setAttr("upAxis", 1) pm.connectAttr(oTransUpV.attr("worldMatrix[0]"), cns.attr("worldUpMatrix")) # getting joint parent if head_joint and isinstance(head_joint, (str, string_types)): try: j_parent = pm.PyNode(head_joint) except pm.MayaNodeError: j_parent = False elif head_joint and isinstance(head_joint, pm.PyNode): j_parent = head_joint else: j_parent = False jnt = rigbits.addJnt(oTrans, noReplace=True, parent=j_parent) upperJoints.append(jnt) pm.sets(defset, add=jnt) pm.progressWindow(e=True, endProgress=True) # lower joints lowerJoints = [] cvs = lowCrv.getCVs(space="world") pm.progressWindow(title='Creating Lower Joints', progress=0, max=len(cvs)) for i, cv in enumerate(cvs): pm.progressWindow(e=True, step=1, status='\nCreating Joint for %s' % cv) oTransUpV = pm.PyNode(pm.createNode( lvlType, n=setName("lowLipRopeUpv", idx=str(i).zfill(3)), p=lipsRope_root, ss=True)) oTrans = pm.PyNode(pm.createNode( lvlType, n=setName("lowLipRope", idx=str(i).zfill(3)), p=lipsRope_root, ss=True)) oParam, oLength = curve.getCurveParamAtPosition(lowRope, cv) uLength = curve.findLenghtFromParam(lowRope, oParam) u = uLength / oLength applyop.pathCns(oTransUpV, lowRope_upv, cnsType=False, u=u, tangent=False) cns = applyop.pathCns(oTrans, lowRope, cnsType=False, u=u, tangent=False) cns.setAttr("worldUpType", 1) cns.setAttr("frontAxis", 0) cns.setAttr("upAxis", 1) pm.connectAttr(oTransUpV.attr("worldMatrix[0]"), cns.attr("worldUpMatrix")) # getting joint parent if jaw_joint and isinstance(jaw_joint, (str, string_types)): try: j_parent = pm.PyNode(jaw_joint) except pm.MayaNodeError: pass elif jaw_joint and isinstance(jaw_joint, pm.PyNode): j_parent = jaw_joint else: j_parent = False jnt = rigbits.addJnt(oTrans, noReplace=True, parent=j_parent) lowerJoints.append(jnt) pm.sets(defset, add=jnt) pm.progressWindow(e=True, endProgress=True) ################## # Controls ################## # Controls lists upControls = [] upVec = [] upNpo = [] lowControls = [] lowVec = [] lowNpo = [] # controls options axis_list = ["sx", "sy", "sz", "ro"] upCtlOptions = [["corner", "R", "square", 4, .05, axis_list], ["upOuter", "R", "circle", 14, .03, []], ["upInner", "R", "circle", 14, .03, []], ["upper", "C", "square", 4, .05, axis_list], ["upInner", "L", "circle", 14, .03, []], ["upOuter", "L", "circle", 14, .03, []], ["corner", "L", "square", 4, .05, axis_list]] lowCtlOptions = [["lowOuter", "R", "circle", 14, .03, []], ["lowInner", "R", "circle", 14, .03, []], ["lower", "C", "square", 4, .05, axis_list], ["lowInner", "L", "circle", 14, .03, []], ["lowOuter", "L", "circle", 14, .03, []]] params = ["tx", "ty", "tz", "rx", "ry", "rz"] # upper controls cvs = upCrv_ctl.getCVs(space="world") pm.progressWindow(title='Upper controls', progress=0, max=len(cvs)) v0 = transform.getTransformFromPos(cvs[0]) v1 = transform.getTransformFromPos(cvs[-1]) distSize = vector.getDistance(v0, v1) * 3 for i, cv in enumerate(cvs): pm.progressWindow(e=True, step=1, status='\nCreating control for%s' % cv) t = transform.getTransformFromPos(cv) # Get nearest joint for orientation of controls joints = upperJoints + lowerJoints nearest_joint = None nearest_distance = None for joint in joints: distance = vector.getDistance( transform.getTranslation(joint), cv ) if nearest_distance is None or distance < nearest_distance: nearest_distance = distance nearest_joint = joint if nearest_joint: t = transform.setMatrixPosition( transform.getTransform(nearest_joint), cv ) temp = primitive.addTransform( lips_root, setName("temp"), t ) temp.rx.set(0) t = transform.getTransform(temp) pm.delete(temp) oName = upCtlOptions[i][0] oSide = upCtlOptions[i][1] o_icon = upCtlOptions[i][2] color = upCtlOptions[i][3] wd = upCtlOptions[i][4] oPar = upCtlOptions[i][5] npo = primitive.addTransform(lips_root, setName("%s_npo" % oName, oSide), t) upNpo.append(npo) ctl = icon.create(npo, setName("%s_%s" % (oName, control_name), oSide), t, icon=o_icon, w=wd * distSize, d=wd * distSize, ro=datatypes.Vector(1.57079633, 0, 0), po=datatypes.Vector(0, 0, .07 * distSize), color=color) upControls.append(ctl) name_split = control_name.split("_") if len(name_split) == 2 and name_split[-1] == "ghost": pass else: pm.sets(ctlSet, add=ctl) attribute.addAttribute(ctl, "isCtl", "bool", keyable=False) attribute.setKeyableAttributes(ctl, params + oPar) upv = primitive.addTransform(ctl, setName("%s_upv" % oName, oSide), t) upv.attr("tz").set(FRONT_OFFSET) upVec.append(upv) if oSide == "R": npo.attr("sx").set(-1) pm.progressWindow(e=True, endProgress=True) # lower controls cvs = lowCrv_ctl.getCVs(space="world") pm.progressWindow(title='Lower controls', progress=0, max=len(cvs)) for i, cv in enumerate(cvs[1:-1]): pm.progressWindow(e=True, step=1, status='\nCreating control for%s' % cv) t = transform.getTransformFromPos(cv) # Get nearest joint for orientation of controls joints = upperJoints + lowerJoints nearest_joint = None nearest_distance = None for joint in joints: distance = vector.getDistance( transform.getTranslation(joint), cv ) if nearest_distance is None or distance < nearest_distance: nearest_distance = distance nearest_joint = joint if nearest_joint: t = transform.setMatrixPosition( transform.getTransform(nearest_joint), cv ) temp = primitive.addTransform( lips_root, setName("temp"), t ) temp.rx.set(0) t = transform.getTransform(temp) pm.delete(temp) oName = lowCtlOptions[i][0] oSide = lowCtlOptions[i][1] o_icon = lowCtlOptions[i][2] color = lowCtlOptions[i][3] wd = lowCtlOptions[i][4] oPar = lowCtlOptions[i][5] npo = primitive.addTransform(lips_root, setName("%s_npo" % oName, oSide), t) lowNpo.append(npo) ctl = icon.create(npo, setName("%s_%s" % (oName, control_name), oSide), t, icon=o_icon, w=wd * distSize, d=wd * distSize, ro=datatypes.Vector(1.57079633, 0, 0), po=datatypes.Vector(0, 0, .07 * distSize), color=color) lowControls.append(ctl) name_split = control_name.split("_") if len(name_split) == 2 and control_name.split("_")[-1] == "ghost": pass else: pm.sets(ctlSet, add=ctl) attribute.addAttribute(ctl, "isCtl", "bool", keyable=False) attribute.setKeyableAttributes(ctl, params + oPar) upv = primitive.addTransform(ctl, setName("%s_upv" % oName, oSide), t) upv.attr("tz").set(FRONT_OFFSET) lowVec.append(upv) if oSide == "R": npo.attr("sx").set(-1) pm.progressWindow(e=True, endProgress=True) # reparentig controls pm.parent(upNpo[1], lowNpo[0], upControls[0]) pm.parent(upNpo[2], upNpo[4], upControls[3]) pm.parent(upNpo[-2], lowNpo[-1], upControls[-1]) pm.parent(lowNpo[1], lowNpo[3], lowControls[2]) # Connecting control crvs with controls applyop.gear_curvecns_op(upCrv_ctl, upControls) applyop.gear_curvecns_op(lowCrv_ctl, [upControls[0]] + lowControls + [upControls[-1]]) applyop.gear_curvecns_op(upCrv_upv, upVec) applyop.gear_curvecns_op(lowCrv_upv, [upVec[0]] + lowVec + [upVec[-1]]) # adding wires pm.wire(upCrv, w=upCrv_ctl, dropoffDistance=[0, 1000]) pm.wire(lowCrv, w=lowCrv_ctl, dropoffDistance=[0, 1000]) pm.wire(upRope, w=upCrv_ctl, dropoffDistance=[0, 1000]) pm.wire(lowRope, w=lowCrv_ctl, dropoffDistance=[0, 1000]) pm.wire(upRope_upv, w=upCrv_upv, dropoffDistance=[0, 1000]) pm.wire(lowRope_upv, w=lowCrv_upv, dropoffDistance=[0, 1000]) # setting constrains # up cns_node = pm.parentConstraint(upControls[0], upControls[3], upControls[1].getParent(), mo=True, skipRotate=["x", "y", "z"]) cns_node.attr(upControls[0].name() + "W0").set(.75) cns_node.attr(upControls[3].name() + "W1").set(.25) cns_node.interpType.set(0) # noFlip cns_node = pm.parentConstraint(upControls[0], upControls[3], upControls[2].getParent(), mo=True, skipRotate=["x", "y", "z"]) cns_node.attr(upControls[0].name() + "W0").set(.25) cns_node.attr(upControls[3].name() + "W1").set(.75) cns_node.interpType.set(0) # noFlip cns_node = pm.parentConstraint(upControls[3], upControls[6], upControls[4].getParent(), mo=True, skipRotate=["x", "y", "z"]) cns_node.attr(upControls[3].name() + "W0").set(.75) cns_node.attr(upControls[6].name() + "W1").set(.25) cns_node.interpType.set(0) # noFlip cns_node = pm.parentConstraint(upControls[3], upControls[6], upControls[5].getParent(), mo=True, skipRotate=["x", "y", "z"]) cns_node.attr(upControls[3].name() + "W0").set(.25) cns_node.attr(upControls[6].name() + "W1").set(.75) cns_node.interpType.set(0) # noFlip # low cns_node = pm.parentConstraint(upControls[0], lowControls[2], lowControls[0].getParent(), mo=True, skipRotate=["x", "y", "z"]) cns_node.attr(upControls[0].name() + "W0").set(.75) cns_node.attr(lowControls[2].name() + "W1").set(.25) cns_node.interpType.set(0) # noFlip cns_node = pm.parentConstraint(upControls[0], lowControls[2], lowControls[1].getParent(), mo=True, skipRotate=["x", "y", "z"]) cns_node.attr(upControls[0].name() + "W0").set(.25) cns_node.attr(lowControls[2].name() + "W1").set(.75) cns_node.interpType.set(0) # noFlip cns_node = pm.parentConstraint(lowControls[2], upControls[6], lowControls[3].getParent(), mo=True, skipRotate=["x", "y", "z"]) cns_node.attr(lowControls[2].name() + "W0").set(.75) cns_node.attr(upControls[6].name() + "W1").set(.25) cns_node.interpType.set(0) # noFlip cns_node = pm.parentConstraint(lowControls[2], upControls[6], lowControls[4].getParent(), mo=True, skipRotate=["x", "y", "z"]) cns_node.attr(lowControls[2].name() + "W0").set(.25) cns_node.attr(upControls[6].name() + "W1").set(.75) cns_node.interpType.set(0) # noFlip ########################################### # Connecting rig ########################################### if parent_node: try: if isinstance(parent_node, string_types): parent_node = pm.PyNode(parent_node) parent_node.addChild(lips_root) except pm.MayaNodeError: pm.displayWarning("The Lips rig can not be parent to: %s. Maybe " "this object doesn't exist." % parent_node) if head_joint and jaw_joint: try: if isinstance(head_joint, string_types): head_joint = pm.PyNode(head_joint) except pm.MayaNodeError: pm.displayWarning("Head Joint or Upper Lip Joint %s. Can not be " "fount in the scene" % head_joint) return try: if isinstance(jaw_joint, string_types): jaw_joint = pm.PyNode(jaw_joint) except pm.MayaNodeError: pm.displayWarning("Jaw Joint or Lower Lip Joint %s. Can not be " "fount in the scene" % jaw_joint) return ref_ctls = [head_joint, jaw_joint] if upper_lip_ctl and lower_lip_ctl: try: if isinstance(upper_lip_ctl, string_types): upper_lip_ctl = pm.PyNode(upper_lip_ctl) except pm.MayaNodeError: pm.displayWarning("Upper Lip Ctl %s. Can not be " "fount in the scene" % upper_lip_ctl) return try: if isinstance(lower_lip_ctl, string_types): lower_lip_ctl = pm.PyNode(lower_lip_ctl) except pm.MayaNodeError: pm.displayWarning("Lower Lip Ctl %s. Can not be " "fount in the scene" % lower_lip_ctl) return ref_ctls = [upper_lip_ctl, lower_lip_ctl] # in order to avoid flips lets create a reference transform # also to avoid flips, set any multi target parentConstraint to noFlip ref_cns_list = [] print (ref_ctls) for cns_ref in ref_ctls: t = transform.getTransformFromPos( cns_ref.getTranslation(space='world')) ref = pm.createNode("transform", n=cns_ref.name() + "_cns", p=cns_ref, ss=True) ref.setMatrix(t, worldSpace=True) ref_cns_list.append(ref) # right corner connection cns_node = pm.parentConstraint(ref_cns_list[0], ref_cns_list[1], upControls[0].getParent(), mo=True) cns_node.interpType.set(0) # noFlip # left corner connection cns_node = pm.parentConstraint(ref_cns_list[0], ref_cns_list[1], upControls[-1].getParent(), mo=True) cns_node.interpType.set(0) # noFlip # up control connection cns_node = pm.parentConstraint(ref_cns_list[0], upControls[3].getParent(), mo=True) # low control connection cns_node = pm.parentConstraint(ref_cns_list[1], lowControls[2].getParent(), mo=True) ########################################### # Auto Skinning ########################################### if do_skin: # eyelid vertex rows totalLoops = rigid_loops + falloff_loops vertexLoopList = meshNavigation.getConcentricVertexLoop(vertexList, totalLoops) vertexRowList = meshNavigation.getVertexRowsFromLoops(vertexLoopList) # we set the first value 100% for the first initial loop skinPercList = [1.0] # we expect to have a regular grid topology for r in range(rigid_loops): for rr in range(2): skinPercList.append(1.0) increment = 1.0 / float(falloff_loops) # we invert to smooth out from 100 to 0 inv = 1.0 - increment for r in range(falloff_loops): for rr in range(2): if inv < 0.0: inv = 0.0 skinPercList.append(inv) inv -= increment # this loop add an extra 0.0 indices to avoid errors for r in range(10): for rr in range(2): skinPercList.append(0.0) # base skin if head_joint: try: head_joint = pm.PyNode(head_joint) except pm.MayaNodeError: pm.displayWarning( "Auto skin aborted can not find %s " % head_joint) return # Check if the object has a skinCluster objName = pm.listRelatives(geo, parent=True)[0] skinCluster = skin.getSkinCluster(objName) if not skinCluster: skinCluster = pm.skinCluster(head_joint, geo, tsb=True, nw=2, n='skinClsEyelid') lipsJoints = upperJoints + lowerJoints closestVtxList = upLip_closestVtxList + lowLip_closestVtxList pm.progressWindow(title='Auto skinning process', progress=0, max=len(lipsJoints)) for i, jnt in enumerate(lipsJoints): pm.progressWindow(e=True, step=1, status='\nSkinning %s' % jnt) skinCluster.addInfluence(jnt, weight=0) v = closestVtxList[i] for row in vertexRowList: if v in row: for i, rv in enumerate(row): # find the deformer with max value for each vertex w = pm.skinPercent(skinCluster, rv, query=True, value=True) transJoint = pm.skinPercent(skinCluster, rv, query=True, t=None) max_value = max(w) max_index = w.index(max_value) perc = skinPercList[i] t_value = [(jnt, perc), (transJoint[max_index], 1.0 - perc)] pm.skinPercent(skinCluster, rv, transformValue=t_value) pm.progressWindow(e=True, endProgress=True)
def addObjects(self): """Add all the objects needed to create the component.""" self.WIP = self.options["mode"] self.up_axis = pm.upAxis(q=True, axis=True) self.normal = self.getNormalFromPos(self.guide.apos) self.length0 = vector.getDistance( self.guide.apos[0], self.guide.apos[1]) self.length1 = vector.getDistance( self.guide.apos[1], self.guide.apos[2]) self.length2 = vector.getDistance( self.guide.apos[2], self.guide.apos[3]) # 1 bone chain for upv ref self.legChainUpvRef = primitive.add2DChain( self.root, self.getName("legUpvRef%s_jnt"), [self.guide.apos[0], self.guide.apos[2]], self.normal, False, self.WIP) self.legChainUpvRef[1].setAttr( "jointOrientZ", self.legChainUpvRef[1].getAttr("jointOrientZ") * -1) # extra neutral pose t = transform.getTransformFromPos(self.guide.apos[0]) self.root_npo = primitive.addTransform(self.root, self.getName("root_npo"), t) self.root_ctl = self.addCtl(self.root_npo, "root_ctl", t, self.color_fk, "circle", w=self.length0 / 6, tp=self.parentCtlTag) # FK Controlers ----------------------------------- t = transform.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, "xz", self.negate) if self.settings["FK_rest_T_Pose"]: if self.negate: x_dir = 1 else: x_dir = -1 if self.up_axis == "y": x = datatypes.Vector(0, x_dir, 0) else: x = datatypes.Vector(0, 0, x_dir) z = datatypes.Vector(-1, 0, 0) t_npo = transform.getRotationFromAxis(x, z, "xz", False) t_npo = transform.setMatrixPosition(t_npo, self.guide.apos[0]) else: t_npo = t self.fk0_npo = primitive.addTransform(self.root_ctl, self.getName("fk0_npo"), t_npo) po_vec = datatypes.Vector(.5 * self.length0 * self.n_factor, 0, 0) self.fk0_ctl = self.addCtl(self.fk0_npo, "fk0_ctl", t, self.color_fk, "cube", w=self.length0, h=self.size * .1, d=self.size * .1, po=po_vec, tp=self.root_ctl) attribute.setKeyableAttributes( self.fk0_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) t = transform.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2], self.normal, "xz", self.negate) if self.settings["FK_rest_T_Pose"]: t_npo = transform.setMatrixPosition( transform.getTransform(self.fk0_ctl), self.guide.apos[1]) else: t_npo = t self.fk1_npo = primitive.addTransform( self.fk0_ctl, self.getName("fk1_npo"), t_npo) po_vec = datatypes.Vector(.5 * self.length1 * self.n_factor, 0, 0) self.fk1_ctl = self.addCtl(self.fk1_npo, "fk1_ctl", t, self.color_fk, "cube", w=self.length1, h=self.size * .1, d=self.size * .1, po=po_vec, tp=self.fk0_ctl) attribute.setKeyableAttributes( self.fk1_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) t = transform.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3], self.normal, "xz", self.negate) if self.settings["FK_rest_T_Pose"]: t_npo = transform.setMatrixPosition( transform.getTransform(self.fk0_ctl), self.guide.apos[2]) else: t_npo = t self.fk2_npo = primitive.addTransform( self.fk1_ctl, self.getName("fk2_npo"), t_npo) if self.settings["FK_rest_T_Pose"]: self.fk2_npo.rz.set(90) po_vec = datatypes.Vector(.5 * self.length2 * self.n_factor, 0, 0) self.fk2_ctl = self.addCtl(self.fk2_npo, "fk2_ctl", t, self.color_fk, "cube", w=self.length2, h=self.size * .1, d=self.size * .1, po=po_vec, tp=self.fk1_ctl) attribute.setKeyableAttributes(self.fk2_ctl) self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl] for x in self.fk_ctl: attribute.setInvertMirror(x, ["tx", "ty", "tz"]) # IK Controlers ----------------------------------- self.ik_cns = primitive.addTransformFromPos(self.root_ctl, self.getName("ik_cns"), self.guide.pos["ankle"]) self.ikcns_ctl = self.addCtl( self.ik_cns, "ikcns_ctl", transform.getTransformFromPos(self.guide.pos["ankle"]), self.color_ik, "null", w=self.size * .12, tp=self.root_ctl) attribute.setInvertMirror(self.ikcns_ctl, ["tx"]) # m = transform.getTransformLookingAt(self.guide.pos["ankle"], # self.guide.pos["eff"], # self.x_axis, # "zx", # False) # if self.settings["FK_rest_T_Pose"]: # t_ik = transform.getTransformLookingAt(self.guide.pos["ankle"], # self.guide.pos["eff"], # self.normal * -1, # "zx", # False) # else: t_ik = transform.getTransformFromPos(self.guide.pos["ankle"]) self.ik_ctl = self.addCtl( self.ikcns_ctl, "ik_ctl", t_ik, self.color_ik, "cube", w=self.size * .12, h=self.size * .12, d=self.size * .12) attribute.setKeyableAttributes(self.ik_ctl) attribute.setRotOrder(self.ik_ctl, "XZY") attribute.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"]) # upv v = self.guide.apos[2] - self.guide.apos[0] v = self.normal ^ v v.normalize() v *= self.size * .5 v += self.guide.apos[1] self.upv_cns = primitive.addTransformFromPos(self.ik_ctl, self.getName("upv_cns"), v) self.upv_ctl = self.addCtl( self.upv_cns, "upv_ctl", transform.getTransform(self.upv_cns), self.color_ik, "diamond", w=self.size * .12, tp=self.root_ctl) self.add_controller_tag(self.ik_ctl, self.upv_ctl) if self.settings["mirrorMid"]: if self.negate: self.upv_cns.rz.set(180) self.upv_cns.sy.set(-1) else: attribute.setInvertMirror(self.upv_ctl, ["tx"]) attribute.setKeyableAttributes(self.upv_ctl, self.t_params) # References -------------------------------------- self.ik_ref = primitive.addTransform( self.ik_ctl, self.getName("ik_ref"), transform.getTransform(self.ik_ctl)) self.fk_ref = primitive.addTransform( self.fk_ctl[2], self.getName("fk_ref"), transform.getTransform(self.ik_ctl)) # Chain -------------------------------------------- # The outputs of the ikfk2bone solver self.bone0 = primitive.addLocator( self.root_ctl, self.getName("0_bone"), transform.getTransform(self.fk_ctl[0])) self.bone0_shp = self.bone0.getShape() self.bone0_shp.setAttr("localPositionX", self.n_factor * .5) self.bone0_shp.setAttr("localScale", .5, 0, 0) self.bone0.setAttr("sx", self.length0) self.bone0.setAttr("visibility", False) self.bone1 = primitive.addLocator( self.root_ctl, self.getName("1_bone"), transform.getTransform(self.fk_ctl[1])) self.bone1_shp = self.bone1.getShape() self.bone1_shp.setAttr("localPositionX", self.n_factor * .5) self.bone1_shp.setAttr("localScale", .5, 0, 0) self.bone1.setAttr("sx", self.length1) self.bone1.setAttr("visibility", False) self.ctrn_loc = primitive.addTransformFromPos(self.root_ctl, self.getName("ctrn_loc"), self.guide.apos[1]) self.eff_loc = primitive.addTransformFromPos(self.root_ctl, self.getName("eff_loc"), self.guide.apos[2]) # tws_ref t = transform.getRotationFromAxis( datatypes.Vector(0, -1, 0), self.normal, "xz", self.negate) t = transform.setMatrixPosition(t, self.guide.pos["ankle"]) # addind an npo parent transform to fix flip in Maya 2018.2 self.tws_npo = primitive.addTransform( self.eff_loc, self.getName("tws_npo"), t) self.tws_ref = primitive.addTransform( self.tws_npo, self.getName("tws_ref"), t) # Mid Controler ------------------------------------ t = transform.getTransform(self.ctrn_loc) self.mid_cns = primitive.addTransform( self.ctrn_loc, self.getName("mid_cns"), t) self.mid_ctl = self.addCtl(self.mid_cns, "mid_ctl", t, self.color_ik, "sphere", w=self.size * .2, tp=self.root_ctl) attribute.setKeyableAttributes(self.mid_ctl, params=["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) if self.settings["mirrorMid"]: if self.negate: self.mid_cns.rz.set(180) self.mid_cns.sz.set(-1) else: attribute.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"]) # Twist references --------------------------------- x = datatypes.Vector(0, -1, 0) x = x * transform.getTransform(self.eff_loc) z = datatypes.Vector(self.normal.x, self.normal.y, self.normal.z) z = z * transform.getTransform(self.eff_loc) m = transform.getRotationFromAxis(x, z, "xz", self.negate) m = transform.setMatrixPosition( m, transform.getTranslation(self.ik_ctl)) self.rollRef = primitive.add2DChain(self.root, self.getName("rollChain"), self.guide.apos[:2], self.normal, self.negate, self.WIP) t = transform.getTransformLookingAt(self.guide.pos["base"], self.guide.apos[1], self.normal, "xz", self.negate) self.tws0_loc = primitive.addTransform( self.root_ctl, self.getName("tws0_loc"), t) self.tws0_rot = primitive.addTransform( self.tws0_loc, self.getName("tws0_rot"), t) self.tws1_loc = primitive.addTransform( self.ctrn_loc, self.getName("tws1_loc"), transform.getTransform(self.ctrn_loc)) self.tws1_rot = primitive.addTransform( self.tws1_loc, self.getName("tws1_rot"), transform.getTransform(self.ctrn_loc)) self.tws2_loc = primitive.addTransform( self.root_ctl, self.getName("tws2_loc"), transform.getTransform(self.tws_ref)) self.tws2_rot = primitive.addTransform( self.tws2_loc, self.getName("tws2_rot"), transform.getTransform(self.tws_ref)) self.tws2_rot.setAttr("sx", .001) # Divisions ---------------------------------------- self.divisions = self.settings["div0"] + self.settings["div1"] + 2 self.div_cns = [] if self.settings["extraTweak"]: tagP = self.parentCtlTag self.tweak_ctl = [] for i in range(self.divisions): div_cns = primitive.addTransform(self.root_ctl, self.getName("div%s_loc" % i)) self.div_cns.append(div_cns) if self.settings["extraTweak"]: t = transform.getTransform(div_cns) tweak_ctl = self.addCtl(div_cns, "tweak%s_ctl" % i, t, self.color_fk, "square", w=self.size * .15, d=self.size * .15, ro=datatypes.Vector([0, 0, 1.5708]), tp=tagP) attribute.setKeyableAttributes(tweak_ctl) tagP = tweak_ctl self.tweak_ctl.append(tweak_ctl) driver = tweak_ctl else: driver = div_cns # setting the joints if i == 0: self.jnt_pos.append([driver, "thigh"]) current_parent = "root" twist_name = "thigh_twist_" twist_idx = 1 increment = 1 elif i == self.settings["div0"] + 1: self.jnt_pos.append([driver, "calf", current_parent]) twist_name = "calf_twist_" current_parent = "knee" twist_idx = self.settings["div1"] increment = -1 else: self.jnt_pos.append( [driver, twist_name + str(twist_idx).zfill(2), current_parent]) twist_idx += increment # End reference ------------------------------------ # To help the deformation on the ankle self.end_ref = primitive.addTransform(self.tws2_rot, self.getName("end_ref"), m) # set the offset rotation for the hand self.end_jnt_off = primitive.addTransform(self.end_ref, self.getName("end_off"), m) if self.up_axis == "z": self.end_jnt_off.rz.set(-90) self.jnt_pos.append([self.end_jnt_off, 'foot', current_parent]) # match IK FK references self.match_fk0_off = self.add_match_ref(self.fk_ctl[1], self.root, "matchFk0_npo", False) self.match_fk0 = self.add_match_ref(self.fk_ctl[0], self.match_fk0_off, "fk0_mth") self.match_fk1_off = self.add_match_ref(self.fk_ctl[2], self.root, "matchFk1_npo", False) self.match_fk1 = self.add_match_ref(self.fk_ctl[1], self.match_fk1_off, "fk1_mth") self.match_fk2 = self.add_match_ref(self.fk_ctl[2], self.ik_ctl, "fk2_mth") self.match_ik = self.add_match_ref(self.ik_ctl, self.fk2_ctl, "ik_mth") self.match_ikUpv = self.add_match_ref(self.upv_ctl, self.fk0_ctl, "upv_mth") # add visual reference self.line_ref = icon.connection_display_curve( self.getName("visalRef"), [self.upv_ctl, self.mid_ctl])
def addOperators(self): """Create operators and set the relations for the component rig Apply operators, constraints, expressions to the hierarchy. In order to keep the code clean and easier to debug, we shouldn't create any new object in this method. """ # Visibilities ------------------------------------- if self.isFkIk: # fk fkvis_node = node.createReverseNode(self.blend_att) for fk_ctl in self.fk_ctl: for shp in fk_ctl.getShapes(): pm.connectAttr(fkvis_node + ".outputX", shp.attr("visibility")) # ik for shp in self.upv_ctl.getShapes(): pm.connectAttr(self.blend_att, shp.attr("visibility")) for shp in self.ikcns_ctl.getShapes(): pm.connectAttr(self.blend_att, shp.attr("visibility")) for shp in self.ik_ctl.getShapes(): pm.connectAttr(self.blend_att, shp.attr("visibility")) # FK Chain ----------------------------------------- if self.isFk: for off, ref in zip(self.fk_off[1:], self.fk_ref): applyop.gear_mulmatrix_op(ref.worldMatrix, off.parentInverseMatrix, off, "rt") # IK Chain ----------------------------------------- if self.isIk: self.ikh = primitive.addIkHandle(self.root, self.getName("ikh"), self.chain) self.ikh.attr("visibility").set(False) # Constraint and up vector pm.pointConstraint(self.ik_ctl, self.ikh, maintainOffset=False) pm.poleVectorConstraint(self.upv_ctl, self.ikh) # TwistTest o_list = [round(elem, 4) for elem in transform.getTranslation(self.chain[1])] \ != [round(elem, 4) for elem in self.guide.apos[1]] if o_list: add_nodeTwist = node.createAddNode(180.0, self.roll_att) pm.connectAttr(add_nodeTwist + ".output", self.ikh.attr("twist")) else: pm.connectAttr(self.roll_att, self.ikh.attr("twist")) # Chain of deformers ------------------------------- if self.settings["mode"] == 0: # fk only # Loop until the last one and connect aim constraints from index+1 for i, loc in enumerate(self.loc[0:-1]): pm.pointConstraint(self.fk_ctl[i], loc, maintainOffset=False) pm.connectAttr(self.fk_ctl[i] + ".scale", loc + ".scale") pm.aimConstraint( self.fk_ctl[i + 1], loc, maintainOffset=False, aimVector=(1, 0, 0), upVector=(0, 1, 0), worldUpType='none', ) oRoot = rigbits.addNPO(loc)[0] pm.parentConstraint(self.fk_ctl[i], oRoot, mo=True) attribute.lockAttribute(oRoot) # Then connect the last in the chain as a parent constraint pm.parentConstraint(self.fk_ctl[-1], self.loc[-1], maintainOffset=False) pm.connectAttr(self.fk_ctl[-1] + ".scale", self.loc[-1] + ".scale")
def addObjects(self): """Add all the objects needed to create the component.""" self.up_axis = pm.upAxis(q=True, axis=True) self.div_count = len(self.guide.apos) - 5 plane = [self.guide.apos[0], self.guide.apos[-4], self.guide.apos[-3]] self.normal = self.getNormalFromPos(plane) self.binormal = self.getBiNormalFromPos(plane) # Heel --------------------------------------------- # bank pivot t = transform.getTransformLookingAt(self.guide.pos["heel"], self.guide.apos[-4], self.normal, "xz", self.negate) t = transform.setMatrixPosition(t, self.guide.pos["inpivot"]) self.in_npo = primitive.addTransform(self.root, self.getName("in_npo"), t) self.in_piv = primitive.addTransform(self.in_npo, self.getName("in_piv"), t) t = transform.setMatrixPosition(t, self.guide.pos["outpivot"]) self.out_piv = primitive.addTransform(self.in_piv, self.getName("out_piv"), t) # heel t = transform.getTransformLookingAt(self.guide.pos["heel"], self.guide.apos[-4], self.normal, "xz", self.negate) self.heel_loc = primitive.addTransform(self.out_piv, self.getName("heel_loc"), t) attribute.setRotOrder(self.heel_loc, "YZX") self.heel_ctl = self.addCtl(self.heel_loc, "heel_ctl", t, self.color_ik, "sphere", w=self.size * .1, tp=self.parentCtlTag) attribute.setKeyableAttributes(self.heel_ctl, self.r_params) # Tip ---------------------------------------------- if self.up_axis == "y": v = datatypes.Vector(self.guide.apos[-5].x, self.guide.pos["heel"].y, self.guide.apos[-5].z) else: v = datatypes.Vector(self.guide.apos[-5].x, self.guide.apos[-5].y, self.guide.pos["heel"].z) t = transform.setMatrixPosition(t, v) self.tip_ctl = self.addCtl(self.heel_ctl, "tip_ctl", t, self.color_ik, "circle", w=self.size, tp=self.heel_ctl) attribute.setKeyableAttributes(self.tip_ctl, self.r_params) # Roll --------------------------------------------- if self.settings["useRollCtl"]: t = transform.getTransformLookingAt(self.guide.pos["heel"], self.guide.apos[-4], self.normal, "xz", self.negate) t = transform.setMatrixPosition(t, self.guide.pos["root"]) self.roll_np = primitive.addTransform(self.root, self.getName("roll_npo"), t) self.roll_ctl = self.addCtl(self.roll_np, "roll_ctl", t, self.color_ik, "cylinder", w=self.size * .5, h=self.size * .5, ro=datatypes.Vector(3.1415 * .5, 0, 0), tp=self.tip_ctl) attribute.setKeyableAttributes(self.roll_ctl, ["rx", "rz"]) # Backward Controlers ------------------------------ bk_pos = self.guide.apos[1:-3] bk_pos.reverse() parent = self.tip_ctl self.bk_ctl = [] self.bk_loc = [] self.previousTag = self.tip_ctl for i, pos in enumerate(bk_pos): if i == 0: t = transform.getTransform(self.heel_ctl) t = transform.setMatrixPosition(t, pos) else: direction = bk_pos[i - 1] t = transform.getTransformLookingAt(pos, direction, self.normal, "xz", self.negate) bk_loc = primitive.addTransform(parent, self.getName("bk%s_loc" % i), t) bk_ctl = self.addCtl(bk_loc, "bk%s_ctl" % i, t, self.color_ik, "sphere", w=self.size * .15, tp=self.previousTag) attribute.setKeyableAttributes(bk_ctl, self.r_params) self.previousTag = bk_ctl self.bk_loc.append(bk_loc) self.bk_ctl.append(bk_ctl) parent = bk_ctl # FK Reference ------------------------------------ self.fk_ref = primitive.addTransformFromPos(self.bk_ctl[-1], self.getName("fk_ref"), self.guide.apos[0]) self.fk_npo = primitive.addTransform( self.fk_ref, self.getName("fk0_npo"), transform.getTransform(self.bk_ctl[-1])) # Forward Controlers ------------------------------ self.fk_ctl = [] self.fk_loc = [] parent = self.fk_npo self.previousTag = self.tip_ctl for i, bk_ctl in enumerate(reversed(self.bk_ctl[1:])): if i == len(self.bk_ctl) - 2: t = transform.getTransform(self.tip_ctl) v = transform.getTranslation(bk_ctl) t = transform.setMatrixPosition(t, v) else: t = transform.getTransform(bk_ctl) dist = vector.getDistance(self.guide.apos[i + 1], self.guide.apos[i + 2]) fk_loc = primitive.addTransform(parent, self.getName("fk%s_loc" % i), t) po_vec = datatypes.Vector(dist * .5 * self.n_factor, 0, 0) fk_ctl = self.addCtl(fk_loc, "fk%s_ctl" % i, t, self.color_fk, "cube", w=dist, h=self.size * .5, d=self.size * .5, po=po_vec, tp=self.previousTag) self.previousTag = fk_ctl attribute.setKeyableAttributes(fk_ctl) if i: name = "ball" + str(i) else: name = "ball" self.jnt_pos.append([fk_ctl, name]) parent = fk_ctl self.fk_ctl.append(fk_ctl) self.fk_loc.append(fk_loc)
def _addControls(self, crv_ctl, option, sidecut): cvs = crv_ctl.getCVs(space="world") pm.progressWindow(title='controls', progress=0, max=len(cvs)) v0 = transform.getTransformFromPos(cvs[0]) v1 = transform.getTransformFromPos(cvs[-1]) distSize = vector.getDistance(v0, v1) * 3 npos = [] ctls = [] upvs = [] params = ["tx", "ty", "tz", "rx", "ry", "rz"] joints = self.upJoints + self.lowJoints iterator = enumerate(cvs) if sidecut: iterator = enumerate(cvs[1:-1]) for i, cv in iterator: pm.progressWindow(e=True, step=1, status='\nCreating control for%s' % cv) t = transform.getTransformFromPos(cv) # Get nearest joint for orientation of controls nearest_joint = None nearest_distance = None for joint in joints: distance = vector.getDistance(transform.getTranslation(joint), cv) if nearest_distance is None or distance < nearest_distance: nearest_distance = distance nearest_joint = joint if nearest_joint: t = transform.setMatrixPosition( transform.getTransform(nearest_joint), cv) temp = addTransform(self.root, self.getName("temp"), t) # temp.rx.set(0) t = transform.getTransform(temp) pm.delete(temp) # print(i, nearest_joint, temp) oName = option[i][0] oSide = option[i][1] o_icon = option[i][2] color = option[i][3] wd = option[i][4] oPar = option[i][5] if oSide == "R": scl = [1, 1, -1] else: scl = [1, 1, 1] t = transform.setMatrixScale(t, scl) npo = addTransform(self.root, self.getName("%s_npo" % oName, oSide), t) npos.append(npo) ctl = self.addCtl( npo, self.getName("{}_{}".format(oName, self.ctlName), oSide), t, color, o_icon, w=wd * distSize, d=wd * distSize, ro=datatypes.Vector(1.57079633, 0, 0), po=datatypes.Vector(0, 0, .07 * distSize), ) ctls.append(ctl) ymt_util.setKeyableAttributesDontLockVisibility(ctl, params + oPar) upv = addTransform(ctl, self.getName("%s_upv" % oName, oSide), t) upv.attr("tz").set(self.FRONT_OFFSET) upvs.append(upv) self.addToSubGroup(ctl, self.primaryControllersGroupName) pm.progressWindow(e=True, endProgress=True) return npos, ctls, upvs
def addObjects(self): """Add all the objects needed to create the component.""" self.WIP = self.options["mode"] self.normal = self.getNormalFromPos(self.guide.apos) self.length0 = vector.getDistance(self.guide.apos[0], self.guide.apos[1]) self.length1 = vector.getDistance(self.guide.apos[1], self.guide.apos[2]) self.length2 = vector.getDistance(self.guide.apos[2], self.guide.apos[3]) # 1 bone chain for upv ref self.legChainUpvRef = primitive.add2DChain( self.root, self.getName("legUpvRef%s_jnt"), [self.guide.apos[0], self.guide.apos[2]], self.normal, False, self.WIP) self.legChainUpvRef[1].setAttr( "jointOrientZ", self.legChainUpvRef[1].getAttr("jointOrientZ") * -1) # extra neutral pose t = transform.getTransformFromPos(self.guide.apos[0]) self.root_npo = primitive.addTransform(self.root, self.getName("root_npo"), t) self.root_ctl = self.addCtl(self.root_npo, "root_ctl", t, self.color_fk, "circle", w=self.length0 / 6, tp=self.parentCtlTag) # FK Controlers ----------------------------------- t = transform.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, "xz", self.negate) self.fk0_npo = primitive.addTransform(self.root_ctl, self.getName("fk0_npo"), t) self.fk0_ctl = self.addCtl(self.fk0_npo, "fk0_ctl", t, self.color_fk, "cube", w=self.length0, h=self.size * .1, d=self.size * .1, po=datatypes.Vector( .5 * self.length0 * self.n_factor, 0, 0), tp=self.root_ctl) attribute.setKeyableAttributes( self.fk0_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) t = transform.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2], self.normal, "xz", self.negate) self.fk1_npo = primitive.addTransform(self.fk0_ctl, self.getName("fk1_npo"), t) self.fk1_ctl = self.addCtl(self.fk1_npo, "fk1_ctl", t, self.color_fk, "cube", w=self.length1, h=self.size * .1, d=self.size * .1, po=datatypes.Vector( .5 * self.length1 * self.n_factor, 0, 0), tp=self.fk0_ctl) attribute.setKeyableAttributes( self.fk1_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) t = transform.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3], self.normal, "xz", self.negate) self.fk2_npo = primitive.addTransform(self.fk1_ctl, self.getName("fk2_npo"), t) self.fk2_ctl = self.addCtl(self.fk2_npo, "fk2_ctl", t, self.color_fk, "cube", w=self.length2, h=self.size * .1, d=self.size * .1, po=datatypes.Vector( .5 * self.length2 * self.n_factor, 0, 0), tp=self.fk1_ctl) attribute.setKeyableAttributes(self.fk2_ctl) self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl] for x in self.fk_ctl: attribute.setInvertMirror(x, ["tx", "ty", "tz"]) # IK Controlers ----------------------------------- self.ik_cns = primitive.addTransformFromPos(self.root_ctl, self.getName("ik_cns"), self.guide.pos["ankle"]) self.ikcns_ctl = self.addCtl(self.ik_cns, "ikcns_ctl", transform.getTransformFromPos( self.guide.pos["ankle"]), self.color_ik, "null", w=self.size * .12, tp=self.root_ctl) attribute.setInvertMirror(self.ikcns_ctl, ["tx"]) m = transform.getTransformLookingAt(self.guide.pos["ankle"], self.guide.pos["eff"], self.x_axis, "zx", False) self.ik_ctl = self.addCtl(self.ikcns_ctl, "ik_ctl", transform.getTransformFromPos( self.guide.pos["ankle"]), self.color_ik, "cube", w=self.size * .12, h=self.size * .12, d=self.size * .12, tp=self.ikcns_ctl) attribute.setKeyableAttributes(self.ik_ctl) attribute.setRotOrder(self.ik_ctl, "XZY") attribute.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"]) # upv v = self.guide.apos[2] - self.guide.apos[0] v = self.normal ^ v v.normalize() v *= self.size * .5 v += self.guide.apos[1] self.upv_cns = primitive.addTransformFromPos(self.ik_ctl, self.getName("upv_cns"), v) self.upv_ctl = self.addCtl(self.upv_cns, "upv_ctl", transform.getTransform(self.upv_cns), self.color_ik, "diamond", w=self.size * .12, tp=self.root_ctl) if self.settings["mirrorMid"]: if self.negate: self.upv_cns.rz.set(180) self.upv_cns.sy.set(-1) else: attribute.setInvertMirror(self.upv_ctl, ["tx"]) attribute.setKeyableAttributes(self.upv_ctl, self.t_params) # References -------------------------------------- self.ik_ref = primitive.addTransform( self.ik_ctl, self.getName("ik_ref"), transform.getTransform(self.ik_ctl)) self.fk_ref = primitive.addTransform( self.fk_ctl[2], self.getName("fk_ref"), transform.getTransform(self.ik_ctl)) # Chain -------------------------------------------- # The outputs of the ikfk2bone solver self.bone0 = primitive.addLocator( self.root_ctl, self.getName("0_bone"), transform.getTransform(self.fk_ctl[0])) self.bone0_shp = self.bone0.getShape() self.bone0_shp.setAttr("localPositionX", self.n_factor * .5) self.bone0_shp.setAttr("localScale", .5, 0, 0) self.bone0.setAttr("sx", self.length0) self.bone0.setAttr("visibility", False) self.bone1 = primitive.addLocator( self.root_ctl, self.getName("1_bone"), transform.getTransform(self.fk_ctl[1])) self.bone1_shp = self.bone1.getShape() self.bone1_shp.setAttr("localPositionX", self.n_factor * .5) self.bone1_shp.setAttr("localScale", .5, 0, 0) self.bone1.setAttr("sx", self.length1) self.bone1.setAttr("visibility", False) tA = transform.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, "xz", self.negate) tA = transform.setMatrixPosition(tA, self.guide.apos[1]) tB = transform.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2], self.normal, "xz", self.negate) t = transform.getInterpolateTransformMatrix(tA, tB) self.ctrn_loc = primitive.addTransform(self.root, self.getName("ctrn_loc"), t) self.eff_loc = primitive.addTransformFromPos(self.root_ctl, self.getName("eff_loc"), self.guide.apos[2]) # tws_ref t = transform.getRotationFromAxis(datatypes.Vector(0, -1, 0), self.normal, "xz", self.negate) t = transform.setMatrixPosition(t, self.guide.pos["ankle"]) self.tws_ref = primitive.addTransform(self.eff_loc, self.getName("tws_ref"), t) # Mid Controler ------------------------------------ t = transform.getTransform(self.ctrn_loc) self.mid_cns = primitive.addTransform(self.ctrn_loc, self.getName("mid_cns"), t) self.mid_ctl = self.addCtl(self.mid_cns, "mid_ctl", t, self.color_ik, "sphere", w=self.size * .2, tp=self.root_ctl) if self.settings["mirrorMid"]: if self.negate: self.mid_cns.rz.set(180) self.mid_cns.sz.set(-1) else: attribute.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"]) attribute.setKeyableAttributes(self.mid_ctl, self.t_params) # Twist references --------------------------------- x = datatypes.Vector(0, -1, 0) x = x * transform.getTransform(self.eff_loc) z = datatypes.Vector(self.normal.x, self.normal.y, self.normal.z) z = z * transform.getTransform(self.eff_loc) m = transform.getRotationFromAxis(x, z, "xz", self.negate) m = transform.setMatrixPosition(m, transform.getTranslation(self.ik_ctl)) self.tws0_loc = primitive.addTransform( self.root_ctl, self.getName("tws0_loc"), transform.getTransform(self.fk_ctl[0])) self.tws0_rot = primitive.addTransform( self.tws0_loc, self.getName("tws0_rot"), transform.getTransform(self.fk_ctl[0])) self.tws1_loc = primitive.addTransform( self.ctrn_loc, self.getName("tws1_loc"), transform.getTransform(self.ctrn_loc)) self.tws1_rot = primitive.addTransform( self.tws1_loc, self.getName("tws1_rot"), transform.getTransform(self.ctrn_loc)) self.tws1A_npo = primitive.addTransform(self.mid_ctl, self.getName("tws1A_npo"), tA) self.tws1A_loc = primitive.addTransform(self.tws1A_npo, self.getName("tws1A_loc"), tA) self.tws1B_npo = primitive.addTransform(self.mid_ctl, self.getName("tws1B_npo"), tB) self.tws1B_loc = primitive.addTransform(self.tws1B_npo, self.getName("tws1B_loc"), tB) self.tws2_npo = primitive.addTransform( self.root, self.getName("tws2_npo"), transform.getTransform(self.fk_ctl[2])) self.tws2_loc = primitive.addTransform( self.tws2_npo, self.getName("tws2_loc"), transform.getTransform(self.fk_ctl[2])) self.tws2_rot = primitive.addTransform( self.tws2_npo, self.getName("tws2_rot"), transform.getTransform(self.fk_ctl[2])) # Roll twist chain --------------------------------- # Arm self.uplegChainPos = [] ii = 1.0 / (self.settings["div0"] + 1) i = 0.0 for p in range(self.settings["div0"] + 2): self.uplegChainPos.append( vector.linearlyInterpolate(self.guide.pos["root"], self.guide.pos["knee"], blend=i)) i = i + ii self.uplegTwistChain = primitive.add2DChain( self.root, self.getName("uplegTwist%s_jnt"), self.uplegChainPos, self.normal, False, self.WIP) # Forearm self.lowlegChainPos = [] ii = 1.0 / (self.settings["div1"] + 1) i = 0.0 for p in range(self.settings["div1"] + 2): self.lowlegChainPos.append( vector.linearlyInterpolate(self.guide.pos["knee"], self.guide.pos["ankle"], blend=i)) i = i + ii self.lowlegTwistChain = primitive.add2DChain( self.root, self.getName("lowlegTwist%s_jnt"), self.lowlegChainPos, self.normal, False, self.WIP) pm.parent(self.lowlegTwistChain[0], self.mid_ctl) # Hand Aux chain and nonroll self.auxChainPos = [] ii = .5 i = 0.0 for p in range(3): self.auxChainPos.append( vector.linearlyInterpolate(self.guide.pos["ankle"], self.guide.pos["eff"], blend=i)) i = i + ii t = self.root.getMatrix(worldSpace=True) self.aux_npo = primitive.addTransform(self.root, self.getName("aux_npo"), t) self.auxTwistChain = primitive.add2DChain( self.aux_npo, self.getName("auxTwist%s_jnt"), self.lowlegChainPos[:3], self.normal, False, self.WIP) # Non Roll join ref --------------------------------- self.uplegRollRef = primitive.add2DChain( self.root, self.getName("uplegRollRef%s_jnt"), self.uplegChainPos[:2], self.normal, False, self.WIP) self.lowlegRollRef = primitive.add2DChain( self.aux_npo, self.getName("lowlegRollRef%s_jnt"), self.lowlegChainPos[:2], self.normal, False, self.WIP) # Divisions ---------------------------------------- # We have at least one division at the start, the end and one for the # elbow. + 2 for knee angle control self.divisions = self.settings["div0"] + self.settings["div1"] + 4 self.div_cns = [] for i in range(self.divisions): div_cns = primitive.addTransform(self.root_ctl, self.getName("div%s_loc" % i)) self.div_cns.append(div_cns) self.jnt_pos.append([div_cns, i]) # End reference ------------------------------------ # To help the deformation on the ankle self.end_ref = primitive.addTransform(self.eff_loc, self.getName("end_ref"), m) for a in "xyz": self.end_ref.attr("s%s" % a).set(1.0) if self.negate: self.end_ref.attr("ry").set(-180.0) self.jnt_pos.append([self.end_ref, 'end']) # Tangent controls t = transform.getInterpolateTransformMatrix(self.fk_ctl[0], self.tws1A_npo, .5) self.uplegTangentA_loc = primitive.addTransform( self.root_ctl, self.getName("uplegTangentA_loc"), self.fk_ctl[0].getMatrix(worldSpace=True)) self.uplegTangentA_npo = primitive.addTransform( self.uplegTangentA_loc, self.getName("uplegTangentA_npo"), t) self.uplegTangentA_ctl = self.addCtl(self.uplegTangentA_npo, "uplegTangentA_ctl", t, self.color_ik, "circle", w=self.size * .2, ro=datatypes.Vector( 0, 0, 1.570796), tp=self.mid_ctl) if self.negate: self.uplegTangentA_npo.rz.set(180) self.uplegTangentA_npo.sz.set(-1) attribute.setKeyableAttributes(self.uplegTangentA_ctl, self.t_params) t = transform.getInterpolateTransformMatrix(self.fk_ctl[0], self.tws1A_npo, .9) self.uplegTangentB_npo = primitive.addTransform( self.tws1A_loc, self.getName("uplegTangentB_npo"), t) self.uplegTangentB_ctl = self.addCtl(self.uplegTangentB_npo, "uplegTangentB_ctl", t, self.color_ik, "circle", w=self.size * .1, ro=datatypes.Vector( 0, 0, 1.570796), tp=self.mid_ctl) if self.negate: self.uplegTangentB_npo.rz.set(180) self.uplegTangentB_npo.sz.set(-1) attribute.setKeyableAttributes(self.uplegTangentB_ctl, self.t_params) tC = self.tws1B_npo.getMatrix(worldSpace=True) tC = transform.setMatrixPosition(tC, self.guide.apos[2]) t = transform.getInterpolateTransformMatrix(self.tws1B_npo, tC, .1) self.lowlegTangentA_npo = primitive.addTransform( self.tws1B_loc, self.getName("lowlegTangentA_npo"), t) self.lowlegTangentA_ctl = self.addCtl(self.lowlegTangentA_npo, "lowlegTangentA_ctl", t, self.color_ik, "circle", w=self.size * .1, ro=datatypes.Vector( 0, 0, 1.570796), tp=self.mid_ctl) if self.negate: self.lowlegTangentA_npo.rz.set(180) self.lowlegTangentA_npo.sz.set(-1) attribute.setKeyableAttributes(self.lowlegTangentA_ctl, self.t_params) t = transform.getInterpolateTransformMatrix(self.tws1B_npo, tC, .5) self.lowlegTangentB_loc = primitive.addTransform( self.root, self.getName("lowlegTangentB_loc"), tC) self.lowlegTangentB_npo = primitive.addTransform( self.lowlegTangentB_loc, self.getName("lowlegTangentB_npo"), t) self.lowlegTangentB_ctl = self.addCtl(self.lowlegTangentB_npo, "lowlegTangentB_ctl", t, self.color_ik, "circle", w=self.size * .2, ro=datatypes.Vector( 0, 0, 1.570796), tp=self.mid_ctl) if self.negate: self.lowlegTangentB_npo.rz.set(180) self.lowlegTangentB_npo.sz.set(-1) attribute.setKeyableAttributes(self.lowlegTangentB_ctl, self.t_params) t = self.mid_ctl.getMatrix(worldSpace=True) self.kneeTangent_npo = primitive.addTransform( self.mid_ctl, self.getName("kneeTangent_npo"), t) self.kneeTangent_ctl = self.addCtl(self.kneeTangent_npo, "kneeTangent_ctl", t, self.color_fk, "circle", w=self.size * .25, ro=datatypes.Vector(0, 0, 1.570796), tp=self.mid_ctl) if self.negate: self.kneeTangent_npo.rz.set(180) self.kneeTangent_npo.sz.set(-1) attribute.setKeyableAttributes(self.kneeTangent_ctl, self.t_params) # match IK FK references self.match_fk0_off = self.add_match_ref(self.fk_ctl[1], self.root, "matchFk0_npo", False) self.match_fk0 = self.add_match_ref(self.fk_ctl[0], self.match_fk0_off, "fk0_mth") self.match_fk1_off = self.add_match_ref(self.fk_ctl[2], self.root, "matchFk1_npo", False) self.match_fk1 = self.add_match_ref(self.fk_ctl[1], self.match_fk1_off, "fk1_mth") self.match_fk2 = self.add_match_ref(self.fk_ctl[2], self.ik_ctl, "fk2_mth") self.match_ik = self.add_match_ref(self.ik_ctl, self.fk2_ctl, "ik_mth") self.match_ikUpv = self.add_match_ref(self.upv_ctl, self.fk0_ctl, "upv_mth") # add visual reference self.line_ref = icon.connection_display_curve( self.getName("visalRef"), [self.upv_ctl, self.mid_ctl])
def addOperators(self): """Create operators and set the relations for the component rig Apply operators, constraints, expressions to the hierarchy. In order to keep the code clean and easier to debug, we shouldn't create any new object in this method. """ # Visibilities ------------------------------------- if self.isFkIk: # fk fkvis_node = node.createReverseNode(self.blend_att) for fk_ctl in self.fk_ctl: for shp in fk_ctl.getShapes(): pm.connectAttr(fkvis_node + ".outputX", shp.attr("visibility")) # ik for shp in self.upv_ctl.getShapes(): pm.connectAttr(self.blend_att, shp.attr("visibility")) for shp in self.ikcns_ctl.getShapes(): pm.connectAttr(self.blend_att, shp.attr("visibility")) for shp in self.ik_ctl.getShapes(): pm.connectAttr(self.blend_att, shp.attr("visibility")) # FK Chain ----------------------------------------- if self.isFk: for off, ref in zip(self.fk_off[1:], self.fk_ref): applyop.gear_mulmatrix_op( ref.worldMatrix, off.parentInverseMatrix, off, "rt") # IK Chain ----------------------------------------- if self.isIk: self.ikh = primitive.addIkHandle( self.root, self.getName("ikh"), self.chain) self.ikh.attr("visibility").set(False) # Constraint and up vector pm.pointConstraint(self.ik_ctl, self.ikh, maintainOffset=False) pm.poleVectorConstraint(self.upv_ctl, self.ikh) # TwistTest o_list = [round(elem, 4) for elem in transform.getTranslation(self.chain[1])] \ != [round(elem, 4) for elem in self.guide.apos[1]] if o_list: add_nodeTwist = node.createAddNode(180.0, self.roll_att) pm.connectAttr(add_nodeTwist + ".output", self.ikh.attr("twist")) else: pm.connectAttr(self.roll_att, self.ikh.attr("twist")) # Chain of deformers ------------------------------- for i, loc in enumerate(self.loc): if self.settings["mode"] == 0: # fk only pm.parentConstraint(self.fk_ctl[i], loc, maintainOffset=False) pm.connectAttr(self.fk_ctl[i] + ".scale", loc + ".scale") elif self.settings["mode"] == 1: # ik only pm.parentConstraint(self.chain[i], loc, maintainOffset=False) elif self.settings["mode"] == 2: # fk/ik rev_node = node.createReverseNode(self.blend_att) # orientation cns = pm.parentConstraint( self.fk_ctl[i], self.chain[i], loc, maintainOffset=False) cns.interpType.set(0) weight_att = pm.parentConstraint( cns, query=True, weightAliasList=True) pm.connectAttr(rev_node + ".outputX", weight_att[0]) pm.connectAttr(self.blend_att, weight_att[1]) # scaling blend_node = pm.createNode("blendColors") pm.connectAttr(self.chain[i].attr("scale"), blend_node + ".color1") pm.connectAttr(self.fk_ctl[i].attr("scale"), blend_node + ".color2") pm.connectAttr(self.blend_att, blend_node + ".blender") pm.connectAttr(blend_node + ".output", loc + ".scale")
def addOperators(self): """Create operators and set the relations for the component rig Apply operators, constraints, expressions to the hierarchy. In order to keep the code clean and easier to debug, we shouldn't create any new object in this method. """ # Soft condition soft_cond_node = node.createConditionNode( self.soft_attr, 0.0001, 4, 0.0001, self.soft_attr) self.soft_attr_cond = soft_cond_node.outColorR if self.settings["ikSolver"]: self.ikSolver = "ikRPsolver" else: pm.mel.eval("ikSpringSolver;") self.ikSolver = "ikSpringSolver" # 1 bone chain Upv ref =============================== self.ikHandleUpvRef = primitive.addIkHandle( self.root, self.getName("ikHandleLegChainUpvRef"), self.legChainUpvRef, "ikSCsolver") pm.pointConstraint(self.ik_ctl, self.ikHandleUpvRef) pm.parentConstraint(self.legChainUpvRef[0], self.upv_cns, mo=True) # mid joints ================================================ for xjnt, midJ in zip(self.legBones[1:3], [self.mid1_jnt, self.mid2_jnt]): node.createPairBlend(None, xjnt, .5, 1, midJ) pm.connectAttr(xjnt + ".translate", midJ + ".translate", f=True) pm.parentConstraint(self.mid1_jnt, self.knee_lvl) pm.parentConstraint(self.mid2_jnt, self.ankle_lvl) # joint length multiply multJnt1_node = node.createMulNode(self.boneALenght_attr, self.boneALenghtMult_attr) multJnt2_node = node.createMulNode(self.boneBLenght_attr, self.boneBLenghtMult_attr) multJnt3_node = node.createMulNode(self.boneCLenght_attr, self.boneCLenghtMult_attr) # # IK 3 bones =============================================== self.ikHandle = primitive.addIkHandle(self.softblendLoc, self.getName("ik3BonesHandle"), self.chain3bones, self.ikSolver, self.upv_ctl) # TwistTest if [round(elem, 4) for elem in transform.getTranslation(self.chain3bones[1])] \ != [round(elem, 4) for elem in self.guide.apos[1]]: add_nodeTwist = node.createAddNode(180.0, self.roll_att) else: add_nodeTwist = node.createAddNode(0, self.roll_att) if self.negate: mulVal = 1 else: mulVal = -1 node.createMulNode( add_nodeTwist + ".output", mulVal, self.ikHandle.attr("twist")) # stable spring solver doble rotation pm.pointConstraint(self.root_ctl, self.chain3bones[0]) # softIK 3 bones operators applyop.aimCns(self.aim_tra, self.ik_ref, axis="zx", wupType=4, wupVector=[1, 0, 0], wupObject=self.root_ctl, maintainOffset=False) plusTotalLength_node = node.createPlusMinusAverage1D( [multJnt1_node.attr("outputX"), multJnt2_node.attr("outputX"), multJnt3_node.attr("outputX")]) subtract1_node = node.createPlusMinusAverage1D( [plusTotalLength_node.attr("output1D"), self.soft_attr_cond], 2) distance1_node = node.createDistNode(self.ik_ref, self.aim_tra) div1_node = node.createDivNode(1.0, self.rig.global_ctl + ".sx") mult1_node = node.createMulNode(distance1_node + ".distance", div1_node + ".outputX") subtract2_node = node.createPlusMinusAverage1D( [mult1_node.attr("outputX"), subtract1_node.attr("output1D")], 2) div2_node = node.createDivNode(subtract2_node + ".output1D", self.soft_attr_cond) mult2_node = node.createMulNode(-1, div2_node + ".outputX") power_node = node.createPowNode(self.softSpeed_attr, mult2_node + ".outputX") mult3_node = node.createMulNode(self.soft_attr_cond, power_node + ".outputX") subtract3_node = node.createPlusMinusAverage1D( [plusTotalLength_node.attr("output1D"), mult3_node.attr("outputX")], 2) cond1_node = node.createConditionNode( self.soft_attr_cond, 0, 2, subtract3_node + ".output1D", plusTotalLength_node + ".output1D") cond2_node = node.createConditionNode(mult1_node + ".outputX", subtract1_node + ".output1D", 2, cond1_node + ".outColorR", mult1_node + ".outputX") pm.connectAttr(cond2_node + ".outColorR", self.wristSoftIK + ".tz") # soft blend pc_node = pm.pointConstraint(self.wristSoftIK, self.ik_ref, self.softblendLoc) node.createReverseNode(self.stretch_attr, pc_node + ".target[0].targetWeight") pm.connectAttr(self.stretch_attr, pc_node + ".target[1].targetWeight", f=True) # Stretch distance2_node = node.createDistNode(self.softblendLoc, self.wristSoftIK) mult4_node = node.createMulNode(distance2_node + ".distance", div1_node + ".outputX") # bones for i, mulNode in enumerate([multJnt1_node, multJnt2_node, multJnt3_node]): div3_node = node.createDivNode(mulNode + ".outputX", plusTotalLength_node + ".output1D") mult5_node = node.createMulNode(mult4_node + ".outputX", div3_node + ".outputX") mult6_node = node.createMulNode(self.stretch_attr, mult5_node + ".outputX") node.createPlusMinusAverage1D( [mulNode.attr("outputX"), mult6_node.attr("outputX")], 1, self.chain3bones[i + 1] + ".tx") # IK 2 bones =============================================== self.ikHandle2 = primitive.addIkHandle(self.softblendLoc2, self.getName("ik2BonesHandle"), self.chain2bones, self.ikSolver, self.upv_ctl) node.createMulNode(self.roll_att, mulVal, self.ikHandle2.attr("twist")) # stable spring solver doble rotation pm.pointConstraint(self.root_ctl, self.chain2bones[0]) parentc_node = pm.parentConstraint( self.ik2b_ikCtl_ref, self.ik2b_bone_ref, self.ik2b_blend) node.createReverseNode(self.fullIK_attr, parentc_node + ".target[0].targetWeight") pm.connectAttr(self.fullIK_attr, parentc_node + ".target[1].targetWeight", f=True) # softIK 2 bones operators applyop.aimCns(self.aim_tra2, self.ik2b_ik_ref, axis="zx", wupType=4, wupVector=[1, 0, 0], wupObject=self.root_ctl, maintainOffset=False) plusTotalLength_node = node.createPlusMinusAverage1D( [multJnt1_node.attr("outputX"), multJnt2_node.attr("outputX")]) subtract1_node = node.createPlusMinusAverage1D( [plusTotalLength_node.attr("output1D"), self.soft_attr_cond], 2) distance1_node = node.createDistNode(self.ik2b_ik_ref, self.aim_tra2) div1_node = node.createDivNode(1, self.rig.global_ctl + ".sx") mult1_node = node.createMulNode(distance1_node + ".distance", div1_node + ".outputX") subtract2_node = node.createPlusMinusAverage1D( [mult1_node.attr("outputX"), subtract1_node.attr("output1D")], 2) div2_node = node.createDivNode(subtract2_node + ".output1D", self.soft_attr_cond) mult2_node = node.createMulNode(-1, div2_node + ".outputX") power_node = node.createPowNode(self.softSpeed_attr, mult2_node + ".outputX") mult3_node = node.createMulNode(self.soft_attr_cond, power_node + ".outputX") subtract3_node = node.createPlusMinusAverage1D( [plusTotalLength_node.attr("output1D"), mult3_node.attr("outputX")], 2) cond1_node = node.createConditionNode( self.soft_attr_cond, 0, 2, subtract3_node + ".output1D", plusTotalLength_node + ".output1D") cond2_node = node.createConditionNode(mult1_node + ".outputX", subtract1_node + ".output1D", 2, cond1_node + ".outColorR", mult1_node + ".outputX") pm.connectAttr(cond2_node + ".outColorR", self.ankleSoftIK + ".tz") # soft blend pc_node = pm.pointConstraint(self.ankleSoftIK, self.ik2b_ik_ref, self.softblendLoc2) node.createReverseNode(self.stretch_attr, pc_node + ".target[0].targetWeight") pm.connectAttr(self.stretch_attr, pc_node + ".target[1].targetWeight", f=True) # Stretch distance2_node = node.createDistNode(self.softblendLoc2, self.ankleSoftIK) mult4_node = node.createMulNode(distance2_node + ".distance", div1_node + ".outputX") for i, mulNode in enumerate([multJnt1_node, multJnt2_node]): div3_node = node.createDivNode(mulNode + ".outputX", plusTotalLength_node + ".output1D") mult5_node = node.createMulNode(mult4_node + ".outputX", div3_node + ".outputX") mult6_node = node.createMulNode(self.stretch_attr, mult5_node + ".outputX") node.createPlusMinusAverage1D([mulNode.attr("outputX"), mult6_node.attr("outputX")], 1, self.chain2bones[i + 1] + ".tx") # IK/FK connections for i, x in enumerate(self.fk_ctl): pm.parentConstraint(x, self.legBonesFK[i], mo=True) for i, x in enumerate([self.chain2bones[0], self.chain2bones[1]]): pm.parentConstraint(x, self.legBonesIK[i], mo=True) pm.pointConstraint(self.ik2b_ik_ref, self.legBonesIK[2]) applyop.aimCns(self.legBonesIK[2], self.roll_ctl, axis="xy", wupType=4, wupVector=[0, 1, 0], wupObject=self.legBonesIK[1], maintainOffset=False) pm.connectAttr(self.chain3bones[-1].attr("tx"), self.legBonesIK[-1].attr("tx")) # foot twist roll pm.orientConstraint(self.ik_ref, self.legBonesIK[-1], mo=True) node.createMulNode( -1, self.chain3bones[-1].attr("tx"), self.ik2b_ik_ref.attr("tx")) for i, x in enumerate(self.legBones): node.createPairBlend( self.legBonesFK[i], self.legBonesIK[i], self.blend_att, 1, x) # Twist references ---------------------------------------- self.ikhArmRef, self.tmpCrv = applyop.splineIK( self.getName("legRollRef"), self.rollRef, parent=self.root, cParent=self.legBones[0]) initRound = .001 multVal = 1 multTangent_node = node.createMulNode(self.roundnessKnee_att, multVal) add_node = node.createAddNode(multTangent_node + ".outputX", initRound) pm.connectAttr(add_node + ".output", self.tws1_rot.attr("sx")) for x in ["translate"]: pm.connectAttr(self.knee_ctl.attr(x), self.tws1_loc.attr(x)) for x in "xy": pm.connectAttr(self.knee_ctl.attr("r" + x), self.tws1_loc.attr("r" + x)) multTangent_node = node.createMulNode(self.roundnessAnkle_att, multVal) add_node = node.createAddNode(multTangent_node + ".outputX", initRound) pm.connectAttr(add_node + ".output", self.tws2_rot.attr("sx")) for x in ["translate"]: pm.connectAttr(self.ankle_ctl.attr(x), self.tws2_loc.attr(x)) for x in "xy": pm.connectAttr(self.ankle_ctl.attr("r" + x), self.tws2_loc.attr("r" + x)) # Volume ------------------------------------------- distA_node = node.createDistNode(self.tws0_loc, self.tws1_loc) distB_node = node.createDistNode(self.tws1_loc, self.tws2_loc) distC_node = node.createDistNode(self.tws2_loc, self.tws3_loc) add_node = node.createAddNode(distA_node + ".distance", distB_node + ".distance") add_node2 = node.createAddNode(distC_node + ".distance", add_node + ".output") div_node = node.createDivNode(add_node2 + ".output", self.root_ctl.attr("sx")) # comp scaling dm_node = node.createDecomposeMatrixNode(self.root.attr("worldMatrix")) div_node2 = node.createDivNode(div_node + ".outputX", dm_node + ".outputScaleX") self.volDriver_att = div_node2 + ".outputX" # Flip Offset ---------------------------------------- pm.connectAttr(self.ankleFlipOffset_att, self.tws2_loc.attr("rz")) pm.connectAttr(self.kneeFlipOffset_att, self.tws1_loc.attr("rz")) # Divisions ---------------------------------------- # at 0 or 1 the division will follow exactly the rotation of the # controler.. and we wont have this nice tangent + roll for i, div_cns in enumerate(self.div_cns): subdiv = False if i == len(self.div_cns) - 1 or i == 0: subdiv = 45 else: subdiv = 45 if i < (self.settings["div0"] + 1): perc = i * .333 / (self.settings["div0"] + 1.0) elif i < (self.settings["div0"] + self.settings["div1"] + 2): perc = i * .333 / (self.settings["div0"] + 1.0) else: perc = (.5 + (i - self.settings["div0"] - 3.0) * .5 / (self.settings["div1"] + 1.0)) if i < (self.settings["div0"] + 2): perc = i * .333 / (self.settings["div0"] + 1.0) elif i < (self.settings["div0"] + self.settings["div1"] + 3): perc = (.333 + (i - self.settings["div0"] - 1) * .333 / (self.settings["div1"] + 1.0)) else: perc = (.666 + (i - self.settings["div1"] - self.settings["div0"] - 2.0) * .333 / (self.settings["div2"] + 1.0)) # we neet to offset the ankle and knee point to force the bone # orientation to the nex bone span if perc == .333: perc = .3338 elif perc == .666: perc = .6669 perc = max(.001, min(.999, perc)) # Roll cts = [self.tws0_rot, self.tws1_rot, self.tws2_rot, self.tws3_rot] o_node = applyop.gear_rollsplinekine_op(div_cns, cts, perc, subdiv) pm.connectAttr(self.resample_att, o_node + ".resample") pm.connectAttr(self.absolute_att, o_node + ".absolute") # Squash n Stretch o_node = applyop.gear_squashstretch2_op( div_cns, None, pm.getAttr(self.volDriver_att), "x") pm.connectAttr(self.volume_att, o_node + ".blend") pm.connectAttr(self.volDriver_att, o_node + ".driver") pm.connectAttr(self.st_att[i], o_node + ".stretch") pm.connectAttr(self.sq_att[i], o_node + ".squash") # Visibilities ------------------------------------- # fk fkvis_node = node.createReverseNode(self.blend_att) for ctrl in self.fk_ctl: for shp in ctrl.getShapes(): pm.connectAttr(fkvis_node + ".outputX", shp.attr("visibility")) # ik for ctrl in [self.ik_ctl, self.roll_ctl, self.upv_ctl, self.line_ref]: for shp in ctrl.getShapes(): pm.connectAttr(self.blend_att, shp.attr("visibility")) # setup leg o_node scale compensate pm.connectAttr(self.rig.global_ctl + ".scale", self.setup + ".scale") # match IK/FK ref pm.parentConstraint(self.legBones[0], self.match_fk0_off, mo=True) pm.parentConstraint(self.legBones[1], self.match_fk1_off, mo=True) pm.parentConstraint(self.legBones[2], self.match_fk2_off, mo=True) return
def add2DChain(parent, name, positions, normal, negate=False, vis=True): """Create a 2D joint chain. Like Softimage 2D chain. Warning: This function will create un expected results if all the positions are not in the same 2D plane. Arguments: parent (dagNode): The parent for the chain. name (str): The node name. positions(list of vectors): the positons to define the chain. normal (vector): The normal vector to define the direction of the chain. negate (bool): If True will negate the direction of the chain Returns; list of dagNodes: The list containg all the joints of the chain >>> self.rollRef = pri.add2DChain( self.root, self.getName("rollChain"), self.guide.apos[:2], self.normal, self.negate) """ if "%s" not in name: name += "%s" transforms = transform.getChainTransform(positions, normal, negate) t = transform.setMatrixPosition(transforms[-1], positions[-1]) transforms.append(t) chain = [] for i, t in enumerate(transforms): node = addJoint(parent, name % i, t, vis) chain.append(node) parent = node # moving rotation value to joint orient for i, jnt in enumerate(chain): if i == 0: jnt.setAttr("jointOrient", jnt.getAttr("rotate")) jnt.setAttr("rotate", 0, 0, 0) elif i == len(chain) - 1: jnt.setAttr("jointOrient", 0, 0, 0) jnt.setAttr("rotate", 0, 0, 0) else: # This will fail if chain is not always oriented the same # way (like X chain) v0 = positions[i] - positions[i - 1] v1 = positions[i + 1] - positions[i] angle = datatypes.degrees(v0.angle(v1)) jnt.setAttr("rotate", 0, 0, 0) jnt.setAttr("jointOrient", 0, 0, angle) # check if we have to negate Z angle by comparing the guide # position and the resulting position. if i >= 1: # round the position values to 6 decimals precission # TODO: test with less precision and new check after apply # Ik solver if ([round(elem, 4) for elem in transform.getTranslation(jnt)] != [round(elem, 4) for elem in positions[i]]): jp = jnt.getParent() # Aviod intermediate e.g. `transform3` groups that can appear # between joints due to basic moving around. while jp.type() == "transform": jp = jp.getParent() jp.setAttr("jointOrient", 0, 0, jp.attr("jointOrient").get()[2] * -1) jnt.setAttr("radius", 1.5) return chain