def addObjects(self): """Add the Guide Root, blade and locators""" self.root = self.addRoot() vTemp = transform.getOffsetPosition(self.root, [0, 4, 0]) self.tip = self.addLoc("tip", self.root, vTemp) vTan0 = vector.linearlyInterpolate( self.root.getTranslation(space="world"), self.tip.getTranslation(space="world"), 0.3333) self.tan0 = self.addLoc("tan0", self.root, vTan0) vTan1 = vector.linearlyInterpolate( self.tip.getTranslation(space="world"), self.root.getTranslation(space="world"), 0.3333) self.tan1 = self.addLoc("tan1", self.tip, vTan1) self.blade = self.addBlade("blade", self.root, self.tan0) # spine curve centers = [self.root, self.tan0, self.tan1, self.tip] self.dispcrv = self.addDispCurve("crv", centers, 3) self.dispcrv.attr("lineWidth").set(5) # tangent handles self.disp_tancrv0 = self.addDispCurve("crvTan0", [self.root, self.tan0]) self.disp_tancrv1 = self.addDispCurve("crvTan1", [self.tip, self.tan1])
def addObjects(self): """Add the Guide Root, blade and locators""" self.root = self.addRoot() vTemp = transform.getOffsetPosition(self.root, [0, 1, 0]) self.neck = self.addLoc("neck", self.root, vTemp) vTemp = transform.getOffsetPosition(self.root, [0, 1.1, 0]) self.head = self.addLoc("head", self.neck, vTemp) vTemp = transform.getOffsetPosition(self.root, [0, 2, 0]) self.eff = self.addLoc("eff", self.head, vTemp) v0 = vector.linearlyInterpolate( self.root.getTranslation(space="world"), self.neck.getTranslation(space="world"), 0.333, ) self.tan0 = self.addLoc("tan0", self.root, v0) v1 = vector.linearlyInterpolate( self.root.getTranslation(space="world"), self.neck.getTranslation(space="world"), 0.666, ) self.tan1 = self.addLoc("tan1", self.neck, v1) self.blade = self.addBlade("blade", self.root, self.tan0) centers = [self.root, self.tan0, self.tan1, self.neck] self.dispcrv = self.addDispCurve("neck_crv", centers, 3) centers = [self.neck, self.head, self.eff] self.dispcrv = self.addDispCurve("head_crv", centers, 1)
def getInterpolateTransformMatrix(t1, t2, blend=.5): """Interpolate 2 matrix. Arguments: t1 (matrix): Input matrix 1. t2 (matrix): Input matrix 2. blend (float): The blending value. Default 0.5 Returns: matrix: The newly interpolated transformation matrix. >>> t = tra.getInterpolateTransformMatrix(self.fk_ctl[0], self.tws1A_npo, .3333) """ # check if the input transforms are transformMatrix t1 = convert2TransformMatrix(t1) t2 = convert2TransformMatrix(t2) if (blend == 1.0): return t2 elif (blend == 0.0): return t1 # translate pos = vector.linearlyInterpolate(t1.getTranslation(space="world"), t2.getTranslation(space="world"), blend) # scale scaleA = datatypes.Vector(*t1.getScale(space="world")) scaleB = datatypes.Vector(*t2.getScale(space="world")) vs = vector.linearlyInterpolate(scaleA, scaleB, blend) # rotate q = quaternionSlerp(datatypes.Quaternion(t1.getRotationQuaternion()), datatypes.Quaternion(t2.getRotationQuaternion()), blend) # out result = datatypes.TransformationMatrix() result.setTranslation(pos, space="world") result.setRotationQuaternion(q.x, q.y, q.z, q.w) result.setScale([vs.x, vs.y, vs.z], space="world") return result
def constrainPointToVectorPlanar(point_a, point_b, driven_point, pcp=False, ws=True): """constrain a driven_point to the vector between two points Args: point_a (vector): point in space point_b (vector): point in space driven_point (str): target node to be constrained pcp (bool, optional): preserve child position ws (bool, optional): worldspace """ point_a = pm.PyNode(point_a) point_b = pm.PyNode(point_b) drivent_point = pm.PyNode(driven_point) v = vector.linearlyInterpolate( point_a.getMatrix(ws=ws).translate, point_b.getMatrix(ws=ws).translate) v.normalize() p1 = v * dot(drivent_point.getMatrix(ws=ws).translate, v) # p1.normalize() if pcp: cmds.move(p1[0], p1[1], p1[2], drivent_point.name(), os=not ws, pcp=True) else: drivent_point.setTranslation(p1, ws=True)
def getRepositionMatrix(node_matrix, orig_ref_matrix, mr_orig_ref_matrix, closestVerts): """Get the delta matrix from the original position and multiply by the new vert position. Add the rotations from the face normals. Args: node_matrix (pm.dt.Matrix): matrix of the guide orig_ref_matrix (pm.dt.Matrix): matrix from the original vert position closestVerts (str): name of the closest vert Returns: mmatrix: matrix of the new offset position, worldSpace """ current_vert = pm.PyNode(closestVerts[0]) mr_current_vert = pm.PyNode(closestVerts[1]) current_length = vector.getDistance(current_vert.getPosition("world"), mr_current_vert.getPosition("world")) orig_length = vector.getDistance(orig_ref_matrix.translate, mr_orig_ref_matrix.translate) orig_center = vector.linearlyInterpolate(orig_ref_matrix.translate, mr_orig_ref_matrix.translate) orig_center_matrix = pm.dt.Matrix() # orig_center_matrix.setTranslation(orig_center, pm.dt.Space.kWorld) orig_center_matrix = transform.setMatrixPosition(orig_center_matrix, orig_center) current_center = vector.linearlyInterpolate( current_vert.getPosition("world"), mr_current_vert.getPosition("world")) length_percentage = 1 if current_length != 0 or orig_length != 0: length_percentage = current_length / orig_length # refPosition_matrix = pm.dt.TransformationMatrix() refPosition_matrix = pm.dt.Matrix() # refPosition_matrix.setTranslation(current_center, pm.dt.Space.kWorld) refPosition_matrix = transform.setMatrixPosition(refPosition_matrix, current_center) deltaMatrix = node_matrix * orig_center_matrix.inverse() deltaMatrix = deltaMatrix * length_percentage deltaMatrix = transform.setMatrixScale(deltaMatrix) refPosition_matrix = deltaMatrix * refPosition_matrix return refPosition_matrix
def addObjects(self): """Add the Guide Root, blade and locators""" self.root = self.addRoot() vTemp = transform.getOffsetPosition(self.root, [0, 0, 0.5]) self.spineBase = self.addLoc("spineBase", self.root, vTemp) vTemp = transform.getOffsetPosition(self.root, [0, 0, 4]) self.spineTop = self.addLoc("spineTop", self.spineBase, vTemp) vTemp = transform.getOffsetPosition(self.root, [0, 0, 5]) self.chest = self.addLoc("chest", self.spineTop, vTemp) vTan0 = vector.linearlyInterpolate( self.spineBase.getTranslation(space="world"), self.spineTop.getTranslation(space="world"), 0.3333, ) self.tan0 = self.addLoc("tan0", self.spineBase, vTan0) vTan1 = vector.linearlyInterpolate( self.spineTop.getTranslation(space="world"), self.spineBase.getTranslation(space="world"), 0.3333, ) self.tan1 = self.addLoc("tan1", self.spineTop, vTan1) self.blade = self.addBlade("blade", self.root, self.spineTop) # spine curve self.disp_crv_hip = self.addDispCurve( "crvHip", [self.root, self.spineBase] ) self.disp_crv_chst = self.addDispCurve( "crvChest", [self.spineTop, self.chest] ) centers = [self.spineBase, self.tan0, self.tan1, self.spineTop] self.dispcrv = self.addDispCurve("crv", centers, 3) self.dispcrv.attr("lineWidth").set(5) # tangent handles self.disp_tancrv0 = self.addDispCurve( "crvTan0", [self.spineBase, self.tan0] ) self.disp_tancrv1 = self.addDispCurve( "crvTan1", [self.spineTop, self.tan1] )
def adjustBackPointPosition(blend=.6, height_only=True): """constrain nodes of the back on a vector distributed evenly Args: blend (float, optional): defaulted to .6 to mimic a sternum height_only (bool, optional): only adjust the height of nodes """ a = pm.PyNode("hips") b = pm.PyNode("shoulders") back_point = pm.PyNode("back") interp_vector = vector.linearlyInterpolate(a.getMatrix(ws=True).translate, b.getMatrix(ws=True).translate, blend=blend) if height_only: back_mat = back_point.getMatrix(ws=True) interp_vector[0] = back_mat.translate[0] interp_vector[2] = back_mat.translate[2] back_point.setTranslation(interp_vector)
def linerlyInterperlateNodes(a, b, nodes): """place the nodes on a vector between point a and b, evenly spaced Args: a (str): name of node b (str): name of node b nodes (list): of nodes to place on vector """ blend = 0 blend_step = .5 a = pm.PyNode(a) b = pm.PyNode(b) if len(nodes) > 1: blend_step = 1.0 / (len(nodes) + 1) for node in nodes: blend += blend_step node = pm.PyNode(node) a_trans = a.getMatrix(ws=True).translate b_trans = b.getMatrix(ws=True).translate interp_vector = vector.linearlyInterpolate(a_trans, b_trans, blend=blend) node.setTranslation(interp_vector)
def addObjects(self): """Add all the objects needed to create the component.""" # Auto bend with position controls ------------------- if self.settings["autoBend"]: self.autoBendChain = primitive.add2DChain( self.root, self.getName("autoBend%s_jnt"), [self.guide.apos[0], self.guide.apos[-1]], self.guide.blades["blade"].z * -1, False, True) for j in self.autoBendChain: j.drawStyle.set(2) # Ik Controlers ------------------------------------ if self.settings["IKWorldOri"]: t = datatypes.TransformationMatrix() t = transform.setMatrixPosition(t, self.guide.apos[0]) else: t = transform.getTransformLookingAt( self.guide.apos[0], self.guide.apos[-1], self.guide.blades["blade"].z * -1, "yx", self.negate) self.ik0_npo = primitive.addTransform(self.root, self.getName("ik0_npo"), t) self.ik0_ctl = self.addCtl(self.ik0_npo, "ik0_ctl", t, self.color_ik, "compas", w=self.size, tp=self.parentCtlTag) attribute.setKeyableAttributes(self.ik0_ctl, self.tr_params) attribute.setRotOrder(self.ik0_ctl, "ZXY") attribute.setInvertMirror(self.ik0_ctl, ["tx", "ry", "rz"]) # hip base joint # TODO: add option in setting for on/off if True: self.hip_lvl = primitive.addTransform(self.ik0_ctl, self.getName("hip_lvl"), t) self.jnt_pos.append([self.hip_lvl, "hip"]) t = transform.setMatrixPosition(t, self.guide.apos[-1]) if self.settings["autoBend"]: self.autoBend_npo = primitive.addTransform( self.root, self.getName("spinePosition_npo"), t) self.autoBend_ctl = self.addCtl(self.autoBend_npo, "spinePosition_ctl", t, self.color_ik, "square", w=self.size, d=.3 * self.size, tp=self.parentCtlTag) attribute.setKeyableAttributes(self.autoBend_ctl, ["tx", "ty", "tz", "ry"]) attribute.setInvertMirror(self.autoBend_ctl, ["tx", "ry"]) self.ik1_npo = primitive.addTransform(self.autoBendChain[0], self.getName("ik1_npo"), t) self.ik1autoRot_lvl = primitive.addTransform( self.ik1_npo, self.getName("ik1autoRot_lvl"), t) self.ik1_ctl = self.addCtl(self.ik1autoRot_lvl, "ik1_ctl", t, self.color_ik, "compas", w=self.size, tp=self.autoBend_ctl) else: t = transform.setMatrixPosition(t, self.guide.apos[-1]) self.ik1_npo = primitive.addTransform(self.root, self.getName("ik1_npo"), t) self.ik1_ctl = self.addCtl(self.ik1_npo, "ik1_ctl", t, self.color_ik, "compas", w=self.size, tp=self.ik0_ctl) attribute.setKeyableAttributes(self.ik1_ctl, self.tr_params) attribute.setRotOrder(self.ik1_ctl, "ZXY") attribute.setInvertMirror(self.ik1_ctl, ["tx", "ry", "rz"]) # Tangent controllers ------------------------------- if self.settings["centralTangent"]: # vec_pos = vector.linearlyInterpolate(self.guide.apos[0], # self.guide.apos[-1], # .33) vec_pos = self.guide.pos["tan0"] t = transform.setMatrixPosition(t, vec_pos) self.tan0_npo = primitive.addTransform(self.ik0_ctl, self.getName("tan0_npo"), t) self.tan0_off = primitive.addTransform(self.tan0_npo, self.getName("tan0_off"), t) self.tan0_ctl = self.addCtl(self.tan0_off, "tan0_ctl", t, self.color_ik, "sphere", w=self.size * .1, tp=self.ik0_ctl) attribute.setKeyableAttributes(self.tan0_ctl, self.t_params) # vec_pos = vector.linearlyInterpolate(self.guide.apos[0], # self.guide.apos[-1], # .66) vec_pos = self.guide.pos["tan1"] t = transform.setMatrixPosition(t, vec_pos) self.tan1_npo = primitive.addTransform(self.ik1_ctl, self.getName("tan1_npo"), t) self.tan1_off = primitive.addTransform(self.tan1_npo, self.getName("tan1_off"), t) self.tan1_ctl = self.addCtl(self.tan1_off, "tan1_ctl", t, self.color_ik, "sphere", w=self.size * .1, tp=self.ik0_ctl) attribute.setKeyableAttributes(self.tan1_ctl, self.t_params) # Tangent mid control vec_pos = vector.linearlyInterpolate(self.guide.apos[0], self.guide.apos[-1], .5) t = transform.setMatrixPosition(t, vec_pos) self.tan_npo = primitive.addTransform(self.tan0_npo, self.getName("tan_npo"), t) self.tan_ctl = self.addCtl(self.tan_npo, "tan_ctl", t, self.color_fk, "sphere", w=self.size * .2, tp=self.ik1_ctl) attribute.setKeyableAttributes(self.tan_ctl, self.t_params) attribute.setInvertMirror(self.tan_ctl, ["tx"]) else: # vec_pos = vector.linearlyInterpolate(self.guide.apos[0], # self.guide.apos[-1], # .33) vec_pos = self.guide.pos["tan0"] t = transform.setMatrixPosition(t, vec_pos) self.tan0_npo = primitive.addTransform(self.ik0_ctl, self.getName("tan0_npo"), t) self.tan0_ctl = self.addCtl(self.tan0_npo, "tan0_ctl", t, self.color_ik, "sphere", w=self.size * .2, tp=self.ik0_ctl) attribute.setKeyableAttributes(self.tan0_ctl, self.t_params) # vec_pos = vector.linearlyInterpolate(self.guide.apos[0], # self.guide.apos[-1], # .66) vec_pos = self.guide.pos["tan1"] t = transform.setMatrixPosition(t, vec_pos) self.tan1_npo = primitive.addTransform(self.ik1_ctl, self.getName("tan1_npo"), t) self.tan1_ctl = self.addCtl(self.tan1_npo, "tan1_ctl", t, self.color_ik, "sphere", w=self.size * .2, tp=self.ik1_ctl) attribute.setKeyableAttributes(self.tan1_ctl, self.t_params) attribute.setInvertMirror(self.tan0_ctl, ["tx"]) attribute.setInvertMirror(self.tan1_ctl, ["tx"]) # Curves ------------------------------------------- self.mst_crv = curve.addCnsCurve( self.root, self.getName("mst_crv"), [self.ik0_ctl, self.tan0_ctl, self.tan1_ctl, self.ik1_ctl], 3) self.slv_crv = curve.addCurve(self.root, self.getName("slv_crv"), [datatypes.Vector()] * 10, False, 3) self.mst_crv.setAttr("visibility", False) self.slv_crv.setAttr("visibility", False) # Division ----------------------------------------- # The user only define how many intermediate division he wants. # First and last divisions are an obligation. parentdiv = self.root parentctl = self.root self.div_cns = [] self.fk_ctl = [] self.fk_npo = [] self.scl_transforms = [] self.twister = [] self.ref_twist = [] t = transform.getTransformLookingAt(self.guide.apos[0], self.guide.apos[-1], self.guide.blades["blade"].z * -1, "yx", self.negate) parent_twistRef = primitive.addTransform( self.root, self.getName("reference"), transform.getTransform(self.root)) self.jointList = [] self.preiviousCtlTag = self.parentCtlTag for i in range(self.settings["division"]): # References div_cns = primitive.addTransform(parentdiv, self.getName("%s_cns" % i)) pm.setAttr(div_cns + ".inheritsTransform", False) self.div_cns.append(div_cns) parentdiv = div_cns # Controlers (First and last one are fake) # if i in [0]: # TODO: add option setting to add or not the first and # last controller for the fk if i in [0, self.settings["division"] - 1] and False: # if i in [0, self.settings["division"] - 1]: fk_ctl = primitive.addTransform( parentctl, self.getName("%s_loc" % i), transform.getTransform(parentctl)) fk_npo = fk_ctl if i in [self.settings["division"] - 1]: self.fk_ctl.append(fk_ctl) else: m = transform.getTransform(self.root) t = transform.getTransform(parentctl) m.inverse() fk_npo = primitive.addTransform(parentctl, self.getName("fk%s_npo" % (i)), t) fk_ctl = self.addCtl(fk_npo, "fk%s_ctl" % (i), transform.getTransform(parentctl), self.color_fk, "cube", w=self.size, h=self.size * .05, d=self.size, tp=self.preiviousCtlTag) 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) 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) # TODO: update this part with the optiona FK controls update for x in self.fk_ctl[:-1]: attribute.setInvertMirror(x, ["tx", "rz", "ry"]) # Connections (Hooks) ------------------------------ self.cnx0 = primitive.addTransform(self.root, self.getName("0_cnx")) self.cnx1 = primitive.addTransform(self.root, self.getName("1_cnx"))
def addObjects(self): """Add all the objects needed to create the component.""" self.WIP = self.options["mode"] self.normal = self.getNormalFromPos(self.guide.apos) self.length0 = vector.getDistance(self.guide.apos[0], self.guide.apos[1]) self.length1 = vector.getDistance(self.guide.apos[1], self.guide.apos[2]) self.length2 = vector.getDistance(self.guide.apos[2], self.guide.apos[3]) # 1 bone chain for upv ref self.legChainUpvRef = primitive.add2DChain( self.root, self.getName("legUpvRef%s_jnt"), [self.guide.apos[0], self.guide.apos[2]], self.normal, False, self.WIP) self.legChainUpvRef[1].setAttr( "jointOrientZ", self.legChainUpvRef[1].getAttr("jointOrientZ") * -1) # extra neutral pose t = transform.getTransformFromPos(self.guide.apos[0]) self.root_npo = primitive.addTransform(self.root, self.getName("root_npo"), t) self.root_ctl = self.addCtl(self.root_npo, "root_ctl", t, self.color_fk, "circle", w=self.length0 / 6, tp=self.parentCtlTag) # FK Controlers ----------------------------------- t = transform.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, "xz", self.negate) self.fk0_npo = primitive.addTransform(self.root_ctl, self.getName("fk0_npo"), t) self.fk0_ctl = self.addCtl(self.fk0_npo, "fk0_ctl", t, self.color_fk, "cube", w=self.length0, h=self.size * .1, d=self.size * .1, po=datatypes.Vector( .5 * self.length0 * self.n_factor, 0, 0), tp=self.root_ctl) attribute.setKeyableAttributes( self.fk0_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) t = transform.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2], self.normal, "xz", self.negate) self.fk1_npo = primitive.addTransform(self.fk0_ctl, self.getName("fk1_npo"), t) self.fk1_ctl = self.addCtl(self.fk1_npo, "fk1_ctl", t, self.color_fk, "cube", w=self.length1, h=self.size * .1, d=self.size * .1, po=datatypes.Vector( .5 * self.length1 * self.n_factor, 0, 0), tp=self.fk0_ctl) attribute.setKeyableAttributes( self.fk1_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) t = transform.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3], self.normal, "xz", self.negate) self.fk2_npo = primitive.addTransform(self.fk1_ctl, self.getName("fk2_npo"), t) self.fk2_ctl = self.addCtl(self.fk2_npo, "fk2_ctl", t, self.color_fk, "cube", w=self.length2, h=self.size * .1, d=self.size * .1, po=datatypes.Vector( .5 * self.length2 * self.n_factor, 0, 0), tp=self.fk1_ctl) attribute.setKeyableAttributes(self.fk2_ctl) self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl] for x in self.fk_ctl: attribute.setInvertMirror(x, ["tx", "ty", "tz"]) # IK Controlers ----------------------------------- self.ik_cns = primitive.addTransformFromPos(self.root_ctl, self.getName("ik_cns"), self.guide.pos["ankle"]) self.ikcns_ctl = self.addCtl(self.ik_cns, "ikcns_ctl", transform.getTransformFromPos( self.guide.pos["ankle"]), self.color_ik, "null", w=self.size * .12, tp=self.root_ctl) attribute.setInvertMirror(self.ikcns_ctl, ["tx"]) m = transform.getTransformLookingAt(self.guide.pos["ankle"], self.guide.pos["eff"], self.x_axis, "zx", False) self.ik_ctl = self.addCtl(self.ikcns_ctl, "ik_ctl", transform.getTransformFromPos( self.guide.pos["ankle"]), self.color_ik, "cube", w=self.size * .12, h=self.size * .12, d=self.size * .12, tp=self.ikcns_ctl) attribute.setKeyableAttributes(self.ik_ctl) attribute.setRotOrder(self.ik_ctl, "XZY") attribute.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"]) # upv v = self.guide.apos[2] - self.guide.apos[0] v = self.normal ^ v v.normalize() v *= self.size * .5 v += self.guide.apos[1] self.upv_cns = primitive.addTransformFromPos(self.ik_ctl, self.getName("upv_cns"), v) self.upv_ctl = self.addCtl(self.upv_cns, "upv_ctl", transform.getTransform(self.upv_cns), self.color_ik, "diamond", w=self.size * .12, tp=self.root_ctl) if self.settings["mirrorMid"]: if self.negate: self.upv_cns.rz.set(180) self.upv_cns.sy.set(-1) else: attribute.setInvertMirror(self.upv_ctl, ["tx"]) attribute.setKeyableAttributes(self.upv_ctl, self.t_params) # References -------------------------------------- self.ik_ref = primitive.addTransform( self.ik_ctl, self.getName("ik_ref"), transform.getTransform(self.ik_ctl)) self.fk_ref = primitive.addTransform( self.fk_ctl[2], self.getName("fk_ref"), transform.getTransform(self.ik_ctl)) # Chain -------------------------------------------- # The outputs of the ikfk2bone solver self.bone0 = primitive.addLocator( self.root_ctl, self.getName("0_bone"), transform.getTransform(self.fk_ctl[0])) self.bone0_shp = self.bone0.getShape() self.bone0_shp.setAttr("localPositionX", self.n_factor * .5) self.bone0_shp.setAttr("localScale", .5, 0, 0) self.bone0.setAttr("sx", self.length0) self.bone0.setAttr("visibility", False) self.bone1 = primitive.addLocator( self.root_ctl, self.getName("1_bone"), transform.getTransform(self.fk_ctl[1])) self.bone1_shp = self.bone1.getShape() self.bone1_shp.setAttr("localPositionX", self.n_factor * .5) self.bone1_shp.setAttr("localScale", .5, 0, 0) self.bone1.setAttr("sx", self.length1) self.bone1.setAttr("visibility", False) tA = transform.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, "xz", self.negate) tA = transform.setMatrixPosition(tA, self.guide.apos[1]) tB = transform.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2], self.normal, "xz", self.negate) t = transform.getInterpolateTransformMatrix(tA, tB) self.ctrn_loc = primitive.addTransform(self.root, self.getName("ctrn_loc"), t) self.eff_loc = primitive.addTransformFromPos(self.root_ctl, self.getName("eff_loc"), self.guide.apos[2]) # tws_ref t = transform.getRotationFromAxis(datatypes.Vector(0, -1, 0), self.normal, "xz", self.negate) t = transform.setMatrixPosition(t, self.guide.pos["ankle"]) self.tws_ref = primitive.addTransform(self.eff_loc, self.getName("tws_ref"), t) # Mid Controler ------------------------------------ t = transform.getTransform(self.ctrn_loc) self.mid_cns = primitive.addTransform(self.ctrn_loc, self.getName("mid_cns"), t) self.mid_ctl = self.addCtl(self.mid_cns, "mid_ctl", t, self.color_ik, "sphere", w=self.size * .2, tp=self.root_ctl) if self.settings["mirrorMid"]: if self.negate: self.mid_cns.rz.set(180) self.mid_cns.sz.set(-1) else: attribute.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"]) attribute.setKeyableAttributes(self.mid_ctl, self.t_params) # Twist references --------------------------------- x = datatypes.Vector(0, -1, 0) x = x * transform.getTransform(self.eff_loc) z = datatypes.Vector(self.normal.x, self.normal.y, self.normal.z) z = z * transform.getTransform(self.eff_loc) m = transform.getRotationFromAxis(x, z, "xz", self.negate) m = transform.setMatrixPosition(m, transform.getTranslation(self.ik_ctl)) self.tws0_loc = primitive.addTransform( self.root_ctl, self.getName("tws0_loc"), transform.getTransform(self.fk_ctl[0])) self.tws0_rot = primitive.addTransform( self.tws0_loc, self.getName("tws0_rot"), transform.getTransform(self.fk_ctl[0])) self.tws1_loc = primitive.addTransform( self.ctrn_loc, self.getName("tws1_loc"), transform.getTransform(self.ctrn_loc)) self.tws1_rot = primitive.addTransform( self.tws1_loc, self.getName("tws1_rot"), transform.getTransform(self.ctrn_loc)) self.tws1A_npo = primitive.addTransform(self.mid_ctl, self.getName("tws1A_npo"), tA) self.tws1A_loc = primitive.addTransform(self.tws1A_npo, self.getName("tws1A_loc"), tA) self.tws1B_npo = primitive.addTransform(self.mid_ctl, self.getName("tws1B_npo"), tB) self.tws1B_loc = primitive.addTransform(self.tws1B_npo, self.getName("tws1B_loc"), tB) self.tws2_npo = primitive.addTransform( self.root, self.getName("tws2_npo"), transform.getTransform(self.fk_ctl[2])) self.tws2_loc = primitive.addTransform( self.tws2_npo, self.getName("tws2_loc"), transform.getTransform(self.fk_ctl[2])) self.tws2_rot = primitive.addTransform( self.tws2_npo, self.getName("tws2_rot"), transform.getTransform(self.fk_ctl[2])) # Roll twist chain --------------------------------- # Arm self.uplegChainPos = [] ii = 1.0 / (self.settings["div0"] + 1) i = 0.0 for p in range(self.settings["div0"] + 2): self.uplegChainPos.append( vector.linearlyInterpolate(self.guide.pos["root"], self.guide.pos["knee"], blend=i)) i = i + ii self.uplegTwistChain = primitive.add2DChain( self.root, self.getName("uplegTwist%s_jnt"), self.uplegChainPos, self.normal, False, self.WIP) # Forearm self.lowlegChainPos = [] ii = 1.0 / (self.settings["div1"] + 1) i = 0.0 for p in range(self.settings["div1"] + 2): self.lowlegChainPos.append( vector.linearlyInterpolate(self.guide.pos["knee"], self.guide.pos["ankle"], blend=i)) i = i + ii self.lowlegTwistChain = primitive.add2DChain( self.root, self.getName("lowlegTwist%s_jnt"), self.lowlegChainPos, self.normal, False, self.WIP) pm.parent(self.lowlegTwistChain[0], self.mid_ctl) # Hand Aux chain and nonroll self.auxChainPos = [] ii = .5 i = 0.0 for p in range(3): self.auxChainPos.append( vector.linearlyInterpolate(self.guide.pos["ankle"], self.guide.pos["eff"], blend=i)) i = i + ii t = self.root.getMatrix(worldSpace=True) self.aux_npo = primitive.addTransform(self.root, self.getName("aux_npo"), t) self.auxTwistChain = primitive.add2DChain( self.aux_npo, self.getName("auxTwist%s_jnt"), self.lowlegChainPos[:3], self.normal, False, self.WIP) # Non Roll join ref --------------------------------- self.uplegRollRef = primitive.add2DChain( self.root, self.getName("uplegRollRef%s_jnt"), self.uplegChainPos[:2], self.normal, False, self.WIP) self.lowlegRollRef = primitive.add2DChain( self.aux_npo, self.getName("lowlegRollRef%s_jnt"), self.lowlegChainPos[:2], self.normal, False, self.WIP) # Divisions ---------------------------------------- # We have at least one division at the start, the end and one for the # elbow. + 2 for knee angle control self.divisions = self.settings["div0"] + self.settings["div1"] + 4 self.div_cns = [] for i in range(self.divisions): div_cns = primitive.addTransform(self.root_ctl, self.getName("div%s_loc" % i)) self.div_cns.append(div_cns) self.jnt_pos.append([div_cns, i]) # End reference ------------------------------------ # To help the deformation on the ankle self.end_ref = primitive.addTransform(self.eff_loc, self.getName("end_ref"), m) for a in "xyz": self.end_ref.attr("s%s" % a).set(1.0) if self.negate: self.end_ref.attr("ry").set(-180.0) self.jnt_pos.append([self.end_ref, 'end']) # Tangent controls t = transform.getInterpolateTransformMatrix(self.fk_ctl[0], self.tws1A_npo, .5) self.uplegTangentA_loc = primitive.addTransform( self.root_ctl, self.getName("uplegTangentA_loc"), self.fk_ctl[0].getMatrix(worldSpace=True)) self.uplegTangentA_npo = primitive.addTransform( self.uplegTangentA_loc, self.getName("uplegTangentA_npo"), t) self.uplegTangentA_ctl = self.addCtl(self.uplegTangentA_npo, "uplegTangentA_ctl", t, self.color_ik, "circle", w=self.size * .2, ro=datatypes.Vector( 0, 0, 1.570796), tp=self.mid_ctl) if self.negate: self.uplegTangentA_npo.rz.set(180) self.uplegTangentA_npo.sz.set(-1) attribute.setKeyableAttributes(self.uplegTangentA_ctl, self.t_params) t = transform.getInterpolateTransformMatrix(self.fk_ctl[0], self.tws1A_npo, .9) self.uplegTangentB_npo = primitive.addTransform( self.tws1A_loc, self.getName("uplegTangentB_npo"), t) self.uplegTangentB_ctl = self.addCtl(self.uplegTangentB_npo, "uplegTangentB_ctl", t, self.color_ik, "circle", w=self.size * .1, ro=datatypes.Vector( 0, 0, 1.570796), tp=self.mid_ctl) if self.negate: self.uplegTangentB_npo.rz.set(180) self.uplegTangentB_npo.sz.set(-1) attribute.setKeyableAttributes(self.uplegTangentB_ctl, self.t_params) tC = self.tws1B_npo.getMatrix(worldSpace=True) tC = transform.setMatrixPosition(tC, self.guide.apos[2]) t = transform.getInterpolateTransformMatrix(self.tws1B_npo, tC, .1) self.lowlegTangentA_npo = primitive.addTransform( self.tws1B_loc, self.getName("lowlegTangentA_npo"), t) self.lowlegTangentA_ctl = self.addCtl(self.lowlegTangentA_npo, "lowlegTangentA_ctl", t, self.color_ik, "circle", w=self.size * .1, ro=datatypes.Vector( 0, 0, 1.570796), tp=self.mid_ctl) if self.negate: self.lowlegTangentA_npo.rz.set(180) self.lowlegTangentA_npo.sz.set(-1) attribute.setKeyableAttributes(self.lowlegTangentA_ctl, self.t_params) t = transform.getInterpolateTransformMatrix(self.tws1B_npo, tC, .5) self.lowlegTangentB_loc = primitive.addTransform( self.root, self.getName("lowlegTangentB_loc"), tC) self.lowlegTangentB_npo = primitive.addTransform( self.lowlegTangentB_loc, self.getName("lowlegTangentB_npo"), t) self.lowlegTangentB_ctl = self.addCtl(self.lowlegTangentB_npo, "lowlegTangentB_ctl", t, self.color_ik, "circle", w=self.size * .2, ro=datatypes.Vector( 0, 0, 1.570796), tp=self.mid_ctl) if self.negate: self.lowlegTangentB_npo.rz.set(180) self.lowlegTangentB_npo.sz.set(-1) attribute.setKeyableAttributes(self.lowlegTangentB_ctl, self.t_params) t = self.mid_ctl.getMatrix(worldSpace=True) self.kneeTangent_npo = primitive.addTransform( self.mid_ctl, self.getName("kneeTangent_npo"), t) self.kneeTangent_ctl = self.addCtl(self.kneeTangent_npo, "kneeTangent_ctl", t, self.color_fk, "circle", w=self.size * .25, ro=datatypes.Vector(0, 0, 1.570796), tp=self.mid_ctl) if self.negate: self.kneeTangent_npo.rz.set(180) self.kneeTangent_npo.sz.set(-1) attribute.setKeyableAttributes(self.kneeTangent_ctl, self.t_params) # match IK FK references self.match_fk0_off = 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.""" t = transform.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.guide.blades["blade"].z * -1, "yx", self.negate) t2 = transform.setMatrixPosition(t, self.guide.apos[1]) int_t = t self.preiviousCtlTag = self.parentCtlTag # FK Controlers ------------------------------------ self.fk_ctl = [] self.fk_npo = [] parentctl = self.root blend_increment = 1.0 / (self.settings["division"] - 1) blend_val = 0.0 for i in range(self.settings["division"]): fk_npo = primitive.addTransform(parentctl, self.getName("fk%s_npo" % (i)), int_t) self.fk_npo.append(fk_npo) fk_ctl = self.addCtl(fk_npo, "fk%s_ctl" % (i), int_t, self.color_fk, "cube", w=self.size, h=self.size * .05, d=self.size, tp=self.preiviousCtlTag) self.fk_ctl.append(fk_ctl) self.preiviousCtlTag = fk_ctl parentctl = fk_ctl blend_val = blend_val + blend_increment int_t = transform.getInterpolateTransformMatrix(t, t2, blend=blend_val) for x in self.fk_ctl: attribute.setKeyableAttributes(x) attribute.setRotOrder(x, "ZXY") attribute.setInvertMirror(x, ["tx", "rz", "ry"]) # Ik Controlers ------------------------------------ self.ik0_npo = primitive.addTransform(self.fk_ctl[0], self.getName("ik0_npo"), t) self.ik0_ctl = self.addCtl(self.ik0_npo, "ik0_ctl", t, self.color_ik, "compas", w=self.size, tp=self.parentCtlTag) attribute.setKeyableAttributes(self.ik0_ctl, self.tr_params) attribute.setRotOrder(self.ik0_ctl, "ZXY") attribute.setInvertMirror(self.ik0_ctl, ["tx", "ry", "rz"]) t = transform.setMatrixPosition(t, self.guide.apos[1]) self.ik1_npo = primitive.addTransform(self.fk_ctl[-1], self.getName("ik1_npo"), t) self.ik1_ctl = self.addCtl(self.ik1_npo, "ik1_ctl", t, self.color_ik, "compas", w=self.size, tp=self.ik0_ctl) attribute.setKeyableAttributes(self.ik1_ctl, self.tr_params) attribute.setRotOrder(self.ik1_ctl, "ZXY") attribute.setInvertMirror(self.ik1_ctl, ["tx", "ry", "rz"]) # Tangent controllers ------------------------------- if self.settings["centralTangent"]: vec_pos = vector.linearlyInterpolate(self.guide.apos[0], self.guide.apos[1], .33) t = transform.setMatrixPosition(t, vec_pos) self.tan0_npo = primitive.addTransform(self.ik0_ctl, self.getName("tan0_npo"), t) self.tan0_off = primitive.addTransform(self.tan0_npo, self.getName("tan0_off"), t) self.tan0_ctl = self.addCtl(self.tan0_off, "tan0_ctl", t, self.color_ik, "sphere", w=self.size * .1, tp=self.ik0_ctl) attribute.setKeyableAttributes(self.tan0_ctl, self.t_params) vec_pos = vector.linearlyInterpolate(self.guide.apos[0], self.guide.apos[1], .66) t = transform.setMatrixPosition(t, vec_pos) self.tan1_npo = primitive.addTransform(self.ik1_ctl, self.getName("tan1_npo"), t) self.tan1_off = primitive.addTransform(self.tan1_npo, self.getName("tan1_off"), t) self.tan1_ctl = self.addCtl(self.tan1_off, "tan1_ctl", t, self.color_ik, "sphere", w=self.size * .1, tp=self.ik0_ctl) attribute.setKeyableAttributes(self.tan1_ctl, self.t_params) # Tangent mid control vec_pos = vector.linearlyInterpolate(self.guide.apos[0], self.guide.apos[1], .5) t = transform.setMatrixPosition(t, vec_pos) self.tan_npo = primitive.addTransform(self.tan0_npo, self.getName("tan_npo"), t) self.tan_ctl = self.addCtl(self.tan_npo, "tan_ctl", t, self.color_fk, "sphere", w=self.size * .2, tp=self.ik1_ctl) attribute.setKeyableAttributes(self.tan_ctl, self.t_params) attribute.setInvertMirror(self.tan_ctl, ["tx"]) else: vec_pos = vector.linearlyInterpolate(self.guide.apos[0], self.guide.apos[1], .33) t = transform.setMatrixPosition(t, vec_pos) self.tan0_npo = primitive.addTransform(self.ik0_ctl, self.getName("tan0_npo"), t) self.tan0_ctl = self.addCtl(self.tan0_npo, "tan0_ctl", t, self.color_ik, "sphere", w=self.size * .2, tp=self.ik0_ctl) attribute.setKeyableAttributes(self.tan0_ctl, self.t_params) vec_pos = vector.linearlyInterpolate(self.guide.apos[0], self.guide.apos[1], .66) t = transform.setMatrixPosition(t, vec_pos) self.tan1_npo = primitive.addTransform(self.ik1_ctl, self.getName("tan1_npo"), t) self.tan1_ctl = self.addCtl(self.tan1_npo, "tan1_ctl", t, self.color_ik, "sphere", w=self.size * .2, tp=self.ik1_ctl) attribute.setKeyableAttributes(self.tan1_ctl, self.t_params) attribute.setInvertMirror(self.tan0_ctl, ["tx"]) attribute.setInvertMirror(self.tan1_ctl, ["tx"]) # Curves ------------------------------------------- self.mst_crv = curve.addCnsCurve( self.root, self.getName("mst_crv"), [self.ik0_ctl, self.tan0_ctl, self.tan1_ctl, self.ik1_ctl], 3) self.slv_crv = curve.addCurve(self.root, self.getName("slv_crv"), [datatypes.Vector()] * 10, False, 3) self.mst_crv.setAttr("visibility", False) self.slv_crv.setAttr("visibility", False) # Division ----------------------------------------- # The user only define how many intermediate division he wants. # First and last divisions are an obligation. parentdiv = self.root parentctl = self.root self.div_cns = [] self.scl_transforms = [] self.twister = [] self.ref_twist = [] t = transform.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.guide.blades["blade"].z * -1, "yx", self.negate) parent_twistRef = primitive.addTransform( self.root, self.getName("reference"), transform.getTransform(self.root)) self.jointList = [] self.preiviousCtlTag = self.parentCtlTag for i in range(self.settings["division"]): # References div_cns = primitive.addTransform(parentdiv, self.getName("%s_cns" % i)) pm.setAttr(div_cns + ".inheritsTransform", False) self.div_cns.append(div_cns) parentdiv = div_cns parentctl = div_cns scl_ref = primitive.addTransform(parentctl, self.getName("%s_scl_ref" % i), transform.getTransform(parentctl)) self.scl_transforms.append(scl_ref) # Deformers (Shadow) self.jnt_pos.append([scl_ref, i]) # Twist references (This objects will replace the spinlookup # slerp solver behavior) t = transform.getTransformLookingAt( self.guide.apos[0], self.guide.apos[1], self.guide.blades["blade"].z * -1, "yx", self.negate) twister = primitive.addTransform(parent_twistRef, self.getName("%s_rot_ref" % i), t) ref_twist = primitive.addTransform(parent_twistRef, self.getName("%s_pos_ref" % i), t) ref_twist.setTranslation(datatypes.Vector(1.0, 0, 0), space="preTransform") self.twister.append(twister) self.ref_twist.append(ref_twist) # Connections (Hooks) ------------------------------ self.cnx0 = primitive.addTransform(self.root, self.getName("0_cnx")) self.cnx1 = primitive.addTransform(self.root, self.getName("1_cnx"))
def addObjects(self): """Add all the objects needed to create the component.""" self.up_axis = pm.upAxis(q=True, axis=True) # Auto bend with position controls ------------------- if self.settings["autoBend"]: self.autoBendChain = primitive.add2DChain( self.root, self.getName("autoBend%s_jnt"), [self.guide.apos[1], self.guide.apos[-2]], self.guide.blades["blade"].z * -1, False, True) for j in self.autoBendChain: j.drawStyle.set(2) # Ik Controlers ------------------------------------ if self.settings["IKWorldOri"]: t = datatypes.TransformationMatrix() t = transform.setMatrixPosition(t, self.guide.apos[1]) else: t = transform.getTransformLookingAt( self.guide.apos[1], self.guide.apos[-2], self.guide.blades["blade"].z * -1, "yx", self.negate) self.ik_off = primitive.addTransform(self.root, self.getName("ik_off"), t) # handle Z up orientation offset if self.up_axis == "z" and self.settings["IKWorldOri"]: self.ik_off.rx.set(90) t = transform.getTransform(self.ik_off) self.ik0_npo = primitive.addTransform(self.ik_off, self.getName("ik0_npo"), t) self.ik0_ctl = self.addCtl(self.ik0_npo, "ik0_ctl", t, self.color_ik, "compas", w=self.size, tp=self.parentCtlTag) attribute.setKeyableAttributes(self.ik0_ctl, self.tr_params) attribute.setRotOrder(self.ik0_ctl, "ZXY") attribute.setInvertMirror(self.ik0_ctl, ["tx", "ry", "rz"]) # pelvis self.length0 = vector.getDistance(self.guide.apos[0], self.guide.apos[1]) vec_po = datatypes.Vector(0, .5 * self.length0 * -1, 0) self.pelvis_npo = primitive.addTransform(self.ik0_ctl, self.getName("pelvis_npo"), t) self.pelvis_ctl = self.addCtl(self.pelvis_npo, "pelvis_ctl", t, self.color_ik, "cube", h=self.length0, w=self.size * .1, d=self.size * .1, po=vec_po, tp=self.parentCtlTag) self.pelvis_lvl = primitive.addTransform( self.pelvis_ctl, self.getName("pelvis_lvl"), transform.setMatrixPosition(t, self.guide.apos[0])) self.jnt_pos.append([self.pelvis_lvl, "pelvis"]) t = transform.setMatrixPosition(t, self.guide.apos[-2]) if self.settings["autoBend"]: self.autoBend_npo = primitive.addTransform( self.root, self.getName("spinePosition_npo"), t) self.autoBend_ctl = self.addCtl(self.autoBend_npo, "spinePosition_ctl", t, self.color_ik, "square", w=self.size, d=.3 * self.size, tp=self.parentCtlTag) attribute.setKeyableAttributes(self.autoBend_ctl, ["tx", "ty", "tz", "ry"]) attribute.setInvertMirror(self.autoBend_ctl, ["tx", "ry"]) self.ik1_npo = primitive.addTransform(self.autoBendChain[0], self.getName("ik1_npo"), t) self.ik1autoRot_lvl = primitive.addTransform( self.ik1_npo, self.getName("ik1autoRot_lvl"), t) self.ik1_ctl = self.addCtl(self.ik1autoRot_lvl, "ik1_ctl", t, self.color_ik, "compas", w=self.size, tp=self.autoBend_ctl) else: t = transform.setMatrixPosition(t, self.guide.apos[-2]) self.ik1_npo = primitive.addTransform(self.root, self.getName("ik1_npo"), t) self.ik1_ctl = self.addCtl(self.ik1_npo, "ik1_ctl", t, self.color_ik, "compas", w=self.size, tp=self.ik0_ctl) attribute.setKeyableAttributes(self.ik1_ctl, self.tr_params) attribute.setRotOrder(self.ik1_ctl, "ZXY") attribute.setInvertMirror(self.ik1_ctl, ["tx", "ry", "rz"]) # Tangent controllers ------------------------------- if self.settings["centralTangent"]: vec_pos = self.guide.pos["tan0"] t = transform.setMatrixPosition(t, vec_pos) self.tan0_npo = primitive.addTransform(self.ik0_ctl, self.getName("tan0_npo"), t) self.tan0_off = primitive.addTransform(self.tan0_npo, self.getName("tan0_off"), t) self.tan0_ctl = self.addCtl(self.tan0_off, "tan0_ctl", t, self.color_ik, "sphere", w=self.size * .1, tp=self.ik0_ctl) attribute.setKeyableAttributes(self.tan0_ctl, self.t_params) vec_pos = self.guide.pos["tan1"] t = transform.setMatrixPosition(t, vec_pos) self.tan1_npo = primitive.addTransform(self.ik1_ctl, self.getName("tan1_npo"), t) self.tan1_off = primitive.addTransform(self.tan1_npo, self.getName("tan1_off"), t) self.tan1_ctl = self.addCtl(self.tan1_off, "tan1_ctl", t, self.color_ik, "sphere", w=self.size * .1, tp=self.ik0_ctl) attribute.setKeyableAttributes(self.tan1_ctl, self.t_params) # Tangent mid control vec_pos = vector.linearlyInterpolate(self.guide.apos[1], self.guide.apos[-2], .5) t = transform.setMatrixPosition(t, vec_pos) self.tan_npo = primitive.addTransform(self.tan0_npo, self.getName("tan_npo"), t) self.tan_ctl = self.addCtl(self.tan_npo, "tan_ctl", t, self.color_fk, "sphere", w=self.size * .2, tp=self.ik1_ctl) attribute.setKeyableAttributes(self.tan_ctl, self.t_params) attribute.setInvertMirror(self.tan_ctl, ["tx"]) else: vec_pos = self.guide.pos["tan0"] t = transform.setMatrixPosition(t, vec_pos) self.tan0_npo = primitive.addTransform(self.ik0_ctl, self.getName("tan0_npo"), t) self.tan0_ctl = self.addCtl(self.tan0_npo, "tan0_ctl", t, self.color_ik, "sphere", w=self.size * .2, tp=self.ik0_ctl) attribute.setKeyableAttributes(self.tan0_ctl, self.t_params) vec_pos = self.guide.pos["tan1"] t = transform.setMatrixPosition(t, vec_pos) self.tan1_npo = primitive.addTransform(self.ik1_ctl, self.getName("tan1_npo"), t) self.tan1_ctl = self.addCtl(self.tan1_npo, "tan1_ctl", t, self.color_ik, "sphere", w=self.size * .2, tp=self.ik1_ctl) attribute.setKeyableAttributes(self.tan1_ctl, self.t_params) attribute.setInvertMirror(self.tan0_ctl, ["tx"]) attribute.setInvertMirror(self.tan1_ctl, ["tx"]) # Curves ------------------------------------------- self.mst_crv = curve.addCnsCurve( self.root, self.getName("mst_crv"), [self.ik0_ctl, self.tan0_ctl, self.tan1_ctl, self.ik1_ctl], 3) self.slv_crv = curve.addCurve(self.root, self.getName("slv_crv"), [datatypes.Vector()] * 10, False, 3) self.mst_crv.setAttr("visibility", False) self.slv_crv.setAttr("visibility", False) # Division ----------------------------------------- # The user only define how many intermediate division he wants. # First and last divisions are an obligation. parentdiv = self.root parentctl = self.root self.div_cns = [] self.fk_ctl = [] self.fk_npo = [] self.scl_transforms = [] self.twister = [] self.ref_twist = [] t = transform.getTransformLookingAt(self.guide.apos[1], self.guide.apos[-2], self.guide.blades["blade"].z * -1, "yx", self.negate) parent_twistRef = primitive.addTransform( self.root, self.getName("reference"), transform.getTransform(self.root)) self.jointList = [] self.preiviousCtlTag = self.parentCtlTag for i in range(self.settings["division"]): # References div_cns = primitive.addTransform(parentdiv, self.getName("%s_cns" % i)) pm.setAttr(div_cns + ".inheritsTransform", False) self.div_cns.append(div_cns) parentdiv = div_cns t = transform.getTransform(parentctl) fk_npo = primitive.addTransform(parentctl, self.getName("fk%s_npo" % (i)), t) fk_ctl = self.addCtl(fk_npo, "fk%s_ctl" % (i), transform.getTransform(parentctl), self.color_fk, "cube", w=self.size, h=self.size * .05, d=self.size, tp=self.preiviousCtlTag) 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 if i == self.settings["division"] - 1: t = transform.getTransformLookingAt( self.guide.pos["spineTop"], self.guide.pos["chest"], self.guide.blades["blade"].z * -1, "yx", False) scl_ref_parent = self.root else: t = transform.getTransform(parentctl) scl_ref_parent = parentctl scl_ref = primitive.addTransform(scl_ref_parent, self.getName("%s_scl_ref" % i), t) self.scl_transforms.append(scl_ref) # Deformers (Shadow) self.jnt_pos.append([scl_ref, "spine_" + str(i + 1).zfill(2)]) # 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"]) # Connections (Hooks) ------------------------------ self.cnx0 = primitive.addTransform(self.root, self.getName("0_cnx")) self.cnx1 = primitive.addTransform(self.root, self.getName("1_cnx")) self.jnt_pos.append([self.cnx1, "spine_" + str(i + 2).zfill(2)])