def addObjectsFkControl(self): parentdiv = self.root parentctl = self.root parent_twistRef = addTransform( self.root, self.getName("reference"), getTransform(self.root)) self.jointList = [] self.preiviousCtlTag = self.parentCtlTag chain = getChainTransform2(self.guide.apos, self.normal, self.negate) for i, t in enumerate(chain): parentdiv, parentctl = self._addObjectsFkControl(i, parentdiv, parentctl, t, parent_twistRef) # add visual reference icon.connection_display_curve(self.getName("visualFKRef"), self.fk_ctl)
def addDispCurve(self, name, centers=[], degree=1): """Add a display curve object to the guide. Display curve object is a simple curve to show the connection between different guide element.. Args: name (str): Local name of the element. centers (list of dagNode): List of object to define the curve. degree (int): Curve degree. Default 1 = lineal. Returns: dagNode: The newly creted curve. """ return icon.connection_display_curve(self.getName(name), centers, degree)
def addObjects(self): """Add all the objects needed to create the component.""" 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]) # FK Controlers ----------------------------------- # *ms* set npo @ Tpose, to make the fk rotation work # best with rot order"yzx" self.fk_cns = primitive.addTransformFromPos( self.root, self.getName("fk_cns"), self.guide.apos[0]) vec_offset = ((self.guide.apos[1] - self.guide.apos[0]) * [1, 0, 0]) tpv = self.guide.apos[0] + vec_offset t = transform.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, "xz", self.negate) # *ms* add FK isolation self.fk0_npo = primitive.addTransform( self.fk_cns, self.getName("fk0_npo"), t) t = transform.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, "xz", self.negate) po_off = datatypes.Vector(.35 * 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 * .7, h=self.size * .1, d=self.size * .1, po=po_off, tp=self.parentCtlTag) attribute.setKeyableAttributes(self.fk0_ctl) # *ms* add fk roll control Simage style po_off = datatypes.Vector(.85 * self.length0 * self.n_factor, 0, 0) 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=po_off, tp=self.fk0_ctl) attribute.setRotOrder(self.fk0_roll_ctl, "YZX") attribute.setKeyableAttributes(self.fk0_roll_ctl, ["rx"]) self.fk0_mtx = primitive.addTransform( self.root, self.getName("fk0_mtx"), t) t = transform.setMatrixPosition(t, self.guide.apos[1]) self.fk1_ref = primitive.addTransform( self.fk0_roll_ctl, self.getName("fk1_ref"), t) self.fk1_loc = primitive.addTransform( self.root, self.getName("fk1_loc"), t) t = transform.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2], self.normal, "xz", self.negate) self.fk1_npo = primitive.addTransform( self.fk1_loc, self.getName("fk1_npo"), t) po_off = datatypes.Vector(.35 * 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 * .7, h=self.size * .1, d=self.size * .1, po=po_off, tp=self.fk0_roll_ctl) attribute.setKeyableAttributes(self.fk1_ctl) self.fk1_mtx = primitive.addTransform( self.fk1_ctl, self.getName("fk1_mtx"), t) po_off = datatypes.Vector(.85 * self.length1 * self.n_factor, 0, 0) 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=po_off, tp=self.fk1_ctl) attribute.setRotOrder(self.fk1_roll_ctl, "XYZ") attribute.setKeyableAttributes(self.fk1_roll_ctl, ["rx"]) t = transform.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 = primitive.addTransform(self.fk1_roll_ctl, self.getName("fk2_mtx"), t) # fk2_loc is need to take the effector position + bone1 rotation t1 = transform.getTransformLookingAt(self.guide.apos[2], self.guide.apos[1], self.normal, "-xz", self.negate) self.fk2_loc = primitive.addTransform( self.root, self.getName("fk2_loc"), t1) self.fk2_npo = primitive.addTransform(self.fk2_loc, self.getName("fk2_npo"), t) po_off = datatypes.Vector(.5 * self.length2 * self.n_factor, 0, 0) self.fk2_ctl = self.addCtl(self.fk2_npo, "fk2_ctl", t, self.color_fk, "cube", w=self.length2, h=self.size * .1, d=self.size * .1, po=po_off, tp=self.fk1_roll_ctl) attribute.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: attribute.setInvertMirror(x, ["tx", "ty", "tz"]) # IK Controlers ----------------------------------- self.ik_cns = primitive.addTransformFromPos( self.root, self.getName("ik_cns"), self.guide.pos["wrist"]) self.ikcns_ctl = self.addCtl( self.ik_cns, "ikcns_ctl", transform.getTransformFromPos(self.guide.pos["wrist"]), 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.ikcns_ctl) attribute.setKeyableAttributes(self.ik_ctl) 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] # *ms* auto up vector ------------------------------ self.upv_cns = primitive.addTransformFromPos(self.root, self.getName("upv_cns"), self.guide.apos[0]) self.upv_auv = primitive.addTransformFromPos(self.root, self.getName("upv_auv"), self.guide.apos[0]) self.upv_mtx = primitive.addTransformFromPos(self.upv_cns, self.getName("upv_mtx"), self.guide.apos[0]) self.upv_npo = primitive.addTransformFromPos(self.upv_mtx, self.getName("upv_npo"), v) self.upv_ctl = self.addCtl(self.upv_npo, "upv_ctl", transform.getTransform(self.upv_npo), self.color_ik, "diamond", w=self.size * .12, tp=self.parentCtlTag) attribute.setKeyableAttributes(self.upv_ctl, self.t_params) attribute.setInvertMirror(self.upv_ctl, ["tx"]) # 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, self.getName("ik_ref"), trnIK_ref) self.fk_ref = primitive.addTransform(self.fk_ctl[2], self.getName("fk_ref"), trnIK_ref) # Chain -------------------------------------------- # take 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]) # eff npo --- take the effector output of gear ik solver self.eff_npo = primitive.addTransformFromPos(self.root, self.getName("eff_npo"), self.guide.apos[2]) # eff loc --- take the fk ik blend result self.eff_loc = primitive.addTransformFromPos(self.eff_npo, self.getName("eff_loc"), self.guide.apos[2]) # Mid Controler ------------------------------------ self.mid_ctl = self.addCtl(self.ctrn_loc, "mid_ctl", transform.getTransform(self.ctrn_loc), self.color_ik, "sphere", w=self.size * .2, tp=self.parentCtlTag) attribute.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"]) # *ms* add elbow thickness # Roll join ref self.tws0_npo = primitive.addTransform( self.root, self.getName("tws0_npo"), transform.getTransform(self.fk_ctl[0])) self.tws0_loc = primitive.addTransform( self.tws0_npo, 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_loc = primitive.addTransform( self.tws1_npo, self.getName("tws2_loc"), transform.getTransform(self.ctrn_loc)) self.tws2_rot = primitive.addTransform( self.tws2_loc, self.getName("tws2_rot"), transform.getTransform(self.ctrn_loc)) self.tws3_npo = primitive.addTransform( self.root, self.getName("tws3_npo"), transform.getTransform(self.fk_ctl[2])) self.tws3_loc = primitive.addTransform( self.tws3_npo, self.getName("tws3_loc"), transform.getTransform(self.fk_ctl[2])) self.tws3_rot = primitive.addTransform( self.tws3_loc, self.getName("tws3_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 # 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 = primitive.addTransform( self.root, self.getName("div_org"), transform.getTransform(self.root)) self.previousTag = self.parentCtlTag for i in range(self.divisions0): div_cns = primitive.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), transform.getTransform(div_cns), self.color_fk, "square", d=self.size * .05, w=self.size * .1, po=datatypes.Vector(0, self.size * -0.05, 0), ro=datatypes.Vector(0, 0, datatypes.radians(90)), tp=self.previousTag) else: div_ctl = self.addCtl( div_cns, self.getName("div%s_ctl" % i), transform.getTransform(div_cns), self.color_fk, "square", d=self.size * .05, w=self.size * .1, po=datatypes.Vector(0, self.size * 0.05, 0), ro=datatypes.Vector(0, 0, datatypes.radians(90)), tp=self.previousTag) attribute.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 = primitive.addTransform( self.div_org, self.getName("div%s_loc" % d), transform.getTransform(self.mid_ctl)) if self.negate: self.div_mid_ctl = self.addCtl( self.div_mid, self.getName("div%s_ctl" % d), transform.getTransform(self.div_mid), self.color_fk, "square", d=self.size * .05, w=self.size * .1, po=datatypes.Vector(0, self.size * -0.05, 0), ro=datatypes.Vector(0, 0, datatypes.radians(90)), tp=self.previousTag) else: self.div_mid_ctl = self.addCtl( self.div_mid, self.getName("div%s_ctl" % d), transform.getTransform(self.div_mid), self.color_fk, "square", d=self.size * .05, w=self.size * .1, po=datatypes.Vector(0, self.size * 0.05, 0), ro=datatypes.Vector(0, 0, datatypes.radians(90)), tp=self.previousTag) attribute.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 = primitive.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), transform.getTransform(div_cns), self.color_fk, "square", d=self.size * .05, w=self.size * .1, po=datatypes.Vector(0, self.size * -0.05, 0), ro=datatypes.Vector(0, 0, datatypes.radians(90)), tp=self.previousTag) else: div_ctl = self.addCtl( div_cns, self.getName("div%s_ctl" % dd), transform.getTransform(div_cns), self.color_fk, "square", d=self.size * .05, w=self.size * .1, po=datatypes.Vector(0, self.size * 0.05, 0), ro=datatypes.Vector(0, 0, datatypes.radians(90)), tp=self.previousTag) attribute.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 = self.add_match_ref(self.fk_ctl[0], self.root, "fk0_mth") self.match_fk1 = self.add_match_ref(self.fk_ctl[1], self.root, "fk1_mth") self.match_fk2 = self.add_match_ref(self.fk_ctl[2], self.ik_ctl, "fk2_mth") self.match_ik = self.add_match_ref(self.ik_ctl, self.fk2_ctl, "ik_mth") self.match_ikUpv = self.add_match_ref(self.upv_ctl, self.fk0_roll_ctl, "upv_mth") # 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.""" self.WIP = self.options["mode"] self.normal = self.getNormalFromPos(self.guide.apos) self.binormal = self.getBiNormalFromPos(self.guide.apos) self.length0 = vector.getDistance(self.guide.apos[0], self.guide.apos[1]) self.length1 = vector.getDistance(self.guide.apos[1], self.guide.apos[2]) self.length2 = vector.getDistance(self.guide.apos[2], self.guide.apos[3]) # 1 bone chain for upv ref self.legChainUpvRef = primitive.add2DChain( self.root, self.getName("legUpvRef%s_jnt"), [self.guide.apos[0], self.guide.apos[2]], self.normal, False, self.WIP) self.legChainUpvRef[1].setAttr( "jointOrientZ", self.legChainUpvRef[1].getAttr("jointOrientZ") * -1) # extra neutral pose t = transform.getTransformFromPos(self.guide.apos[0]) self.root_npo = primitive.addTransform(self.root, self.getName("root_npo"), t) self.root_ctl = self.addCtl(self.root_npo, "root_ctl", t, self.color_fk, "circle", w=self.length0 / 6, tp=self.parentCtlTag) # FK Controlers ----------------------------------- t = transform.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, "xz", self.negate) self.fk0_npo = primitive.addTransform(self.root_ctl, self.getName("fk0_npo"), t) po_vec = datatypes.Vector(.5 * self.length0 * self.n_factor, 0, 0) self.fk0_ctl = self.addCtl(self.fk0_npo, "fk0_ctl", t, self.color_fk, "cube", w=self.length0, h=self.size * .1, d=self.size * .1, po=po_vec, tp=self.root_ctl) attribute.setKeyableAttributes( self.fk0_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) t = transform.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2], self.normal, "xz", self.negate) self.fk1_npo = primitive.addTransform(self.fk0_ctl, self.getName("fk1_npo"), t) po_vec = datatypes.Vector(.5 * self.length1 * self.n_factor, 0, 0) self.fk1_ctl = self.addCtl(self.fk1_npo, "fk1_ctl", t, self.color_fk, "cube", w=self.length1, h=self.size * .1, d=self.size * .1, po=po_vec, tp=self.fk0_ctl) attribute.setKeyableAttributes( self.fk1_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) t = transform.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3], self.normal, "xz", self.negate) self.fk2_npo = primitive.addTransform(self.fk1_ctl, self.getName("fk2_npo"), t) po_vec = datatypes.Vector(.5 * self.length2 * self.n_factor, 0, 0) self.fk2_ctl = self.addCtl(self.fk2_npo, "fk2_ctl", t, self.color_fk, "cube", w=self.length2, h=self.size * .1, d=self.size * .1, po=po_vec, tp=self.fk1_ctl) attribute.setKeyableAttributes(self.fk2_ctl) self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl] for x in self.fk_ctl: attribute.setInvertMirror(x, ["tx", "ty", "tz"]) # IK Controlers ----------------------------------- self.ik_cns = primitive.addTransformFromPos(self.root_ctl, self.getName("ik_cns"), self.guide.pos["ankle"]) self.ikcns_ctl = self.addCtl(self.ik_cns, "ikcns_ctl", transform.getTransformFromPos( self.guide.pos["ankle"]), self.color_ik, "null", w=self.size * .12, tp=self.root_ctl) attribute.setInvertMirror(self.ikcns_ctl, ["tx"]) m = transform.getTransformLookingAt(self.guide.pos["ankle"], self.guide.pos["eff"], self.x_axis, "zx", False) self.ik_ctl = self.addCtl(self.ikcns_ctl, "ik_ctl", transform.getTransformFromPos( self.guide.pos["ankle"]), self.color_ik, "cube", w=self.size * .12, h=self.size * .12, d=self.size * .12) attribute.setKeyableAttributes(self.ik_ctl) attribute.setRotOrder(self.ik_ctl, "XZY") attribute.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"]) # upv v = self.guide.apos[2] - self.guide.apos[0] v = self.normal ^ v v.normalize() v *= self.size * .5 v += self.guide.apos[1] self.upv_cns = primitive.addTransformFromPos(self.ik_ctl, self.getName("upv_cns"), v) self.upv_ctl = self.addCtl(self.upv_cns, "upv_ctl", transform.getTransform(self.upv_cns), self.color_ik, "diamond", w=self.size * .12, tp=self.root_ctl) self.add_controller_tag(self.ik_ctl, self.upv_ctl) if self.settings["mirrorMid"]: if self.negate: self.upv_cns.rz.set(180) self.upv_cns.sy.set(-1) else: attribute.setInvertMirror(self.upv_ctl, ["tx"]) attribute.setKeyableAttributes(self.upv_ctl, self.t_params) # References -------------------------------------- self.ik_ref = primitive.addTransform( self.ik_ctl, self.getName("ik_ref"), transform.getTransform(self.ik_ctl)) self.fk_ref = primitive.addTransform( self.fk_ctl[2], self.getName("fk_ref"), transform.getTransform(self.ik_ctl)) # Chain -------------------------------------------- # The outputs of the ikfk2bone solver self.bone0 = primitive.addLocator( self.root_ctl, self.getName("0_bone"), transform.getTransform(self.fk_ctl[0])) self.bone0_shp = self.bone0.getShape() self.bone0_shp.setAttr("localPositionX", self.n_factor * .5) self.bone0_shp.setAttr("localScale", .5, 0, 0) self.bone0.setAttr("sx", self.length0) self.bone0.setAttr("visibility", False) self.bone1 = primitive.addLocator( self.root_ctl, self.getName("1_bone"), transform.getTransform(self.fk_ctl[1])) self.bone1_shp = self.bone1.getShape() self.bone1_shp.setAttr("localPositionX", self.n_factor * .5) self.bone1_shp.setAttr("localScale", .5, 0, 0) self.bone1.setAttr("sx", self.length1) self.bone1.setAttr("visibility", False) self.ctrn_loc = primitive.addTransformFromPos(self.root_ctl, self.getName("ctrn_loc"), self.guide.apos[1]) self.eff_loc = primitive.addTransformFromPos(self.root_ctl, self.getName("eff_loc"), self.guide.apos[2]) # tws_ref t = transform.getRotationFromAxis(datatypes.Vector(0, -1, 0), self.normal, "xz", self.negate) t = transform.setMatrixPosition(t, self.guide.pos["ankle"]) # addind an npo parent transform to fix flip in Maya 2018.2 self.tws_npo = primitive.addTransform(self.eff_loc, self.getName("tws_npo"), t) self.tws_ref = primitive.addTransform(self.tws_npo, self.getName("tws_ref"), t) # Mid Controler ------------------------------------ t = transform.getTransform(self.ctrn_loc) self.mid_cns = primitive.addTransform(self.ctrn_loc, self.getName("mid_cns"), t) self.mid_ctl = self.addCtl(self.mid_cns, "mid_ctl", t, self.color_ik, "sphere", w=self.size * .2, tp=self.root_ctl) attribute.setKeyableAttributes( self.mid_ctl, params=["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) if self.settings["mirrorMid"]: if self.negate: self.mid_cns.rz.set(180) self.mid_cns.sz.set(-1) else: attribute.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"]) # Twist references --------------------------------- x = datatypes.Vector(0, -1, 0) x = x * transform.getTransform(self.eff_loc) z = datatypes.Vector(self.normal.x, self.normal.y, self.normal.z) z = z * transform.getTransform(self.eff_loc) m = transform.getRotationFromAxis(x, z, "xz", self.negate) m = transform.setMatrixPosition(m, transform.getTranslation(self.ik_ctl)) self.rollRef = primitive.add2DChain(self.root, self.getName("rollChain"), self.guide.apos[:2], self.normal, self.negate, self.WIP) self.tws0_loc = primitive.addTransform( self.rollRef[0], self.getName("tws0_loc"), transform.getTransform(self.fk_ctl[0])) self.tws0_rot = primitive.addTransform( self.tws0_loc, self.getName("tws0_rot"), transform.getTransform(self.fk_ctl[0])) self.tws1_loc = primitive.addTransform( self.ctrn_loc, self.getName("tws1_loc"), transform.getTransform(self.ctrn_loc)) self.tws1_rot = primitive.addTransform( self.tws1_loc, self.getName("tws1_rot"), transform.getTransform(self.ctrn_loc)) # thickness control self.thick_lvl = primitive.addTransform( self.mid_ctl, self.getName("thickness_lvl"), transform.getTransform(self.ctrn_loc)) self.thick_ctl = self.addCtl(self.thick_lvl, "thickness_ctl", transform.getTransform(self.mid_ctl), self.color_ik, "arrow", w=self.size * .1, ro=datatypes.Vector([0, 1.5708, 0]), tp=self.mid_ctl) if self.negate and not self.settings["mirrorMid"]: self.thick_ctl.rz.set(180) self.thick_ctl.sz.set(-1) attribute.setKeyableAttributes(self.thick_ctl, ["tx", "ty"]) self.tws1B_loc = primitive.addTransform( self.ctrn_loc, self.getName("tws1B_loc"), transform.getTransform(self.ctrn_loc)) self.tws1B_rot = primitive.addTransform( self.tws1B_loc, self.getName("tws1B_rot"), transform.getTransform(self.ctrn_loc)) self.tws2_loc = primitive.addTransform( self.root_ctl, self.getName("tws2_loc"), transform.getTransform(self.tws_ref)) self.tws2_rot = primitive.addTransform( self.tws2_loc, self.getName("tws2_rot"), transform.getTransform(self.tws_ref)) self.tws2_rot.setAttr("sx", .001) # angle reader ---------------------------------------- t = transform.getTransformLookingAt(self.guide.apos[1], self.guide.apos[0], self.binormal, "yz") self.readerA = primitive.addTransform(self.root, self.getName("readerA_loc"), t) self.readerB = primitive.addTransform(self.readerA, self.getName("readerB_loc"), t) self.readerB.rotateOrder.set(2) # Divisions ---------------------------------------- # We have at least one division at the start, the end and one for # the elbow. + 2 for knee angle control if self.settings["supportJoints"]: ej = 2 else: ej = 0 self.divisions = self.settings["div0"] + self.settings["div1"] + 3 + ej self.div_cns = [] if self.settings["extraTweak"]: tagP = self.parentCtlTag self.tweak_ctl = [] for i in range(self.divisions): div_cns = primitive.addTransform(self.root_ctl, self.getName("div%s_loc" % i)) self.div_cns.append(div_cns) if self.settings["extraTweak"]: t = transform.getTransform(div_cns) tweak_ctl = self.addCtl(div_cns, "tweak%s_ctl" % i, t, self.color_fk, "square", w=self.size * .15, d=self.size * .15, ro=datatypes.Vector([0, 0, 1.5708]), tp=tagP) attribute.setKeyableAttributes(tweak_ctl) tagP = tweak_ctl self.tweak_ctl.append(tweak_ctl) self.jnt_pos.append([tweak_ctl, i, None, False]) else: self.jnt_pos.append([div_cns, i]) # End reference ------------------------------------ # To help the deformation on the ankle self.end_ref = primitive.addTransform(self.tws2_rot, self.getName("end_ref"), m) self.jnt_pos.append([self.end_ref, 'end']) # match IK FK references self.match_fk0_off = self.add_match_ref(self.fk_ctl[1], self.root, "matchFk0_npo", False) self.match_fk0 = self.add_match_ref(self.fk_ctl[0], self.match_fk0_off, "fk0_mth") self.match_fk1_off = self.add_match_ref(self.fk_ctl[2], self.root, "matchFk1_npo", False) self.match_fk1 = self.add_match_ref(self.fk_ctl[1], self.match_fk1_off, "fk1_mth") self.match_fk2 = self.add_match_ref(self.fk_ctl[2], self.ik_ctl, "fk2_mth") self.match_ik = self.add_match_ref(self.ik_ctl, self.fk2_ctl, "ik_mth") self.match_ikUpv = self.add_match_ref(self.upv_ctl, self.fk0_ctl, "upv_mth") # add visual reference self.line_ref = icon.connection_display_curve( self.getName("visalRef"), [self.upv_ctl, self.mid_ctl])
def addObjects(self): """Add all the objects needed to create the component.""" self.WIP = self.options["mode"] self.up_axis = pm.upAxis(q=True, axis=True) self.normal = self.getNormalFromPos(self.guide.apos) self.length0 = vector.getDistance( self.guide.apos[0], self.guide.apos[1]) self.length1 = vector.getDistance( self.guide.apos[1], self.guide.apos[2]) self.length2 = vector.getDistance( self.guide.apos[2], self.guide.apos[3]) # 1 bone chain for upv ref self.legChainUpvRef = primitive.add2DChain( self.root, self.getName("legUpvRef%s_jnt"), [self.guide.apos[0], self.guide.apos[2]], self.normal, False, self.WIP) self.legChainUpvRef[1].setAttr( "jointOrientZ", self.legChainUpvRef[1].getAttr("jointOrientZ") * -1) # extra neutral pose t = transform.getTransformFromPos(self.guide.apos[0]) self.root_npo = primitive.addTransform(self.root, self.getName("root_npo"), t) self.root_ctl = self.addCtl(self.root_npo, "root_ctl", t, self.color_fk, "circle", w=self.length0 / 6, tp=self.parentCtlTag) # FK Controlers ----------------------------------- t = transform.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, "xz", self.negate) if self.settings["FK_rest_T_Pose"]: if self.negate: x_dir = 1 else: x_dir = -1 if self.up_axis == "y": x = datatypes.Vector(0, x_dir, 0) else: x = datatypes.Vector(0, 0, x_dir) z = datatypes.Vector(-1, 0, 0) t_npo = transform.getRotationFromAxis(x, z, "xz", False) t_npo = transform.setMatrixPosition(t_npo, self.guide.apos[0]) else: t_npo = t self.fk0_npo = primitive.addTransform(self.root_ctl, self.getName("fk0_npo"), t_npo) po_vec = datatypes.Vector(.5 * self.length0 * self.n_factor, 0, 0) self.fk0_ctl = self.addCtl(self.fk0_npo, "fk0_ctl", t, self.color_fk, "cube", w=self.length0, h=self.size * .1, d=self.size * .1, po=po_vec, tp=self.root_ctl) attribute.setKeyableAttributes( self.fk0_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) t = transform.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2], self.normal, "xz", self.negate) if self.settings["FK_rest_T_Pose"]: t_npo = transform.setMatrixPosition( transform.getTransform(self.fk0_ctl), self.guide.apos[1]) else: t_npo = t self.fk1_npo = primitive.addTransform( self.fk0_ctl, self.getName("fk1_npo"), t_npo) po_vec = datatypes.Vector(.5 * self.length1 * self.n_factor, 0, 0) self.fk1_ctl = self.addCtl(self.fk1_npo, "fk1_ctl", t, self.color_fk, "cube", w=self.length1, h=self.size * .1, d=self.size * .1, po=po_vec, tp=self.fk0_ctl) attribute.setKeyableAttributes( self.fk1_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) t = transform.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3], self.normal, "xz", self.negate) if self.settings["FK_rest_T_Pose"]: t_npo = transform.setMatrixPosition( transform.getTransform(self.fk0_ctl), self.guide.apos[2]) else: t_npo = t self.fk2_npo = primitive.addTransform( self.fk1_ctl, self.getName("fk2_npo"), t_npo) if self.settings["FK_rest_T_Pose"]: self.fk2_npo.rz.set(90) po_vec = datatypes.Vector(.5 * self.length2 * self.n_factor, 0, 0) self.fk2_ctl = self.addCtl(self.fk2_npo, "fk2_ctl", t, self.color_fk, "cube", w=self.length2, h=self.size * .1, d=self.size * .1, po=po_vec, tp=self.fk1_ctl) attribute.setKeyableAttributes(self.fk2_ctl) self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl] for x in self.fk_ctl: attribute.setInvertMirror(x, ["tx", "ty", "tz"]) # IK Controlers ----------------------------------- self.ik_cns = primitive.addTransformFromPos(self.root_ctl, self.getName("ik_cns"), self.guide.pos["ankle"]) self.ikcns_ctl = self.addCtl( self.ik_cns, "ikcns_ctl", transform.getTransformFromPos(self.guide.pos["ankle"]), self.color_ik, "null", w=self.size * .12, tp=self.root_ctl) attribute.setInvertMirror(self.ikcns_ctl, ["tx"]) # m = transform.getTransformLookingAt(self.guide.pos["ankle"], # self.guide.pos["eff"], # self.x_axis, # "zx", # False) # if self.settings["FK_rest_T_Pose"]: # t_ik = transform.getTransformLookingAt(self.guide.pos["ankle"], # self.guide.pos["eff"], # self.normal * -1, # "zx", # False) # else: t_ik = transform.getTransformFromPos(self.guide.pos["ankle"]) self.ik_ctl = self.addCtl( self.ikcns_ctl, "ik_ctl", t_ik, self.color_ik, "cube", w=self.size * .12, h=self.size * .12, d=self.size * .12) attribute.setKeyableAttributes(self.ik_ctl) attribute.setRotOrder(self.ik_ctl, "XZY") attribute.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"]) # upv v = self.guide.apos[2] - self.guide.apos[0] v = self.normal ^ v v.normalize() v *= self.size * .5 v += self.guide.apos[1] self.upv_cns = primitive.addTransformFromPos(self.ik_ctl, self.getName("upv_cns"), v) self.upv_ctl = self.addCtl( self.upv_cns, "upv_ctl", transform.getTransform(self.upv_cns), self.color_ik, "diamond", w=self.size * .12, tp=self.root_ctl) self.add_controller_tag(self.ik_ctl, self.upv_ctl) if self.settings["mirrorMid"]: if self.negate: self.upv_cns.rz.set(180) self.upv_cns.sy.set(-1) else: attribute.setInvertMirror(self.upv_ctl, ["tx"]) attribute.setKeyableAttributes(self.upv_ctl, self.t_params) # References -------------------------------------- self.ik_ref = primitive.addTransform( self.ik_ctl, self.getName("ik_ref"), transform.getTransform(self.ik_ctl)) self.fk_ref = primitive.addTransform( self.fk_ctl[2], self.getName("fk_ref"), transform.getTransform(self.ik_ctl)) # Chain -------------------------------------------- # The outputs of the ikfk2bone solver self.bone0 = primitive.addLocator( self.root_ctl, self.getName("0_bone"), transform.getTransform(self.fk_ctl[0])) self.bone0_shp = self.bone0.getShape() self.bone0_shp.setAttr("localPositionX", self.n_factor * .5) self.bone0_shp.setAttr("localScale", .5, 0, 0) self.bone0.setAttr("sx", self.length0) self.bone0.setAttr("visibility", False) self.bone1 = primitive.addLocator( self.root_ctl, self.getName("1_bone"), transform.getTransform(self.fk_ctl[1])) self.bone1_shp = self.bone1.getShape() self.bone1_shp.setAttr("localPositionX", self.n_factor * .5) self.bone1_shp.setAttr("localScale", .5, 0, 0) self.bone1.setAttr("sx", self.length1) self.bone1.setAttr("visibility", False) self.ctrn_loc = primitive.addTransformFromPos(self.root_ctl, self.getName("ctrn_loc"), self.guide.apos[1]) self.eff_loc = primitive.addTransformFromPos(self.root_ctl, self.getName("eff_loc"), self.guide.apos[2]) # tws_ref t = transform.getRotationFromAxis( datatypes.Vector(0, -1, 0), self.normal, "xz", self.negate) t = transform.setMatrixPosition(t, self.guide.pos["ankle"]) # addind an npo parent transform to fix flip in Maya 2018.2 self.tws_npo = primitive.addTransform( self.eff_loc, self.getName("tws_npo"), t) self.tws_ref = primitive.addTransform( self.tws_npo, self.getName("tws_ref"), t) # Mid Controler ------------------------------------ t = transform.getTransform(self.ctrn_loc) self.mid_cns = primitive.addTransform( self.ctrn_loc, self.getName("mid_cns"), t) self.mid_ctl = self.addCtl(self.mid_cns, "mid_ctl", t, self.color_ik, "sphere", w=self.size * .2, tp=self.root_ctl) attribute.setKeyableAttributes(self.mid_ctl, params=["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) if self.settings["mirrorMid"]: if self.negate: self.mid_cns.rz.set(180) self.mid_cns.sz.set(-1) else: attribute.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"]) # Twist references --------------------------------- x = datatypes.Vector(0, -1, 0) x = x * transform.getTransform(self.eff_loc) z = datatypes.Vector(self.normal.x, self.normal.y, self.normal.z) z = z * transform.getTransform(self.eff_loc) m = transform.getRotationFromAxis(x, z, "xz", self.negate) m = transform.setMatrixPosition( m, transform.getTranslation(self.ik_ctl)) self.rollRef = primitive.add2DChain(self.root, self.getName("rollChain"), self.guide.apos[:2], self.normal, self.negate, self.WIP) t = transform.getTransformLookingAt(self.guide.pos["base"], self.guide.apos[1], self.normal, "xz", self.negate) self.tws0_loc = primitive.addTransform( self.root_ctl, self.getName("tws0_loc"), t) self.tws0_rot = primitive.addTransform( self.tws0_loc, self.getName("tws0_rot"), t) self.tws1_loc = primitive.addTransform( self.ctrn_loc, self.getName("tws1_loc"), transform.getTransform(self.ctrn_loc)) self.tws1_rot = primitive.addTransform( self.tws1_loc, self.getName("tws1_rot"), transform.getTransform(self.ctrn_loc)) self.tws2_loc = primitive.addTransform( self.root_ctl, self.getName("tws2_loc"), transform.getTransform(self.tws_ref)) self.tws2_rot = primitive.addTransform( self.tws2_loc, self.getName("tws2_rot"), transform.getTransform(self.tws_ref)) self.tws2_rot.setAttr("sx", .001) # Divisions ---------------------------------------- self.divisions = self.settings["div0"] + self.settings["div1"] + 2 self.div_cns = [] if self.settings["extraTweak"]: tagP = self.parentCtlTag self.tweak_ctl = [] for i in range(self.divisions): div_cns = primitive.addTransform(self.root_ctl, self.getName("div%s_loc" % i)) self.div_cns.append(div_cns) if self.settings["extraTweak"]: t = transform.getTransform(div_cns) tweak_ctl = self.addCtl(div_cns, "tweak%s_ctl" % i, t, self.color_fk, "square", w=self.size * .15, d=self.size * .15, ro=datatypes.Vector([0, 0, 1.5708]), tp=tagP) attribute.setKeyableAttributes(tweak_ctl) tagP = tweak_ctl self.tweak_ctl.append(tweak_ctl) driver = tweak_ctl else: driver = div_cns # setting the joints if i == 0: self.jnt_pos.append([driver, "thigh"]) current_parent = "root" twist_name = "thigh_twist_" twist_idx = 1 increment = 1 elif i == self.settings["div0"] + 1: self.jnt_pos.append([driver, "calf", current_parent]) twist_name = "calf_twist_" current_parent = "knee" twist_idx = self.settings["div1"] increment = -1 else: self.jnt_pos.append( [driver, twist_name + str(twist_idx).zfill(2), current_parent]) twist_idx += increment # End reference ------------------------------------ # To help the deformation on the ankle self.end_ref = primitive.addTransform(self.tws2_rot, self.getName("end_ref"), m) # set the offset rotation for the hand self.end_jnt_off = primitive.addTransform(self.end_ref, self.getName("end_off"), m) if self.up_axis == "z": self.end_jnt_off.rz.set(-90) self.jnt_pos.append([self.end_jnt_off, 'foot', current_parent]) # match IK FK references self.match_fk0_off = self.add_match_ref(self.fk_ctl[1], self.root, "matchFk0_npo", False) self.match_fk0 = self.add_match_ref(self.fk_ctl[0], self.match_fk0_off, "fk0_mth") self.match_fk1_off = self.add_match_ref(self.fk_ctl[2], self.root, "matchFk1_npo", False) self.match_fk1 = self.add_match_ref(self.fk_ctl[1], self.match_fk1_off, "fk1_mth") self.match_fk2 = self.add_match_ref(self.fk_ctl[2], self.ik_ctl, "fk2_mth") self.match_ik = self.add_match_ref(self.ik_ctl, self.fk2_ctl, "ik_mth") self.match_ikUpv = self.add_match_ref(self.upv_ctl, self.fk0_ctl, "upv_mth") # add visual reference self.line_ref = icon.connection_display_curve( self.getName("visalRef"), [self.upv_ctl, self.mid_ctl])
def 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) # Define the wrist transform (wt) if self.settings["guideOrientWrist"]: wt = self.guide.tra["wrist"] if self.settings["mirrorIK"] and self.negate: scl = [1, 1, -1] else: scl = [1, 1, 1] wt = transform.setMatrixScale(wt, scl) t = wt 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 --------------------------------- # create tip point self.tip_ref = primitive.addTransform( self.armChainUpvRef[0], self.getName("tip_ref"), self.armChainUpvRef[0].getMatrix(worldSpace=True)) # create interpolate obj self.interpolate_lvl = primitive.addTransform( self.armChainUpvRef[0], self.getName("int_lvl"), self.armChainUpvRef[0].getMatrix(worldSpace=True)) # create roll npo and ctl self.roll_ctl_npo = primitive.addTransform( self.root, self.getName("roll_ctl_npo"), self.armChainUpvRef[0].getMatrix(worldSpace=True)) if self.negate: off_x = -1.5708 else: off_x = 1.5708 off_y = 1.5708 self.roll_ctl = self.addCtl(self.roll_ctl_npo, "roll_ctl", transform.getTransform(self.roll_ctl_npo), self.color_ik, "compas", w=self.size * .3, ro=datatypes.Vector([off_x, off_y, 0]), tp=self.parentCtlTag) attribute.setKeyableAttributes(self.roll_ctl, ["rx"]) # create upv control v = self.guide.apos[2] - self.guide.apos[0] v = self.normal ^ v v.normalize() v *= self.size * .8 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"]) if self.settings["guideOrientWrist"]: t = wt self.ik_cns.setMatrix(t) self.ik_cns.setTranslation(self.guide.pos["wrist"], space="world") 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) if self.settings["guideOrientWrist"]: m = wt 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.roll_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) if self.settings["guideOrientWrist"]: trnIK_ref = wt 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)) # thickness control self.thick_lvl = primitive.addTransform( self.mid_ctl, self.getName("thickness_lvl"), transform.getTransform(self.ctrn_loc)) self.thick_ctl = self.addCtl(self.thick_lvl, "thickness_ctl", transform.getTransform(self.mid_ctl), self.color_ik, "arrow", w=self.size * .1, ro=datatypes.Vector([0, 1.5708, 0]), tp=self.mid_ctl) if self.negate and not self.settings["mirrorMid"]: self.thick_ctl.rz.set(180) self.thick_ctl.sz.set(-1) attribute.setKeyableAttributes(self.thick_ctl, ["tx", "ty"]) self.tws1B_loc = primitive.addTransform( self.ctrn_loc, self.getName("tws1B_loc"), transform.getTransform(self.ctrn_loc)) self.tws1B_rot = primitive.addTransform( self.tws1B_loc, self.getName("tws1B_rot"), transform.getTransform(self.ctrn_loc)) self.tws2_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])) # angle reader ---------------------------------------- t = transform.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2], self.normal, "xy") self.readerA = primitive.addTransform(self.root, self.getName("readerA_loc"), t) self.readerB = primitive.addTransform(self.readerA, self.getName("readerB_loc"), t) self.readerB.rotateOrder.set(2) # Divisions ---------------------------------------- # We have at least one division at the start, the end and one for the # elbow. + 2 for elbow angle control if self.settings["supportJoints"]: ej = 2 else: ej = 0 self.divisions = self.settings["div0"] + self.settings["div1"] + 3 + ej self.div_cns = [] if self.settings["extraTweak"]: tagP = self.parentCtlTag self.tweak_ctl = [] for i in range(self.divisions): div_cns = primitive.addTransform(self.root, 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 = self.add_match_ref(self.fk_ctl[1], self.root, "matchFk0_npo", False) self.match_fk0 = self.add_match_ref(self.fk_ctl[0], self.match_fk0_off, "fk0_mth") self.match_fk1_off = self.add_match_ref(self.fk_ctl[2], self.root, "matchFk1_npo", False) self.match_fk1 = self.add_match_ref(self.fk_ctl[1], self.match_fk1_off, "fk1_mth") if self.settings["ikTR"]: reference = self.ikRot_ctl self.match_ikRot = self.add_match_ref(self.ikRot_ctl, self.fk2_ctl, "ikRot_mth") else: reference = self.ik_ctl self.match_fk2 = self.add_match_ref(self.fk_ctl[2], reference, "fk2_mth") self.match_ik = self.add_match_ref(self.ik_ctl, self.fk2_ctl, "ik_mth") self.match_ikUpv = self.add_match_ref(self.upv_ctl, self.fk0_ctl, "upv_mth") # add visual reference self.line_ref = icon.connection_display_curve( self.getName("visalRef"), [self.upv_ctl, self.mid_ctl])
def addObjects(self): """Add all the objects needed to create the component.""" self.WIP = self.options["mode"] self.up_axis = pm.upAxis(q=True, axis=True) self.blade_normal = self.guide.blades["blade"].z * -1 self.blade_binormal = self.guide.blades["blade"].x 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, ) if self.settings["FK_rest_T_Pose"]: x = datatypes.Vector(1, 0, 0) if self.negate: z_dir = -1 else: z_dir = 1 if self.up_axis == "y": z = datatypes.Vector(0, z_dir, 0) else: z = datatypes.Vector(0, 0, z_dir) t_npo = transform.getRotationFromAxis(x, z, "xz", False) t_npo = transform.setMatrixPosition(t_npo, self.guide.apos[0]) else: t_npo = t self.fk0_npo = primitive.addTransform( self.root, self.getName("fk0_npo"), t_npo ) vec_po = datatypes.Vector(0.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 * 0.1, d=self.size * 0.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, ) if self.settings["FK_rest_T_Pose"]: t_npo = transform.setMatrixPosition( transform.getTransform(self.fk0_ctl), self.guide.apos[1] ) else: t_npo = t self.fk1_npo = primitive.addTransform( self.fk0_ctl, self.getName("fk1_npo"), t_npo ) vec_po = datatypes.Vector(0.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 * 0.1, d=self.size * 0.1, po=vec_po, tp=self.fk0_ctl, ) attribute.setKeyableAttributes( self.fk1_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"] ) if self.settings["use_blade"]: t = transform.getTransformLookingAt( self.guide.apos[2], self.guide.apos[3], self.blade_normal, "x-z", self.negate, ) else: t = transform.getTransformLookingAt( self.guide.apos[2], self.guide.apos[3], self.normal, "xz", self.negate, ) if self.settings["FK_rest_T_Pose"]: t_npo = transform.setMatrixPosition( transform.getTransform(self.fk1_ctl), self.guide.apos[2] ) else: t_npo = t self.fk2_npo = primitive.addTransform( self.fk1_ctl, self.getName("fk2_npo"), t_npo ) vec_po = datatypes.Vector(0.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 * 0.1, d=self.size * 0.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 --------------------------------- # create tip point self.tip_ref = primitive.addTransform( self.armChainUpvRef[0], self.getName("tip_ref"), self.armChainUpvRef[0].getMatrix(worldSpace=True), ) # create interpolate obj self.interpolate_lvl = primitive.addTransform( self.armChainUpvRef[0], self.getName("int_lvl"), self.armChainUpvRef[0].getMatrix(worldSpace=True), ) # create roll npo and ctl self.roll_ctl_npo = primitive.addTransform( self.root, self.getName("roll_ctl_npo"), self.armChainUpvRef[0].getMatrix(worldSpace=True), ) if self.negate: off_x = -1.5708 else: off_x = 1.5708 off_y = 1.5708 self.roll_ctl = self.addCtl( self.roll_ctl_npo, "roll_ctl", transform.getTransform(self.roll_ctl_npo), self.color_ik, "compas", w=self.size * 0.3, ro=datatypes.Vector([off_x, off_y, 0]), tp=self.parentCtlTag, ) attribute.setKeyableAttributes(self.roll_ctl, ["rx"]) # create upv control v = self.guide.apos[2] - self.guide.apos[0] v = self.normal ^ v v.normalize() v *= self.size * 0.8 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 * 0.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 * 0.12, tp=self.parentCtlTag, ) attribute.setInvertMirror(self.ikcns_ctl, ["tx", "ty", "tz"]) if self.settings["use_blade"]: normal = self.blade_normal axis_ref1 = "xz" axis_ref2 = "x-z" else: normal = self.normal axis_ref1 = "x-y" axis_ref2 = "xy" if self.negate: m = transform.getTransformLookingAt( self.guide.pos["wrist"], self.guide.pos["eff"], normal, axis_ref1, True, ) else: m = transform.getTransformLookingAt( self.guide.pos["wrist"], self.guide.pos["eff"], normal, axis_ref2, False, ) self.ik_ctl = self.addCtl( self.ikcns_ctl, "ik_ctl", m, self.color_ik, "cube", w=self.size * 0.12, h=self.size * 0.12, d=self.size * 0.12, tp=self.roll_ctl, ) if self.settings["mirrorIK"]: if self.negate: self.ik_cns.sx.set(-1) self.ik_ctl.ry.set(self.ik_ctl.ry.get() * -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 * 0.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 if self.settings["use_blade"]: normal = self.blade_normal axis_ref = "x-z" else: normal = self.normal axis_ref = "xz" trnIK_ref = transform.getTransformLookingAt( self.guide.pos["wrist"], self.guide.pos["eff"], normal, axis_ref, 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 * 0.5) self.bone0_shp.setAttr("localScale", 0.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 * 0.5) self.bone1_shp.setAttr("localScale", 0.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] ) if self.settings["use_blade"]: # set the offset rotation for the hand self.off_t = transform.getTransformLookingAt( self.guide.pos["wrist"], self.guide.pos["eff"], self.blade_normal, axis="xy", negate=self.negate, ) self.eff_jnt_off = primitive.addTransform( self.eff_loc, self.getName("eff_off"), self.off_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 * 0.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) if self.settings["div0"]: twst0_parent = self.rollRef[0] else: twst0_parent = self.root self.tws0_loc = primitive.addTransform( twst0_parent, 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 ---------------------------------------- self.divisions = self.settings["div0"] + self.settings["div1"] + 2 self.div_cns = [] if self.settings["extraTweak"]: tagP = self.parentCtlTag self.tweak_ctl = [] for i in range(self.divisions): div_cns = primitive.addTransform( self.root, 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 * 0.15, d=self.size * 0.15, ro=datatypes.Vector([0, 0, 1.5708]), tp=tagP, ) attribute.setKeyableAttributes(tweak_ctl) tagP = tweak_ctl self.tweak_ctl.append(tweak_ctl) driver = tweak_ctl else: driver = div_cns # joint Description Name jd_names = ast.literal_eval( self.settings["jointNamesDescription_custom"] ) jdn_upperarm = jd_names[0] jdn_lowerarm = jd_names[1] jdn_upperarm_twist = jd_names[2] jdn_lowerarm_twist = jd_names[3] jdn_hand = jd_names[4] # setting the joints if i == 0: self.jnt_pos.append([driver, jdn_upperarm]) current_parent = "root" twist_name = jdn_upperarm_twist twist_idx = 1 increment = 1 elif i == self.settings["div0"] + 1: self.jnt_pos.append([driver, jdn_lowerarm, current_parent]) twist_name = jdn_lowerarm_twist current_parent = "elbow" twist_idx = self.settings["div1"] increment = -1 else: self.jnt_pos.append( [ driver, string.replaceSharpWithPadding(twist_name, twist_idx), current_parent, ] ) twist_idx += increment if self.settings["use_blade"]: eff_loc = self.eff_jnt_off else: eff_loc = self.eff_loc self.jnt_pos.append([eff_loc, jdn_hand, current_parent]) # match IK FK references self.match_fk0_off = self.add_match_ref( self.fk_ctl[1], self.root, "matchFk0_npo", False ) self.match_fk0 = self.add_match_ref( self.fk_ctl[0], self.match_fk0_off, "fk0_mth" ) self.match_fk1_off = self.add_match_ref( self.fk_ctl[2], self.root, "matchFk1_npo", False ) self.match_fk1 = self.add_match_ref( self.fk_ctl[1], self.match_fk1_off, "fk1_mth" ) if self.settings["ikTR"]: reference = self.ikRot_ctl self.match_ikRot = self.add_match_ref( self.ikRot_ctl, self.fk2_ctl, "ikRot_mth" ) else: reference = self.ik_ctl self.match_fk2 = self.add_match_ref( self.fk_ctl[2], reference, "fk2_mth" ) self.match_ik = self.add_match_ref(self.ik_ctl, self.fk2_ctl, "ik_mth") self.match_ikUpv = self.add_match_ref( self.upv_ctl, self.fk0_ctl, "upv_mth" ) # add visual reference self.line_ref = icon.connection_display_curve( self.getName("visalRef"), [self.upv_ctl, self.mid_ctl] )
def 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_global_in = [] self.fk_local_in = [] self.fk_local_out = [] self.fk_global_out = [] self.fk_global_ref = [] 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)) # global input global_t = transform.setMatrixPosition( datatypes.Matrix(), transform.getPositionFromMatrix(t)) fk_global_npo = primitive.addTransform( parent, self.getName("fk%s_global_npo" % i), global_t) fk_global_in = primitive.addTransform( fk_global_npo, self.getName("fk%s_global_in" % i), global_t) self.fk_global_in.append(fk_global_in) # local input fk_local_npo = primitive.addTransform( fk_global_in, self.getName("fk%s_local_npo" % i), tnpo) fk_local_in = primitive.addTransform( fk_local_npo, self.getName("fk%s_local_in" % i), tnpo) self.fk_local_in.append(fk_local_in) # output fk_global_out_npo = primitive.addTransform( parent, self.getName("fk%s_global_out_npo" % i), global_t) fk_global_out = primitive.addTransform( fk_global_out_npo, self.getName("fk%s_global_out" % i), global_t) self.fk_global_out.append(fk_global_out) fk_local_out_npo = primitive.addTransform( parent, self.getName("fk%s_local_out_npo" % i), tnpo) fk_local_out = primitive.addTransform( fk_local_out_npo, self.getName("fk%s_local_out" % i), tnpo) self.fk_local_out.append(fk_local_out) # fk npo fk_npo = primitive.addTransform(fk_local_in, self.getName("fk%s_npo" % i), tnpo) self.fk_npo.append(fk_npo) # ctl 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) self.fk_ctl.append(fk_ctl) # fk global ref fk_global_ref = primitive.addTransform( fk_ctl, self.getName("fk%s_global_ref" % i), global_t) self.fk_global_ref.append(fk_global_ref) attribute.setKeyableAttributes(fk_global_ref, []) parent = fk_ctl if not self.settings["simpleFK"]: 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.tweak_ctl.append(tweak_ctl) self.upv_curv_lvl.append(upv_curv_lvl) tOld = t self.previusTag = fk_ctl if not self.settings["simpleFK"]: # 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) if self.settings["extraTweak"]: tagP = self.parentCtlTag self.extratweak_ctl = [] 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]) if self.settings["extraTweak"]: t = transform.getTransform(div_cns) ro_vector = datatypes.Vector([0, 0, 1.5708]) tweak_ctl = self.addCtl(div_cns, "extraTweak%s_ctl" % i, t, self.color_fk, "square", w=self.size * .08, d=self.size * .08, ro=ro_vector, tp=tagP) attribute.setKeyableAttributes(tweak_ctl) tagP = tweak_ctl self.extratweak_ctl.append(tweak_ctl) self.jnt_pos.append([tweak_ctl, i, None, False]) else: self.jnt_pos.append([div_cns, i])
def addObjects(self): """Add all the objects needed to create the component.""" # FIXME: remove unneccessary guide.tan self.guide.apos.pop() self.divisions = len(self.guide.apos) 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] # -------------------------------------------------------- self.ik_ctl = [] self.ik_npo = [] self.ik_global_in = [] self.ik_local_in = [] self.ik_global_out = [] self.ik_global_ref = [] self.ik_uv_param = [] self.previusTag = self.parentCtlTag self.div_cns = [] self.div_cns_npo = [] self.fk_ctl = [] self.fk_npo = [] self.fk_local_npo = [] self.scl_transforms = [] self.twister = [] self.ref_twist = [] self.fk_global_in = [] self.fk_local_in = [] self.fk_global_out = [] self.fk_global_ref = [] self.fk_uv_param = [] # IK controls --------------------------------------------- self.dummy_crv = curve.addCurve( self.root, self.getName("dummy_crv"), self.guide.apos, close=False, degree=min([len(self.guide.apos) - 1, 3]) ) for i in range(self.settings["ikNb"]): self.addObjectsChainIk(i, self.dummy_crv) pm.delete(self.dummy_crv) # Curves ------------------------------------------- self.mst_crv = curve.addCnsCurve( self.root, self.getName("mst_crv"), 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) icon.connection_display_curve(self.getName("visualIKRef"), self.ik_ctl) if self.settings["isGlobalMaster"]: return else: self.addObjectsFkControl()
def addObjects(self): """Add all the objects needed to create the component.""" self.WIP = self.options["mode"] self.normal = self.getNormalFromPos(self.guide.apos) self.length0 = vector.getDistance(self.guide.apos[0], self.guide.apos[1]) self.length1 = vector.getDistance(self.guide.apos[1], self.guide.apos[2]) self.length2 = vector.getDistance(self.guide.apos[2], self.guide.apos[3]) # 1 bone chain for upv ref self.legChainUpvRef = primitive.add2DChain( self.root, self.getName("legUpvRef%s_jnt"), [self.guide.apos[0], self.guide.apos[2]], self.normal, False, self.WIP) self.legChainUpvRef[1].setAttr( "jointOrientZ", self.legChainUpvRef[1].getAttr("jointOrientZ") * -1) # extra neutral pose t = transform.getTransformFromPos(self.guide.apos[0]) self.root_npo = primitive.addTransform(self.root, self.getName("root_npo"), t) self.root_ctl = self.addCtl(self.root_npo, "root_ctl", t, self.color_fk, "circle", w=self.length0 / 6, tp=self.parentCtlTag) # FK Controlers ----------------------------------- t = transform.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, "xz", self.negate) self.fk0_npo = primitive.addTransform(self.root_ctl, self.getName("fk0_npo"), t) self.fk0_ctl = self.addCtl(self.fk0_npo, "fk0_ctl", t, self.color_fk, "cube", w=self.length0, h=self.size * .1, d=self.size * .1, po=datatypes.Vector( .5 * self.length0 * self.n_factor, 0, 0), tp=self.root_ctl) attribute.setKeyableAttributes( self.fk0_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) t = transform.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2], self.normal, "xz", self.negate) self.fk1_npo = primitive.addTransform(self.fk0_ctl, self.getName("fk1_npo"), t) self.fk1_ctl = self.addCtl(self.fk1_npo, "fk1_ctl", t, self.color_fk, "cube", w=self.length1, h=self.size * .1, d=self.size * .1, po=datatypes.Vector( .5 * self.length1 * self.n_factor, 0, 0), tp=self.fk0_ctl) attribute.setKeyableAttributes( self.fk1_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) t = transform.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3], self.normal, "xz", self.negate) self.fk2_npo = primitive.addTransform(self.fk1_ctl, self.getName("fk2_npo"), t) self.fk2_ctl = self.addCtl(self.fk2_npo, "fk2_ctl", t, self.color_fk, "cube", w=self.length2, h=self.size * .1, d=self.size * .1, po=datatypes.Vector( .5 * self.length2 * self.n_factor, 0, 0), tp=self.fk1_ctl) attribute.setKeyableAttributes(self.fk2_ctl) self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl] for x in self.fk_ctl: attribute.setInvertMirror(x, ["tx", "ty", "tz"]) # IK Controlers ----------------------------------- self.ik_cns = primitive.addTransformFromPos(self.root_ctl, self.getName("ik_cns"), self.guide.pos["ankle"]) self.ikcns_ctl = self.addCtl(self.ik_cns, "ikcns_ctl", transform.getTransformFromPos( self.guide.pos["ankle"]), self.color_ik, "null", w=self.size * .12, tp=self.root_ctl) attribute.setInvertMirror(self.ikcns_ctl, ["tx"]) m = transform.getTransformLookingAt(self.guide.pos["ankle"], self.guide.pos["eff"], self.x_axis, "zx", False) self.ik_ctl = self.addCtl(self.ikcns_ctl, "ik_ctl", transform.getTransformFromPos( self.guide.pos["ankle"]), self.color_ik, "cube", w=self.size * .12, h=self.size * .12, d=self.size * .12, tp=self.ikcns_ctl) attribute.setKeyableAttributes(self.ik_ctl) attribute.setRotOrder(self.ik_ctl, "XZY") attribute.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"]) # upv v = self.guide.apos[2] - self.guide.apos[0] v = self.normal ^ v v.normalize() v *= self.size * .5 v += self.guide.apos[1] self.upv_cns = primitive.addTransformFromPos(self.ik_ctl, self.getName("upv_cns"), v) self.upv_ctl = self.addCtl(self.upv_cns, "upv_ctl", transform.getTransform(self.upv_cns), self.color_ik, "diamond", w=self.size * .12, tp=self.root_ctl) if self.settings["mirrorMid"]: if self.negate: self.upv_cns.rz.set(180) self.upv_cns.sy.set(-1) else: attribute.setInvertMirror(self.upv_ctl, ["tx"]) attribute.setKeyableAttributes(self.upv_ctl, self.t_params) # References -------------------------------------- self.ik_ref = primitive.addTransform( self.ik_ctl, self.getName("ik_ref"), transform.getTransform(self.ik_ctl)) self.fk_ref = primitive.addTransform( self.fk_ctl[2], self.getName("fk_ref"), transform.getTransform(self.ik_ctl)) # Chain -------------------------------------------- # The outputs of the ikfk2bone solver self.bone0 = primitive.addLocator( self.root_ctl, self.getName("0_bone"), transform.getTransform(self.fk_ctl[0])) self.bone0_shp = self.bone0.getShape() self.bone0_shp.setAttr("localPositionX", self.n_factor * .5) self.bone0_shp.setAttr("localScale", .5, 0, 0) self.bone0.setAttr("sx", self.length0) self.bone0.setAttr("visibility", False) self.bone1 = primitive.addLocator( self.root_ctl, self.getName("1_bone"), transform.getTransform(self.fk_ctl[1])) self.bone1_shp = self.bone1.getShape() self.bone1_shp.setAttr("localPositionX", self.n_factor * .5) self.bone1_shp.setAttr("localScale", .5, 0, 0) self.bone1.setAttr("sx", self.length1) self.bone1.setAttr("visibility", False) tA = transform.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, "xz", self.negate) tA = transform.setMatrixPosition(tA, self.guide.apos[1]) tB = transform.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2], self.normal, "xz", self.negate) t = transform.getInterpolateTransformMatrix(tA, tB) self.ctrn_loc = primitive.addTransform(self.root, self.getName("ctrn_loc"), t) self.eff_loc = primitive.addTransformFromPos(self.root_ctl, self.getName("eff_loc"), self.guide.apos[2]) # tws_ref t = transform.getRotationFromAxis(datatypes.Vector(0, -1, 0), self.normal, "xz", self.negate) t = transform.setMatrixPosition(t, self.guide.pos["ankle"]) self.tws_ref = primitive.addTransform(self.eff_loc, self.getName("tws_ref"), t) # Mid Controler ------------------------------------ t = transform.getTransform(self.ctrn_loc) self.mid_cns = primitive.addTransform(self.ctrn_loc, self.getName("mid_cns"), t) self.mid_ctl = self.addCtl(self.mid_cns, "mid_ctl", t, self.color_ik, "sphere", w=self.size * .2, tp=self.root_ctl) if self.settings["mirrorMid"]: if self.negate: self.mid_cns.rz.set(180) self.mid_cns.sz.set(-1) else: attribute.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"]) attribute.setKeyableAttributes(self.mid_ctl, self.t_params) # Twist references --------------------------------- x = datatypes.Vector(0, -1, 0) x = x * transform.getTransform(self.eff_loc) z = datatypes.Vector(self.normal.x, self.normal.y, self.normal.z) z = z * transform.getTransform(self.eff_loc) m = transform.getRotationFromAxis(x, z, "xz", self.negate) m = transform.setMatrixPosition(m, transform.getTranslation(self.ik_ctl)) self.tws0_loc = primitive.addTransform( self.root_ctl, self.getName("tws0_loc"), transform.getTransform(self.fk_ctl[0])) self.tws0_rot = primitive.addTransform( self.tws0_loc, self.getName("tws0_rot"), transform.getTransform(self.fk_ctl[0])) self.tws1_loc = primitive.addTransform( self.ctrn_loc, self.getName("tws1_loc"), transform.getTransform(self.ctrn_loc)) self.tws1_rot = primitive.addTransform( self.tws1_loc, self.getName("tws1_rot"), transform.getTransform(self.ctrn_loc)) self.tws1A_npo = primitive.addTransform(self.mid_ctl, self.getName("tws1A_npo"), tA) self.tws1A_loc = primitive.addTransform(self.tws1A_npo, self.getName("tws1A_loc"), tA) self.tws1B_npo = primitive.addTransform(self.mid_ctl, self.getName("tws1B_npo"), tB) self.tws1B_loc = primitive.addTransform(self.tws1B_npo, self.getName("tws1B_loc"), tB) self.tws2_npo = primitive.addTransform( self.root, self.getName("tws2_npo"), transform.getTransform(self.fk_ctl[2])) self.tws2_loc = primitive.addTransform( self.tws2_npo, self.getName("tws2_loc"), transform.getTransform(self.fk_ctl[2])) self.tws2_rot = primitive.addTransform( self.tws2_npo, self.getName("tws2_rot"), transform.getTransform(self.fk_ctl[2])) # Roll twist chain --------------------------------- # Arm self.uplegChainPos = [] ii = 1.0 / (self.settings["div0"] + 1) i = 0.0 for p in range(self.settings["div0"] + 2): self.uplegChainPos.append( vector.linearlyInterpolate(self.guide.pos["root"], self.guide.pos["knee"], blend=i)) i = i + ii self.uplegTwistChain = primitive.add2DChain( self.root, self.getName("uplegTwist%s_jnt"), self.uplegChainPos, self.normal, False, self.WIP) # Forearm self.lowlegChainPos = [] ii = 1.0 / (self.settings["div1"] + 1) i = 0.0 for p in range(self.settings["div1"] + 2): self.lowlegChainPos.append( vector.linearlyInterpolate(self.guide.pos["knee"], self.guide.pos["ankle"], blend=i)) i = i + ii self.lowlegTwistChain = primitive.add2DChain( self.root, self.getName("lowlegTwist%s_jnt"), self.lowlegChainPos, self.normal, False, self.WIP) pm.parent(self.lowlegTwistChain[0], self.mid_ctl) # Hand Aux chain and nonroll self.auxChainPos = [] ii = .5 i = 0.0 for p in range(3): self.auxChainPos.append( vector.linearlyInterpolate(self.guide.pos["ankle"], self.guide.pos["eff"], blend=i)) i = i + ii t = self.root.getMatrix(worldSpace=True) self.aux_npo = primitive.addTransform(self.root, self.getName("aux_npo"), t) self.auxTwistChain = primitive.add2DChain( self.aux_npo, self.getName("auxTwist%s_jnt"), self.lowlegChainPos[:3], self.normal, False, self.WIP) # Non Roll join ref --------------------------------- self.uplegRollRef = primitive.add2DChain( self.root, self.getName("uplegRollRef%s_jnt"), self.uplegChainPos[:2], self.normal, False, self.WIP) self.lowlegRollRef = primitive.add2DChain( self.aux_npo, self.getName("lowlegRollRef%s_jnt"), self.lowlegChainPos[:2], self.normal, False, self.WIP) # Divisions ---------------------------------------- # We have at least one division at the start, the end and one for the # elbow. + 2 for knee angle control self.divisions = self.settings["div0"] + self.settings["div1"] + 4 self.div_cns = [] for i in range(self.divisions): div_cns = primitive.addTransform(self.root_ctl, self.getName("div%s_loc" % i)) self.div_cns.append(div_cns) self.jnt_pos.append([div_cns, i]) # End reference ------------------------------------ # To help the deformation on the ankle self.end_ref = primitive.addTransform(self.eff_loc, self.getName("end_ref"), m) for a in "xyz": self.end_ref.attr("s%s" % a).set(1.0) if self.negate: self.end_ref.attr("ry").set(-180.0) self.jnt_pos.append([self.end_ref, 'end']) # Tangent controls t = transform.getInterpolateTransformMatrix(self.fk_ctl[0], self.tws1A_npo, .5) self.uplegTangentA_loc = primitive.addTransform( self.root_ctl, self.getName("uplegTangentA_loc"), self.fk_ctl[0].getMatrix(worldSpace=True)) self.uplegTangentA_npo = primitive.addTransform( self.uplegTangentA_loc, self.getName("uplegTangentA_npo"), t) self.uplegTangentA_ctl = self.addCtl(self.uplegTangentA_npo, "uplegTangentA_ctl", t, self.color_ik, "circle", w=self.size * .2, ro=datatypes.Vector( 0, 0, 1.570796), tp=self.mid_ctl) if self.negate: self.uplegTangentA_npo.rz.set(180) self.uplegTangentA_npo.sz.set(-1) attribute.setKeyableAttributes(self.uplegTangentA_ctl, self.t_params) t = transform.getInterpolateTransformMatrix(self.fk_ctl[0], self.tws1A_npo, .9) self.uplegTangentB_npo = primitive.addTransform( self.tws1A_loc, self.getName("uplegTangentB_npo"), t) self.uplegTangentB_ctl = self.addCtl(self.uplegTangentB_npo, "uplegTangentB_ctl", t, self.color_ik, "circle", w=self.size * .1, ro=datatypes.Vector( 0, 0, 1.570796), tp=self.mid_ctl) if self.negate: self.uplegTangentB_npo.rz.set(180) self.uplegTangentB_npo.sz.set(-1) attribute.setKeyableAttributes(self.uplegTangentB_ctl, self.t_params) tC = self.tws1B_npo.getMatrix(worldSpace=True) tC = transform.setMatrixPosition(tC, self.guide.apos[2]) t = transform.getInterpolateTransformMatrix(self.tws1B_npo, tC, .1) self.lowlegTangentA_npo = primitive.addTransform( self.tws1B_loc, self.getName("lowlegTangentA_npo"), t) self.lowlegTangentA_ctl = self.addCtl(self.lowlegTangentA_npo, "lowlegTangentA_ctl", t, self.color_ik, "circle", w=self.size * .1, ro=datatypes.Vector( 0, 0, 1.570796), tp=self.mid_ctl) if self.negate: self.lowlegTangentA_npo.rz.set(180) self.lowlegTangentA_npo.sz.set(-1) attribute.setKeyableAttributes(self.lowlegTangentA_ctl, self.t_params) t = transform.getInterpolateTransformMatrix(self.tws1B_npo, tC, .5) self.lowlegTangentB_loc = primitive.addTransform( self.root, self.getName("lowlegTangentB_loc"), tC) self.lowlegTangentB_npo = primitive.addTransform( self.lowlegTangentB_loc, self.getName("lowlegTangentB_npo"), t) self.lowlegTangentB_ctl = self.addCtl(self.lowlegTangentB_npo, "lowlegTangentB_ctl", t, self.color_ik, "circle", w=self.size * .2, ro=datatypes.Vector( 0, 0, 1.570796), tp=self.mid_ctl) if self.negate: self.lowlegTangentB_npo.rz.set(180) self.lowlegTangentB_npo.sz.set(-1) attribute.setKeyableAttributes(self.lowlegTangentB_ctl, self.t_params) t = self.mid_ctl.getMatrix(worldSpace=True) self.kneeTangent_npo = primitive.addTransform( self.mid_ctl, self.getName("kneeTangent_npo"), t) self.kneeTangent_ctl = self.addCtl(self.kneeTangent_npo, "kneeTangent_ctl", t, self.color_fk, "circle", w=self.size * .25, ro=datatypes.Vector(0, 0, 1.570796), tp=self.mid_ctl) if self.negate: self.kneeTangent_npo.rz.set(180) self.kneeTangent_npo.sz.set(-1) attribute.setKeyableAttributes(self.kneeTangent_ctl, self.t_params) # match IK FK references self.match_fk0_off = self.add_match_ref(self.fk_ctl[1], self.root, "matchFk0_npo", False) self.match_fk0 = self.add_match_ref(self.fk_ctl[0], self.match_fk0_off, "fk0_mth") self.match_fk1_off = self.add_match_ref(self.fk_ctl[2], self.root, "matchFk1_npo", False) self.match_fk1 = self.add_match_ref(self.fk_ctl[1], self.match_fk1_off, "fk1_mth") self.match_fk2 = self.add_match_ref(self.fk_ctl[2], self.ik_ctl, "fk2_mth") self.match_ik = self.add_match_ref(self.ik_ctl, self.fk2_ctl, "ik_mth") self.match_ikUpv = self.add_match_ref(self.upv_ctl, self.fk0_ctl, "upv_mth") # add visual reference self.line_ref = icon.connection_display_curve( self.getName("visalRef"), [self.upv_ctl, self.mid_ctl])
def 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 # "z-x", t_align = transform.getTransformLookingAt(self.guide.apos[3], self.guide.apos[4], self.normal, "zx", False) if self.settings["ikOri"]: t = transform.getTransformFromPos(self.guide.pos["foot"]) # t = transform.getTransformLookingAt(self.guide.pos["foot"], # self.guide.pos["eff"], # self.x_axis, # "zx", # False) else: t = t_align 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_align) self.ik2b_bone_ref = primitive.addTransform( self.chain3bones[3], self.getName("ik2B_B_ref"), t_align) self.ik2b_blend = primitive.addTransform( self.ik_ctl, self.getName("ik2B_blend"), t_align) self.roll_ctl = self.addCtl(self.ik2b_blend, "roll_ctl", t_align, 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']) # 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_off = primitive.addTransform( self.root, self.getName("matchFk2_npo"), transform.getTransform(self.fk_ctl[3])) self.match_fk2 = primitive.addTransform( self.match_fk2_off, self.getName("fk2_mth"), transform.getTransform(self.fk_ctl[2])) self.match_fk3 = primitive.addTransform( self.ik_ctl, self.getName("fk3_mth"), transform.getTransform(self.fk_ctl[3])) self.match_ik = primitive.addTransform( self.fk3_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.knee_ctl])
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 # FK controllers ------------------------------------ self.fk_npo = [] self.fk_ctl = [] self.tweak_npo = [] self.tweak_ctl = [] self.curv_pos = [] self.upv_curv_pos = [] self.upv_curv_lvl = [] self.tangentsCtl = [] 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) tweak_npo = primitive.addTransform( parent, self.getName("tweak%s_npo" % i), tnpo) self.tweak_npo.append(tweak_npo) tweak_ctl = self.addCtl( tweak_npo, "tweak%s_ctl" % i, t, self.color_ik, "cube", w=self.size * .15, h=self.size * .05, d=self.size * .15, ro=datatypes.Vector([0, 0, 1.5708]), tp=self.previusTag) 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 # TANGENTS tangents = [] tangents_npo = [] tangents_upv = [] if not i: letters = "A" else: letters = "AB" for tang in letters: tang_npo = primitive.addTransform( tweak_ctl, self.getName("tng{}{}_npo".format(tang, str(i))), t) tangents_npo.append(tang_npo) tang_ctl = self.addCtl( tang_npo, "tng{}{}_ctl".format(tang, str(i)), t, self.color_ik, "square", w=self.size * .07, h=self.size * .07, d=self.size * .07, ro=datatypes.Vector([0, 0, 1.5708]), tp=self.previusTag) upv_tang_curv_lvl = primitive.addTransform( tang_ctl, self.getName("tngUpv{}{}_lvl".format(tang, str(i))), t) upv_tang_curv_lvl.attr("tz").set(.01) tangents_upv.append(upv_tang_curv_lvl) tangents.append(tang_ctl) tangents_npo[0].attr("tx").set(self.dist * .3333) # delete the first B tangent if not i: self.curv_pos.append(tweak_ctl) self.curv_pos.append(tangents[0]) self.upv_curv_pos.append(upv_curv_lvl) self.upv_curv_pos.append(tangents_upv[0]) else: self.curv_pos.append(tangents[1]) self.curv_pos.append(tweak_ctl) self.curv_pos.append(tangents[0]) self.upv_curv_pos.append(tangents_upv[1]) self.upv_curv_pos.append(upv_curv_lvl) self.upv_curv_pos.append(tangents_upv[0]) tangents_npo[1].attr("tx").set(self.dist * -.3333) self.tangentsCtl.extend(tangents) # ========== # 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, "cube", w=self.size * .15, h=self.size * .05, d=self.size * .15, ro=datatypes.Vector([0, 0, 1.5708]), tp=self.previusTag) 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) # tangent END tang_npo = primitive.addTransform( tweak_ctl, self.getName("tngEnd{}_npo".format(tang, str(i))), t) tang_ctl = self.addCtl( tang_npo, "tngEnd{}_ctl".format(tang, str(i)), t, self.color_ik, "square", w=self.size * .07, h=self.size * .07, d=self.size * .07, ro=datatypes.Vector([0, 0, 1.5708]), tp=self.previusTag) upv_tang_curv_lvl = primitive.addTransform( tang_ctl, self.getName("tngUpv{}{}_lvl".format(tang, str(i))), t) upv_tang_curv_lvl.attr("tz").set(.01) tangents_upv.append(upv_tang_curv_lvl) tang_npo.attr("tx").set(self.dist * -.3333) self.curv_pos.append(tang_ctl) self.curv_pos.append(tweak_ctl) self.upv_curv_pos.append(tang_ctl) self.upv_curv_pos.append(upv_curv_lvl) self.tangentsCtl.append(tang_ctl) # 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) 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]) # Curves ------------------------------------------- self.mst_crv = curve.addCnsCurve(self.root, self.getName("mst_crv"), self.curv_pos, 3) self.slv_crv = curve.addCurve(self.root, self.getName("slv_crv"), [datatypes.Vector()] * 32, False, 3) self.upv_crv = curve.addCnsCurve(self.root, self.getName("upv_crv"), self.upv_curv_pos, 3) self.slv_upv_crv = curve.addCurve(self.root, self.getName("slv_upv_crv"), [datatypes.Vector()] * 32, False, 3) self.mst_crv.setAttr("template", True) self.slv_crv.setAttr("visibility", False) self.upv_crv.setAttr("visibility", False) self.slv_upv_crv.setAttr("visibility", False) # Divisions self.div_cns = [] self.upv_cns = [] tagP = self.parentCtlTag self.Extra_tweak_npo = [] self.Extra_tweak_ctl = [] 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) t = transform.getTransform(div_cns) extraTweak_npo = primitive.addTransform( div_cns, self.getName("extraTweak{}_npo".format(tang, str(i))), t) self.Extra_tweak_npo.append(extraTweak_npo) Extra_tweak_ctl = self.addCtl(extraTweak_npo, "extraTweak%s_ctl" % i, t, self.color_fk, "circle", w=self.size * .15, d=self.size * .15, ro=datatypes.Vector([0, 0, 1.5708]), tp=tagP) attribute.setKeyableAttributes(Extra_tweak_ctl) self.Extra_tweak_ctl.append(Extra_tweak_ctl) self.jnt_pos.append([Extra_tweak_ctl, i])
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] # IK controls --------------------------------------------- self.ik_ctl = [] self.ik_global_in = [] self.ik_local_in = [] self.ik_global_out = [] self.ik_global_ref = [] self.previusTag = self.parentCtlTag for i, t in enumerate( transform.getChainTransform2(self.guide.apos, self.normal, self.negate)): # global input global_t = transform.setMatrixPosition( datatypes.Matrix(), transform.getPositionFromMatrix(t)) ik_global_npo = primitive.addTransform( self.root, self.getName("ik%s_global_npo" % i), global_t) ik_global_in = primitive.addTransform( ik_global_npo, self.getName("ik%s_global_in" % i), global_t) self.ik_global_in.append(ik_global_in) # local input ik_local_npo = primitive.addTransform( ik_global_in, self.getName("ik%s_local_npo" % i), t) ik_local_in = primitive.addTransform( ik_local_npo, self.getName("ik%s_local_in" % i), t) self.ik_local_in.append(ik_local_in) ik_npo = primitive.addTransform(ik_local_in, self.getName("ik%s_npo" % i), t) # output ik_global_out_npo = primitive.addTransform( self.root, self.getName("ik%s_global_out_npo" % i), global_t) ik_global_out = primitive.addTransform( ik_global_out_npo, self.getName("ik%s_global_out" % i), global_t) self.ik_global_out.append(ik_global_out) ik_ctl = self.addCtl(ik_npo, "ik%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) attribute.setKeyableAttributes(ik_ctl, self.tr_params) self.ik_ctl.append(ik_ctl) # ik global ref ik_global_ref = primitive.addTransform( ik_ctl, self.getName("ik%s_global_ref" % i), global_t) self.ik_global_ref.append(ik_global_ref) attribute.setKeyableAttributes(ik_global_ref, []) # Curves ------------------------------------------- self.mst_crv = curve.addCnsCurve(self.root, self.getName("mst_crv"), 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) # add visual reference icon.connection_display_curve(self.getName("visualIKRef"), self.ik_ctl) if not self.settings["isGlobalMaster"]: # 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 = [] self.fk_global_in = [] self.fk_local_in = [] self.fk_global_out = [] self.fk_global_ref = [] 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["fkNb"]): # 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 if i in [0, self.settings["fkNb"] - 1] and False: fk_ctl = primitive.addTransform( parentctl, self.getName("%s_loc" % i), transform.getTransform(parentctl)) fk_npo = fk_ctl if i in [self.settings["fkNb"] - 1]: self.fk_ctl.append(fk_ctl) else: m = transform.getTransform(self.root) m.inverse() t = transform.getTransform(parentctl) fk_npo = primitive.addTransform( parentctl, self.getName("fk%s_npo" % (i)), t) # local input fk_local_npo = primitive.addTransform( fk_npo, self.getName("fk%s_local_npo" % i), t) fk_local_in = primitive.addTransform( fk_local_npo, self.getName("fk%s_local_in" % i), t) self.fk_local_in.append(fk_local_in) fk_ctl = self.addCtl(fk_local_in, "fk%s_ctl" % (i), transform.getTransform(parentctl), self.color_fk, "cube", w=self.size * .1, h=self.size * .1, d=self.size * .1, tp=self.preiviousCtlTag, mirrorConf=self.mirror_conf) attribute.setKeyableAttributes(self.fk_ctl) attribute.setRotOrder(fk_ctl, "ZXY") self.fk_ctl.append(fk_ctl) self.preiviousCtlTag = fk_ctl 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) if self.settings["addJoints"]: 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) for x in self.fk_ctl[:-1]: attribute.setInvertMirror(x, ["tx", "rz", "ry"]) # add visual reference icon.connection_display_curve(self.getName("visualFKRef"), self.fk_ctl)