def initialHierarchy(self): # Root --------------------------------------------- # For this component we need the root to be correctly oriented t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.guide.blades["blade"].z, "yx", self.negate) self.root = pri.addTransform(self.model, self.getName("root"), t) # Shd ---------------------------------------------- if self.options["shadow_rig"]: self.shd_org = pri.addTransform(self.rig.shd_org, self.getName("shd_org"))
def addObjects(self): self.normal = self.guide.blades["blade"].z self.binormal = self.guide.blades["blade"].x self.isFk = self.settings["mode"] != 1 self.isIk = self.settings["mode"] != 0 self.isFkIk = self.settings["mode"] == 2 # FK controlers ------------------------------------ if self.isFk: self.fk_npo = [] self.fk_ctl = [] parent = self.root for i, t in enumerate(tra.getChainTransform(self.guide.apos, self.normal, self.negate)): dist = vec.getDistance(self.guide.apos[i], self.guide.apos[i+1]) fk_npo = pri.addTransform(parent, self.getName("fk%s_npo"%i), t) fk_ctl = self.addCtl(fk_npo, "fk%s_ctl"%i, t, self.color_fk, "cube", w=dist, h=self.size*.1, d=self.size*.1, po=dt.Vector(dist*.5*self.n_factor,0,0)) parent = fk_ctl self.fk_npo.append(fk_npo) self.fk_ctl.append(fk_ctl) # IK controlers ------------------------------------ if self.isIk: normal = vec.getTransposedVector(self.normal, [self.guide.apos[0], self.guide.apos[1]], [self.guide.apos[-2], self.guide.apos[-1]]) t = tra.getTransformLookingAt(self.guide.apos[-2], self.guide.apos[-1], normal, "xy", self.negate) t = tra.setMatrixPosition(t, self.guide.apos[-1]) self.ik_cns = pri.addTransform(self.root, self.getName("ik_cns"), t) self.ikcns_ctl = self.addCtl(self.ik_cns, "ikcns_ctl", t, self.color_ik, "null", w=self.size) self.ik_ctl = self.addCtl(self.ikcns_ctl, "ik_ctl", t, self.color_ik, "cube", w=self.size*.3, h=self.size*.3, d=self.size*.3) v = self.guide.apos[-1] - self.guide.apos[0] v = v ^ self.normal v.normalize() v *= self.size v += self.guide.apos[1] self.upv_cns = pri.addTransformFromPos(self.root, self.getName("upv_cns"), v) self.upv_ctl = self.addCtl(self.upv_cns, "upv_ctl", tra.getTransform(self.upv_cns), self.color_ik, "diamond", w=self.size*.1) # Chain self.chain = pri.add2DChain(self.root, self.getName("chain"), self.guide.apos, self.normal, self.negate) self.ikh = pri.addIkHandle(self.root, self.getName("ikh"), self.chain) # Chain of deformers ------------------------------- self.loc = [] parent = self.root for i, t in enumerate(tra.getChainTransform(self.guide.apos, self.normal, self.negate)): loc = pri.addTransform(parent, self.getName("%s_loc"%i), t) self.addShadow(loc, i) self.loc.append(loc) parent = loc
def initialHierarchy(self): # Root self.root = pri.addTransformFromPos(self.model, self.getName("root"), self.guide.pos["root"]) # Shd -------------------------------- if self.options["shadow_rig"]: self.shd_org = pri.addTransform(self.rig.shd_org, self.getName("shd_org")) return
def addCtl(self, parent, name, m, color, icon, **kwargs): if name in self.guide.controlers.keys(): ctl_ref = self.guide.controlers[name] ctl = pri.addTransform(parent, name, m) for shape in ctl_ref.getShapes(): ctl.addChild(shape, shape=True, add=True) else: ctl = ico.create(parent, name, m, color, icon, **kwargs) self.addToGroup(ctl, "controlers") return ctl
def addObjects(self): """ """ self.WIP = self.options["mode"] self.normal = self.getNormalFromPos(self.guide.apos) self.binormal = self.getBiNormalFromPos(self.guide.apos) self.length0 = vec.getDistance(self.guide.apos[0], self.guide.apos[1]) self.length1 = vec.getDistance(self.guide.apos[1], self.guide.apos[2]) self.length2 = vec.getDistance(self.guide.apos[2], self.guide.apos[3]) # 1 bone chain for upv ref self.armChainUpvRef = pri.add2DChain( self.root, self.getName("armUpvRef%s_jnt"), [self.guide.apos[0], self.guide.apos[2]], self.normal, False, self.WIP) self.armChainUpvRef[1].setAttr( "jointOrientZ", self.armChainUpvRef[1].getAttr("jointOrientZ") * -1) # FK Controlers ----------------------------------- t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, "xz", self.negate) self.fk0_npo = pri.addTransform(self.root, 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=dt.Vector( .5 * self.length0 * self.n_factor, 0, 0)) att.setKeyableAttributes(self.fk0_ctl) t = tra.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2], self.normal, "xz", self.negate) self.fk1_npo = pri.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=dt.Vector( .5 * self.length1 * self.n_factor, 0, 0)) att.setKeyableAttributes(self.fk1_ctl) t = tra.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3], self.normal, "xz", self.negate) self.fk2_npo = pri.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=dt.Vector( .5 * self.length2 * self.n_factor, 0, 0)) att.setKeyableAttributes(self.fk2_ctl) self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl] for x in self.fk_ctl: att.setInvertMirror(x, ["tx", "ty", "tz"]) # IK Controlers ----------------------------------- self.ik_cns = pri.addTransformFromPos(self.root, self.getName("ik_cns"), self.guide.pos["wrist"]) self.ikcns_ctl = self.addCtl(self.ik_cns, "ikcns_ctl", tra.getTransformFromPos( self.guide.pos["wrist"]), self.color_ik, "null", w=self.size * .12) att.setInvertMirror(self.ikcns_ctl, ["tx", "ty", "tz"]) if self.negate: m = tra.getTransformLookingAt(self.guide.pos["wrist"], self.guide.pos["eff"], self.normal, "x-y", True) else: m = tra.getTransformLookingAt(self.guide.pos["wrist"], self.guide.pos["eff"], self.normal, "xy", False) self.ik_ctl = self.addCtl(self.ikcns_ctl, "ik_ctl", m, self.color_ik, "cube", w=self.size * .12, h=self.size * .12, d=self.size * .12) att.setKeyableAttributes(self.ik_ctl) att.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 = pri.addTransformFromPos(self.root, self.getName("upv_cns"), v) self.upv_ctl = self.addCtl(self.upv_cns, "upv_ctl", tra.getTransform(self.upv_cns), self.color_ik, "diamond", w=self.size * .12) att.setKeyableAttributes(self.upv_ctl, self.t_params) att.setInvertMirror(self.upv_ctl, ["tx"]) #IK rotation controls if self.settings["ikTR"]: self.ikRot_npo = pri.addTransform(self.root, self.getName("ikRot_npo"), m) self.ikRot_cns = pri.addTransform(self.ikRot_npo, self.getName("ikRot_cns"), m) self.ikRot_ctl = self.addCtl(self.ikRot_cns, "ikRot_ctl", m, self.color_ik, "sphere", w=self.size * .12) att.setKeyableAttributes(self.ikRot_ctl, ["rx", "ry", "rz"]) # References -------------------------------------- # Calculate again the transfor for the IK ref. This way align with FK trnIK_ref = tra.getTransformLookingAt(self.guide.pos["wrist"], self.guide.pos["eff"], self.normal, "xz", self.negate) self.ik_ref = pri.addTransform(self.ik_ctl, self.getName("ik_ref"), trnIK_ref) self.fk_ref = pri.addTransform(self.fk_ctl[2], self.getName("fk_ref"), trnIK_ref) # Chain -------------------------------------------- # The outputs of the ikfk2bone solver self.bone0 = pri.addLocator(self.root, self.getName("0_bone"), tra.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 = pri.addLocator(self.root, self.getName("1_bone"), tra.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 = pri.addTransformFromPos(self.root, self.getName("ctrn_loc"), self.guide.apos[1]) self.eff_loc = pri.addTransformFromPos(self.root, self.getName("eff_loc"), self.guide.apos[2]) # Mid Controler ------------------------------------ self.mid_ctl = self.addCtl(self.ctrn_loc, "mid_ctl", tra.getTransform(self.ctrn_loc), self.color_ik, "sphere", w=self.size * .2) att.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"]) #Roll join ref self.rollRef = pri.add2DChain(self.root, self.getName("rollChain"), self.guide.apos[:2], self.normal, self.negate) for x in self.rollRef: x.setAttr("visibility", False) self.tws0_loc = pri.addTransform(self.rollRef[0], self.getName("tws0_loc"), tra.getTransform(self.fk_ctl[0])) self.tws0_rot = pri.addTransform(self.tws0_loc, self.getName("tws0_rot"), tra.getTransform(self.fk_ctl[0])) self.tws1_npo = pri.addTransform(self.ctrn_loc, self.getName("tws1_npo"), tra.getTransform(self.ctrn_loc)) self.tws1_loc = pri.addTransform(self.tws1_npo, self.getName("tws1_loc"), tra.getTransform(self.ctrn_loc)) self.tws1_rot = pri.addTransform(self.tws1_loc, self.getName("tws1_rot"), tra.getTransform(self.ctrn_loc)) self.tws2_npo = pri.addTransform(self.root, self.getName("tws2_npo"), tra.getTransform(self.fk_ctl[2])) self.tws2_loc = pri.addTransform(self.tws2_npo, self.getName("tws2_loc"), tra.getTransform(self.fk_ctl[2])) self.tws2_rot = pri.addTransform(self.tws2_loc, self.getName("tws2_rot"), tra.getTransform(self.fk_ctl[2])) # Divisions ---------------------------------------- # We have at least one division at the start, the end and one for the elbow. + 2 for elbow angle control self.divisions = self.settings["div0"] + self.settings["div1"] + 3 + 2 self.div_cns = [] for i in range(self.divisions): div_cns = pri.addTransform(self.root, 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 wrist self.jnt_pos.append([self.eff_loc, 'end']) #match IK FK references self.match_fk0_off = pri.addTransform(self.root, self.getName("matchFk0_npo"), tra.getTransform(self.fk_ctl[1])) # self.match_fk0_off.attr("tx").set(1.0) self.match_fk0 = pri.addTransform(self.match_fk0_off, self.getName("fk0_mth"), tra.getTransform(self.fk_ctl[0])) self.match_fk1_off = pri.addTransform(self.root, self.getName("matchFk1_npo"), tra.getTransform(self.fk_ctl[2])) # self.match_fk1_off.attr("tx").set(1.0) self.match_fk1 = pri.addTransform(self.match_fk1_off, self.getName("fk1_mth"), tra.getTransform(self.fk_ctl[1])) self.match_fk2 = pri.addTransform(self.ik_ctl, self.getName("fk2_mth"), tra.getTransform(self.fk_ctl[2])) self.match_ik = pri.addTransform(self.fk2_ctl, self.getName("ik_mth"), tra.getTransform(self.ik_ctl)) self.match_ikUpv = pri.addTransform(self.fk0_ctl, self.getName("upv_mth"), tra.getTransform(self.upv_ctl))
def addObjects(self): #jaw control t = tra.getTransformFromPos(self.guide.pos["jaw"]) self.ctl_npo = pri.addTransform(self.root, self.getName("ctl_npo"), t) self.jaw_ctl = self.addCtl(self.ctl_npo, "jaw_ctl", t, self.color_fk, "circle", w=1) #mouth center t = tra.getTransformFromPos(self.guide.pos["rotcenter"]) self.mouthCenter_npo = pri.addTransform( self.root, self.getName("mouthCenter_npo"), t) self.mouthCenter = pri.addTransform(self.mouthCenter_npo, self.getName("mouthCenter"), t) #jaw "UPPER" t = tra.getTransformFromPos(self.guide.pos["root"]) self.jawUp_npo = pri.addTransform(self.mouthCenter, self.getName("jawUpper_npo"), t) self.jawUp_pos = pri.addTransform(self.jawUp_npo, self.getName("jawUpper_pos"), t) self.jawUp_rot = pri.addTransform(self.jawUp_pos, self.getName("jawUpper_rot"), t) #jaw "LOWER" t = tra.getTransformFromPos(self.guide.pos["root"]) self.jawLow_npo = pri.addTransform(self.mouthCenter, self.getName("jaw_npo"), t) self.jawLow_pos = pri.addTransform(self.jawLow_npo, self.getName("jawLow_pos"), t) self.jawLow_rot = pri.addTransform(self.jawLow_pos, self.getName("jawLow_rot"), t) #lips t = tra.getTransformFromPos(self.guide.pos["lipup"]) self.lipup_npo = pri.addTransform(self.jawUp_rot, self.getName("lipup_npo"), t) self.lipup_ctl = self.addCtl(self.lipup_npo, "lipup_ctl", t, self.color_fk, "square", w=1) t = tra.getTransformFromPos(self.guide.pos["liplow"]) self.liplow_npo = pri.addTransform(self.jawLow_rot, self.getName("liplow_npo"), t) self.liplow_ctl = self.addCtl(self.liplow_npo, "liplow_ctl", t, self.color_fk, "square", w=1) #teeth t = tra.getTransformFromPos(self.guide.pos["lipup"]) self.teethup_npo = pri.addTransform(self.jawUp_rot, self.getName("teethup_npo"), t) self.teethup_ctl = self.addCtl(self.teethup_npo, "teethup_ctl", t, self.color_fk, "square", w=.7) t = tra.getTransformFromPos(self.guide.pos["liplow"]) self.teethlow_npo = pri.addTransform(self.jawLow_rot, self.getName("teethlow_npo"), t) self.teethlow_ctl = self.addCtl(self.teethlow_npo, "teethlow_ctl", t, self.color_fk, "square", w=.7) self.jnt_pos.append([self.jawLow_rot, "jaw", "parent_relative_jnt"]) self.jnt_pos.append([self.lipup_ctl, "lipup", "parent_relative_jnt"]) self.jnt_pos.append([self.liplow_ctl, "liplow", "jaw"]) # relative 0 is the jaw jnt self.jnt_pos.append( [self.teethup_ctl, "teethup", "parent_relative_jnt"]) self.jnt_pos.append([self.teethlow_ctl, "teethlow", "jaw"])
def addObjects(self): self.WIP = self.options["mode"] self.normal = self.getNormalFromPos(self.guide.apos) self.length0 = vec.getDistance(self.guide.apos[0], self.guide.apos[1]) self.length1 = vec.getDistance(self.guide.apos[1], self.guide.apos[2]) self.length2 = vec.getDistance(self.guide.apos[2], self.guide.apos[3]) # 1 bone chain for upv ref self.legChainUpvRef= pri.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 = tra.getTransformFromPos(self.guide.apos[0]) self.root_npo = pri.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 = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, "xz", self.negate) self.fk0_npo = pri.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=dt.Vector(.5*self.length0*self.n_factor,0,0), tp=self.root_ctl) att.setKeyableAttributes(self.fk0_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) t = tra.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2], self.normal, "xz", self.negate) self.fk1_npo = pri.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=dt.Vector(.5*self.length1*self.n_factor,0,0), tp=self.fk0_ctl) att.setKeyableAttributes(self.fk1_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) t = tra.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3], self.normal, "xz", self.negate) self.fk2_npo = pri.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=dt.Vector(.5*self.length2*self.n_factor,0,0), tp=self.fk1_ctl) att.setKeyableAttributes(self.fk2_ctl) self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl] for x in self.fk_ctl: att.setInvertMirror(x, ["tx", "ty", "tz"]) # IK Controlers ----------------------------------- self.ik_cns = pri.addTransformFromPos(self.root_ctl, self.getName("ik_cns"), self.guide.pos["ankle"]) self.ikcns_ctl = self.addCtl(self.ik_cns, "ikcns_ctl", tra.getTransformFromPos(self.guide.pos["ankle"]), self.color_ik, "null", w=self.size*.12, tp=self.root_ctl) att.setInvertMirror(self.ikcns_ctl, ["tx"]) m = tra.getTransformLookingAt(self.guide.pos["ankle"], self.guide.pos["eff"], self.x_axis, "zx", False) self.ik_ctl = self.addCtl(self.ikcns_ctl, "ik_ctl", tra.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) att.setKeyableAttributes(self.ik_ctl) att.setRotOrder(self.ik_ctl, "XZY") att.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 = pri.addTransformFromPos(self.ik_ctl, self.getName("upv_cns"), v) self.upv_ctl = self.addCtl(self.upv_cns, "upv_ctl", tra.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: att.setInvertMirror(self.upv_ctl, ["tx"]) att.setKeyableAttributes(self.upv_ctl, self.t_params) # References -------------------------------------- self.ik_ref = pri.addTransform(self.ik_ctl, self.getName("ik_ref"), tra.getTransform(self.ik_ctl)) self.fk_ref = pri.addTransform(self.fk_ctl[2], self.getName("fk_ref"), tra.getTransform(self.ik_ctl)) # Chain -------------------------------------------- # The outputs of the ikfk2bone solver self.bone0 = pri.addLocator(self.root_ctl, self.getName("0_bone"), tra.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 = pri.addLocator(self.root_ctl, self.getName("1_bone"), tra.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 = pri.addTransformFromPos(self.root_ctl, self.getName("ctrn_loc"), self.guide.apos[1]) self.eff_loc = pri.addTransformFromPos(self.root_ctl, self.getName("eff_loc"), self.guide.apos[2]) # tws_ref t = tra.getRotationFromAxis(dt.Vector(0,-1,0), self.normal, "xz", self.negate) t = tra.setMatrixPosition(t, self.guide.pos["ankle"]) self.tws_ref = pri.addTransform(self.eff_loc, self.getName("tws_ref"), t) # Mid Controler ------------------------------------ t = tra.getTransform(self.ctrn_loc) self.mid_cns = pri.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: att.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"]) # Twist references --------------------------------- x = dt.Vector(0,-1,0) x = x * tra.getTransform(self.eff_loc) z = dt.Vector(self.normal.x,self.normal.y,self.normal.z) z = z * tra.getTransform(self.eff_loc) m = tra.getRotationFromAxis(x, z, "xz", self.negate) m = tra.setMatrixPosition(m, tra.getTranslation(self.ik_ctl)) self.rollRef = pri.add2DChain(self.root, self.getName("rollChain"), self.guide.apos[:2], self.normal, self.negate, self.WIP) self.tws0_loc = pri.addTransform(self.rollRef[0], self.getName("tws0_loc"), tra.getTransform(self.fk_ctl[0])) self.tws0_rot = pri.addTransform(self.tws0_loc, self.getName("tws0_rot"), tra.getTransform(self.fk_ctl[0])) self.tws1_loc = pri.addTransform(self.ctrn_loc, self.getName("tws1_loc"), tra.getTransform(self.ctrn_loc)) self.tws1_rot = pri.addTransform(self.tws1_loc, self.getName("tws1_rot"), tra.getTransform(self.ctrn_loc)) self.tws2_loc = pri.addTransform(self.root_ctl, self.getName("tws2_loc"), tra.getTransform(self.tws_ref)) self.tws2_rot = pri.addTransform(self.tws2_loc, self.getName("tws2_rot"), tra.getTransform(self.tws_ref)) self.tws2_rot.setAttr("sx", .001) # 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"] + 3 + 2 self.div_cns = [] for i in range(self.divisions): div_cns = pri.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 = pri.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 = pri.addTransform(self.root, self.getName("matchFk0_npo"), tra.getTransform(self.fk_ctl[1])) self.match_fk0 = pri.addTransform(self.match_fk0_off, self.getName("fk0_mth"), tra.getTransform(self.fk_ctl[0])) self.match_fk1_off = pri.addTransform(self.root, self.getName("matchFk1_npo"), tra.getTransform(self.fk_ctl[2])) self.match_fk1 = pri.addTransform(self.match_fk1_off, self.getName("fk1_mth"), tra.getTransform(self.fk_ctl[1])) self.match_fk2 = pri.addTransform(self.ik_ctl, self.getName("fk2_mth"), tra.getTransform(self.fk_ctl[2])) self.match_ik = pri.addTransform(self.fk2_ctl, self.getName("ik_mth"), tra.getTransform(self.ik_ctl)) self.match_ikUpv = pri.addTransform(self.fk0_ctl, self.getName("upv_mth"), tra.getTransform(self.upv_ctl))
def addObjects(self): self.normal = self.getNormalFromPos(self.guide.apos) self.length0 = vec.getDistance(self.guide.apos[0], self.guide.apos[1]) self.length1 = vec.getDistance(self.guide.apos[1], self.guide.apos[2]) self.length2 = vec.getDistance(self.guide.apos[2], self.guide.apos[3]) # FK Controlers ----------------------------------- t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, "xz", self.negate) ### FK NEUTRAL POSE IS DIFFERENT self.fk0_npo = pri.addTransform(self.root, 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=dt.Vector( .5 * self.length0 * self.n_factor, 0, 0)) t = tra.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2], self.normal, "xz", self.negate) self.fk1_ctl = self.addCtl(self.fk0_ctl, "fk1_ctl", t, self.color_fk, "cube", w=self.length1, h=self.size * .1, d=self.size * .1, po=dt.Vector( .5 * self.length1 * self.n_factor, 0, 0)) t = tra.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3], self.normal, "xz", self.negate) self.fk2_ctl = self.addCtl(self.fk1_ctl, "fk2_ctl", t, self.color_fk, "cube", w=self.length2, h=self.size * .1, d=self.size * .1, po=dt.Vector( .5 * self.length2 * self.n_factor, 0, 0)) self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl] # IK Controlers ----------------------------------- self.ik_cns = pri.addTransformFromPos(self.root, self.getName("ik_cns"), self.guide.pos["wrist"]) self.ikcns_ctl = self.addCtl(self.ik_cns, "ikcns_ctl", tra.getTransformFromPos( self.guide.pos["wrist"]), self.color_ik, "null", w=self.size * .12) ### IK CONTROLER POSE IS DIFFERENT m = tra.getTransformLookingAt(self.guide.pos["wrist"], self.guide.pos["eff"], self.normal, "xz", False) self.ik_ctl = self.addCtl(self.ikcns_ctl, "ik_ctl", m, self.color_ik, "cube", w=self.size * .12, h=self.size * .12, d=self.size * .12) # 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 = pri.addTransformFromPos(self.root, self.getName("upv_cns"), v) self.upv_ctl = self.addCtl(self.upv_cns, "upv_ctl", tra.getTransform(self.upv_cns), self.color_ik, "diamond", w=self.size * .12) att.setKeyableAttributes(self.upv_ctl, self.t_params) # References -------------------------------------- self.ik_ref = pri.addTransform(self.ik_ctl, self.getName("ik_ref"), tra.getTransform(self.ik_ctl)) self.fk_ref = pri.addTransform(self.fk_ctl[2], self.getName("fk_ref"), tra.getTransform(self.ik_ctl)) # Chain -------------------------------------------- # The outputs of the ikfk2bone solver self.bone0 = pri.addLocator(self.root, self.getName("0_jnt"), tra.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 = pri.addLocator(self.root, self.getName("1_jnt"), tra.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 = pri.addTransformFromPos(self.root, self.getName("ctrn_loc"), self.guide.apos[1]) self.eff_loc = pri.addTransformFromPos(self.root, self.getName("eff_loc"), self.guide.apos[2]) # Mid Controler ------------------------------------ self.mid_ctl = self.addCtl(self.ctrn_loc, "mid_ctl", tra.getTransform(self.ctrn_loc), self.color_ik, "sphere", w=self.size * .2) # Twist references --------------------------------- x = dt.Vector(0, -1, 0) x = x * tra.getTransform(self.eff_loc) z = dt.Vector(self.normal.x, self.normal.y, self.normal.z) z = z * tra.getTransform(self.eff_loc) m = tra.getRotationFromAxis(x, z, "xz", self.negate) m = tra.setMatrixPosition(m, tra.getTranslation(self.ik_ctl)) self.tws0_loc = pri.addTransform(self.root, self.getName("tws0_loc"), tra.getTransform(self.fk_ctl[0])) self.tws0_rot = pri.addTransform(self.tws0_loc, self.getName("tws0_rot"), tra.getTransform(self.fk_ctl[0])) self.tws1_loc = pri.addTransform(self.ctrn_loc, self.getName("tws1_loc"), tra.getTransform(self.ctrn_loc)) self.tws1_rot = pri.addTransform(self.tws1_loc, self.getName("tws1_rot"), tra.getTransform(self.ctrn_loc)) self.tws2_loc = pri.addTransform(self.root, self.getName("tws2_loc"), tra.getTransform(self.fk_ctl[2])) self.tws2_rot = pri.addTransform(self.tws2_loc, self.getName("tws2_rot"), tra.getTransform(self.fk_ctl[2])) self.tws2_rot.setAttr("sx", .001) # Divisions ---------------------------------------- # We have at least one division at the start, the end and one for the elbow. self.divisions = self.settings["div0"] + self.settings["div1"] + 3 self.div_cns = [] for i in range(self.divisions): div_cns = pri.addTransform(self.root, self.getName("div%s_loc" % i)) self.div_cns.append(div_cns) self.addShadow(div_cns, i) # End reference ------------------------------------ # To help the deformation on the wrist self.end_ref = pri.addTransform(self.tws2_rot, self.getName("end_ref"), m) self.addShadow(self.end_ref, "end")
def addObjects(self): """Add all the objects needed to create the component.""" self.normal = self.guide.blades["blade"].z * -1 self.binormal = self.guide.blades["blade"].x self.isFk = self.settings["mode"] != 1 self.isIk = self.settings["mode"] != 0 self.isFkIk = self.settings["mode"] == 2 self.WIP = self.options["mode"] # FK controllers ------------------------------------ if self.isFk: self.fk_npo = [] self.fk_ctl = [] self.fk_ref = [] self.fk_off = [] t = self.guide.tra["root"] self.ik_cns = primitive.addTransform(self.root, self.getName("ik_cns"), t) parent = self.ik_cns tOld = False fk_ctl = None self.previusTag = self.parentCtlTag for i, t in enumerate( transform.getChainTransform(self.guide.apos, self.normal, self.negate)): dist = vector.getDistance(self.guide.apos[i], self.guide.apos[i + 1]) if self.settings["neutralpose"] or not tOld: tnpo = t else: tnpo = transform.setMatrixPosition( tOld, transform.getPositionFromMatrix(t)) if i: tref = transform.setMatrixPosition( tOld, transform.getPositionFromMatrix(t)) fk_ref = primitive.addTransform( fk_ctl, self.getName("fk%s_ref" % i), tref) self.fk_ref.append(fk_ref) else: tref = t fk_off = primitive.addTransform(parent, self.getName("fk%s_off" % i), tref) fk_npo = primitive.addTransform(fk_off, self.getName("fk%s_npo" % i), tnpo) fk_ctl = self.addCtl(fk_npo, "fk%s_ctl" % i, t, self.color_fk, "cube", w=dist, h=self.size * .1, d=self.size * .1, po=datatypes.Vector( dist * .5 * self.n_factor, 0, 0), tp=self.previusTag) self.fk_off.append(fk_off) self.fk_npo.append(fk_npo) self.fk_ctl.append(fk_ctl) tOld = t self.previusTag = fk_ctl # IK controllers ------------------------------------ if self.isIk: normal = vector.getTransposedVector( self.normal, [self.guide.apos[0], self.guide.apos[1]], [self.guide.apos[-2], self.guide.apos[-1]]) t = transform.getTransformLookingAt(self.guide.apos[-2], self.guide.apos[-1], normal, "xy", self.negate) t = transform.setMatrixPosition(t, self.guide.apos[-1]) self.ik_cns = primitive.addTransform(self.root, self.getName("ik_cns"), t) self.ikcns_ctl = self.addCtl(self.ik_cns, "ikcns_ctl", t, self.color_ik, "null", w=self.size, tp=self.parentCtlTag) self.ik_ctl = self.addCtl(self.ikcns_ctl, "ik_ctl", t, self.color_ik, "cube", w=self.size * .3, h=self.size * .3, d=self.size * .3, tp=self.ikcns_ctl) attribute.setKeyableAttributes(self.ik_ctl, self.t_params) v = self.guide.apos[-1] - self.guide.apos[0] v = v ^ self.normal v.normalize() v *= self.size v += self.guide.apos[1] self.upv_cns = primitive.addTransformFromPos( self.root, 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 * .1, tp=self.parentCtlTag) attribute.setKeyableAttributes(self.upv_ctl, self.t_params) # Chain self.chain = primitive.add2DChain(self.root, self.getName("chain"), self.guide.apos, self.normal, self.negate) self.chain[0].attr("visibility").set(self.WIP) # Chain of deformers ------------------------------- self.loc = [] parent = self.root for i, t in enumerate( transform.getChainTransform(self.guide.apos, self.normal, self.negate)): loc = primitive.addTransform(parent, self.getName("%s_loc" % i), t) self.loc.append(loc) self.jnt_pos.append([loc, i, None, False])
def addObjects(self): # blades computation self.normal = self.guide.blades["blade"].z self.binormal = self.guide.blades["blade"].x self.fk_npo = [] self.fk_ctl = [] self.spring_cns = [] self.spring_aim = [] self.spring_lvl = [] self.spring_ref = [] self.spring_npo = [] self.spring_target = [] parent = self.root for i, t in enumerate( tra.getChainTransform(self.guide.apos, self.normal, self.negate)): dist = vec.getDistance(self.guide.apos[i], self.guide.apos[i + 1]) fk_npo = pri.addTransform(parent, self.getName("fk%s_npo" % i), t) spring_aim = pri.addTransform(fk_npo, self.getName("spring%s_aim" % i), t) spring_cns = pri.addTransform(fk_npo, self.getName("spring%s_cns" % i), t) fk_ctl = self.addCtl(spring_cns, "fk%s_ctl" % i, t, self.color_fk, "cube", w=dist, h=self.size * .1, d=self.size * .1, po=dt.Vector(dist * .5 * self.n_factor, 0, 0)) t = tra.getTransformFromPos(self.guide.apos[i + 1]) spring_npo = pri.addTransform(parent, self.getName("spring%s_npo" % i), t) spring_target = pri.addTransform(spring_npo, self.getName("spring%s" % i), t) parent = fk_ctl self.spring_cns.append(spring_cns) self.spring_aim.append(spring_aim) self.addToGroup(spring_cns, "PLOT") self.fk_npo.append(fk_npo) self.fk_ctl.append(fk_ctl) self.spring_target.append(spring_target) # Chain of deformers ------------------------------- self.loc = [] parent = self.root for i, t in enumerate( tra.getChainTransform(self.guide.apos, self.normal, self.negate)): loc = pri.addTransform(parent, self.getName("%s_loc" % i), t) self.loc.append(loc) self.jnt_pos.append([loc, i]) parent = loc
def addObjects(self): # Ik Controlers ------------------------------------ t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.guide.blades["blade"].z, "yx", self.negate) self.ik0_npo = pri.addTransform(self.root, self.getName("ik0_npo"), t) self.ik0_ctl = self.addCtl(self.ik0_npo, "ik0_ctl", t, self.color_ik, "compas", w=self.size) att.setKeyableAttributes(self.ik0_ctl) att.setRotOrder(self.ik0_ctl, "XZY") t = tra.setMatrixPosition(t, self.guide.apos[1]) self.ik1_npo = pri.addTransform(self.root, self.getName("ik1_npo"), t) self.ik1_ctl = self.addCtl(self.ik1_npo, "ik1_ctl", t, self.color_ik, "compas", w=self.size) att.setKeyableAttributes(self.ik1_ctl) att.setRotOrder(self.ik1_ctl, "XZY") # Tangent controlers ------------------------------- t = tra.setMatrixPosition( t, vec.linearlyInterpolate(self.guide.apos[0], self.guide.apos[1], .33)) self.tan0_npo = pri.addTransform(self.ik0_ctl, self.getName("tan0_npo"), t) self.tan0_ctl = self.addCtl(self.tan0_npo, "tan0_ctl", t, self.color_ik, "sphere", w=self.size * .2) att.setKeyableAttributes(self.tan0_ctl, self.t_params) t = tra.setMatrixPosition( t, vec.linearlyInterpolate(self.guide.apos[0], self.guide.apos[1], .66)) self.tan1_npo = pri.addTransform(self.ik1_ctl, self.getName("tan1_npo"), t) self.tan1_ctl = self.addCtl(self.tan1_npo, "tan1_ctl", t, self.color_ik, "sphere", w=self.size * .2) att.setKeyableAttributes(self.tan1_ctl, self.t_params) # Curves ------------------------------------------- self.mst_crv = cur.addCnsCurve( self.root, self.getName("mst_crv"), [self.ik0_ctl, self.tan0_ctl, self.tan1_ctl, self.ik1_ctl], 3) self.slv_crv = cur.addCurve(self.root, self.getName("slv_crv"), [dt.Vector()] * 10, False, 3) self.mst_crv.setAttr("visibility", False) self.slv_crv.setAttr("visibility", False) # Division ----------------------------------------- # The user only define how many intermediate division he wants. # First and last divisions are an obligation. parentdiv = self.root parentctl = self.root self.div_cns = [] self.fk_ctl = [] self.fk_npo = [] self.scl_npo = [] for i in range(self.settings["division"]): # References div_cns = pri.addTransform(parentdiv, self.getName("%s_cns" % i)) setAttr(div_cns + ".inheritsTransform", False) self.div_cns.append(div_cns) parentdiv = div_cns scl_npo = pri.addTransform(parentctl, self.getName("%s_scl_npo" % i), tra.getTransform(parentctl)) # Controlers (First and last one are fake) if i in [0, self.settings["division"] - 1]: fk_ctl = pri.addTransform(scl_npo, self.getName("%s_loc" % i), tra.getTransform(parentctl)) fk_npo = fk_ctl else: fk_npo = pri.addTransform(scl_npo, self.getName("fk%s_npo" % (i - 1)), tra.getTransform(parentctl)) fk_ctl = self.addCtl(fk_npo, "fk%s_ctl" % (i - 1), tra.getTransform(parentctl), self.color_fk, "cube", w=self.size, h=self.size * .05, d=self.size) att.setKeyableAttributes(self.fk_ctl) att.setRotOrder(fk_ctl, "XZY") # setAttr(fk_npo+".inheritsTransform", False) self.scl_npo.append(scl_npo) self.fk_npo.append(fk_npo) self.fk_ctl.append(fk_ctl) parentctl = fk_ctl # Deformers (Shadow) self.addShadow(fk_ctl, i) # Connections (Hooks) ------------------------------ self.cnx0 = pri.addTransform(self.root, self.getName("0_cnx")) self.cnx1 = pri.addTransform(self.root, self.getName("1_cnx"))
def addObjects(self): self.normal = self.getNormalFromPos(self.guide.apos) self.length0 = vec.getDistance(self.guide.apos[0], self.guide.apos[1]) self.length1 = vec.getDistance(self.guide.apos[1], self.guide.apos[2]) self.length2 = vec.getDistance(self.guide.apos[2], self.guide.apos[3]) # FK Controlers ----------------------------------- t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, "xz", self.negate) ### FK NEUTRAL POSE IS DIFFERENT self.fk0_npo = pri.addTransform(self.root, 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=dt.Vector(.5*self.length0*self.n_factor,0,0)) t = tra.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2], self.normal, "xz", self.negate) self.fk1_ctl = self.addCtl(self.fk0_ctl, "fk1_ctl", t, self.color_fk, "cube", w=self.length1, h=self.size*.1, d=self.size*.1, po=dt.Vector(.5*self.length1*self.n_factor,0,0)) t = tra.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3], self.normal, "xz", self.negate) self.fk2_ctl = self.addCtl(self.fk1_ctl, "fk2_ctl", t, self.color_fk, "cube", w=self.length2, h=self.size*.1, d=self.size*.1, po=dt.Vector(.5*self.length2*self.n_factor,0,0)) self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl] # IK Controlers ----------------------------------- self.ik_cns = pri.addTransformFromPos(self.root, self.getName("ik_cns"), self.guide.pos["wrist"]) self.ikcns_ctl = self.addCtl(self.ik_cns, "ikcns_ctl", tra.getTransformFromPos(self.guide.pos["wrist"]), self.color_ik, "null", w=self.size*.12) ### IK CONTROLER POSE IS DIFFERENT m = tra.getTransformLookingAt(self.guide.pos["wrist"], self.guide.pos["eff"], self.normal, "xz", False) self.ik_ctl = self.addCtl(self.ikcns_ctl, "ik_ctl", m, self.color_ik, "cube", w=self.size*.12, h=self.size*.12, d=self.size*.12) # 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 = pri.addTransformFromPos(self.root, self.getName("upv_cns"), v) self.upv_ctl = self.addCtl(self.upv_cns, "upv_ctl", tra.getTransform(self.upv_cns), self.color_ik, "diamond", w=self.size*.12) att.setKeyableAttributes(self.upv_ctl, self.t_params) # References -------------------------------------- self.ik_ref = pri.addTransform(self.ik_ctl, self.getName("ik_ref"), tra.getTransform(self.ik_ctl)) self.fk_ref = pri.addTransform(self.fk_ctl[2], self.getName("fk_ref"), tra.getTransform(self.ik_ctl)) # Chain -------------------------------------------- # The outputs of the ikfk2bone solver self.bone0 = pri.addLocator(self.root, self.getName("0_jnt"), tra.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 = pri.addLocator(self.root, self.getName("1_jnt"), tra.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 = pri.addTransformFromPos(self.root, self.getName("ctrn_loc"), self.guide.apos[1]) self.eff_loc = pri.addTransformFromPos(self.root, self.getName("eff_loc"), self.guide.apos[2]) # Mid Controler ------------------------------------ self.mid_ctl = self.addCtl(self.ctrn_loc, "mid_ctl", tra.getTransform(self.ctrn_loc), self.color_ik, "sphere", w=self.size*.2) # Twist references --------------------------------- x = dt.Vector(0,-1,0) x = x * tra.getTransform(self.eff_loc) z = dt.Vector(self.normal.x,self.normal.y,self.normal.z) z = z * tra.getTransform(self.eff_loc) m = tra.getRotationFromAxis(x, z, "xz", self.negate) m = tra.setMatrixPosition(m, tra.getTranslation(self.ik_ctl)) self.tws0_loc = pri.addTransform(self.root, self.getName("tws0_loc"), tra.getTransform(self.fk_ctl[0])) self.tws0_rot = pri.addTransform(self.tws0_loc, self.getName("tws0_rot"), tra.getTransform(self.fk_ctl[0])) self.tws1_loc = pri.addTransform(self.ctrn_loc, self.getName("tws1_loc"), tra.getTransform(self.ctrn_loc)) self.tws1_rot = pri.addTransform(self.tws1_loc, self.getName("tws1_rot"), tra.getTransform(self.ctrn_loc)) self.tws2_loc = pri.addTransform(self.root, self.getName("tws2_loc"), tra.getTransform(self.fk_ctl[2])) self.tws2_rot = pri.addTransform(self.tws2_loc, self.getName("tws2_rot"), tra.getTransform(self.fk_ctl[2])) self.tws2_rot.setAttr("sx", .001) # Divisions ---------------------------------------- # We have at least one division at the start, the end and one for the elbow. self.divisions = self.settings["div0"] + self.settings["div1"] + 3 self.div_cns = [] for i in range(self.divisions): div_cns = pri.addTransform(self.root, self.getName("div%s_loc" % i)) self.div_cns.append(div_cns) self.addShadow(div_cns, i) # End reference ------------------------------------ # To help the deformation on the wrist self.end_ref = pri.addTransform(self.tws2_rot, self.getName("end_ref"), m) self.addShadow(self.end_ref, "end")
def addObjects(self): self.normal = self.guide.blades["blade"].z*-1 # Ik Controlers ------------------------------------ t = tra.getTransformLookingAt(self.guide.pos["tan1"], self.guide.pos["neck"], self.normal, "yx", self.negate) t = tra.setMatrixPosition(t, self.guide.pos["neck"]) self.ik_cns = pri.addTransform(self.root, self.getName("ik_cns"), t) self.ik_ctl = self.addCtl(self.ik_cns, "ik_ctl", t, self.color_ik, "compas", w=self.size*.5) att.setKeyableAttributes(self.ik_ctl) att.setRotOrder(self.ik_ctl, "ZXY") # Tangents ----------------------------------------- t = tra.setMatrixPosition(t, self.guide.pos["tan1"]) self.tan1_loc = pri.addTransform(self.ik_ctl, self.getName("tan1_loc"), t) t = tra.getTransformLookingAt(self.guide.pos["root"], self.guide.pos["tan0"], self.normal, "yx", self.negate) t = tra.setMatrixPosition(t, self.guide.pos["tan0"]) self.tan0_loc = pri.addTransform(self.root, self.getName("tan0_loc"), t) # Curves ------------------------------------------- self.mst_crv = cur.addCnsCurve(self.root, self.getName("mst_crv"), [self.root, self.tan0_loc, self.tan1_loc, self.ik_ctl], 3) self.slv_crv = cur.addCurve(self.root, self.getName("slv_crv"), [dt.Vector()]*10, False, 3) self.mst_crv.setAttr("visibility", False) self.slv_crv.setAttr("visibility", False) # Division ----------------------------------------- # The user only define how many intermediate division he wants. # First and last divisions are an obligation. parentdiv = self.root parentctl = self.root self.div_cns = [] self.fk_ctl = [] self.fk_npo = [] self.scl_npo = [] self.twister = [] self.ref_twist = [] parent_twistRef = pri.addTransform(self.root, self.getName("reference"), tra.getTransform(self.root)) for i in range(self.settings["division"]): # References div_cns = pri.addTransform(parentdiv, self.getName("%s_cns"%i)) pm.setAttr(div_cns+".inheritsTransform", False) self.div_cns.append(div_cns) parentdiv = div_cns scl_npo = pri.addTransform(parentctl, self.getName("%s_scl_npo"%i), tra.getTransform(parentctl)) # Controlers (First and last one are fake) if i in [ self.settings["division"] - 1]: # 0, fk_ctl = pri.addTransform(scl_npo, self.getName("%s_loc"%i), tra.getTransform(parentctl)) fk_npo = fk_ctl else: fk_npo = pri.addTransform(scl_npo, self.getName("fk%s_npo"%i), tra.getTransform(parentctl)) fk_ctl = self.addCtl(fk_npo, "fk%s_ctl"%i, tra.getTransform(parentctl), self.color_fk, "cube", w=self.size*.2, h=self.size*.05, d=self.size*.2) att.setKeyableAttributes(self.fk_ctl) att.setRotOrder(fk_ctl, "ZXY") self.scl_npo.append(scl_npo) self.fk_npo.append(fk_npo) self.fk_ctl.append(fk_ctl) parentctl = fk_ctl self.jnt_pos.append([fk_ctl, i]) #Twist references (This objects will replace the spinlookup slerp solver behavior) twister = pri.addTransform(parent_twistRef, self.getName("%s_rot_ref"%i), tra.getTransform(parent_twistRef)) t = tra.getTransform(self.root) t[3] = [t[3][0], t[3][1], 1.0, 1.0] ref_twist = pri.addTransform(parent_twistRef, self.getName("%s_pos_ref"%i), t) self.twister.append(twister) self.ref_twist.append(ref_twist) # Head --------------------------------------------- t = tra.getTransformLookingAt(self.guide.pos["head"], self.guide.pos["eff"], self.normal, "yx", self.negate) self.head_cns = pri.addTransform(self.root, self.getName("head_cns"), t) dist = vec.getDistance(self.guide.pos["head"], self.guide.pos["eff"]) self.head_ctl = self.addCtl(self.head_cns, "head_ctl", t, self.color_fk, "cube", w=self.size*.5, h=dist, d=self.size*.5, po=dt.Vector(0,dist*.5,0)) att.setRotOrder(self.head_ctl, "ZXY") self.jnt_pos.append([self.head_ctl, "head"])
def addObjects(self): self.normal = self.guide.blades["blade"].z*-1 self.binormal = self.guide.blades["blade"].x self.isFk = self.settings["mode"] != 1 self.isIk = self.settings["mode"] != 0 self.isFkIk = self.settings["mode"] == 2 self.WIP = self.options["mode"] # FK controllers ------------------------------------ if self.isFk: self.fk_npo = [] self.fk_ctl = [] t = self.guide.tra["root"] self.ik_cns = pri.addTransform(self.root, self.getName("ik_cns"), t) parent = self.ik_cns tOld = False for i, t in enumerate(tra.getChainTransform(self.guide.apos, self.normal, self.negate)): dist = vec.getDistance(self.guide.apos[i], self.guide.apos[i+1]) if self.settings["neutralpose"] or not tOld: tnpo = t else: tnpo = tra.setMatrixPosition(tOld, tra.getPositionFromMatrix(t)) fk_npo = pri.addTransform(parent, self.getName("fk%s_npo"%i), tnpo) fk_ctl = self.addCtl(fk_npo, "fk%s_ctl"%i, t, self.color_fk, "cube", w=dist, h=self.size*.1, d=self.size*.1, po=dt.Vector(dist*.5*self.n_factor,0,0)) parent = fk_ctl self.fk_npo.append(fk_npo) self.fk_ctl.append(fk_ctl) tOld = t # IK controllers ------------------------------------ if self.isIk: normal = vec.getTransposedVector(self.normal, [self.guide.apos[0], self.guide.apos[1]], [self.guide.apos[-2], self.guide.apos[-1]]) t = tra.getTransformLookingAt(self.guide.apos[-2], self.guide.apos[-1], normal, "xy", self.negate) t = tra.setMatrixPosition(t, self.guide.apos[-1]) self.ik_cns = pri.addTransform(self.root, self.getName("ik_cns"), t) self.ikcns_ctl = self.addCtl(self.ik_cns, "ikcns_ctl", t, self.color_ik, "null", w=self.size) self.ik_ctl = self.addCtl(self.ikcns_ctl, "ik_ctl", t, self.color_ik, "cube", w=self.size*.3, h=self.size*.3, d=self.size*.3) v = self.guide.apos[-1] - self.guide.apos[0] v = v ^ self.normal v.normalize() v *= self.size v += self.guide.apos[1] self.upv_cns = pri.addTransformFromPos(self.root, self.getName("upv_cns"), v) self.upv_ctl = self.addCtl(self.upv_cns, "upv_ctl", tra.getTransform(self.upv_cns), self.color_ik, "diamond", w=self.size*.1) # Chain self.chain = pri.add2DChain(self.root, self.getName("chain"), self.guide.apos, self.normal, self.negate) self.chain[0].attr("visibility").set(self.WIP) # Chain of deformers ------------------------------- self.loc = [] parent = self.root for i, t in enumerate(tra.getChainTransform(self.guide.apos, self.normal, self.negate)): loc = pri.addTransform(parent, self.getName("%s_loc"%i), t) self.loc.append(loc) self.jnt_pos.append([loc, i]) parent = loc
def addObjects(self): # Ik Controlers ------------------------------------ t = tra.getTransformLookingAt(self.guide.pos["tan1"], self.guide.pos["neck"], self.guide.blades["blade"].z, "yx", self.negate) t = tra.setMatrixPosition(t, self.guide.pos["neck"]) self.ik_cns = pri.addTransform(self.root, self.getName("ik_cns"), t) self.ik_ctl = self.addCtl(self.ik_cns, "ik_ctl", t, self.color_ik, "compas", w=self.size*.5) att.setKeyableAttributes(self.ik_ctl) att.setRotOrder(self.ik_ctl, "XZY") # Tangents ----------------------------------------- t = tra.setMatrixPosition(t, self.guide.pos["tan1"]) self.tan1_loc = pri.addTransform(self.ik_ctl, self.getName("tan1_loc"), t) t = tra.getTransformLookingAt(self.guide.pos["root"], self.guide.pos["tan0"], self.guide.blades["blade"].z, "yx", self.negate) t = tra.setMatrixPosition(t, self.guide.pos["tan0"]) self.tan0_loc = pri.addTransform(self.root, self.getName("tan0_loc"), t) # Curves ------------------------------------------- self.mst_crv = cur.addCnsCurve(self.root, self.getName("mst_crv"), [self.root, self.tan0_loc, self.tan1_loc, self.ik_ctl], 3) self.slv_crv = cur.addCurve(self.root, self.getName("slv_crv"), [dt.Vector()]*10, False, 3) self.mst_crv.setAttr("visibility", False) self.slv_crv.setAttr("visibility", False) # Division ----------------------------------------- # The user only define how many intermediate division he wants. # First and last divisions are an obligation. parentdiv = self.root parentctl = self.root self.div_cns = [] self.fk_ctl = [] self.fk_npo = [] self.scl_npo = [] for i in range(self.settings["division"]): # References div_cns = pri.addTransform(parentdiv, self.getName("%s_cns"%i)) setAttr(div_cns+".inheritsTransform", False) self.div_cns.append(div_cns) parentdiv = div_cns scl_npo = pri.addTransform(parentctl, self.getName("%s_scl_npo"%i), tra.getTransform(parentctl)) # Controlers (First and last one are fake) if i in [0, self.settings["division"] - 1]: fk_ctl = pri.addTransform(scl_npo, self.getName("%s_loc"%i), tra.getTransform(parentctl)) fk_npo = fk_ctl else: fk_npo = pri.addTransform(scl_npo, self.getName("fk%s_npo"%(i-1)), tra.getTransform(parentctl)) fk_ctl = self.addCtl(fk_npo, "fk%s_ctl"%(i-1), tra.getTransform(parentctl), self.color_fk, "cube", w=self.size*.2, h=self.size*.05, d=self.size*.2) att.setKeyableAttributes(self.fk_ctl) att.setRotOrder(fk_ctl, "XZY") # setAttr(fk_npo+".inheritsTransform", False) self.scl_npo.append(scl_npo) self.fk_npo.append(fk_npo) self.fk_ctl.append(fk_ctl) parentctl = fk_ctl # Deformers (Shadow) self.addShadow(fk_ctl, i) # Head --------------------------------------------- t = tra.getTransformLookingAt(self.guide.pos["head"], self.guide.pos["eff"], self.guide.blades["blade"].z, "yx", self.negate) self.head_cns = pri.addTransform(self.root, self.getName("head_cns"), t) dist = vec.getDistance(self.guide.pos["head"], self.guide.pos["eff"]) self.head_ctl = self.addCtl(self.head_cns, "head_ctl", t, self.color_fk, "cube", w=self.size*.5, h=dist, d=self.size*.5, po=dt.Vector(0,dist*.5,0)) att.setRotOrder(self.head_ctl, "XZY") self.addShadow(self.head_ctl, "head")
def lipsRig(eLoop, upVertex, lowVertex, namePrefix, thickness, doSkin, rigidLoops, falloffLoops, headJnt=None, jawJnt=None, parent=None, ctlName="ctl"): ###### # Var ###### FRONT_OFFSET = .02 NB_ROPE = 15 ################## # Helper functions ################## def setName(name, side="C", idx=None): namesList = [namePrefix, side, name] if idx is not None: namesList[1] = side + str(idx) name = "_".join(namesList) return name ############### # Checkers ############## # Loop if eLoop: try: eLoop = [pm.PyNode(e) for e in eLoop.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 upVertex: try: upVertex = pm.PyNode(upVertex) except pm.MayaNodeError: pm.displayWarning("%s can not be found" % upVertex) return else: pm.displayWarning("Please set the upper lip central vertex") return if lowVertex: try: lowVertex = pm.PyNode(lowVertex) except pm.MayaNodeError: pm.displayWarning("%s can not be found" % lowVertex) return else: pm.displayWarning("Please set the lower lip central vertex") return # skinnign data if doSkin: if not headJnt: pm.displayWarning("Please set the Head Jnt or unCheck Compute " "Topological Autoskin") return else: try: headJnt = pm.PyNode(headJnt) except pm.MayaNodeError: pm.displayWarning("Head Joint: %s can not be found" % headJnt) return if not jawJnt: pm.displayWarning("Please set the Jaw Jnt or unCheck Compute " "Topological Autoskin") return else: try: jawJnt = pm.PyNode(jawJnt) except pm.MayaNodeError: pm.displayWarning("Jaw Joint: %s can not be found" % jawJnt) 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(eLoop[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(eLoop) 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 = upVertex lowPos = lowVertex # 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("upCrv_%s" % ctlName), nbPoints=7, parent=lipsCrv_root) lowCrv_ctl = curve.createCurveFromCurve(lowCrv, setName("lowCrv_%s" % ctlName), 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) ################## # Controls ################## # Controls lists upControls = [] upVec = [] upNpo = [] lowControls = [] lowVec = [] lowNpo = [] # controls options axis_list = ["sx", "sy", "sz", "ro", "rx", "ry", "rz"] 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"] # 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 # print distSize for i, cv in enumerate(cvs): pm.progressWindow(e=True, step=1, status='\nCreating control for%s' % cv) t = transform.getTransformFromPos(cv) 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, ctlName), 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) if len(ctlName.split("_")) == 2 and ctlName.split("_")[-1] == "ghost": pass else: pm.sets(ctlSet, add=ctl) 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) 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, ctlName), 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) if len(ctlName.split("_")) == 2 and ctlName.split("_")[-1] == "ghost": pass else: pm.sets(ctlSet, add=ctl) 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) pm.wire(lowCrv, w=lowCrv_ctl) pm.wire(upRope, w=upCrv_ctl) pm.wire(lowRope, w=lowCrv_ctl) pm.wire(upRope_upv, w=upCrv_upv) pm.wire(lowRope_upv, w=lowCrv_upv) # 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 = 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 = 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 = 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) # 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 = 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 = 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 = 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) ################## # 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 headJnt and isinstance(headJnt, str): try: j_parent = pm.PyNode(headJnt) except pm.MayaNodeError: j_parent = False elif headJnt and isinstance(headJnt, pm.PyNode): j_parent = headJnt 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 jawJnt and isinstance(jawJnt, str): try: j_parent = pm.PyNode(jawJnt) except pm.MayaNodeError: pass elif jawJnt and isinstance(jawJnt, pm.PyNode): j_parent = jawJnt 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) ########################################### # Connecting rig ########################################### if parent: try: if isinstance(parent, basestring): parent = pm.PyNode(parent) parent.addChild(lips_root) except pm.MayaNodeError: pm.displayWarning("The Lips rig can not be parent to: %s. Maybe " "this object doesn't exist." % parent) if headJnt and jawJnt: try: if isinstance(headJnt, basestring): headJnt = pm.PyNode(headJnt) except pm.MayaNodeError: pm.displayWarning("Head Joint or Upper Lip Joint %s. Can not be " "fount in the scene" % headJnt) return try: if isinstance(jawJnt, basestring): jawJnt = pm.PyNode(jawJnt) except pm.MayaNodeError: pm.displayWarning("Jaw Joint or Lower Lip Joint %s. Can not be " "fount in the scene" % jawJnt) return # right corner connection pm.parentConstraint(headJnt, jawJnt, upControls[0].getParent(), mo=True) # left corner connection pm.parentConstraint(headJnt, jawJnt, upControls[-1].getParent(), mo=True) # up control connection pm.parentConstraint(headJnt, upControls[3].getParent(), mo=True) # low control connection pm.parentConstraint(jawJnt, lowControls[2].getParent(), mo=True) ########################################### # Auto Skinning ########################################### if doSkin: # eyelid vertex rows totalLoops = rigidLoops + falloffLoops 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(rigidLoops): for rr in range(2): skinPercList.append(1.0) increment = 1.0 / float(falloffLoops) # we invert to smooth out from 100 to 0 inv = 1.0 - increment for r in range(falloffLoops): 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 headJnt: try: headJnt = pm.PyNode(headJnt) except pm.MayaNodeError: pm.displayWarning("Auto skin aborted can not find %s " % headJnt) 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(headJnt, 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 _createSoftTweakControls(name, parent=None, t=datatypes.Matrix(), grps=None, size=0.5): root_name = "{}_{}".format(name, "softTweak_root") namespace = None try: # simple check if exist a tweak with the same name exist = pm.PyNode(root_name) if exist: pm.displayError("the tweak: {} already exist. Please use a " "unique name.".format(name)) return False, False except pm.MayaNodeError: if parent: try: p = pm.PyNode(parent) namespace = p.namespace() except pm.MayaNodeError: pm.displayWarning("{} is not a valid parent or doesn't " "exist".format(parent)) p = None else: p = None root = primitive.addTransform(p, root_name, t) attribute.addAttribute(root, "iconSize", "float", size, keyable=False) baseCtl = icon.create(parent=root, name="{}_{}".format(name, "baseSoftTweak_ctl"), m=t, color=[1, 0.622, 0], icon="square", d=size, w=size) tweakCtl = icon.create(parent=baseCtl, name="{}_{}".format(name, "softTweak_ctl"), m=t, color=[0.89, 0.0, 0.143], icon="diamond", w=size * .8) attribute.addAttribute(tweakCtl, "falloff", "float", size) if grps: if not isinstance(grps, list): grps = [grps] for grp in grps: try: # try if exist oGrp = pm.PyNode(grp) except pm.MayaNodeError: # create a new grp if does't exist if len(grp.split("_")) >= 3: # check name convention name = grp else: name = "rig_{}_grp".format(grp) # namespace basic handling # NOTE: Doesn't support more than one namespace stacked if namespace and len(name.split(":")) < 2: name = namespace + name oGrp = pm.sets(n=name, em=True) pm.sets(oGrp, add=[baseCtl, tweakCtl]) if t: root.setMatrix(t, worldSpace=True) return baseCtl, tweakCtl
def addObjects(self): # Ik Controlers ------------------------------------ t = tra.getTransformLookingAt(self.guide.pos["tan1"], self.guide.pos["neck"], self.guide.blades["blade"].z, "yx", self.negate) t = tra.setMatrixPosition(t, self.guide.pos["neck"]) self.ik_cns = pri.addTransform(self.root, self.getName("ik_cns"), t) self.ik_ctl = self.addCtl(self.ik_cns, "ik_ctl", t, self.color_ik, "compas", w=self.size * .5) att.setKeyableAttributes(self.ik_ctl) att.setRotOrder(self.ik_ctl, "XZY") # Tangents ----------------------------------------- t = tra.setMatrixPosition(t, self.guide.pos["tan1"]) self.tan1_loc = pri.addTransform(self.ik_ctl, self.getName("tan1_loc"), t) t = tra.getTransformLookingAt(self.guide.pos["root"], self.guide.pos["tan0"], self.guide.blades["blade"].z, "yx", self.negate) t = tra.setMatrixPosition(t, self.guide.pos["tan0"]) self.tan0_loc = pri.addTransform(self.root, self.getName("tan0_loc"), t) # Curves ------------------------------------------- self.mst_crv = cur.addCnsCurve( self.root, self.getName("mst_crv"), [self.root, self.tan0_loc, self.tan1_loc, self.ik_ctl], 3) self.slv_crv = cur.addCurve(self.root, self.getName("slv_crv"), [dt.Vector()] * 10, False, 3) self.mst_crv.setAttr("visibility", False) self.slv_crv.setAttr("visibility", False) # Division ----------------------------------------- # The user only define how many intermediate division he wants. # First and last divisions are an obligation. parentdiv = self.root parentctl = self.root self.div_cns = [] self.fk_ctl = [] self.fk_npo = [] self.scl_npo = [] for i in range(self.settings["division"]): # References div_cns = pri.addTransform(parentdiv, self.getName("%s_cns" % i)) setAttr(div_cns + ".inheritsTransform", False) self.div_cns.append(div_cns) parentdiv = div_cns scl_npo = pri.addTransform(parentctl, self.getName("%s_scl_npo" % i), tra.getTransform(parentctl)) # Controlers (First and last one are fake) if i in [0, self.settings["division"] - 1]: fk_ctl = pri.addTransform(scl_npo, self.getName("%s_loc" % i), tra.getTransform(parentctl)) fk_npo = fk_ctl else: fk_npo = pri.addTransform(scl_npo, self.getName("fk%s_npo" % (i - 1)), tra.getTransform(parentctl)) fk_ctl = self.addCtl(fk_npo, "fk%s_ctl" % (i - 1), tra.getTransform(parentctl), self.color_fk, "cube", w=self.size * .2, h=self.size * .05, d=self.size * .2) att.setKeyableAttributes(self.fk_ctl) att.setRotOrder(fk_ctl, "XZY") # setAttr(fk_npo+".inheritsTransform", False) self.scl_npo.append(scl_npo) self.fk_npo.append(fk_npo) self.fk_ctl.append(fk_ctl) parentctl = fk_ctl # Deformers (Shadow) self.addShadow(fk_ctl, i) # Head --------------------------------------------- t = tra.getTransformLookingAt(self.guide.pos["head"], self.guide.pos["eff"], self.guide.blades["blade"].z, "yx", self.negate) self.head_cns = pri.addTransform(self.root, self.getName("head_cns"), t) dist = vec.getDistance(self.guide.pos["head"], self.guide.pos["eff"]) self.head_ctl = self.addCtl(self.head_cns, "head_ctl", t, self.color_fk, "cube", w=self.size * .5, h=dist, d=self.size * .5, po=dt.Vector(0, dist * .5, 0)) att.setRotOrder(self.head_ctl, "XZY") self.addShadow(self.head_ctl, "head")
def eyeRig(eyeMesh, edgeLoop, blinkH, namePrefix, offset, rigidLoops, falloffLoops, headJnt, doSkin, parent=None, ctlName="ctl", sideRange=False, customCorner=False, intCorner=None, extCorner=None, ctlGrp=None, defGrp=None): """Create eyelid and eye rig Args: eyeMesh (TYPE): Description edgeLoop (TYPE): Description blinkH (TYPE): Description namePrefix (TYPE): Description offset (TYPE): Description rigidLoops (TYPE): Description falloffLoops (TYPE): Description headJnt (TYPE): Description doSkin (TYPE): Description parent (None, optional): Description ctlName (str, optional): Description sideRange (bool, optional): Description customCorner (bool, optional): Description intCorner (None, optional): Description extCorner (None, optional): Description ctlGrp (None, optional): Description defGrp (None, optional): Description Returns: TYPE: Description """ # Checkers if edgeLoop: edgeLoopList = [pm.PyNode(e) for e in edgeLoop.split(",")] else: pm.displayWarning("Please set the edge loop first") return if eyeMesh: try: eyeMesh = pm.PyNode(eyeMesh) except pm.MayaNodeError: pm.displayWarning("The object %s can not be found in the " "scene" % (eyeMesh)) return else: pm.displayWarning("Please set the eye mesh first") if doSkin: if not headJnt: pm.displayWarning("Please set the Head Jnt or unCheck " "Compute Topological Autoskin") return # Initial Data bboxCenter = meshNavigation.bboxCenter(eyeMesh) extr_v = meshNavigation.getExtremeVertexFromLoop(edgeLoopList, sideRange) upPos = extr_v[0] lowPos = extr_v[1] inPos = extr_v[2] outPos = extr_v[3] edgeList = extr_v[4] vertexList = extr_v[5] # Detect the side L or R from the x value if inPos.getPosition(space='world')[0] < 0.0: side = "R" inPos = extr_v[3] outPos = extr_v[2] normalPos = outPos npw = normalPos.getPosition(space='world') normalVec = npw - bboxCenter else: side = "L" normalPos = outPos npw = normalPos.getPosition(space='world') normalVec = bboxCenter - npw # Manual Vertex corners if customCorner: if intCorner: try: if side == "R": inPos = pm.PyNode(extCorner) else: inPos = pm.PyNode(intCorner) except pm.MayaNodeError: pm.displayWarning("%s can not be found" % intCorner) return else: pm.displayWarning("Please set the internal eyelid corner") return if extCorner: try: normalPos = pm.PyNode(extCorner) npw = normalPos.getPosition(space='world') if side == "R": outPos = pm.PyNode(intCorner) normalVec = npw - bboxCenter else: outPos = pm.PyNode(extCorner) normalVec = bboxCenter - npw except pm.MayaNodeError: pm.displayWarning("%s can not be found" % extCorner) return else: pm.displayWarning("Please set the external eyelid corner") return # Check if we have prefix: if namePrefix: namePrefix = string.removeInvalidCharacter(namePrefix) else: pm.displayWarning("Prefix is needed") return def setName(name, ind=None): namesList = [namePrefix, side, name] if ind is not None: namesList[1] = side + str(ind) name = "_".join(namesList) return name if pm.ls(setName("root")): pm.displayWarning("The object %s already exist in the scene. Please " "choose another name prefix" % setName("root")) return # Eye root eye_root = primitive.addTransform(None, setName("root")) eyeCrv_root = primitive.addTransform(eye_root, setName("crvs")) # Eyelid Main crvs try: upEyelid = meshNavigation.edgeRangeInLoopFromMid( edgeList, upPos, inPos, outPos) upCrv = curve.createCurveFromOrderedEdges( upEyelid, inPos, setName("upperEyelid"), parent=eyeCrv_root) upCrv_ctl = curve.createCurveFromOrderedEdges( upEyelid, inPos, setName("upCrv_%s" % ctlName), parent=eyeCrv_root) pm.rebuildCurve(upCrv_ctl, s=2, rt=0, rpo=True, ch=False) lowEyelid = meshNavigation.edgeRangeInLoopFromMid( edgeList, lowPos, inPos, outPos) lowCrv = curve.createCurveFromOrderedEdges( lowEyelid, inPos, setName("lowerEyelid"), parent=eyeCrv_root) lowCrv_ctl = curve.createCurveFromOrderedEdges( lowEyelid, inPos, setName("lowCrv_%s" % ctlName), parent=eyeCrv_root) pm.rebuildCurve(lowCrv_ctl, s=2, rt=0, rpo=True, ch=False) except UnboundLocalError: if customCorner: pm.displayWarning("This error is maybe caused because the custom " "Corner vertex is not part of the edge loop") pm.displayError(traceback.format_exc()) return upBlink = curve.createCurveFromCurve( upCrv, setName("upblink_crv"), nbPoints=30, parent=eyeCrv_root) lowBlink = curve.createCurveFromCurve( lowCrv, setName("lowBlink_crv"), nbPoints=30, parent=eyeCrv_root) upTarget = curve.createCurveFromCurve( upCrv, setName("upblink_target"), nbPoints=30, parent=eyeCrv_root) lowTarget = curve.createCurveFromCurve( lowCrv, setName("lowBlink_target"), nbPoints=30, parent=eyeCrv_root) midTarget = curve.createCurveFromCurve( lowCrv, setName("midBlink_target"), nbPoints=30, parent=eyeCrv_root) rigCrvs = [upCrv, lowCrv, upCrv_ctl, lowCrv_ctl, upBlink, lowBlink, upTarget, lowTarget, midTarget] for crv in rigCrvs: crv.attr("visibility").set(False) # localBBOX localBBox = eyeMesh.getBoundingBox(invisible=True, space='world') wRadius = abs((localBBox[0][0] - localBBox[1][0])) dRadius = abs((localBBox[0][1] - localBBox[1][1]) / 1.7) # Groups if not ctlGrp: ctlGrp = "rig_controllers_grp" try: ctlSet = pm.PyNode(ctlGrp) except pm.MayaNodeError: pm.sets(n=ctlGrp, em=True) ctlSet = pm.PyNode(ctlGrp) if not defGrp: defGrp = "rig_deformers_grp" try: defset = pm.PyNode(defGrp) except pm.MayaNodeError: pm.sets(n=defGrp, em=True) defset = pm.PyNode(defGrp) # Calculate center looking at averagePosition = ((upPos.getPosition(space='world') + lowPos.getPosition(space='world') + inPos.getPosition(space='world') + outPos.getPosition(space='world')) / 4) if side == "R": negate = False offset = offset over_offset = dRadius else: negate = False over_offset = dRadius if side == "R" and sideRange or side == "R" and customCorner: axis = "z-x" # axis = "zx" else: axis = "z-x" t = transform.getTransformLookingAt( bboxCenter, averagePosition, normalVec, axis=axis, negate=negate) over_npo = primitive.addTransform( eye_root, setName("center_lookatRoot"), t) over_ctl = icon.create(over_npo, setName("over_%s" % ctlName), t, icon="square", w=wRadius, d=dRadius, ro=datatypes.Vector(1.57079633, 0, 0), po=datatypes.Vector(0, 0, over_offset), color=4) node.add_controller_tag(over_ctl) attribute.add_mirror_config_channels(over_ctl) attribute.setKeyableAttributes( over_ctl, params=["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx", "sy", "sz"]) if side == "R": over_npo.attr("rx").set(over_npo.attr("rx").get() * -1) over_npo.attr("ry").set(over_npo.attr("ry").get() + 180) over_npo.attr("sz").set(-1) if len(ctlName.split("_")) == 2 and ctlName.split("_")[-1] == "ghost": pass else: pm.sets(ctlSet, add=over_ctl) center_lookat = primitive.addTransform( over_ctl, setName("center_lookat"), t) # Tracking # Eye aim control t_arrow = transform.getTransformLookingAt(bboxCenter, averagePosition, upPos.getPosition(space='world'), axis="zy", negate=False) radius = abs((localBBox[0][0] - localBBox[1][0]) / 1.7) arrow_npo = primitive.addTransform(eye_root, setName("aim_npo"), t_arrow) arrow_ctl = icon.create(arrow_npo, setName("aim_%s" % ctlName), t_arrow, icon="arrow", w=1, po=datatypes.Vector(0, 0, radius), color=4) if len(ctlName.split("_")) == 2 and ctlName.split("_")[-1] == "ghost": pass else: pm.sets(ctlSet, add=arrow_ctl) attribute.setKeyableAttributes(arrow_ctl, params=["rx", "ry", "rz"]) # tracking custom trigger if side == "R": tt = t_arrow else: tt = t aimTrigger_root = primitive.addTransform( center_lookat, setName("aimTrigger_root"), tt) aimTrigger_lvl = primitive.addTransform( aimTrigger_root, setName("aimTrigger_lvl"), tt) aimTrigger_lvl.attr("tz").set(1.0) aimTrigger_ref = primitive.addTransform( aimTrigger_lvl, setName("aimTrigger_ref"), tt) aimTrigger_ref.attr("tz").set(0.0) # connect trigger with arrow_ctl pm.parentConstraint(arrow_ctl, aimTrigger_ref, mo=True) # Controls lists upControls = [] trackLvl = [] # upper eyelid controls upperCtlNames = ["inCorner", "upInMid", "upMid", "upOutMid", "outCorner"] cvs = upCrv_ctl.getCVs(space="world") if side == "R" and not sideRange: # if side == "R": cvs = [cv for cv in reversed(cvs)] for i, cv in enumerate(cvs): if utils.is_odd(i): color = 14 wd = .5 icon_shape = "circle" params = ["tx", "ty", "tz"] else: color = 4 wd = .7 icon_shape = "square" params = ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx", "sy", "sz"] t = transform.setMatrixPosition(t, cvs[i]) npo = primitive.addTransform(center_lookat, setName("%s_npo" % upperCtlNames[i]), t) npoBase = npo if i == 2: # we add an extra level to input the tracking ofset values npo = primitive.addTransform(npo, setName("%s_trk" % upperCtlNames[i]), t) trackLvl.append(npo) ctl = icon.create(npo, setName("%s_%s" % (upperCtlNames[i], ctlName)), t, icon=icon_shape, w=wd, d=wd, ro=datatypes.Vector(1.57079633, 0, 0), po=datatypes.Vector(0, 0, offset), color=color) attribute.add_mirror_config_channels(ctl) node.add_controller_tag(ctl, over_ctl) upControls.append(ctl) if len(ctlName.split("_")) == 2 and ctlName.split("_")[-1] == "ghost": pass else: pm.sets(ctlSet, add=ctl) attribute.setKeyableAttributes(ctl, params) if side == "R": npoBase.attr("ry").set(180) npoBase.attr("sz").set(-1) # adding parent average contrains to odd controls for i, ctl in enumerate(upControls): if utils.is_odd(i): pm.parentConstraint(upControls[i - 1], upControls[i + 1], ctl.getParent(), mo=True) # lower eyelid controls lowControls = [upControls[0]] lowerCtlNames = ["inCorner", "lowInMid", "lowMid", "lowOutMid", "outCorner"] cvs = lowCrv_ctl.getCVs(space="world") if side == "R" and not sideRange: cvs = [cv for cv in reversed(cvs)] for i, cv in enumerate(cvs): # we skip the first and last point since is already in the uper eyelid if i in [0, 4]: continue if utils.is_odd(i): color = 14 wd = .5 icon_shape = "circle" params = ["tx", "ty", "tz"] else: color = 4 wd = .7 icon_shape = "square" params = ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx", "sy", "sz"] t = transform.setMatrixPosition(t, cvs[i]) npo = primitive.addTransform(center_lookat, setName("%s_npo" % lowerCtlNames[i]), t) npoBase = npo if i == 2: # we add an extra level to input the tracking ofset values npo = primitive.addTransform(npo, setName("%s_trk" % lowerCtlNames[i]), t) trackLvl.append(npo) ctl = icon.create(npo, setName("%s_%s" % (lowerCtlNames[i], ctlName)), t, icon=icon_shape, w=wd, d=wd, ro=datatypes.Vector(1.57079633, 0, 0), po=datatypes.Vector(0, 0, offset), color=color) attribute.add_mirror_config_channels(ctl) lowControls.append(ctl) if len(ctlName.split("_")) == 2 and ctlName.split("_")[-1] == "ghost": pass else: pm.sets(ctlSet, add=ctl) attribute.setKeyableAttributes(ctl, params) # mirror behaviout on R side controls if side == "R": npoBase.attr("ry").set(180) npoBase.attr("sz").set(-1) for lctl in reversed(lowControls[1:]): node.add_controller_tag(lctl, over_ctl) lowControls.append(upControls[-1]) # adding parent average contrains to odd controls for i, ctl in enumerate(lowControls): if utils.is_odd(i): pm.parentConstraint(lowControls[i - 1], lowControls[i + 1], ctl.getParent(), mo=True) # Connecting control crvs with controls applyop.gear_curvecns_op(upCrv_ctl, upControls) applyop.gear_curvecns_op(lowCrv_ctl, lowControls) # adding wires w1 = pm.wire(upCrv, w=upBlink)[0] w2 = pm.wire(lowCrv, w=lowBlink)[0] w3 = pm.wire(upTarget, w=upCrv_ctl)[0] w4 = pm.wire(lowTarget, w=lowCrv_ctl)[0] # adding blendshapes bs_upBlink = pm.blendShape(upTarget, midTarget, upBlink, n="blendShapeUpBlink") bs_lowBlink = pm.blendShape(lowTarget, midTarget, lowBlink, n="blendShapeLowBlink") bs_mid = pm.blendShape(lowTarget, upTarget, midTarget, n="blendShapeLowBlink") # setting blendshape reverse connections rev_node = pm.createNode("reverse") pm.connectAttr(bs_upBlink[0].attr(midTarget.name()), rev_node + ".inputX") pm.connectAttr(rev_node + ".outputX", bs_upBlink[0].attr(upTarget.name())) rev_node = pm.createNode("reverse") pm.connectAttr(bs_lowBlink[0].attr(midTarget.name()), rev_node + ".inputX") pm.connectAttr(rev_node + ".outputX", bs_lowBlink[0].attr(lowTarget.name())) rev_node = pm.createNode("reverse") pm.connectAttr(bs_mid[0].attr(upTarget.name()), rev_node + ".inputX") pm.connectAttr(rev_node + ".outputX", bs_mid[0].attr(lowTarget.name())) # setting default values bs_mid[0].attr(upTarget.name()).set(blinkH) # joints root jnt_root = primitive.addTransformFromPos( eye_root, setName("joints"), pos=bboxCenter) # head joint if headJnt: try: headJnt = pm.PyNode(headJnt) jnt_base = headJnt except pm.MayaNodeError: pm.displayWarning( "Aborted can not find %s " % headJnt) return else: # Eye root jnt_base = jnt_root eyeTargets_root = primitive.addTransform(eye_root, setName("targets")) eyeCenter_jnt = rigbits.addJnt(arrow_ctl, jnt_base, grp=defset, jntName=setName("center_jnt")) # Upper Eyelid joints ################################################## cvs = upCrv.getCVs(space="world") upCrv_info = node.createCurveInfoNode(upCrv) # aim constrain targets and joints upperEyelid_aimTargets = [] upperEyelid_jnt = [] upperEyelid_jntRoot = [] for i, cv in enumerate(cvs): # aim targets trn = primitive.addTransformFromPos(eyeTargets_root, setName("upEyelid_aimTarget", i), pos=cv) upperEyelid_aimTargets.append(trn) # connecting positions with crv pm.connectAttr(upCrv_info + ".controlPoints[%s]" % str(i), trn.attr("translate")) # joints jntRoot = primitive.addJointFromPos(jnt_root, setName("upEyelid_jnt_base", i), pos=bboxCenter) jntRoot.attr("radius").set(.08) jntRoot.attr("visibility").set(False) upperEyelid_jntRoot.append(jntRoot) applyop.aimCns(jntRoot, trn, axis="zy", wupObject=jnt_root) jnt_ref = primitive.addJointFromPos(jntRoot, setName("upEyelid_jnt_ref", i), pos=cv) jnt_ref.attr("radius").set(.08) jnt_ref.attr("visibility").set(False) jnt = rigbits.addJnt(jnt_ref, jnt_base, grp=defset, jntName=setName("upEyelid_jnt", i)) upperEyelid_jnt.append(jnt) # Lower Eyelid joints ################################################## cvs = lowCrv.getCVs(space="world") lowCrv_info = node.createCurveInfoNode(lowCrv) # aim constrain targets and joints lowerEyelid_aimTargets = [] lowerEyelid_jnt = [] lowerEyelid_jntRoot = [] for i, cv in enumerate(cvs): if i in [0, len(cvs) - 1]: continue # aim targets trn = primitive.addTransformFromPos(eyeTargets_root, setName("lowEyelid_aimTarget", i), pos=cv) lowerEyelid_aimTargets.append(trn) # connecting positions with crv pm.connectAttr(lowCrv_info + ".controlPoints[%s]" % str(i), trn.attr("translate")) # joints jntRoot = primitive.addJointFromPos(jnt_root, setName("lowEyelid_base", i), pos=bboxCenter) jntRoot.attr("radius").set(.08) jntRoot.attr("visibility").set(False) lowerEyelid_jntRoot.append(jntRoot) applyop.aimCns(jntRoot, trn, axis="zy", wupObject=jnt_root) jnt_ref = primitive.addJointFromPos(jntRoot, setName("lowEyelid_jnt_ref", i), pos=cv) jnt_ref.attr("radius").set(.08) jnt_ref.attr("visibility").set(False) jnt = rigbits.addJnt(jnt_ref, jnt_base, grp=defset, jntName=setName("lowEyelid_jnt", i)) lowerEyelid_jnt.append(jnt) # Channels # Adding and connecting attributes for the blink up_ctl = upControls[2] blink_att = attribute.addAttribute( over_ctl, "blink", "float", 0, minValue=0, maxValue=1) blinkMult_att = attribute.addAttribute( over_ctl, "blinkMult", "float", 1, minValue=1, maxValue=2) midBlinkH_att = attribute.addAttribute( over_ctl, "blinkHeight", "float", blinkH, minValue=0, maxValue=1) mult_node = node.createMulNode(blink_att, blinkMult_att) pm.connectAttr(mult_node + ".outputX", bs_upBlink[0].attr(midTarget.name())) pm.connectAttr(mult_node + ".outputX", bs_lowBlink[0].attr(midTarget.name())) pm.connectAttr(midBlinkH_att, bs_mid[0].attr(upTarget.name())) low_ctl = lowControls[2] # Adding channels for eye tracking upVTracking_att = attribute.addAttribute(up_ctl, "vTracking", "float", .02, minValue=0, maxValue=1, keyable=False, channelBox=True) upHTracking_att = attribute.addAttribute(up_ctl, "hTracking", "float", .01, minValue=0, maxValue=1, keyable=False, channelBox=True) lowVTracking_att = attribute.addAttribute(low_ctl, "vTracking", "float", .01, minValue=0, maxValue=1, keyable=False, channelBox=True) lowHTracking_att = attribute.addAttribute(low_ctl, "hTracking", "float", .01, minValue=0, maxValue=1, keyable=False, channelBox=True) mult_node = node.createMulNode(upVTracking_att, aimTrigger_ref.attr("ty")) pm.connectAttr(mult_node + ".outputX", trackLvl[0].attr("ty")) mult_node = node.createMulNode(upHTracking_att, aimTrigger_ref.attr("tx")) pm.connectAttr(mult_node + ".outputX", trackLvl[0].attr("tx")) mult_node = node.createMulNode(lowVTracking_att, aimTrigger_ref.attr("ty")) pm.connectAttr(mult_node + ".outputX", trackLvl[1].attr("ty")) mult_node = node.createMulNode(lowHTracking_att, aimTrigger_ref.attr("tx")) pm.connectAttr(mult_node + ".outputX", trackLvl[1].attr("tx")) # Tension on blink node.createReverseNode(blink_att, w1.scale[0]) node.createReverseNode(blink_att, w3.scale[0]) node.createReverseNode(blink_att, w2.scale[0]) node.createReverseNode(blink_att, w4.scale[0]) ########################################### # Reparenting ########################################### if parent: try: if isinstance(parent, basestring): parent = pm.PyNode(parent) parent.addChild(eye_root) except pm.MayaNodeError: pm.displayWarning("The eye rig can not be parent to: %s. Maybe " "this object doesn't exist." % parent) ########################################### # Auto Skinning ########################################### if doSkin: # eyelid vertex rows totalLoops = rigidLoops + falloffLoops 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(rigidLoops): for rr in range(2): skinPercList.append(1.0) increment = 1.0 / float(falloffLoops) # we invert to smooth out from 100 to 0 inv = 1.0 - increment for r in range(falloffLoops): 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 geo = pm.listRelatives(edgeLoopList[0], parent=True)[0] # Check if the object has a skinCluster objName = pm.listRelatives(geo, parent=True)[0] skinCluster = skin.getSkinCluster(objName) if not skinCluster: skinCluster = pm.skinCluster(headJnt, geo, tsb=True, nw=2, n='skinClsEyelid') eyelidJoints = upperEyelid_jnt + lowerEyelid_jnt pm.progressWindow(title='Auto skinning process', progress=0, max=len(eyelidJoints)) firstBoundary = False for jnt in eyelidJoints: pm.progressWindow(e=True, step=1, status='\nSkinning %s' % jnt) skinCluster.addInfluence(jnt, weight=0) v = meshNavigation.getClosestVertexFromTransform(geo, jnt) for row in vertexRowList: if v in row: it = 0 # iterator inc = 1 # increment for i, rv in enumerate(row): try: perc = skinPercList[it] t_val = [(jnt, perc), (headJnt, 1.0 - perc)] pm.skinPercent(skinCluster, rv, transformValue=t_val) if rv.isOnBoundary(): # we need to compare with the first boundary # to check if the row have inverted direction # and offset the value if not firstBoundary: firstBoundary = True firstBoundaryValue = it else: if it < firstBoundaryValue: it -= 1 elif it > firstBoundaryValue: it += 1 inc = 2 except IndexError: continue it = it + inc pm.progressWindow(e=True, endProgress=True) # Eye Mesh skinning skinCluster = skin.getSkinCluster(eyeMesh) if not skinCluster: skinCluster = pm.skinCluster(eyeCenter_jnt, eyeMesh, tsb=True, nw=1, n='skinClsEye')
def addCtl(self, parent, name, m, color, icon, tp=None, **kwargs): """ Create the control and apply the shape, if this is alrealdy stored in the guide controllers grp. Args: parent (dagNode): The control parent name (str): The control name. m (matrix): The transfromation matrix for the control. color (int or list of float): The color for the control in idex or RGB. icon (str): The controls default shape. tp (dagNode): Tag Parent Control object to connect as a parent controller kwargs (variant): Other arguments for the icon type variations. Returns: dagNode: The Control. """ fullName = self.getName(name) bufferName = fullName + "_controlBuffer" if bufferName in self.rig.guide.controllers.keys(): ctl_ref = self.rig.guide.controllers[bufferName] ctl = pri.addTransform(parent, fullName, m) for shape in ctl_ref.getShapes(): ctl.addChild(shape, shape=True, add=True) pm.rename(shape, fullName + "Shape") ico.setcolor(ctl, color) else: ctl = ico.create(parent, fullName, m, color, icon, **kwargs) # create the attributes to handlde mirror and symetrical pose att.addAttribute(ctl, "invTx", "bool", 0, keyable=False, niceName="Invert Mirror TX") att.addAttribute(ctl, "invTy", "bool", 0, keyable=False, niceName="Invert Mirror TY") att.addAttribute(ctl, "invTz", "bool", 0, keyable=False, niceName="Invert Mirror TZ") att.addAttribute(ctl, "invRx", "bool", 0, keyable=False, niceName="Invert Mirror RX") att.addAttribute(ctl, "invRy", "bool", 0, keyable=False, niceName="Invert Mirror RY") att.addAttribute(ctl, "invRz", "bool", 0, keyable=False, niceName="Invert Mirror RZ") att.addAttribute(ctl, "invSx", "bool", 0, keyable=False, niceName="Invert Mirror SX") att.addAttribute(ctl, "invSy", "bool", 0, keyable=False, niceName="Invert Mirror SY") att.addAttribute(ctl, "invSz", "bool", 0, keyable=False, niceName="Invert Mirror SZ") if self.settings["ctlGrp"]: ctlGrp = self.settings["ctlGrp"] self.addToGroup(ctl, ctlGrp, "controllers") else: ctlGrp = "controllers" self.addToGroup(ctl, ctlGrp) #lock the control parent attributes if is not a control if parent not in self.groups[ctlGrp]: self.transform2Lock.append(parent) # Set the control shapes isHistoricallyInteresting for oShape in ctl.getShapes(): oShape.isHistoricallyInteresting.set(False) #set controller tag if versions.current() >= 201650: try: oldTag = pm.PyNode(ctl.name() + "_tag") if not oldTag.controllerObject.connections(): # NOTE: The next line is comment out. Because this will happend alot since maya does't clean # controller tags after deleting the control Object of the tag. This have been log to Autodesk. # If orphane tags are found, it will be clean in silence. # pm.displayWarning("Orphane Tag: %s will be delete and created new for: %s"%(oldTag.name(), ctl.name())) pm.delete(oldTag) except: pass pm.controller(ctl) if tp: ctt = pm.PyNode(pm.controller(ctl, q=True)[0]) tpTagNode = pm.PyNode(pm.controller(tp, q=True)[0]) tpTagNode.cycleWalkSibling.set(True) pm.connectAttr(tpTagNode.prepopulate, ctt.prepopulate, f=True) # The connectAttr to the children attribute is giving error # i.e: pm.connectAttr(ctt.attr("parent"), tpTagNode.attr("children"), na=True) # if using the next available option tag # I was expecting to use ctt.setParent(tp) but doest't work as expected. # After reading the documentation this method looks prety useless. # Looks like is boolean and works based on selection :( # this is a dirty loop workaround. Naaah! i = 0 while True: try: pm.connectAttr(ctt.parent, tpTagNode.attr("children[%s]" % str(i))) break except: i += 1 if i > 100: pm.displayWarning( "The controller tag for %s has reached the limit index of 100 children" % ctl.name()) break return ctl
def addObjects(self): """Add all the objects needed to create the component.""" 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 ---------------------------------------------- v = datatypes.Vector(self.guide.apos[-5].x, self.guide.apos[-1].y, self.guide.apos[-5].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: dir = bk_pos[i - 1] t = transform.getTransformLookingAt( pos, dir, 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:])): 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) self.jnt_pos.append([fk_ctl, i]) parent = fk_ctl self.fk_ctl.append(fk_ctl) self.fk_loc.append(fk_loc)
def addObjects(self): """Add all the objects needed to create the component.""" self.normal = self.guide.blades["blade"].z * -1 self.binormal = self.guide.blades["blade"].x self.WIP = self.options["mode"] if self.negate and self.settings["overrideNegate"]: self.negate = False self.n_factor = 1 if self.settings["overrideNegate"]: self.mirror_conf = [0, 0, 1, 1, 1, 0, 0, 0, 0] else: self.mirror_conf = [0, 0, 0, 0, 0, 0, 0, 0, 0] # FK controllers ------------------------------------ self.fk_npo = [] self.fk_ctl = [] self.tweak_ctl = [] self.upv_curv_lvl = [] t = self.guide.tra["root"] parent = self.root tOld = False fk_ctl = None self.previusTag = self.parentCtlTag for i, t in enumerate( transform.getChainTransform(self.guide.apos, self.normal, self.negate)): self.dist = vector.getDistance(self.guide.apos[i], self.guide.apos[i + 1]) if self.settings["neutralpose"] or not tOld: tnpo = t else: tnpo = transform.setMatrixPosition( tOld, transform.getPositionFromMatrix(t)) fk_npo = primitive.addTransform(parent, self.getName("fk%s_npo" % i), tnpo) fk_ctl = self.addCtl(fk_npo, "fk%s_ctl" % i, t, self.color_fk, "cube", w=self.dist, h=self.size * .1, d=self.size * .1, po=datatypes.Vector( self.dist * .5 * self.n_factor, 0, 0), tp=self.previusTag, mirrorConf=self.mirror_conf) tweak_ctl = self.addCtl(fk_ctl, "tweak%s_ctl" % i, t, self.color_ik, "square", w=self.size * .15, h=self.size * .15, d=self.size * .15, ro=datatypes.Vector([0, 0, 1.5708]), tp=self.previusTag, mirrorConf=self.mirror_conf) upv_curv_lvl = primitive.addTransform( tweak_ctl, self.getName("upv%s_lvl" % i), t) upv_curv_lvl.attr("tz").set(.01) self.fk_npo.append(fk_npo) self.fk_ctl.append(fk_ctl) self.tweak_ctl.append(tweak_ctl) self.upv_curv_lvl.append(upv_curv_lvl) tOld = t self.previusTag = fk_ctl parent = fk_ctl # self.jnt_pos.append([fk_ctl, i, None, False]) # add end control tweak_npo = primitive.addTransform(fk_ctl, self.getName("tweakEnd_npo"), t) tweak_ctl = self.addCtl(tweak_npo, "tweakEnd_ctl", t, self.color_ik, "square", w=self.size * .15, h=self.size * .15, d=self.size * .15, ro=datatypes.Vector([0, 0, 1.5708]), tp=self.previusTag, mirrorConf=self.mirror_conf) upv_curv_lvl = primitive.addTransform(tweak_ctl, self.getName("upvEnd_lvl"), t) upv_curv_lvl.attr("tz").set(.01) if self.negate: self.off_dist = self.dist * -1 else: self.off_dist = self.dist tweak_npo.attr("tx").set(self.off_dist) self.tweak_ctl.append(tweak_ctl) self.upv_curv_lvl.append(upv_curv_lvl) # add length offset control if keep length # This option will be added only if keep length is active if self.settings["keepLength"]: self.tweakTip_npo = primitive.addTransform( tweak_ctl, self.getName("tweakTip_npo"), t) tweak_ctl = self.addCtl(self.tweakTip_npo, "tweakTip_ctl", t, self.color_fk, "square", w=self.size * .1, h=self.size * .1, d=self.size * .1, ro=datatypes.Vector([0, 0, 1.5708]), tp=self.previusTag, mirrorConf=self.mirror_conf) upv_curv_lvl = primitive.addTransform(tweak_ctl, self.getName("upvTip_lvl"), t) upv_curv_lvl.attr("tz").set(.01) # move to align with the parent self.tweakTip_npo.attr("tx").set(0) self.tweak_ctl.append(tweak_ctl) self.upv_curv_lvl.append(upv_curv_lvl) # add visual reference self.line_ref = icon.connection_display_curve( self.getName("visualRef"), [self.tweakTip_npo.getParent(), tweak_ctl]) # set keyable attr for tweak controls [ attribute.setKeyableAttributes(t_ctl, ["tx", "ty", "tz", "rx"]) for t_ctl in self.tweak_ctl ] # Curves ------------------------------------------- self.mst_crv = curve.addCnsCurve(self.root, self.getName("mst_crv"), self.tweak_ctl[:], 3) self.upv_crv = curve.addCnsCurve(self.root, self.getName("upv_crv"), self.upv_curv_lvl, 3) self.mst_crv.setAttr("visibility", False) self.upv_crv.setAttr("visibility", False) # Divisions self.div_cns = [] self.upv_cns = [] if self.settings["overrideJntNb"]: self.def_number = self.settings["jntNb"] else: self.def_number = len(self.guide.apos) for i in range(self.def_number): # References div_cns = primitive.addTransform(self.root, self.getName("%s_cns" % i)) pm.setAttr(div_cns + ".inheritsTransform", False) self.div_cns.append(div_cns) upv_cns = primitive.addTransform(self.root, self.getName("%s_upv" % i)) pm.setAttr(upv_cns + ".inheritsTransform", False) self.upv_cns.append(upv_cns) self.jnt_pos.append([div_cns, i])
def addObjects(self): """Add all the objects needed to create the component.""" # jaw control t = transform.getTransformFromPos(self.guide.pos["jaw"]) self.ctl_npo = primitive.addTransform( self.root, self.getName("ctl_npo"), t) self.jaw_ctl = self.addCtl( self.ctl_npo, "jaw_ctl", t, self.color_fk, "circle", w=1 * self.size, ro=datatypes.Vector([1.5708, 0, 0]), tp=self.parentCtlTag) attribute.setKeyableAttributes(self.jaw_ctl, ["tx", "ty", "tz", "rz"]) # mouth center t = transform.getTransformFromPos(self.guide.pos["rotcenter"]) self.mouthCenter_npo = primitive.addTransform( self.root, self.getName("mouthCenter_npo"), t) self.mouthCenter = primitive.addTransform( self.mouthCenter_npo, self.getName("mouthCenter"), t) # jaw "UPPER" t = transform.getTransformFromPos(self.guide.pos["root"]) self.jawUp_npo = primitive.addTransform( self.mouthCenter, self.getName("jawUpper_npo"), t) self.jawUp_pos = primitive.addTransform( self.jawUp_npo, self.getName("jawUpper_pos"), t) self.jawUp_rot = primitive.addTransform( self.jawUp_pos, self.getName("jawUpper_rot"), t) # jaw "LOWER" t = transform.getTransformFromPos(self.guide.pos["root"]) self.jawLow_npo = primitive.addTransform( self.mouthCenter, self.getName("jaw_npo"), t) self.jawLow_pos = primitive.addTransform( self.jawLow_npo, self.getName("jawLow_pos"), t) self.jawLow_rot = primitive.addTransform( self.jawLow_pos, self.getName("jawLow_rot"), t) # lips t = transform.getTransformFromPos(self.guide.pos["lipup"]) self.lipup_npo = primitive.addTransform( self.jawUp_rot, self.getName("lipup_npo"), t) self.lipup_ctl = self.addCtl( self.lipup_npo, "lipup_ctl", t, self.color_fk, "square", d=.15 * self.size, w=1 * self.size, ro=datatypes.Vector([1.5708, 0, 0]), tp=self.jaw_ctl) t = transform.getTransformFromPos(self.guide.pos["liplow"]) self.liplow_npo = primitive.addTransform( self.jawLow_rot, self.getName("liplow_npo"), t) self.liplow_ctl = self.addCtl( self.liplow_npo, "liplow_ctl", t, self.color_fk, "square", d=.15 * self.size, w=1 * self.size, ro=datatypes.Vector([1.5708, 0, 0]), tp=self.jaw_ctl) # teeth t = transform.getTransformFromPos(self.guide.pos["lipup"]) self.teethup_npo = primitive.addTransform( self.jawUp_rot, self.getName("teethup_npo"), t) self.teethup_ctl = self.addCtl(self.teethup_npo, "teethup_ctl", t, self.color_ik, "square", d=.1 * self.size, w=.7 * self.size, ro=datatypes.Vector([1.5708, 0, 0]), tp=self.lipup_ctl) t = transform.getTransformFromPos(self.guide.pos["liplow"]) self.teethlow_npo = primitive.addTransform( self.jawLow_rot, self.getName("teethlow_npo"), t) self.teethlow_ctl = self.addCtl(self.teethlow_npo, "teethlow_ctl", t, self.color_ik, "square", d=.1 * self.size, w=.7 * self.size, ro=datatypes.Vector([1.5708, 0, 0]), tp=self.liplow_ctl) self.jnt_pos.append( [self.jawLow_rot, "jaw", "parent_relative_jnt", False]) self.jnt_pos.append( [self.lipup_ctl, "lipup", "parent_relative_jnt", False]) # relative 0 is the jaw jnt self.jnt_pos.append( [self.liplow_ctl, "liplow", "jaw", False]) self.jnt_pos.append( [self.teethup_ctl, "teethup", "parent_relative_jnt", False]) self.jnt_pos.append( [self.teethlow_ctl, "teethlow", "jaw", False])
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.armChainUpvRef = primitive.add2DChain( self.root, self.getName("armUpvRef%s_jnt"), [self.guide.apos[0], self.guide.apos[2]], self.normal, False, self.WIP) negateOri = self.armChainUpvRef[1].getAttr("jointOrientZ") * -1 self.armChainUpvRef[1].setAttr("jointOrientZ", negateOri) # 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, self.getName("fk0_npo"), t) vec_po = 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=vec_po, tp=self.parentCtlTag) 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) vec_po = 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=vec_po, 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) vec_po = 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=vec_po, 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 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.root, 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.parentCtlTag) 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) # IK Controlers ----------------------------------- self.ik_cns = primitive.addTransformFromPos( self.root, self.getName("ik_cns"), self.guide.pos["wrist"]) t = transform.getTransformFromPos(self.guide.pos["wrist"]) self.ikcns_ctl = self.addCtl(self.ik_cns, "ikcns_ctl", t, self.color_ik, "null", w=self.size * .12, tp=self.parentCtlTag) attribute.setInvertMirror(self.ikcns_ctl, ["tx", "ty", "tz"]) if self.negate: m = transform.getTransformLookingAt(self.guide.pos["wrist"], self.guide.pos["eff"], self.normal, "x-y", True) else: m = transform.getTransformLookingAt(self.guide.pos["wrist"], self.guide.pos["eff"], self.normal, "xy", False) self.ik_ctl = self.addCtl(self.ikcns_ctl, "ik_ctl", m, self.color_ik, "cube", w=self.size * .12, h=self.size * .12, d=self.size * .12, tp=self.upv_ctl) if self.settings["mirrorIK"]: if self.negate: self.ik_cns.sx.set(-1) self.ik_ctl.rz.set(self.ik_ctl.rz.get() * -1) else: attribute.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"]) attribute.setKeyableAttributes(self.ik_ctl) self.ik_ctl_ref = primitive.addTransform(self.ik_ctl, self.getName("ikCtl_ref"), m) # IK rotation controls if self.settings["ikTR"]: self.ikRot_npo = primitive.addTransform(self.root, self.getName("ikRot_npo"), m) self.ikRot_cns = primitive.addTransform(self.ikRot_npo, self.getName("ikRot_cns"), m) self.ikRot_ctl = self.addCtl(self.ikRot_cns, "ikRot_ctl", m, self.color_ik, "sphere", w=self.size * .12, tp=self.ik_ctl) attribute.setKeyableAttributes(self.ikRot_ctl, self.r_params) # References -------------------------------------- # Calculate again the transfor for the IK ref. This way align with FK trnIK_ref = transform.getTransformLookingAt(self.guide.pos["wrist"], self.guide.pos["eff"], self.normal, "xz", self.negate) self.ik_ref = primitive.addTransform(self.ik_ctl_ref, self.getName("ik_ref"), trnIK_ref) self.fk_ref = primitive.addTransform(self.fk_ctl[2], self.getName("fk_ref"), trnIK_ref) # Chain -------------------------------------------- # The outputs of the ikfk2bone solver self.bone0 = primitive.addLocator( self.root, 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, 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, self.getName("ctrn_loc"), self.guide.apos[1]) self.eff_loc = primitive.addTransformFromPos(self.root, self.getName("eff_loc"), self.guide.apos[2]) # 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.parentCtlTag) 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) self.mid_ctl_twst_npo = primitive.addTransform( self.mid_ctl, self.getName("mid_twst_npo"), t) self.mid_ctl_twst_ref = primitive.addTransform( self.mid_ctl_twst_npo, self.getName("mid_twst_ref"), t) else: self.mid_ctl_twst_ref = self.mid_ctl attribute.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"]) # Roll join ref self.rollRef = primitive.add2DChain(self.root, self.getName( "rollChain"), self.guide.apos[:2], self.normal, self.negate) for x in self.rollRef: x.setAttr("visibility", False) 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_npo = primitive.addTransform( self.ctrn_loc, self.getName("tws1_npo"), transform.getTransform(self.ctrn_loc)) self.tws1_loc = primitive.addTransform( self.tws1_npo, 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_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_loc, self.getName("tws2_rot"), transform.getTransform(self.fk_ctl[2])) # Divisions ---------------------------------------- # We have at least one division at the start, the end and one for the # elbow. + 2 for elbow angle control self.divisions = self.settings["div0"] + self.settings["div1"] + 3 + 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, 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 wrist self.jnt_pos.append([self.eff_loc, 'end']) # match IK FK references self.match_fk0_off = primitive.addTransform( self.root, self.getName("matchFk0_npo"), transform.getTransform(self.fk_ctl[1])) self.match_fk0 = primitive.addTransform( self.match_fk0_off, self.getName("fk0_mth"), transform.getTransform(self.fk_ctl[0])) self.match_fk1_off = primitive.addTransform( self.root, self.getName( "matchFk1_npo"), transform.getTransform(self.fk_ctl[2])) self.match_fk1 = primitive.addTransform( self.match_fk1_off, self.getName("fk1_mth"), transform.getTransform(self.fk_ctl[1])) if self.settings["ikTR"]: reference = self.ikRot_ctl self.match_ikRot = primitive.addTransform( self.fk2_ctl, self.getName("ikRot_mth"), transform.getTransform(self.ikRot_ctl)) else: reference = self.ik_ctl self.match_fk2 = primitive.addTransform( reference, self.getName("fk2_mth"), transform.getTransform(self.fk_ctl[2])) self.match_ik = primitive.addTransform( self.fk2_ctl, self.getName("ik_mth"), transform.getTransform(self.ik_ctl)) self.match_ikUpv = primitive.addTransform( self.fk0_ctl, self.getName("upv_mth"), transform.getTransform(self.upv_ctl)) # add visual reference self.line_ref = icon.connection_display_curve( self.getName("visalRef"), [self.upv_ctl, self.mid_ctl])
def addObjects(self): """Add all the objects needed to create the component.""" # Auto bend with position controls ------------------- if self.settings["autoBend"]: self.autoBendChain = primitive.add2DChain( self.root, self.getName("autoBend%s_jnt"), [self.guide.apos[0], self.guide.apos[1]], self.guide.blades["blade"].z * -1, False, True) for j in self.autoBendChain: j.drawStyle.set(2) # Ik Controlers ------------------------------------ t = transform.getTransformLookingAt( self.guide.apos[0], self.guide.apos[1], self.guide.blades["blade"].z * -1, "yx", self.negate) self.ik0_npo = primitive.addTransform( self.root, self.getName("ik0_npo"), t) self.ik0_ctl = self.addCtl(self.ik0_npo, "ik0_ctl", t, self.color_ik, "compas", w=self.size, tp=self.parentCtlTag) attribute.setKeyableAttributes(self.ik0_ctl, self.tr_params) attribute.setRotOrder(self.ik0_ctl, "ZXY") attribute.setInvertMirror(self.ik0_ctl, ["tx", "ry", "rz"]) # hip base joint # TODO: add option in setting for on/off if True: self.hip_lvl = primitive.addTransform( self.ik0_ctl, self.getName("hip_lvl"), t) self.jnt_pos.append([self.hip_lvl, "hip"]) t = transform.setMatrixPosition(t, self.guide.apos[1]) if self.settings["autoBend"]: self.autoBend_npo = primitive.addTransform( self.root, self.getName("spinePosition_npo"), t) self.autoBend_ctl = self.addCtl(self.autoBend_npo, "spinePosition_ctl", t, self.color_ik, "square", w=self.size, d=.3 * self.size, tp=self.parentCtlTag) attribute.setKeyableAttributes(self.autoBend_ctl, ["tx", "ty", "tz", "ry"]) attribute.setInvertMirror(self.autoBend_ctl, ["tx", "ry"]) self.ik1_npo = primitive.addTransform( self.autoBendChain[0], self.getName("ik1_npo"), t) self.ik1autoRot_lvl = primitive.addTransform( self.ik1_npo, self.getName("ik1autoRot_lvl"), t) self.ik1_ctl = self.addCtl(self.ik1autoRot_lvl, "ik1_ctl", t, self.color_ik, "compas", w=self.size, tp=self.autoBend_ctl) else: t = transform.setMatrixPosition(t, self.guide.apos[1]) self.ik1_npo = primitive.addTransform( self.root, self.getName("ik1_npo"), t) self.ik1_ctl = self.addCtl(self.ik1_npo, "ik1_ctl", t, self.color_ik, "compas", w=self.size, tp=self.ik0_ctl) attribute.setKeyableAttributes(self.ik1_ctl, self.tr_params) attribute.setRotOrder(self.ik1_ctl, "ZXY") attribute.setInvertMirror(self.ik1_ctl, ["tx", "ry", "rz"]) # Tangent controllers ------------------------------- if self.settings["centralTangent"]: vec_pos = vector.linearlyInterpolate(self.guide.apos[0], self.guide.apos[1], .33) t = transform.setMatrixPosition(t, vec_pos) self.tan0_npo = primitive.addTransform( self.ik0_ctl, self.getName("tan0_npo"), t) self.tan0_off = primitive.addTransform( self.tan0_npo, self.getName("tan0_off"), t) self.tan0_ctl = self.addCtl(self.tan0_off, "tan0_ctl", t, self.color_ik, "sphere", w=self.size * .1, tp=self.ik0_ctl) attribute.setKeyableAttributes(self.tan0_ctl, self.t_params) vec_pos = vector.linearlyInterpolate(self.guide.apos[0], self.guide.apos[1], .66) t = transform.setMatrixPosition(t, vec_pos) self.tan1_npo = primitive.addTransform( self.ik1_ctl, self.getName("tan1_npo"), t) self.tan1_off = primitive.addTransform( self.tan1_npo, self.getName("tan1_off"), t) self.tan1_ctl = self.addCtl(self.tan1_off, "tan1_ctl", t, self.color_ik, "sphere", w=self.size * .1, tp=self.ik0_ctl) attribute.setKeyableAttributes(self.tan1_ctl, self.t_params) # Tangent mid control vec_pos = vector.linearlyInterpolate(self.guide.apos[0], self.guide.apos[1], .5) t = transform.setMatrixPosition(t, vec_pos) self.tan_npo = primitive.addTransform( self.tan0_npo, self.getName("tan_npo"), t) self.tan_ctl = self.addCtl(self.tan_npo, "tan_ctl", t, self.color_fk, "sphere", w=self.size * .2, tp=self.ik1_ctl) attribute.setKeyableAttributes(self.tan_ctl, self.t_params) attribute.setInvertMirror(self.tan_ctl, ["tx"]) else: vec_pos = vector.linearlyInterpolate(self.guide.apos[0], self.guide.apos[1], .33) t = transform.setMatrixPosition(t, vec_pos) self.tan0_npo = primitive.addTransform( self.ik0_ctl, self.getName("tan0_npo"), t) self.tan0_ctl = self.addCtl(self.tan0_npo, "tan0_ctl", t, self.color_ik, "sphere", w=self.size * .2, tp=self.ik0_ctl) attribute.setKeyableAttributes(self.tan0_ctl, self.t_params) vec_pos = vector.linearlyInterpolate(self.guide.apos[0], self.guide.apos[1], .66) t = transform.setMatrixPosition(t, vec_pos) self.tan1_npo = primitive.addTransform( self.ik1_ctl, self.getName("tan1_npo"), t) self.tan1_ctl = self.addCtl(self.tan1_npo, "tan1_ctl", t, self.color_ik, "sphere", w=self.size * .2, tp=self.ik1_ctl) attribute.setKeyableAttributes(self.tan1_ctl, self.t_params) attribute.setInvertMirror(self.tan0_ctl, ["tx"]) attribute.setInvertMirror(self.tan1_ctl, ["tx"]) # Curves ------------------------------------------- self.mst_crv = curve.addCnsCurve( self.root, self.getName("mst_crv"), [self.ik0_ctl, self.tan0_ctl, self.tan1_ctl, self.ik1_ctl], 3) self.slv_crv = curve.addCurve(self.root, self.getName("slv_crv"), [datatypes.Vector()] * 10, False, 3) self.mst_crv.setAttr("visibility", False) self.slv_crv.setAttr("visibility", False) # Division ----------------------------------------- # The user only define how many intermediate division he wants. # First and last divisions are an obligation. parentdiv = self.root parentctl = self.root self.div_cns = [] self.fk_ctl = [] self.fk_npo = [] self.scl_transforms = [] self.twister = [] self.ref_twist = [] t = transform.getTransformLookingAt( self.guide.apos[0], self.guide.apos[1], self.guide.blades["blade"].z * -1, "yx", self.negate) parent_twistRef = primitive.addTransform( self.root, self.getName("reference"), transform.getTransform(self.root)) self.jointList = [] self.preiviousCtlTag = self.parentCtlTag for i in range(self.settings["division"]): # References div_cns = primitive.addTransform(parentdiv, self.getName("%s_cns" % i)) pm.setAttr(div_cns + ".inheritsTransform", False) self.div_cns.append(div_cns) parentdiv = div_cns # Controlers (First and last one are fake) # if i in [0]: # TODO: add option setting to add or not the first and # last controller for the fk if i in [0, self.settings["division"] - 1] and False: # if i in [0, self.settings["division"] - 1]: fk_ctl = primitive.addTransform( parentctl, self.getName("%s_loc" % i), transform.getTransform(parentctl)) fk_npo = fk_ctl if i in [self.settings["division"] - 1]: self.fk_ctl.append(fk_ctl) else: fk_npo = primitive.addTransform( parentctl, self.getName("fk%s_npo" % (i)), transform.getTransform(parentctl)) fk_ctl = self.addCtl(fk_npo, "fk%s_ctl" % (i), transform.getTransform(parentctl), self.color_fk, "cube", w=self.size, h=self.size * .05, d=self.size, tp=self.preiviousCtlTag) self.fk_ctl.append(fk_ctl) self.preiviousCtlTag = fk_ctl for x in self.fk_ctl: attribute.setKeyableAttributes(x) attribute.setRotOrder(x, "ZXY") attribute.setInvertMirror(x, ["tx", "rz", "ry"]) self.fk_npo.append(fk_npo) parentctl = fk_ctl scl_ref = primitive.addTransform(parentctl, self.getName("%s_scl_ref" % i), transform.getTransform(parentctl)) self.scl_transforms.append(scl_ref) # Deformers (Shadow) self.jnt_pos.append([scl_ref, i]) # Twist references (This objects will replace the spinlookup # slerp solver behavior) t = transform.getTransformLookingAt( self.guide.apos[0], self.guide.apos[1], self.guide.blades["blade"].z * -1, "yx", self.negate) twister = primitive.addTransform( parent_twistRef, self.getName("%s_rot_ref" % i), t) ref_twist = primitive.addTransform( parent_twistRef, self.getName("%s_pos_ref" % i), t) ref_twist.setTranslation( datatypes.Vector(1.0, 0, 0), space="preTransform") self.twister.append(twister) self.ref_twist.append(ref_twist) # Connections (Hooks) ------------------------------ self.cnx0 = primitive.addTransform(self.root, self.getName("0_cnx")) self.cnx1 = primitive.addTransform(self.root, self.getName("1_cnx"))
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 = primitive.addTransform( self.root, self.getName("matchFk0_npo"), transform.getTransform(self.fk_ctl[1])) self.match_fk0 = primitive.addTransform( self.match_fk0_off, self.getName("fk0_mth"), transform.getTransform(self.fk_ctl[0])) self.match_fk1_off = primitive.addTransform( self.root, self.getName("matchFk1_npo"), transform.getTransform(self.fk_ctl[2])) self.match_fk1 = primitive.addTransform( self.match_fk1_off, self.getName("fk1_mth"), transform.getTransform(self.fk_ctl[1])) self.match_fk2 = primitive.addTransform( self.ik_ctl, self.getName("fk2_mth"), transform.getTransform(self.fk_ctl[2])) self.match_ik = primitive.addTransform( self.fk2_ctl, self.getName("ik_mth"), transform.getTransform(self.ik_ctl)) self.match_ikUpv = primitive.addTransform( self.fk0_ctl, self.getName("upv_mth"), transform.getTransform(self.upv_ctl))
def addObjects(self): self.normal = self.getNormalFromPos(self.guide.apos) self.binormal = self.getBiNormalFromPos(self.guide.apos) self.length0 = vec.getDistance(self.guide.apos[0], self.guide.apos[1]) self.length1 = vec.getDistance(self.guide.apos[1], self.guide.apos[2]) self.length2 = vec.getDistance(self.guide.apos[2], self.guide.apos[3]) # FK Controlers ----------------------------------- # *ms* set npo @ Tpose, to make the fk rotation work best with rot order"yzx" self.fk_cns = pri.addTransformFromPos(self.root, self.getName("fk_cns"), self.guide.apos[0]) tpv = self.guide.apos[0] + ( (self.guide.apos[1] - self.guide.apos[0]) * [1, 0, 0]) t = tra.getTransformLookingAt(self.guide.apos[0], tpv, self.normal, "xz", self.negate) # *ms* add FK isolation self.fk0_npo = pri.addTransform(self.fk_cns, self.getName("fk0_npo"), t) t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, "xz", self.negate) self.fk0_ctl = self.addCtl(self.fk0_npo, "fk0_ctl", t, self.color_fk, "cube", w=self.length0 * .7, h=self.size * .1, d=self.size * .1, po=dt.Vector( .35 * self.length0 * self.n_factor, 0, 0), tp=self.parentCtlTag) att.setKeyableAttributes(self.fk0_ctl) # *ms* add fk roll control Simage style self.fk0_roll_ctl = self.addCtl(self.fk0_ctl, "fk0_roll_ctl", t, self.color_fk, "cube", w=self.length0 * .3, h=self.size * .1, d=self.size * 0.1, po=dt.Vector( .85 * self.length0 * self.n_factor, 0, 0), tp=self.fk0_ctl) att.setRotOrder(self.fk0_roll_ctl, "YZX") att.setKeyableAttributes(self.fk0_roll_ctl, ["rx"]) self.fk0_mtx = pri.addTransform(self.root, self.getName("fk0_mtx"), t) t = tra.setMatrixPosition(t, self.guide.apos[1]) self.fk1_ref = pri.addTransform(self.fk0_roll_ctl, self.getName("fk1_ref"), t) self.fk1_loc = pri.addTransform(self.root, self.getName("fk1_loc"), t) t = tra.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2], self.normal, "xz", self.negate) self.fk1_npo = pri.addTransform(self.fk1_loc, self.getName("fk1_npo"), t) self.fk1_ctl = self.addCtl(self.fk1_npo, "fk1_ctl", t, self.color_fk, "cube", w=self.length1 * .7, h=self.size * .1, d=self.size * .1, po=dt.Vector( .35 * self.length1 * self.n_factor, 0, 0), tp=self.fk0_roll_ctl) att.setKeyableAttributes(self.fk1_ctl) self.fk1_mtx = pri.addTransform(self.fk1_ctl, self.getName("fk1_mtx"), t) self.fk1_roll_ctl = self.addCtl(self.fk1_ctl, "fk1_roll_ctl", t, self.color_fk, "cube", w=self.length1 * .3, h=self.size * .1, d=self.size * .1, po=dt.Vector( .85 * self.length1 * self.n_factor, 0, 0), tp=self.fk1_ctl) att.setRotOrder(self.fk1_roll_ctl, "XYZ") att.setKeyableAttributes(self.fk1_roll_ctl, ["rx"]) t = tra.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3], self.normal, "xz", self.negate) # *ms* buffer object to feed into ikfk solver for hand seperation self.fk2_mtx = pri.addTransform(self.fk1_roll_ctl, self.getName("fk2_mtx"), t) # fk2_loc is need to take the effector position + bone1 rotation t1 = tra.getTransformLookingAt(self.guide.apos[2], self.guide.apos[1], self.normal, "-xz", self.negate) self.fk2_loc = pri.addTransform(self.root, self.getName("fk2_loc"), t1) self.fk2_npo = pri.addTransform(self.fk2_loc, 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=dt.Vector( .5 * self.length2 * self.n_factor, 0, 0), tp=self.fk1_roll_ctl) att.setKeyableAttributes(self.fk2_ctl) self.fk_ctl = [self.fk0_roll_ctl, self.fk1_mtx, self.fk2_ctl] self.fk_ctls = [ self.fk0_ctl, self.fk0_roll_ctl, self.fk1_ctl, self.fk1_roll_ctl, self.fk2_ctl ] for x in self.fk_ctls: att.setInvertMirror(x, ["tx", "ty", "tz"]) # IK Controlers ----------------------------------- self.ik_cns = pri.addTransformFromPos(self.root, self.getName("ik_cns"), self.guide.pos["wrist"]) self.ikcns_ctl = self.addCtl(self.ik_cns, "ikcns_ctl", tra.getTransformFromPos( self.guide.pos["wrist"]), self.color_ik, "null", w=self.size * .12, tp=self.parentCtlTag) att.setInvertMirror(self.ikcns_ctl, ["tx", "ty", "tz"]) if self.negate: m = tra.getTransformLookingAt(self.guide.pos["wrist"], self.guide.pos["eff"], self.normal, "x-y", True) else: m = tra.getTransformLookingAt(self.guide.pos["wrist"], self.guide.pos["eff"], self.normal, "xy", False) self.ik_ctl = self.addCtl(self.ikcns_ctl, "ik_ctl", m, self.color_ik, "cube", w=self.size * .12, h=self.size * .12, d=self.size * .12, tp=self.ikcns_ctl) att.setKeyableAttributes(self.ik_ctl) att.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] # *ms* auto up vector ------------------------------ self.upv_cns = pri.addTransformFromPos(self.root, self.getName("upv_cns"), self.guide.apos[0]) self.upv_auv = pri.addTransformFromPos(self.root, self.getName("upv_auv"), self.guide.apos[0]) self.upv_mtx = pri.addTransformFromPos(self.upv_cns, self.getName("upv_mtx"), self.guide.apos[0]) self.upv_npo = pri.addTransformFromPos(self.upv_mtx, self.getName("upv_npo"), v) self.upv_ctl = self.addCtl(self.upv_npo, "upv_ctl", tra.getTransform(self.upv_npo), self.color_ik, "diamond", w=self.size * .12, tp=self.parentCtlTag) att.setKeyableAttributes(self.upv_ctl, self.t_params) att.setInvertMirror(self.upv_ctl, ["tx"]) # References -------------------------------------- # Calculate again the transfor for the IK ref. This way align with FK trnIK_ref = tra.getTransformLookingAt(self.guide.pos["wrist"], self.guide.pos["eff"], self.normal, "xz", self.negate) self.ik_ref = pri.addTransform(self.ik_ctl, self.getName("ik_ref"), trnIK_ref) self.fk_ref = pri.addTransform(self.fk_ctl[2], self.getName("fk_ref"), trnIK_ref) # Chain -------------------------------------------- # take outputs of the ikfk2bone solver self.bone0 = pri.addLocator(self.root, self.getName("0_bone"), tra.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 = pri.addLocator(self.root, self.getName("1_bone"), tra.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 = pri.addTransformFromPos(self.root, self.getName("ctrn_loc"), self.guide.apos[1]) # eff npo --- take the effector output of gear ik solver self.eff_npo = pri.addTransformFromPos(self.root, self.getName("eff_npo"), self.guide.apos[2]) # eff loc --- take the fk ik blend result self.eff_loc = pri.addTransformFromPos(self.eff_npo, self.getName("eff_loc"), self.guide.apos[2]) # Mid Controler ------------------------------------ self.mid_ctl = self.addCtl(self.ctrn_loc, "mid_ctl", tra.getTransform(self.ctrn_loc), self.color_ik, "sphere", w=self.size * .2, tp=self.parentCtlTag) att.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"]) # *ms* add elbow thickness #Roll join ref self.tws0_npo = pri.addTransform(self.root, self.getName("tws0_npo"), tra.getTransform(self.fk_ctl[0])) self.tws0_loc = pri.addTransform(self.tws0_npo, self.getName("tws0_loc"), tra.getTransform(self.fk_ctl[0])) self.tws0_rot = pri.addTransform(self.tws0_loc, self.getName("tws0_rot"), tra.getTransform(self.fk_ctl[0])) self.tws1_npo = pri.addTransform(self.ctrn_loc, self.getName("tws1_npo"), tra.getTransform(self.ctrn_loc)) self.tws1_loc = pri.addTransform(self.tws1_npo, self.getName("tws1_loc"), tra.getTransform(self.ctrn_loc)) self.tws1_rot = pri.addTransform(self.tws1_loc, self.getName("tws1_rot"), tra.getTransform(self.ctrn_loc)) self.tws2_loc = pri.addTransform(self.tws1_npo, self.getName("tws2_loc"), tra.getTransform(self.ctrn_loc)) self.tws2_rot = pri.addTransform(self.tws2_loc, self.getName("tws2_rot"), tra.getTransform(self.ctrn_loc)) self.tws3_npo = pri.addTransform(self.root, self.getName("tws3_npo"), tra.getTransform(self.fk_ctl[2])) self.tws3_loc = pri.addTransform(self.tws3_npo, self.getName("tws3_loc"), tra.getTransform(self.fk_ctl[2])) self.tws3_rot = pri.addTransform(self.tws3_loc, self.getName("tws3_rot"), tra.getTransform(self.fk_ctl[2])) # Divisions ---------------------------------------- # We have at least one division at the start, the end and one for the elbow. + 2 for elbow angle control # separate up and dn limb self.divisions = self.settings["div0"] + self.settings["div1"] + 3 + 2 self.divisions0 = self.settings["div0"] + 2 self.divisions1 = self.settings["div1"] + 2 self.div_cns = [] self.div_cnsUp = [] self.div_cnsDn = [] self.div_ctls = [] self.div_org = pri.addTransform(self.root, self.getName("div_org"), tra.getTransform(self.root)) self.previousTag = self.parentCtlTag for i in range(self.divisions0): div_cns = pri.addTransform(self.div_org, self.getName("div%s_loc" % i)) if self.negate: div_ctl = self.addCtl(div_cns, self.getName("div%s_ctl" % i), tra.getTransform(div_cns), self.color_fk, "square", d=self.size * .05, w=self.size * .1, po=dt.Vector(0, self.size * -0.05, 0), ro=dt.Vector(0, 0, dt.radians(90)), tp=self.previousTag) else: div_ctl = self.addCtl(div_cns, self.getName("div%s_ctl" % i), tra.getTransform(div_cns), self.color_fk, "square", d=self.size * .05, w=self.size * .1, po=dt.Vector(0, self.size * 0.05, 0), ro=dt.Vector(0, 0, dt.radians(90)), tp=self.previousTag) att.setKeyableAttributes(div_ctl) self.previousTag = div_ctl self.div_cns.append(div_cns) self.div_cnsUp.append(div_cns) self.jnt_pos.append([div_ctl, i]) self.div_ctls.append(div_ctl) # mid division d = self.divisions0 self.div_mid = pri.addTransform(self.div_org, self.getName("div%s_loc" % d), tra.getTransform(self.mid_ctl)) if self.negate: self.div_mid_ctl = self.addCtl(self.div_mid, self.getName("div%s_ctl" % d), tra.getTransform(self.div_mid), self.color_fk, "square", d=self.size * .05, w=self.size * .1, po=dt.Vector( 0, self.size * -0.05, 0), ro=dt.Vector(0, 0, dt.radians(90)), tp=self.previousTag) else: self.div_mid_ctl = self.addCtl(self.div_mid, self.getName("div%s_ctl" % d), tra.getTransform(self.div_mid), self.color_fk, "square", d=self.size * .05, w=self.size * .1, po=dt.Vector( 0, self.size * 0.05, 0), ro=dt.Vector(0, 0, dt.radians(90)), tp=self.previousTag) att.setKeyableAttributes(self.div_mid_ctl) self.previousTag = div_ctl self.div_cns.append(self.div_mid) self.jnt_pos.append([self.div_mid_ctl, self.divisions0]) self.div_ctls.append(self.div_mid_ctl) # down division for i in range(self.divisions1): dd = i + self.divisions1 + 1 div_cns = pri.addTransform(self.div_org, self.getName("div%s_loc" % dd)) if self.negate: div_ctl = self.addCtl(div_cns, self.getName("div%s_ctl" % dd), tra.getTransform(div_cns), self.color_fk, "square", d=self.size * .05, w=self.size * .1, po=dt.Vector(0, self.size * -0.05, 0), ro=dt.Vector(0, 0, dt.radians(90)), tp=self.previousTag) else: div_ctl = self.addCtl(div_cns, self.getName("div%s_ctl" % dd), tra.getTransform(div_cns), self.color_fk, "square", d=self.size * .05, w=self.size * .1, po=dt.Vector(0, self.size * 0.05, 0), ro=dt.Vector(0, 0, dt.radians(90)), tp=self.previousTag) att.setKeyableAttributes(div_ctl) self.previousTag = div_ctl self.div_cns.append(div_cns) self.div_cnsDn.append(div_cns) self.jnt_pos.append([div_ctl, i + self.divisions0 + 1]) self.div_ctls.append(div_ctl) # End reference ------------------------------------ # To help the deformation on the wrist self.jnt_pos.append([self.eff_loc, 'end']) #match IK FK references self.match_fk0 = pri.addTransform(self.root, self.getName("fk0_mth"), tra.getTransform(self.fk_ctl[0])) self.match_fk1 = pri.addTransform(self.root, self.getName("fk1_mth"), tra.getTransform(self.fk_ctl[1])) self.match_fk2 = pri.addTransform(self.ik_ctl, self.getName("fk2_mth"), tra.getTransform(self.fk_ctl[2])) self.match_ik = pri.addTransform(self.fk2_ctl, self.getName("ik_mth"), tra.getTransform(self.ik_ctl)) self.match_ikUpv = pri.addTransform(self.fk0_roll_ctl, self.getName("upv_mth"), tra.getTransform(self.upv_ctl))
def addObjects(self): """Add all the objects needed to create the component.""" self.normal = self.guide.blades["blade"].z * -1 # Ik Controlers ------------------------------------ t = transform.getTransformLookingAt(self.guide.pos["tan1"], self.guide.pos["neck"], self.normal, "yx", self.negate) t = transform.setMatrixPosition(t, self.guide.pos["neck"]) self.ik_cns = primitive.addTransform(self.root, self.getName("ik_cns"), t) self.ik_ctl = self.addCtl(self.ik_cns, "ik_ctl", t, self.color_ik, "compas", w=self.size * .5, tp=self.parentCtlTag) attribute.setKeyableAttributes(self.ik_ctl, self.tr_params) attribute.setRotOrder(self.ik_ctl, "ZXY") attribute.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"]) # Tangents ----------------------------------------- if self.settings["tangentControls"]: t = transform.setMatrixPosition(t, self.guide.pos["tan1"]) self.tan1_loc = primitive.addTransform(self.ik_ctl, self.getName("tan1_loc"), t) self.tan1_ctl = self.addCtl(self.tan1_loc, "tan1_ctl", t, self.color_ik, "sphere", w=self.size * .2, tp=self.ik_ctl) attribute.setKeyableAttributes(self.tan1_ctl, self.t_params) attribute.setInvertMirror(self.tan1_ctl, ["tx"]) t = transform.getTransformLookingAt(self.guide.pos["root"], self.guide.pos["tan0"], self.normal, "yx", self.negate) t = transform.setMatrixPosition(t, self.guide.pos["tan0"]) self.tan0_loc = primitive.addTransform(self.root, self.getName("tan0_loc"), t) self.tan0_ctl = self.addCtl(self.tan0_loc, "tan0_ctl", t, self.color_ik, "sphere", w=self.size * .2, tp=self.ik_ctl) attribute.setKeyableAttributes(self.tan0_ctl, self.t_params) attribute.setInvertMirror(self.tan0_ctl, ["tx"]) # Curves ------------------------------------------- self.mst_crv = curve.addCnsCurve( self.root, self.getName("mst_crv"), [self.root, self.tan0_ctl, self.tan1_ctl, self.ik_ctl], 3) self.slv_crv = curve.addCurve(self.root, self.getName("slv_crv"), [datatypes.Vector()] * 10, False, 3) self.mst_crv.setAttr("visibility", False) else: t = transform.setMatrixPosition(t, self.guide.pos["tan1"]) self.tan1_loc = primitive.addTransform(self.ik_ctl, self.getName("tan1_loc"), t) t = transform.getTransformLookingAt(self.guide.pos["root"], self.guide.pos["tan0"], self.normal, "yx", self.negate) t = transform.setMatrixPosition(t, self.guide.pos["tan0"]) self.tan0_loc = primitive.addTransform(self.root, self.getName("tan0_loc"), t) # Curves ------------------------------------------- self.mst_crv = curve.addCnsCurve( self.root, self.getName("mst_crv"), [self.root, self.tan0_loc, self.tan1_loc, self.ik_ctl], 3) self.slv_crv = curve.addCurve(self.root, self.getName("slv_crv"), [datatypes.Vector()] * 10, False, 3) self.mst_crv.setAttr("visibility", False) self.slv_crv.setAttr("visibility", False) # Division ----------------------------------------- # The user only define how many intermediate division he wants. # First and last divisions are an obligation. parentdiv = self.root parentctl = self.root self.div_cns = [] self.fk_ctl = [] self.fk_npo = [] self.scl_npo = [] self.twister = [] self.ref_twist = [] parent_twistRef = primitive.addTransform( self.root, self.getName("reference"), transform.getTransform(self.root)) t = transform.getTransformLookingAt(self.guide.pos["root"], self.guide.pos["neck"], self.normal, "yx", self.negate) self.intMRef = primitive.addTransform(self.root, self.getName("intMRef"), t) self.previousCtlTag = self.parentCtlTag for i in range(self.settings["division"]): # References div_cns = primitive.addTransform(parentdiv, self.getName("%s_cns" % i), t) pm.setAttr(div_cns + ".inheritsTransform", False) self.div_cns.append(div_cns) parentdiv = div_cns scl_npo = primitive.addTransform(parentctl, self.getName("%s_scl_npo" % i), transform.getTransform(parentctl)) # Controlers (First and last one are fake) if i in [self.settings["division"] - 1]: # 0, fk_ctl = primitive.addTransform( scl_npo, self.getName("%s_loc" % i), transform.getTransform(parentctl)) fk_npo = fk_ctl else: fk_npo = primitive.addTransform( scl_npo, self.getName("fk%s_npo" % i), transform.getTransform(parentctl)) fk_ctl = self.addCtl(fk_npo, "fk%s_ctl" % i, transform.getTransform(parentctl), self.color_fk, "cube", w=self.size * .2, h=self.size * .05, d=self.size * .2, tp=self.previousCtlTag) attribute.setKeyableAttributes(self.fk_ctl) attribute.setRotOrder(fk_ctl, "ZXY") self.previousCtlTag = fk_ctl self.fk_ctl.append(fk_ctl) self.scl_npo.append(scl_npo) self.fk_npo.append(fk_npo) parentctl = fk_ctl self.jnt_pos.append([fk_ctl, i]) t = transform.getTransformLookingAt( self.guide.pos["root"], self.guide.pos["neck"], self.guide.blades["blade"].z * -1, "yx", self.negate) twister = primitive.addTransform(parent_twistRef, self.getName("%s_rot_ref" % i), t) ref_twist = primitive.addTransform(parent_twistRef, self.getName("%s_pos_ref" % i), t) ref_twist.setTranslation(datatypes.Vector(0.0, 0, 1.0), space="preTransform") self.twister.append(twister) self.ref_twist.append(ref_twist) for x in self.fk_ctl[:-1]: attribute.setInvertMirror(x, ["tx", "rz", "ry"]) # Head --------------------------------------------- t = transform.getTransformLookingAt(self.guide.pos["head"], self.guide.pos["eff"], self.normal, "yx", self.negate) self.head_cns = primitive.addTransform(self.root, self.getName("head_cns"), t) dist = vector.getDistance(self.guide.pos["head"], self.guide.pos["eff"]) self.head_ctl = self.addCtl(self.head_cns, "head_ctl", t, self.color_fk, "cube", w=self.size * .5, h=dist, d=self.size * .5, po=datatypes.Vector(0, dist * .5, 0), tp=self.previousCtlTag) attribute.setRotOrder(self.head_ctl, "ZXY") attribute.setInvertMirror(self.head_ctl, ["tx", "rz", "ry"]) self.jnt_pos.append([self.head_ctl, "head"])
def addObjects(self): self.WIP = self.options["mode"] self.normal = self.getNormalFromPos(self.guide.apos) self.binormal = self.getBiNormalFromPos(self.guide.apos) self.length0 = vec.getDistance(self.guide.apos[0], self.guide.apos[1]) self.length1 = vec.getDistance(self.guide.apos[1], self.guide.apos[2]) self.length2 = vec.getDistance(self.guide.apos[2], self.guide.apos[3]) # 1 bone chain for upv ref self.armChainUpvRef= pri.add2DChain(self.root, self.getName("armUpvRef%s_jnt"), [self.guide.apos[0],self.guide.apos[2]], self.normal, False, self.WIP) self.armChainUpvRef[1].setAttr("jointOrientZ", self.armChainUpvRef[1].getAttr("jointOrientZ")*-1) # FK Controlers ----------------------------------- t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, "xz", self.negate) self.fk0_npo = pri.addTransform(self.root, 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=dt.Vector(.5*self.length0*self.n_factor,0,0), tp=self.parentCtlTag) att.setKeyableAttributes(self.fk0_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) t = tra.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2], self.normal, "xz", self.negate) self.fk1_npo = pri.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=dt.Vector(.5*self.length1*self.n_factor,0,0), tp=self.fk0_ctl) att.setKeyableAttributes(self.fk1_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) t = tra.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3], self.normal, "xz", self.negate) self.fk2_npo = pri.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=dt.Vector(.5*self.length2*self.n_factor,0,0), tp=self.fk1_ctl) att.setKeyableAttributes(self.fk2_ctl) self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl] for x in self.fk_ctl: att.setInvertMirror(x, ["tx", "ty", "tz"]) # IK Controlers ----------------------------------- self.ik_cns = pri.addTransformFromPos(self.root, self.getName("ik_cns"), self.guide.pos["wrist"]) self.ikcns_ctl = self.addCtl(self.ik_cns, "ikcns_ctl", tra.getTransformFromPos(self.guide.pos["wrist"]), self.color_ik, "null", w=self.size*.12, tp=self.parentCtlTag) att.setInvertMirror(self.ikcns_ctl, ["tx", "ty", "tz"]) if self.negate: m = tra.getTransformLookingAt(self.guide.pos["wrist"], self.guide.pos["eff"], self.normal, "x-y", True) else: m = tra.getTransformLookingAt(self.guide.pos["wrist"], self.guide.pos["eff"], self.normal, "xy", False) self.ik_ctl = self.addCtl(self.ikcns_ctl, "ik_ctl", m, self.color_ik, "cube", w=self.size*.12, h=self.size*.12, d=self.size*.12, tp=self.ikcns_ctl) if self.settings["mirrorIK"]: if self.negate: self.ik_cns.sx.set(-1) self.ik_ctl.rz.set(self.ik_ctl.rz.get()*-1) else: att.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"]) att.setKeyableAttributes(self.ik_ctl) self.ik_ctl_ref = pri.addTransform(self.ik_ctl, self.getName("ikCtl_ref"), m) # 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 = pri.addTransformFromPos(self.root, self.getName("upv_cns"), v) self.upv_ctl = self.addCtl(self.upv_cns, "upv_ctl", tra.getTransform(self.upv_cns), self.color_ik, "diamond", w=self.size*.12, tp=self.parentCtlTag) if self.settings["mirrorMid"]: if self.negate: self.upv_cns.rz.set(180) self.upv_cns.sy.set(-1) else: att.setInvertMirror(self.upv_ctl, ["tx"]) att.setKeyableAttributes(self.upv_ctl, self.t_params) #IK rotation controls if self.settings["ikTR"]: self.ikRot_npo = pri.addTransform(self.root, self.getName("ikRot_npo"), m) self.ikRot_cns = pri.addTransform(self.ikRot_npo, self.getName("ikRot_cns"), m) self.ikRot_ctl = self.addCtl(self.ikRot_cns, "ikRot_ctl", m, self.color_ik, "sphere", w=self.size*.12, tp=self.ik_ctl) att.setKeyableAttributes(self.ikRot_ctl, self.r_params) # References -------------------------------------- # Calculate again the transfor for the IK ref. This way align with FK trnIK_ref = tra.getTransformLookingAt(self.guide.pos["wrist"], self.guide.pos["eff"], self.normal, "xz", self.negate) self.ik_ref = pri.addTransform(self.ik_ctl_ref, self.getName("ik_ref"), trnIK_ref) self.fk_ref = pri.addTransform(self.fk_ctl[2], self.getName("fk_ref"), trnIK_ref) # Chain -------------------------------------------- # The outputs of the ikfk2bone solver self.bone0 = pri.addLocator(self.root, self.getName("0_bone"), tra.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) bShape = self.bone0.getShape() bShape.setAttr("visibility", False) self.bone1 = pri.addLocator(self.root, self.getName("1_bone"), tra.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) bShape = self.bone1.getShape() bShape.setAttr("visibility", False) #Elbow control tA = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, "xz", self.negate) tA = tra.setMatrixPosition(tA, self.guide.apos[1]) tB = tra.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2], self.normal, "xz", self.negate) t = tra.getInterpolateTransformMatrix(tA, tB) self.ctrn_loc = pri.addTransform(self.root, self.getName("ctrn_loc"), t) #match IK FK references self.match_fk0_off = pri.addTransform(self.root, self.getName("matchFk0_npo"), tra.getTransform(self.fk_ctl[1])) self.match_fk0 = pri.addTransform(self.match_fk0_off, self.getName("fk0_mth"), tra.getTransform(self.fk_ctl[0])) self.match_fk1_off = pri.addTransform(self.root, self.getName("matchFk1_npo"), tra.getTransform(self.fk_ctl[2])) self.match_fk1 = pri.addTransform(self.match_fk1_off, self.getName("fk1_mth"), tra.getTransform(self.fk_ctl[1])) self.match_fk2 = pri.addTransform(self.ik_ctl, self.getName("fk2_mth"), tra.getTransform(self.fk_ctl[2])) self.match_ik = pri.addTransform(self.fk2_ctl, self.getName("ik_mth"), tra.getTransform(self.ik_ctl)) self.match_ikUpv = pri.addTransform(self.fk0_ctl, self.getName("upv_mth"), tra.getTransform(self.upv_ctl)) # Eff locator self.eff_loc = pri.addTransformFromPos(self.root, self.getName("eff_loc"), self.guide.apos[2]) # Mid Controler ------------------------------------ t = tra.getTransform(self.ctrn_loc) self.mid_cns = pri.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.parentCtlTag) if self.settings["mirrorMid"]: if self.negate: self.mid_cns.rz.set(180) self.mid_cns.sz.set(-1) else: att.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"]) att.setKeyableAttributes(self.mid_ctl, self.t_params) #Roll join ref--------------------------------- self.tws0_loc = pri.addTransform(self.root, self.getName("tws0_loc"), tra.getTransform(self.fk_ctl[0])) self.tws1_npo = pri.addTransform(self.ctrn_loc, self.getName("tws1_npo"), tra.getTransform(self.ctrn_loc)) self.tws1_loc = pri.addTransform(self.tws1_npo, self.getName("tws1_loc"), tra.getTransform(self.ctrn_loc)) self.tws1A_npo = pri.addTransform(self.mid_ctl, self.getName("tws1A_npo"), tA) self.tws1A_loc = pri.addTransform(self.tws1A_npo, self.getName("tws1A_loc"), tA) self.tws1B_npo = pri.addTransform(self.mid_ctl, self.getName("tws1B_npo"), tB) self.tws1B_loc = pri.addTransform(self.tws1B_npo, self.getName("tws1B_loc"), tB) self.tws2_npo = pri.addTransform(self.root, self.getName("tws2_npo"), tra.getTransform(self.fk_ctl[2])) self.tws2_loc = pri.addTransform(self.tws2_npo, self.getName("tws2_loc"), tra.getTransform(self.fk_ctl[2])) # Roll twist chain --------------------------------- #Arm self.armChainPos = [] ii = 1.0/(self.settings["div0"]+1) i = 0.0 for p in range(self.settings["div0"]+2): self.armChainPos.append(vec.linearlyInterpolate(self.guide.pos["root"], self.guide.pos["elbow"], blend=i)) i=i+ii self.armTwistChain= pri.add2DChain(self.root, self.getName("armTwist%s_jnt"), self.armChainPos, self.normal, False, self.WIP) #Forearm self.forearmChainPos = [] ii = 1.0/(self.settings["div1"]+1) i = 0.0 for p in range(self.settings["div1"]+2): self.forearmChainPos.append(vec.linearlyInterpolate(self.guide.pos["elbow"], self.guide.pos["wrist"], blend=i)) i=i+ii self.forearmTwistChain= pri.add2DChain(self.root, self.getName("forearmTwist%s_jnt"), self.forearmChainPos, self.normal, False, self.WIP) pm.parent(self.forearmTwistChain[0], self.mid_ctl) #Hand Aux chain and nonroll self.auxChainPos = [] ii = .5 i = 0.0 for p in range(3): self.auxChainPos.append(vec.linearlyInterpolate(self.guide.pos["wrist"], self.guide.pos["eff"], blend=i)) i=i+ii t = self.root.getMatrix(worldSpace=True) self.aux_npo = pri.addTransform(self.root, self.getName("aux_npo"), t) self.auxTwistChain = pri.add2DChain(self.aux_npo, self.getName("auxTwist%s_jnt"), self.auxChainPos, self.normal, False, self.WIP) #Non Roll join ref --------------------------------- self.armRollRef = pri.add2DChain(self.root, self.getName("armRollRef%s_jnt"), self.armChainPos[:2], self.normal, False, self.WIP) self.forearmRollRef = pri.add2DChain(self.aux_npo, self.getName("forearmRollRef%s_jnt"), self.auxChainPos[: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 elbow angle control self.divisions = self.settings["div0"] + self.settings["div1"] + 4 self.div_cns = [] for i in range(self.divisions): div_cns = pri.addTransform(self.root, 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 wrist self.end_ref = pri.addTransform(self.eff_loc, self.getName("end_ref"), tra.getTransform(self.eff_loc)) if self.negate: self.end_ref.attr("rz").set(180.0) if self.settings["ikTR"]: reference = self.ikRot_ctl self.match_ikRot = pri.addTransform(self.fk2_ctl, self.getName("ikRot_mth"), tra.getTransform(self.ikRot_ctl)) else: reference = self.ik_ctl self.jnt_pos.append([self.end_ref, "end"]) # Tangent controls t = tra.getInterpolateTransformMatrix(self.fk_ctl[0], self.tws1A_npo, .5) self.armTangentA_loc = pri.addTransform(self.root, self.getName("armTangentA_loc"), self.fk_ctl[0].getMatrix(worldSpace=True)) self.armTangentA_npo = pri.addTransform(self.armTangentA_loc, self.getName("armTangentA_npo"), t) self.armTangentA_ctl = self.addCtl(self.armTangentA_npo, "armTangentA_ctl", t, self.color_ik, "circle", w=self.size*.2, ro=dt.Vector(0,0,1.570796), tp=self.mid_ctl) if self.negate: self.armTangentA_npo.rz.set(180) self.armTangentA_npo.sz.set(-1) att.setKeyableAttributes(self.armTangentA_ctl, self.t_params) t = tra.getInterpolateTransformMatrix(self.fk_ctl[0], self.tws1A_npo, .9) self.armTangentB_npo = pri.addTransform(self.tws1A_loc, self.getName("armTangentB_npo"), t) self.armTangentB_ctl = self.addCtl(self.armTangentB_npo, "armTangentB_ctl", t, self.color_ik, "circle", w=self.size*.1, ro=dt.Vector(0,0,1.570796), tp=self.mid_ctl) if self.negate: self.armTangentB_npo.rz.set(180) self.armTangentB_npo.sz.set(-1) att.setKeyableAttributes(self.armTangentB_ctl, self.t_params) tC = self.tws1B_npo.getMatrix(worldSpace=True) tC = tra.setMatrixPosition(tC, self.guide.apos[2]) t = tra.getInterpolateTransformMatrix(self.tws1B_npo, tC, .1) self.forearmTangentA_npo = pri.addTransform(self.tws1B_loc, self.getName("forearmTangentA_npo"), t) self.forearmTangentA_ctl = self.addCtl(self.forearmTangentA_npo, "forearmTangentA_ctl", t, self.color_ik, "circle", w=self.size*.1, ro=dt.Vector(0,0,1.570796), tp=self.mid_ctl) if self.negate: self.forearmTangentA_npo.rz.set(180) self.forearmTangentA_npo.sz.set(-1) att.setKeyableAttributes(self.forearmTangentA_ctl, self.t_params) t = tra.getInterpolateTransformMatrix(self.tws1B_npo, tC, .5) self.forearmTangentB_loc = pri.addTransform(self.root, self.getName("forearmTangentB_loc"), tC) self.forearmTangentB_npo = pri.addTransform(self.forearmTangentB_loc, self.getName("forearmTangentB_npo"), t) self.forearmTangentB_ctl = self.addCtl(self.forearmTangentB_npo, "forearmTangentB_ctl", t, self.color_ik, "circle", w=self.size*.2, ro=dt.Vector(0,0,1.570796), tp=self.mid_ctl) if self.negate: self.forearmTangentB_npo.rz.set(180) self.forearmTangentB_npo.sz.set(-1) att.setKeyableAttributes(self.forearmTangentB_ctl, self.t_params) t = self.mid_ctl.getMatrix(worldSpace=True) self.elbowTangent_npo = pri.addTransform(self.mid_ctl, self.getName("elbowTangent_npo"), t) self.elbowTangent_ctl = self.addCtl(self.elbowTangent_npo, "elbowTangent_ctl", t, self.color_fk, "circle", w=self.size*.15, ro=dt.Vector(0,0,1.570796), tp=self.mid_ctl) if self.negate: self.elbowTangent_npo.rz.set(180) self.elbowTangent_npo.sz.set(-1) att.setKeyableAttributes(self.elbowTangent_ctl, self.t_params)
def addObjects(self): """Add all the objects needed to create the component.""" self.normal = self.guide.blades["blade"].z * -1 self.binormal = self.guide.blades["blade"].x self.WIP = self.options["mode"] if self.negate and self.settings["overrideNegate"]: self.negate = False self.n_factor = 1 if self.settings["overrideNegate"]: self.mirror_conf = [0, 0, 1, 1, 1, 0, 0, 0, 0] else: self.mirror_conf = [0, 0, 0, 0, 0, 0, 0, 0, 0] # FK controllers ------------------------------------ self.fk_npo = [] self.fk_ctl = [] t = self.guide.tra["root"] parent = self.root tOld = False fk_ctl = None self.previusTag = self.parentCtlTag for i, t in enumerate(transform.getChainTransform(self.guide.apos, self.normal, self.negate)): dist = vector.getDistance(self.guide.apos[i], self.guide.apos[i + 1]) if self.settings["neutralpose"] or not tOld: tnpo = t else: tnpo = transform.setMatrixPosition( tOld, transform.getPositionFromMatrix(t)) fk_npo = primitive.addTransform( parent, self.getName("fk%s_npo" % i), tnpo) fk_ctl = self.addCtl( fk_npo, "fk%s_ctl" % i, t, self.color_fk, "cube", w=dist, h=self.size * .1, d=self.size * .1, po=datatypes.Vector(dist * .5 * self.n_factor, 0, 0), tp=self.previusTag, mirrorConf=self.mirror_conf) self.fk_npo.append(fk_npo) self.fk_ctl.append(fk_ctl) tOld = t self.previusTag = fk_ctl parent = fk_ctl self.jnt_pos.append([fk_ctl, i, None, False])
def addObjects(self): """Add all the objects needed to create the component.""" self.setup = primitive.addTransformFromPos(self.setupWS, self.getName("WS")) attribute.lockAttribute(self.setup) 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]) self.length3 = vector.getDistance(self.guide.apos[3], self.guide.apos[4]) # 3bones chain self.chain3bones = primitive.add2DChain( self.setup, self.getName("chain3bones%s_jnt"), self.guide.apos[0:4], self.normal, False, self.WIP) # 2bones chain self.chain2bones = primitive.add2DChain( self.setup, self.getName("chain2bones%s_jnt"), self.guide.apos[0:3], self.normal, False, self.WIP) # Leg chain self.legBones = primitive.add2DChain(self.root, self.getName("legBones%s_jnt"), self.guide.apos[0:4], self.normal, False, self.WIP) # Leg chain FK ref self.legBonesFK = primitive.add2DChain(self.root, self.getName("legFK%s_jnt"), self.guide.apos[0:4], self.normal, False, self.WIP) # Leg chain IK ref self.legBonesIK = primitive.add2DChain(self.root, self.getName("legIK%s_jnt"), self.guide.apos[0:4], self.normal, False, self.WIP) # 1 bone chain for upv ref self.legChainUpvRef = primitive.add2DChain( self.root, self.getName("legUpvRef%s_jnt"), [self.guide.apos[0], self.guide.apos[3]], self.normal, False, self.WIP) # mid joints self.mid1_jnt = primitive.addJoint( self.legBones[0], self.getName("mid1_jnt"), self.legBones[1].getMatrix(worldSpace=True), self.WIP) self.mid1_jnt.attr("radius").set(3) self.mid1_jnt.setAttr("jointOrient", 0, 0, 0) self.mid2_jnt = primitive.addJoint( self.legBones[1], self.getName("mid2_jnt"), self.legBones[2].getMatrix(worldSpace=True), self.WIP) self.mid2_jnt.attr("radius").set(3) self.mid2_jnt.setAttr("jointOrient", 0, 0, 0) # base Controlers ----------------------------------- 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) attribute.lockAttribute(self.root_ctl, ["sx", "sy", "sz", "v"]) # 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) 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) 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) t = transform.getTransformLookingAt(self.guide.apos[3], self.guide.apos[4], self.normal, "xz", self.negate) self.fk3_npo = primitive.addTransform(self.fk2_ctl, self.getName("fk3_npo"), t) self.fk3_ctl = self.addCtl(self.fk3_npo, "fk3_ctl", t, self.color_fk, "cube", w=self.length3, h=self.size * .1, d=self.size * .1, po=datatypes.Vector( .5 * self.length3 * self.n_factor, 0, 0), tp=self.fk2_ctl) attribute.setKeyableAttributes(self.fk3_ctl) self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl, self.fk3_ctl] for x in self.fk_ctl: attribute.setInvertMirror(x, ["tx", "ty", "tz"]) # Mid Controlers ------------------------------------ self.knee_lvl = primitive.addTransform( self.root, self.getName("knee_lvl"), transform.getTransform(self.mid1_jnt)) self.knee_ctl = self.addCtl(self.knee_lvl, "knee_ctl", transform.getTransform(self.mid1_jnt), self.color_ik, "sphere", w=self.size * .2, tp=self.root_ctl) attribute.setInvertMirror(self.knee_ctl, ["tx", "ty", "tz"]) attribute.lockAttribute(self.knee_ctl, ["sx", "sy", "sz", "v"]) self.ankle_lvl = primitive.addTransform( self.root, self.getName("ankle_lvl"), transform.getTransform(self.mid2_jnt)) self.ankle_ctl = self.addCtl(self.ankle_lvl, "ankle_ctl", transform.getTransform(self.mid2_jnt), self.color_ik, "sphere", w=self.size * .2, tp=self.knee_ctl) attribute.setInvertMirror(self.ankle_ctl, ["tx", "ty", "tz"]) attribute.lockAttribute(self.ankle_ctl, ["sx", "sy", "sz", "v"]) # IK controls -------------------------------------------------------- # foot IK if self.settings["ikOri"]: t = transform.getTransformLookingAt(self.guide.pos["foot"], self.guide.pos["eff"], self.x_axis, "zx", False) else: t = transform.getTransformLookingAt(self.guide.apos[3], self.guide.apos[4], self.normal, "z-x", False) self.ik_cns = primitive.addTransform(self.root_ctl, self.getName("ik_cns"), t) self.ikcns_ctl = self.addCtl(self.ik_cns, "ikcns_ctl", t, self.color_ik, "null", w=self.size * .12, tp=self.ankle_ctl) attribute.setInvertMirror(self.ikcns_ctl, ["tx"]) attribute.lockAttribute(self.ikcns_ctl, ["sx", "sy", "sz", "v"]) self.ik_ctl = self.addCtl(self.ikcns_ctl, "ik_ctl", t, 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"]) attribute.lockAttribute(self.ik_ctl, ["sx", "sy", "sz", "v"]) # 2 bones ik layer self.ik2b_ikCtl_ref = primitive.addTransform( self.ik_ctl, self.getName("ik2B_A_ref"), t) self.ik2b_bone_ref = primitive.addTransform(self.chain3bones[3], self.getName("ik2B_B_ref"), t) self.ik2b_blend = primitive.addTransform(self.ik_ctl, self.getName("ik2B_blend"), t) self.roll_ctl = self.addCtl(self.ik2b_blend, "roll_ctl", t, self.color_ik, "crossarrow", w=self.length2 * .5 * self.n_factor, tp=self.ik_ctl) self.ik2b_ik_npo = primitive.addTransform( self.roll_ctl, self.getName("ik2B_ik_npo"), transform.getTransform(self.chain3bones[-1])) self.ik2b_ik_ref = primitive.addTransformFromPos( self.ik2b_ik_npo, self.getName("ik2B_ik_ref"), self.guide.pos["ankle"]) attribute.lockAttribute(self.roll_ctl, ["tx", "ty", "tz", "sx", "sy", "sz", "v"]) # 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_lvl = primitive.addTransformFromPos(self.root, self.getName("upv_lvl"), v) self.upv_cns = primitive.addTransformFromPos(self.upv_lvl, 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.ik_ctl) attribute.setInvertMirror(self.upv_ctl, ["tx"]) attribute.setKeyableAttributes(self.upv_ctl, ["tx", "ty", "tz"]) # Soft IK objects 3 bones chain -------------------------------- t = transform.getTransformLookingAt(self.guide.pos["root"], self.guide.pos["foot"], self.x_axis, "zx", False) self.aim_tra = primitive.addTransform(self.root_ctl, self.getName("aimSoftIK"), t) t = transform.getTransformFromPos(self.guide.pos["foot"]) self.wristSoftIK = primitive.addTransform(self.aim_tra, self.getName("wristSoftIK"), t) self.softblendLoc = primitive.addTransform( self.root, self.getName("softblendLoc"), t) # Soft IK objects 2 Bones chain ---------------------------- t = transform.getTransformLookingAt(self.guide.pos["root"], self.guide.pos["ankle"], self.x_axis, "zx", False) self.aim_tra2 = primitive.addTransform(self.root_ctl, self.getName("aimSoftIK2"), t) t = transform.getTransformFromPos(self.guide.pos["ankle"]) self.ankleSoftIK = primitive.addTransform(self.aim_tra2, self.getName("ankleSoftIK"), t) self.softblendLoc2 = primitive.addTransform( self.root, self.getName("softblendLoc2"), t) # 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[3], self.getName("fk_ref"), transform.getTransform(self.ik_ctl)) # twist references -------------------------------------- self.rollRef = primitive.add2DChain(self.root, self.getName("rollChain"), self.guide.apos[:2], self.normal, False, self.WIP) self.tws0_loc = primitive.addTransform( self.rollRef[0], self.getName("tws0_loc"), transform.getTransform(self.legBones[0])) self.tws0_rot = primitive.addTransform( self.tws0_loc, self.getName("tws0_rot"), transform.getTransform(self.legBones[0])) self.tws0_rot.setAttr("sx", .001) self.tws1_loc = primitive.addTransform( self.mid1_jnt, self.getName("tws1_loc"), transform.getTransform(self.mid1_jnt)) self.tws1_rot = primitive.addTransform( self.tws1_loc, self.getName("tws1_rot"), transform.getTransform(self.mid1_jnt)) self.tws1_rot.setAttr("sx", .001) self.tws2_loc = primitive.addTransform( self.mid2_jnt, self.getName("tws2_loc"), transform.getTransform(self.mid2_jnt)) self.tws2_rot = primitive.addTransform( self.tws2_loc, self.getName("tws2_rot"), transform.getTransform(self.mid2_jnt)) self.tws2_rot.setAttr("sx", .001) self.tws3_loc = primitive.addTransform( self.legBones[3], self.getName("tws3_loc"), transform.getTransform(self.legBones[3])) self.tws3_rot = primitive.addTransform( self.tws3_loc, self.getName("tws3_rot"), transform.getTransform(self.legBones[3])) self.tws3_rot.setAttr("sx", .001) # Divisions ---------------------------------------- # We have at least one division at the start, the end and one for # the knee and one ankle o_set = self.settings self.divisions = o_set["div0"] + o_set["div1"] + o_set["div2"] + 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 foot self.end_ref = primitive.addTransform( self.tws3_rot, self.getName("end_ref"), transform.getTransform(self.legBones[3])) self.jnt_pos.append([self.end_ref, 'end']) # add visual reference self.line_ref = icon.connection_display_curve( self.getName("visalRef"), [self.upv_ctl, self.knee_ctl])
def addObjects(self): """Add all the objects needed to create the component.""" ctlSize = vector.getDistance(self.guide.apos[0], self.guide.apos[1]) / 3.0 t_root = self.guide.tra["root"] t_root = transform.setMatrixScale(t_root) self.ik_cns = primitive.addTransform(self.root, self.getName("ik_cns"), t_root) t = transform.setMatrixPosition(t_root, self.guide.pos["top"]) self.top_npo = primitive.addTransform(self.ik_cns, self.getName("top_npo"), t) self.top_ctl = self.addCtl(self.top_npo, "top_ctl", t, self.color_ik, "arrow", w=ctlSize, ro=datatypes.Vector(1.5708, 1.5708, 0), tp=self.parentCtlTag) attribute.setKeyableAttributes(self.top_ctl, ["ty"]) t = transform.setMatrixPosition(t_root, self.guide.pos["bottom"]) self.bottom_npo = primitive.addTransform(self.top_npo, self.getName("bottom_npo"), t) self.bottom_npo.rz.set(180) self.bottom_ctl = self.addCtl(self.bottom_npo, "bottom_ctl", t, self.color_ik, "arrow", w=ctlSize, ro=datatypes.Vector(1.5708, 1.5708, 0), tp=self.parentCtlTag) self.bottom_ctl.rz.set(0) attribute.setKeyableAttributes(self.bottom_ctl, ["ty"]) self.bottom_pivot = primitive.addTransform( self.bottom_npo, self.getName("bottom_pivot"), transform.getTransform(self.top_ctl)) t = transform.setMatrixPosition(t_root, self.guide.pos["ext"]) self.ext_npo = primitive.addTransform(self.bottom_pivot, self.getName("ext_npo"), t) self.ext_npo.rz.set(-90) self.ext_ctl = self.addCtl(self.ext_npo, "ext_ctl", t, self.color_ik, "arrow", w=ctlSize, ro=datatypes.Vector(1.5708, 1.5708, 0), tp=self.parentCtlTag) self.ext_ctl.rz.set(0) attribute.setKeyableAttributes(self.ext_ctl, ["ty"]) t = transform.setMatrixPosition(t_root, self.guide.pos["int"]) self.int_npo = primitive.addTransform(self.ext_npo, self.getName("int_npo"), t) self.int_npo.rz.set(180) self.int_ctl = self.addCtl(self.int_npo, "int_ctl", t, self.color_ik, "arrow", w=ctlSize, ro=datatypes.Vector(1.5708, 1.5708, 0), tp=self.parentCtlTag) self.int_ctl.rz.set(0) attribute.setKeyableAttributes(self.int_ctl, ["ty"]) self.int_pivot = primitive.addTransform( self.int_npo, self.getName("int_pivot"), transform.getTransform(self.ext_ctl)) self.anchor = primitive.addTransform( self.int_pivot, self.getName("int_npo"), transform.getTransform(self.ik_cns)) if self.settings["joint"]: self.jnt_pos.append([self.anchor, 0, None, False])
def addCtl(self, parent, name, m, color, iconShape, tp=None, lp=True, **kwargs): """ Create the control and apply the shape, if this is alrealdy stored in the guide controllers grp. Args: parent (dagNode): The control parent name (str): The control name. m (matrix): The transfromation matrix for the control. color (int or list of float): The color for the control in index or RGB. iconShape (str): The controls default shape. tp (dagNode): Tag Parent Control object to connect as a parent controller lp (bool): Lock the parent controller channels kwargs (variant): Other arguments for the iconShape type variations Returns: dagNode: The Control. """ if "degree" not in kwargs.keys(): kwargs["degree"] = 1 fullName = self.getName(name) bufferName = fullName + "_controlBuffer" if bufferName in self.rig.guide.controllers.keys(): ctl_ref = self.rig.guide.controllers[bufferName] ctl = primitive.addTransform(parent, fullName, m) for shape in ctl_ref.getShapes(): ctl.addChild(shape, shape=True, add=True) pm.rename(shape, fullName + "Shape") icon.setcolor(ctl, color) else: ctl = icon.create( parent, fullName, m, color, iconShape, **kwargs) # create the attributes to handlde mirror and symetrical pose attribute.add_mirror_config_channels(ctl) if self.settings["ctlGrp"]: ctlGrp = self.settings["ctlGrp"] self.addToGroup(ctl, ctlGrp, "controllers") else: ctlGrp = "controllers" self.addToGroup(ctl, ctlGrp) # lock the control parent attributes if is not a control if parent not in self.groups[ctlGrp] and lp: self.transform2Lock.append(parent) # Set the control shapes isHistoricallyInteresting for oShape in ctl.getShapes(): oShape.isHistoricallyInteresting.set(False) # set controller tag if versions.current() >= 201650: try: oldTag = pm.PyNode(ctl.name() + "_tag") if not oldTag.controllerObject.connections(): # NOTE: The next line is comment out. Because this will # happend alot since maya does't clean # controller tags after deleting the control Object of the # tag. This have been log to Autodesk. # If orphane tags are found, it will be clean in silence. # pm.displayWarning("Orphane Tag: %s will be delete and # created new for: %s"%(oldTag.name(), ctl.name())) pm.delete(oldTag) except TypeError: pass self.add_controller_tag(ctl, tp) return ctl
def ghostSlider(ghostControls, surface, sliderParent): """Modify the ghost control behaviour to slide on top of a surface Args: ghostControls (dagNode): The ghost control surface (Surface): The NURBS surface sliderParent (dagNode): The parent for the slider. """ if not isinstance(ghostControls, list): ghostControls = [ghostControls] # Seleccionamos los controles Ghost que queremos mover sobre el surface surfaceShape = surface.getShape() for ctlGhost in ghostControls: ctl = pm.listConnections(ctlGhost, t="transform")[-1] t = ctl.getMatrix(worldSpace=True) gDriver = primitive.addTransform(ctlGhost.getParent(), ctl.name() + "_slideDriver", t) try: pm.connectAttr(ctl + ".translate", gDriver + ".translate") pm.disconnectAttr(ctl + ".translate", ctlGhost + ".translate") except RuntimeError: pass try: pm.connectAttr(ctl + ".scale", gDriver + ".scale") pm.disconnectAttr(ctl + ".scale", ctlGhost + ".scale") except RuntimeError: pass try: pm.connectAttr(ctl + ".rotate", gDriver + ".rotate") pm.disconnectAttr(ctl + ".rotate", ctlGhost + ".rotate") except RuntimeError: pass oParent = ctlGhost.getParent() npoName = "_".join(ctlGhost.name().split("_")[:-1]) + "_npo" oTra = pm.PyNode( pm.createNode("transform", n=npoName, p=oParent, ss=True)) oTra.setTransformation(ctlGhost.getMatrix()) pm.parent(ctlGhost, oTra) slider = primitive.addTransform(sliderParent, ctl.name() + "_slideDriven", t) # connexion dm_node = node.createDecomposeMatrixNode( gDriver.attr("worldMatrix[0]")) cps_node = pm.createNode("closestPointOnSurface") dm_node.attr("outputTranslate") >> cps_node.attr("inPosition") surfaceShape.attr("worldSpace[0]") >> cps_node.attr("inputSurface") cps_node.attr("position") >> slider.attr("translate") pm.normalConstraint(surfaceShape, slider, aimVector=[0, 0, 1], upVector=[0, 1, 0], worldUpType="objectrotation", worldUpVector=[0, 1, 0], worldUpObject=gDriver) pm.parent(ctlGhost.getParent(), slider)
def addObjects(self): 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 = tra.getTransformLookingAt(self.guide.pos["heel"], self.guide.apos[-4], self.normal, "xz", self.negate) t = tra.setMatrixPosition(t, self.guide.pos["inpivot"]) self.in_piv = pri.addTransform(self.root, self.getName("in_piv"), t) t = tra.setMatrixPosition(t, self.guide.pos["outpivot"]) self.out_piv = pri.addTransform(self.in_piv, self.getName("out_piv"), t) # heel t = tra.getTransformLookingAt(self.guide.pos["heel"], self.guide.apos[-4], self.normal, "xz", self.negate) self.heel_loc = pri.addTransform(self.out_piv, self.getName("heel_loc"), t) att.setRotOrder(self.heel_loc, "YZX") self.heel_ctl = self.addCtl(self.heel_loc, "heel_ctl", t, self.color_ik, "sphere", w=self.size*.1) att.setKeyableAttributes(self.heel_ctl, self.r_params) # Tip ---------------------------------------------- v = dt.Vector(self.guide.apos[-5].x,self.guide.apos[-1].y,self.guide.apos[-5].z) t = tra.setMatrixPosition(t, v) self.tip_ctl = self.addCtl(self.heel_ctl, "tip_ctl", t, self.color_ik, "circle", w=self.size) att.setKeyableAttributes(self.tip_ctl, self.r_params) # Roll --------------------------------------------- if self.settings["roll"] == 0: t = tra.getRotationFromAxis(self.y_axis, self.normal, "yz", self.negate) t = tra.setMatrixPosition(t, self.guide.pos["root"]) self.roll_np = pri.addTransform(self.root, self.getName("roll_np"), 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=dt.Vector(3.1415*.5,0,0)) att.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 = [] for i, pos in enumerate(bk_pos): if i == 0: t = tra.getTransform(self.heel_ctl) t = tra.setMatrixPosition(t, pos) else: dir = bk_pos[i-1] t = tra.getTransformLookingAt(pos, dir, self.normal, "xz", self.negate) bk_loc = pri.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) att.setKeyableAttributes(bk_ctl, self.r_params) self.bk_loc.append(bk_loc) self.bk_ctl.append(bk_ctl) parent = bk_ctl # FK Reference ------------------------------------ self.fk_ref = pri.addTransformFromPos(self.bk_ctl[-1], self.getName("fk_ref"), self.guide.apos[0]) self.fk_npo = pri.addTransform(self.fk_ref, self.getName("fk0_npo"), tra.getTransform(self.bk_ctl[-1])) # Forward Controlers ------------------------------ self.fk_ctl = [] self.fk_loc = [] parent = self.fk_npo for i, bk_ctl in enumerate(reversed(self.bk_ctl[1:])): t = tra.getTransform(bk_ctl) dist = vec.getDistance(self.guide.apos[i+1], self.guide.apos[i+2]) # fk_npo = pri.addTransform(parent, self.getName("fk%s_npo"%i), t) fk_loc = pri.addTransform(parent, self.getName("fk%s_loc"%i), t) 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=dt.Vector(dist*.5*self.n_factor,0,0)) att.setKeyableAttributes(fk_ctl) self.addShadow(fk_ctl, i) parent = fk_ctl self.fk_ctl.append(fk_ctl) self.fk_loc.append(fk_loc)
def addObjects(self): # Ik Controlers ------------------------------------ t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.guide.blades["blade"].z, "yx", self.negate) self.ik0_npo = pri.addTransform(self.root, self.getName("ik0_npo"), t) self.ik0_ctl = self.addCtl(self.ik0_npo, "ik0_ctl", t, self.color_ik, "compas", w=self.size) att.setKeyableAttributes(self.ik0_ctl) att.setRotOrder(self.ik0_ctl, "XZY") t = tra.setMatrixPosition(t, self.guide.apos[1]) self.ik1_npo = pri.addTransform(self.root, self.getName("ik1_npo"), t) self.ik1_ctl = self.addCtl(self.ik1_npo, "ik1_ctl", t, self.color_ik, "compas", w=self.size) att.setKeyableAttributes(self.ik1_ctl) att.setRotOrder(self.ik1_ctl, "XZY") # Tangent controlers ------------------------------- t = tra.setMatrixPosition(t, vec.linearlyInterpolate(self.guide.apos[0], self.guide.apos[1], .33)) self.tan0_npo = pri.addTransform(self.ik0_ctl, self.getName("tan0_npo"), t) self.tan0_ctl = self.addCtl(self.tan0_npo, "tan0_ctl", t, self.color_ik, "sphere", w=self.size*.2) att.setKeyableAttributes(self.tan0_ctl, self.t_params) t = tra.setMatrixPosition(t, vec.linearlyInterpolate(self.guide.apos[0], self.guide.apos[1], .66)) self.tan1_npo = pri.addTransform(self.ik1_ctl, self.getName("tan1_npo"), t) self.tan1_ctl = self.addCtl(self.tan1_npo, "tan1_ctl", t, self.color_ik, "sphere", w=self.size*.2) att.setKeyableAttributes(self.tan1_ctl, self.t_params) # Curves ------------------------------------------- self.mst_crv = cur.addCnsCurve(self.root, self.getName("mst_crv"), [self.ik0_ctl, self.tan0_ctl, self.tan1_ctl, self.ik1_ctl], 3) self.slv_crv = cur.addCurve(self.root, self.getName("slv_crv"), [dt.Vector()]*10, False, 3) self.mst_crv.setAttr("visibility", False) self.slv_crv.setAttr("visibility", False) # Division ----------------------------------------- # The user only define how many intermediate division he wants. # First and last divisions are an obligation. parentdiv = self.root parentctl = self.root self.div_cns = [] self.fk_ctl = [] self.fk_npo = [] self.scl_npo = [] for i in range(self.settings["division"]): # References div_cns = pri.addTransform(parentdiv, self.getName("%s_cns"%i)) setAttr(div_cns+".inheritsTransform", False) self.div_cns.append(div_cns) parentdiv = div_cns scl_npo = pri.addTransform(parentctl, self.getName("%s_scl_npo"%i), tra.getTransform(parentctl)) # Controlers (First and last one are fake) if i in [0, self.settings["division"] - 1]: fk_ctl = pri.addTransform(scl_npo, self.getName("%s_loc"%i), tra.getTransform(parentctl)) fk_npo = fk_ctl else: fk_npo = pri.addTransform(scl_npo, self.getName("fk%s_npo"%(i-1)), tra.getTransform(parentctl)) fk_ctl = self.addCtl(fk_npo, "fk%s_ctl"%(i-1), tra.getTransform(parentctl), self.color_fk, "cube", w=self.size, h=self.size*.05, d=self.size) att.setKeyableAttributes(self.fk_ctl) att.setRotOrder(fk_ctl, "XZY") # setAttr(fk_npo+".inheritsTransform", False) self.scl_npo.append(scl_npo) self.fk_npo.append(fk_npo) self.fk_ctl.append(fk_ctl) parentctl = fk_ctl # Deformers (Shadow) self.addShadow(fk_ctl, i) # Connections (Hooks) ------------------------------ self.cnx0 = pri.addTransform(self.root, self.getName("0_cnx")) self.cnx1 = pri.addTransform(self.root, self.getName("1_cnx"))