def null(parent=None, name="null", width=1, color=[0, 0, 0], m=datatypes.Matrix(), pos_offset=None, rot_offset=None): """Create a curve with a NULL shape. Arguments: parent (dagNode): The parent object of the newly created curve. name (str): Name of the curve. width (float): Width of the shape. color (int or list of float): The color in index base or RGB. m (matrix): The global transformation of the curve. pos_offset (vector): The xyz position offset of the curve from its center. rot_offset (vector): The xyz rotation offset of the curve from its center. xyz in radians Returns: dagNode: The newly created icon. """ dlen = width * .5 v0 = datatypes.Vector(dlen, 0, 0) v1 = datatypes.Vector(-dlen, 0, 0) v2 = datatypes.Vector(0, dlen, 0) v3 = datatypes.Vector(0, -dlen, 0) v4 = datatypes.Vector(0, 0, dlen) v5 = datatypes.Vector(0, 0, -dlen) points = getPointArrayWithOffset([v0, v1], pos_offset, rot_offset) node = curve.addCurve(parent, name, points, False, 1, m) points = getPointArrayWithOffset([v2, v3], pos_offset, rot_offset) crv_0 = curve.addCurve(parent, name, points, False, 1, m) points = getPointArrayWithOffset([v4, v5], pos_offset, rot_offset) crv_1 = curve.addCurve(parent, name, points, False, 1, m) for crv in [crv_0, crv_1]: for shp in crv.listRelatives(shapes=True): node.addChild(shp, add=True, shape=True) pm.delete(crv) setcolor(node, color) return node
def addCnsCurve(parent, name, centers, degree=1): """Create a curve attached to given centers. One point per center Return gear curvecns node. Arguments: parent (dagNode): Parent object. name (str): Name centers (list of dagNode): Object that will drive the curve. degree (int): 1 for linear curve, 3 for Cubic. Returns: dagNode: The newly created curve. """ # rebuild list to avoid input list modification centers = centers[:] if degree == 3: if len(centers) == 2: centers.insert(0, centers[0]) centers.append(centers[-1]) elif len(centers) == 3: centers.append(centers[-1]) points = [datatypes.Vector() for center in centers] node = curve.addCurve(parent, name, points, False, degree) gearNode = applyop.gear_curvecns_op(node, centers) return node, gearNode
def create_guide_rig(name, pos, scalp, sections, length, thickness): global COLOR if pos: face = transform.getClosestPolygonFromTransform( pm.PyNode(scalp), pos)[0] rot = transform.get_orientation_from_polygon(face) # section distance sd = length / (sections - 1) points = [] x = 0.0 for s in range(sections): p = [x, 0, 0] points.append(p) x += sd # create curve crv = curve.addCurve(None, name, points) crv.rotate.set(rot) crv.translate.set(pos) # lock first point in the curve curve.lock_first_point(crv) # set color and thickness curve.set_color(crv, COLOR) curve.set_thickness(crv, thickness) return crv
def cross(parent=None, name="cross", width=1, color=[0, 0, 0], m=datatypes.Matrix(), pos_offset=None, rot_offset=None): """Create a curve with a CROSS shape. Arguments: parent (dagNode): The parent object of the newly created curve. name (str): Name of the curve. width (float): Width of the shape. color (int or list of float): The color in index base or RGB. m (matrix): The global transformation of the curve. pos_offset (vector): The xyz position offset of the curve from its center. rot_offset (vector): The xyz rotation offset of the curve from its center. xyz in radians Returns: dagNode: The newly created icon. """ width = width * 0.35 offset1 = width * .5 offset2 = width * 1.5 v0 = datatypes.Vector(width, offset2, 0) v1 = datatypes.Vector(offset2, width, 0) v2 = datatypes.Vector(offset1, 0, 0) v3 = datatypes.Vector(offset2, -width, 0) v4 = datatypes.Vector(width, -offset2, 0) v5 = datatypes.Vector(0, -offset1, 0) v6 = datatypes.Vector(-width, -offset2, 0) v7 = datatypes.Vector(-offset2, -width, 0) v8 = datatypes.Vector(-offset1, 0, 0) v9 = datatypes.Vector(-offset2, width, 0) v10 = datatypes.Vector(-width, offset2, 0) v11 = datatypes.Vector(0, offset1, 0) points = getPointArrayWithOffset( [v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11], pos_offset, rot_offset) node = curve.addCurve(parent, name, points, True, 1, m) setcolor(node, color) return node
def cube(parent=None, name="cube", width=1, height=1, depth=1, color=[0, 0, 0], m=datatypes.Matrix(), pos_offset=None, rot_offset=None): """Create a curve with a CUBE shape. Arguments: parent (dagNode): The parent object of the newly created curve. name (str): Name of the curve. width (float): Width of the shape. height (float): Height of the shape. depth (float): Depth of the shape. color (int or list of float): The color in index base or RGB. m (matrix): The global transformation of the curve. pos_offset (vector): The xyz position offset of the curve from its center. rot_offset (vector): The xyz rotation offset of the curve from its center. xyz in radians Returns: dagNode: The newly created icon. """ lenX = width * 0.5 lenY = height * 0.5 lenZ = depth * 0.5 # p is positive, N is negative ppp = datatypes.Vector(lenX, lenY, lenZ) ppN = datatypes.Vector(lenX, lenY, lenZ * -1) pNp = datatypes.Vector(lenX, lenY * -1, lenZ) Npp = datatypes.Vector(lenX * -1, lenY, lenZ) pNN = datatypes.Vector(lenX, lenY * -1, lenZ * -1) NNp = datatypes.Vector(lenX * -1, lenY * -1, lenZ) NpN = datatypes.Vector(lenX * -1, lenY, lenZ * -1) NNN = datatypes.Vector(lenX * -1, lenY * -1, lenZ * -1) v_array = [ ppp, ppN, NpN, NNN, NNp, Npp, NpN, Npp, ppp, pNp, NNp, pNp, pNN, ppN, pNN, NNN ] points = getPointArrayWithOffset(v_array, pos_offset, rot_offset) node = curve.addCurve(parent, name, points, False, 1, m) setcolor(node, color) return node
def guideBladeIcon(parent=None, name="blade", lenX=1.0, color=[0, 0, 0], m=datatypes.Matrix(), pos_offset=None, rot_offset=None): """Create a curve with a BLADE GUIDE shape. Note: This icon is specially design for **Shifter** blade guides Arguments: parent (dagNode): The parent object of the newly created curve. name (str): Name of the curve. lenX (float): Width of the shape. color (int or list of float): The color in index base or RGB. m (matrix): The global transformation of the curve. pos_offset (vector): The xyz position offset of the curve from its center. rot_offset (vector): The xyz rotation offset of the curve from its center. xyz in radians Returns: dagNode: The newly created icon. """ v0 = datatypes.Vector(0, 0, 0) v1 = datatypes.Vector(lenX / 2, 0, 0) v2 = datatypes.Vector(lenX, lenX / 4, 0) v3 = datatypes.Vector(lenX / 2, lenX / 2, 0) v4 = datatypes.Vector(0, lenX / 2, 0) points = getPointArrayWithOffset([v0, v1, v2, v3, v4], pos_offset, rot_offset) bladeIco = curve.addCurve(parent, name, points, True, 1, m) setcolor(bladeIco, color) attribute.setNotKeyableAttributes(bladeIco) attribute.unlockAttribute(bladeIco, attributes=[ "tx", "ty", "tz", "rx", "ry", "rz", "sx", "sy", "sz", "v", "ro" ]) # bladeIco.scale.set(1, 1, 1) # Set the control shapes isHistoricallyInteresting for oShape in bladeIco.getShapes(): oShape.isHistoricallyInteresting.set(False) return bladeIco
def cubewithpeak(parent=None, name="cubewithpeak", width=1, color=[0, 0, 0], m=datatypes.Matrix(), pos_offset=None, rot_offset=None): """Create a curve with a CUBE WITH PEAK shape. Arguments: parent (dagNode): The parent object of the newly created curve. name (str): Name of the curve. width (float): Width of the shape. color (int or list of float): The color in index base or RGB. m (matrix): The global transformation of the curve. pos_offset (vector): The xyz position offset of the curve from its center. rot_offset (vector): The xyz rotation offset of the curve from its center. xyz in radians Returns: dagNode: The newly created icon. """ dlen = width * 0.5 peak = datatypes.Vector(0, width, 0) ppp = datatypes.Vector(dlen, dlen, dlen) ppN = datatypes.Vector(dlen, dlen, dlen * -1) pNp = datatypes.Vector(dlen, 0, dlen) Npp = datatypes.Vector(dlen * -1, dlen, dlen) pNN = datatypes.Vector(dlen, 0, dlen * -1) NNp = datatypes.Vector(dlen * -1, 0, dlen) NpN = datatypes.Vector(dlen * -1, dlen, dlen * -1) NNN = datatypes.Vector(dlen * -1, 0, dlen * -1) v_array = [ peak, ppp, ppN, peak, NpN, ppN, NpN, peak, Npp, NpN, NNN, NNp, Npp, NpN, Npp, ppp, pNp, NNp, pNp, pNN, ppN, pNN, NNN ] points = getPointArrayWithOffset(v_array, pos_offset, rot_offset) node = curve.addCurve(parent, name, points, False, 1, m) setcolor(node, color) return node
def diamond(parent=None, name="diamond", width=1, color=[0, 0, 0], m=datatypes.Matrix(), pos_offset=None, rot_offset=None): """Create a curve with a DIAMOND shape. Arguments: parent (dagNode): The parent object of the newly created curve. name (str): Name of the curve. width (float): Width of the shape. height (float): Height of the shape. depth (float): Depth of the shape. color (int or list of float): The color in index base or RGB. m (matrix): The global transformation of the curve. pos_offset (vector): The xyz position offset of the curve from its center. rot_offset (vector): The xyz rotation offset of the curve from its center. xyz in radians Returns: dagNode: The newly created icon. """ dlen = width * 0.5 top = datatypes.Vector(0, dlen, 0) pp = datatypes.Vector(dlen, 0, dlen) pN = datatypes.Vector(dlen, 0, dlen * -1) Np = datatypes.Vector(dlen * -1, 0, dlen) NN = datatypes.Vector(dlen * -1, 0, dlen * -1) bottom = (0, -dlen, 0) v_array = [ pp, top, pN, pp, Np, top, NN, Np, NN, pN, bottom, NN, bottom, Np, bottom, pp ] points = getPointArrayWithOffset(v_array, pos_offset, rot_offset) node = curve.addCurve(parent, name, points, False, 1, m) setcolor(node, color) return node
def compas(parent=None, name="compas", width=1, color=[0, 0, 0], m=datatypes.Matrix(), pos_offset=None, rot_offset=None, degree=3): """Create a curve with a COMPAS shape. Arguments: parent (dagNode): The parent object of the newly created curve. name (str): Name of the curve. width (float): Width of the shape. color (int or list of float): The color in index base or RGB. m (matrix): The global transformation of the curve. pos_offset (vector): The xyz position offset of the curve from its center. rot_offset (vector): The xyz rotation offset of the curve from its center. xyz in radians Returns: dagNode: The newly created icon. """ dlen = width * 0.5 division = 24 point_pos = [] v = datatypes.Vector(0, 0, dlen) for i in range(division): if i == division / 2: w = datatypes.Vector(v.x, v.y, v.z - dlen * .4) else: w = datatypes.Vector(v.x, v.y, v.z) point_pos.append(w) v = v.rotateBy((0, (2 * pmu.math.pi) / (division + 0.0), 0)) points = getPointArrayWithOffset(point_pos, pos_offset, rot_offset) node = curve.addCurve(parent, name, points, True, degree, m) setcolor(node, color) return node
def circle(parent=None, name="circle", width=1, color=[0, 0, 0], m=datatypes.Matrix(), pos_offset=None, rot_offset=None, degree=3): """Create a curve with a CIRCLE shape. Arguments: parent (dagNode): The parent object of the newly created curve. name (str): Name of the curve. width (float): Width of the shape. color (int or list of float): The color in index base or RGB. m (matrix): The global transformation of the curve. pos_offset (vector): The xyz position offset of the curve from its center. rot_offset (vector): The xyz rotation offset of the curve from its center. xyz in radians Returns: dagNode: The newly created icon. """ dlen = width * 0.5 v0 = datatypes.Vector(0, 0, -dlen * 1.108) v1 = datatypes.Vector(dlen * .78, 0, -dlen * .78) v2 = datatypes.Vector(dlen * 1.108, 0, 0) v3 = datatypes.Vector(dlen * .78, 0, dlen * .78) v4 = datatypes.Vector(0, 0, dlen * 1.108) v5 = datatypes.Vector(-dlen * .78, 0, dlen * .78) v6 = datatypes.Vector(-dlen * 1.108, 0, 0) v7 = datatypes.Vector(-dlen * .78, 0, -dlen * .78) points = getPointArrayWithOffset([v0, v1, v2, v3, v4, v5, v6, v7], pos_offset, rot_offset) node = curve.addCurve(parent, name, points, True, degree, m) setcolor(node, color) return node
def addCurve(parent, name, centers, degree=1): """Create a curve based on given centers. One point per center """ # rebuild list to avoid input list modification centers = centers[:] if degree == 3: if len(centers) == 2: centers.insert(0, centers[0]) centers.append(centers[-1]) elif len(centers) == 3: centers.append(centers[-1]) # points = [datatypes.Vector() for center in centers] points = [] for center in centers: points.append(center.getTranslation(space="world")) node = curve.addCurve(parent, name, points, False, degree) return node
def square(parent=None, name="square", width=1, depth=1, color=[0, 0, 0], m=datatypes.Matrix(), pos_offset=None, rot_offset=None): """Create a curve with a SQUARE shape. Arguments: parent (dagNode): The parent object of the newly created curve. name (str): Name of the curve. width (float): Width of the shape. depth (float): Depth of the shape. color (int or list of float): The color in index base or RGB. m (matrix): The global transformation of the curve. pos_offset (vector): The xyz position offset of the curve from its center. rot_offset (vector): The xyz rotation offset of the curve from its center. xyz in radians Returns: dagNode: The newly created icon. """ lenX = width * 0.5 lenZ = depth * 0.5 v0 = datatypes.Vector(lenX, 0, lenZ) v1 = datatypes.Vector(lenX, 0, lenZ * -1) v2 = datatypes.Vector(lenX * -1, 0, lenZ * -1) v3 = datatypes.Vector(lenX * -1, 0, lenZ) points = getPointArrayWithOffset([v0, v1, v2, v3], pos_offset, rot_offset) node = curve.addCurve(parent, name, points, True, 1, m) setcolor(node, color) return node
def addTCurve(self, name, rotation=None, parent=None): """Creates a T shape to show the boundaries of the slider. """ points = [ datatypes.Vector(0, 0, 0), datatypes.Vector(0, 1, 0), datatypes.Vector(0.2, 1, 0), datatypes.Vector(-0.2, 1, 0) ] if rotation: rot_offset = datatypes.Vector(math.radians(rotation.x), math.radians(rotation.y), math.radians(rotation.z)) points = icon.getPointArrayWithOffset(points, rot_offset=rot_offset) t_curve = curve.addCurve(parent=parent, name=name, points=points, degree=1) return t_curve
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.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 = [] # tOld = False self.previusTag = self.parentCtlTag for i, t in enumerate( transform.getChainTransform2(self.guide.apos, self.normal, self.negate)): ik_npo = primitive.addTransform(self.root, self.getName("ik%s_npo" % i), t) 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) # 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) # 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 = [] 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) 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 * .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) 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"])
def crossarrow(parent=None, name="crossArrow", width=1, color=[0, 0, 0], m=datatypes.Matrix(), pos_offset=None, rot_offset=None): """Create a curve with a CROSS ARROW shape. Arguments: parent (dagNode): The parent object of the newly created curve. name (str): Name of the curve. width (float): Width of the shape. color (int or list of float): The color in index base or RGB. m (matrix): The global transformation of the curve. pos_offset (vector): The xyz position offset of the curve from its center. rot_offset (vector): The xyz rotation offset of the curve from its center. xyz in radians Returns: dagNode: The newly created icon. """ dlen = width * 0.5 v0 = datatypes.Vector(0.2 * dlen, 0, 0.2 * dlen) v1 = datatypes.Vector(0.2 * dlen, 0, 0.6 * dlen) v2 = datatypes.Vector(0.4 * dlen, 0, 0.6 * dlen) v3 = datatypes.Vector(0, 0, dlen) v4 = datatypes.Vector(-0.4 * dlen, 0, 0.6 * dlen) v5 = datatypes.Vector(-0.2 * dlen, 0, 0.6 * dlen) v6 = datatypes.Vector(-0.2 * dlen, 0, 0.2 * dlen) v7 = datatypes.Vector(-0.6 * dlen, 0, 0.2 * dlen) v8 = datatypes.Vector(-0.6 * dlen, 0, 0.4 * dlen) v9 = datatypes.Vector(-dlen, 0, 0) v10 = datatypes.Vector(-0.6 * dlen, 0, -0.4 * dlen) v11 = datatypes.Vector(-0.6 * dlen, 0, -0.2 * dlen) v12 = datatypes.Vector(-0.2 * dlen, 0, -0.2 * dlen) v13 = datatypes.Vector(-0.2 * dlen, 0, -0.6 * dlen) v14 = datatypes.Vector(-0.4 * dlen, 0, -0.6 * dlen) v15 = datatypes.Vector(0, 0, -dlen) v16 = datatypes.Vector(0.4 * dlen, 0, -0.6 * dlen) v17 = datatypes.Vector(0.2 * dlen, 0, -0.6 * dlen) v18 = datatypes.Vector(0.2 * dlen, 0, -0.2 * dlen) v19 = datatypes.Vector(0.6 * dlen, 0, -0.2 * dlen) v20 = datatypes.Vector(0.6 * dlen, 0, -0.4 * dlen) v21 = datatypes.Vector(dlen, 0, 0) v22 = datatypes.Vector(0.6 * dlen, 0, 0.4 * dlen) v23 = datatypes.Vector(0.6 * dlen, 0, 0.2 * dlen) v_array = [ v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23 ] points = getPointArrayWithOffset(v_array, pos_offset, rot_offset) node = curve.addCurve(parent, name, points, True, 1, m) setcolor(node, color) return node
def sphere(parent=None, name="sphere", width=1, color=[0, 0, 0], m=datatypes.Matrix(), pos_offset=None, rot_offset=None, degree=3): """Create a curve with a SPHERE shape. Arguments: parent (dagNode): The parent object of the newly created curve. name (str): Name of the curve. width (float): Width of the shape. color (int or list of float): The color in index base or RGB. m (matrix): The global transformation of the curve. pos_offset (vector): The xyz position offset of the curve from its center. rot_offset (vector): The xyz rotation offset of the curve from its center. xyz in radians Returns: dagNode: The newly created icon. """ dlen = width * .5 v0 = datatypes.Vector(0, 0, -dlen * 1.108) v1 = datatypes.Vector(dlen * .78, 0, -dlen * .78) v2 = datatypes.Vector(dlen * 1.108, 0, 0) v3 = datatypes.Vector(dlen * .78, 0, dlen * .78) v4 = datatypes.Vector(0, 0, dlen * 1.108) v5 = datatypes.Vector(-dlen * .78, 0, dlen * .78) v6 = datatypes.Vector(-dlen * 1.108, 0, 0) v7 = datatypes.Vector(-dlen * .78, 0, -dlen * .78) ro = datatypes.Vector([1.5708, 0, 0]) points = getPointArrayWithOffset([v0, v1, v2, v3, v4, v5, v6, v7], pos_offset, rot_offset) node = curve.addCurve(parent, name, points, True, degree, m) if rot_offset: rot_offset += ro else: rot_offset = ro points = getPointArrayWithOffset([v0, v1, v2, v3, v4, v5, v6, v7], pos_offset, rot_offset) crv_0 = curve.addCurve(parent, node + "_0crv", points, True, degree, m) ro = datatypes.Vector([1.5708, 0, 1.5708]) if rot_offset: rot_offset += ro else: rot_offset = ro points = getPointArrayWithOffset([v0, v1, v2, v3, v4, v5, v6, v7], pos_offset, rot_offset + ro + ro) crv_1 = curve.addCurve(parent, node + "_1crv", points, True, degree, m) for crv in [crv_0, crv_1]: for shp in crv.listRelatives(shapes=True): node.addChild(shp, add=True, shape=True) pm.delete(crv) setcolor(node, color) return node
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.""" # 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 cylinder(parent=None, name="cylinder", width=1, heigth=1, color=[0, 0, 0], m=datatypes.Matrix(), pos_offset=None, rot_offset=None, degree=3): """Create a curve with a CYLINDER shape. Arguments: parent (dagNode): The parent object of the newly created curve. name (str): Name of the curve. width (float): Width of the shape. height (float): Height of the shape. color (int or list of float): The color in index base or RGB. m (matrix): The global transformation of the curve. pos_offset (vector): The xyz position offset of the curve from its center. rot_offset (vector): The xyz rotation offset of the curve from its center. xyz in radians Returns: dagNode: The newly created icon. """ dlen = width * .5 dhei = heigth * .5 if degree == 3: offsetMult = 1 else: offsetMult = 1.108 # upper circle v0 = datatypes.Vector(0, dhei, -dlen * 1.108) v1 = datatypes.Vector(dlen * .78, dhei, -dlen * .78) v2 = datatypes.Vector(dlen * 1.108, dhei, 0) v3 = datatypes.Vector(dlen * .78, dhei, dlen * .78) v4 = datatypes.Vector(0, dhei, dlen * 1.108) v5 = datatypes.Vector(-dlen * .78, dhei, dlen * .78) v6 = datatypes.Vector(-dlen * 1.108, dhei, 0) v7 = datatypes.Vector(-dlen * .78, dhei, -dlen * .78) # lower circle v8 = datatypes.Vector(0, -dhei, -dlen * 1.108) v9 = datatypes.Vector(dlen * .78, -dhei, -dlen * .78) v10 = datatypes.Vector(dlen * 1.108, -dhei, 0) v11 = datatypes.Vector(dlen * .78, -dhei, dlen * .78) v12 = datatypes.Vector(0, -dhei, dlen * 1.108) v13 = datatypes.Vector(-dlen * .78, -dhei, dlen * .78) v14 = datatypes.Vector(-dlen * 1.108, -dhei, 0) v15 = datatypes.Vector(-dlen * .78, -dhei, -dlen * .78) # curves v16 = datatypes.Vector(0, dhei, -dlen * offsetMult) v17 = datatypes.Vector(0, -dhei, -dlen * offsetMult) v18 = datatypes.Vector(0, -dhei, dlen * offsetMult) v19 = datatypes.Vector(0, dhei, dlen * offsetMult) v20 = datatypes.Vector(dlen * offsetMult, dhei, 0) v21 = datatypes.Vector(dlen * offsetMult, -dhei, 0) v22 = datatypes.Vector(-dlen * offsetMult, -dhei, 0) v23 = datatypes.Vector(-dlen * offsetMult, dhei, 0) points = getPointArrayWithOffset([v0, v1, v2, v3, v4, v5, v6, v7], pos_offset, rot_offset) node = curve.addCurve(parent, name, points, True, degree, m) points = getPointArrayWithOffset([v8, v9, v10, v11, v12, v13, v14, v15], pos_offset, rot_offset) crv_0 = curve.addCurve(parent, node + "_0crv", points, True, degree, m) points = getPointArrayWithOffset([v16, v17], pos_offset, rot_offset) crv_1 = curve.addCurve(parent, node + "_1crv", points, True, 1, m) points = getPointArrayWithOffset([v18, v19], pos_offset, rot_offset) crv_2 = curve.addCurve(parent, node + "_2crv", points, True, 1, m) points = getPointArrayWithOffset([v20, v21], pos_offset, rot_offset) crv_3 = curve.addCurve(parent, node + "_3crv", points, True, 1, m) points = getPointArrayWithOffset([v22, v23], pos_offset, rot_offset) crv_4 = curve.addCurve(parent, node + "_4crv", points, True, 1, m) for crv in [crv_0, crv_1, crv_2, crv_3, crv_4]: for shp in crv.listRelatives(shapes=True): node.addChild(shp, add=True, shape=True) pm.delete(crv) setcolor(node, color) return node
def addObjects(self): """Add all the objects needed to create the component.""" # joint Description Names jd_names = ast.literal_eval( self.settings["jointNamesDescription_custom"]) jdn_neck = jd_names[0] jdn_head = jd_names[1] self.normal = self.guide.blades["blade"].z * -1 self.up_axis = pm.upAxis(q=True, axis=True) # Ik Controlers ------------------------------------ if self.settings["IKWorldOri"]: t = datatypes.TransformationMatrix() else: t = transform.getTransformLookingAt( self.guide.pos["tan1"], self.guide.pos["neck"], self.normal, "yx", self.negate, ) t = transform.setMatrixPosition(t, self.guide.pos["neck"]) self.ik_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.ik_cns = primitive.addTransform(self.ik_off, self.getName("ik_cns"), t) self.ik_ctl = self.addCtl( self.ik_cns, "ik_ctl", t, self.color_ik, "compas", w=self.size * 0.5, tp=self.parentCtlTag, ) attribute.setKeyableAttributes(self.ik_ctl, self.tr_params) attribute.setRotOrder(self.ik_ctl, "ZXY") attribute.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"]) # Tangents ----------------------------------------- if self.settings["tangentControls"]: t = transform.setMatrixPosition(t, self.guide.pos["tan1"]) self.tan1_loc = primitive.addTransform(self.ik_ctl, self.getName("tan1_loc"), t) self.tan1_ctl = self.addCtl( self.tan1_loc, "tan1_ctl", t, self.color_ik, "sphere", w=self.size * 0.2, tp=self.ik_ctl, ) attribute.setKeyableAttributes(self.tan1_ctl, self.t_params) attribute.setInvertMirror(self.tan1_ctl, ["tx"]) t = transform.getTransformLookingAt( self.guide.pos["root"], self.guide.pos["tan0"], self.normal, "yx", self.negate, ) t = transform.setMatrixPosition(t, self.guide.pos["tan0"]) self.tan0_loc = primitive.addTransform(self.root, self.getName("tan0_loc"), t) self.tan0_ctl = self.addCtl( self.tan0_loc, "tan0_ctl", t, self.color_ik, "sphere", w=self.size * 0.2, tp=self.ik_ctl, ) attribute.setKeyableAttributes(self.tan0_ctl, self.t_params) attribute.setInvertMirror(self.tan0_ctl, ["tx"]) # Curves ------------------------------------------- self.mst_crv = curve.addCnsCurve( self.root, self.getName("mst_crv"), [self.root, self.tan0_ctl, self.tan1_ctl, self.ik_ctl], 3, ) self.slv_crv = curve.addCurve( self.root, self.getName("slv_crv"), [datatypes.Vector()] * 10, False, 3, ) self.mst_crv.setAttr("visibility", False) else: t = transform.setMatrixPosition(t, self.guide.pos["tan1"]) self.tan1_loc = primitive.addTransform(self.ik_ctl, self.getName("tan1_loc"), t) t = transform.getTransformLookingAt( self.guide.pos["root"], self.guide.pos["tan0"], self.normal, "yx", self.negate, ) t = transform.setMatrixPosition(t, self.guide.pos["tan0"]) self.tan0_loc = primitive.addTransform(self.root, self.getName("tan0_loc"), t) # Curves ------------------------------------------- self.mst_crv = curve.addCnsCurve( self.root, self.getName("mst_crv"), [self.root, self.tan0_loc, self.tan1_loc, self.ik_ctl], 3, ) self.slv_crv = curve.addCurve( self.root, self.getName("slv_crv"), [datatypes.Vector()] * 10, False, 3, ) self.mst_crv.setAttr("visibility", False) self.slv_crv.setAttr("visibility", False) # Division ----------------------------------------- # The user only define how many intermediate division he wants. # First and last divisions are an obligation. parentdiv = self.root parentctl = self.root self.div_cns = [] self.fk_ctl = [] self.fk_npo = [] self.scl_npo = [] self.twister = [] self.ref_twist = [] # adding 1 for the head self.divisions = self.settings["division"] + 1 parent_twistRef = primitive.addTransform( self.root, self.getName("reference"), transform.getTransform(self.root), ) t = transform.getTransformLookingAt( self.guide.pos["root"], self.guide.pos["neck"], self.normal, "yx", self.negate, ) self.intMRef = primitive.addTransform(self.root, self.getName("intMRef"), t) self.previousCtlTag = self.parentCtlTag for i in range(self.divisions): # References div_cns = primitive.addTransform(parentdiv, self.getName("%s_cns" % i), t) pm.setAttr(div_cns + ".inheritsTransform", False) self.div_cns.append(div_cns) parentdiv = div_cns scl_npo = primitive.addTransform( parentctl, self.getName("%s_scl_npo" % i), transform.getTransform(parentctl), ) # Controlers (First and last one are fake) if i in [self.divisions - 1]: # 0, fk_ctl = primitive.addTransform( scl_npo, self.getName("%s_loc" % i), transform.getTransform(parentctl), ) fk_npo = fk_ctl else: fk_npo = primitive.addTransform( scl_npo, self.getName("fk%s_npo" % i), transform.getTransform(parentctl), ) fk_ctl = self.addCtl( fk_npo, "fk%s_ctl" % i, transform.getTransform(parentctl), self.color_fk, "cube", w=self.size * 0.2, h=self.size * 0.05, d=self.size * 0.2, tp=self.previousCtlTag, ) attribute.setKeyableAttributes(self.fk_ctl) attribute.setRotOrder(fk_ctl, "ZXY") self.previousCtlTag = fk_ctl self.fk_ctl.append(fk_ctl) self.scl_npo.append(scl_npo) self.fk_npo.append(fk_npo) parentctl = fk_ctl if i != self.divisions - 1: self.jnt_pos.append( [fk_ctl, string.replaceSharpWithPadding(jdn_neck, i + 1)]) t = transform.getTransformLookingAt( self.guide.pos["root"], self.guide.pos["neck"], self.guide.blades["blade"].z * -1, "yx", self.negate, ) twister = primitive.addTransform(parent_twistRef, self.getName("%s_rot_ref" % i), t) ref_twist = primitive.addTransform(parent_twistRef, self.getName("%s_pos_ref" % i), t) ref_twist.setTranslation(datatypes.Vector(0.0, 0, 1.0), space="preTransform") self.twister.append(twister) self.ref_twist.append(ref_twist) for x in self.fk_ctl[:-1]: attribute.setInvertMirror(x, ["tx", "rz", "ry"]) # Head --------------------------------------------- t = transform.getTransformLookingAt( self.guide.pos["head"], self.guide.pos["eff"], self.normal, "yx", self.negate, ) self.head_cns = primitive.addTransform(self.root, self.getName("head_cns"), t) dist = vector.getDistance(self.guide.pos["head"], self.guide.pos["eff"]) self.head_ctl = self.addCtl( self.head_cns, "head_ctl", t, self.color_fk, "cube", w=self.size * 0.5, h=dist, d=self.size * 0.5, po=datatypes.Vector(0, dist * 0.5, 0), tp=self.previousCtlTag, ) attribute.setRotOrder(self.head_ctl, "ZXY") attribute.setInvertMirror(self.head_ctl, ["tx", "rz", "ry"]) self.jnt_pos.append([self.head_ctl, jdn_head])
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.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)])