def addControllers(self): axis = "zy" inPos = self.guide.apos[-5] outPos = self.guide.apos[-4] upPos = self.guide.apos[-3] lowPos = self.guide.apos[-2] frontPos = self.guide.apos[-1] self.bboxCenter = meshNavigation.bboxCenter(self.guide.eyeMesh) averagePosition = ((upPos + lowPos + inPos + outPos) / 4) # normalPos = outPos normalVec = upPos - lowPos if self.negate: pass # normalVec = normalVec * -1.0 t = transform.getTransformLookingAt( self.root.getTranslation(space="world"), # self.bboxCenter, frontPos, normalVec, axis=axis, # negate=self.negate ) # averagePosition, t_arrow = setMatrixPosition(t, self.bboxCenter) scl = [1, 1, 1] t = transform.setMatrixScale(t, scl) bt = transform.setMatrixPosition(t, self.bboxCenter) self.eyeTargets_root = addTransform(self.root, self.getName("targets"), t) self.jnt_root = addTransform(self.root, self.getName("joints"), bt) # self.jnt_root = primitive.addTransformFromPos(self.root, self.getName("joints"), pos=self.bboxCenter) # TODO: implement later # if deformers_group: # deformers_group = pm.PyNode(deformers_group) # pm.parentConstraint(self.root, jnt_root, mo=True) # pm.scaleConstraint(self.root, jnt_root, mo=True) # deformers_group.addChild(jnt_root) if self.negate: scl = [-1, 1, 1] t = transform.setMatrixScale(t, scl) self.addOverControllers(t) self.addLookAtControlers(t, t_arrow) self.addAimControllers(t) self.addCurveControllers(t) self.addCurveJoints(t) self.addWires()
def addObjects(self): """Add all the objects needed to create the component.""" if self.settings["neutralRotation"]: t = transform.getTransformFromPos(self.guide.pos["root"]) else: t = self.guide.tra["root"] if self._needToMirror(): scl = [1, 1, 1] scl[0] = -1 if self.settings["mirrorAxisX"] else 1 scl[1] = -1 if self.settings["mirrorAxisY"] else 1 scl[2] = -1 if self.settings["mirrorAxisZ"] else 1 t = transform.setMatrixScale(t, scl) rx = self.settings["mirrorAxisX"] * math.pi ry = self.settings["mirrorAxisY"] * math.pi rz = self.settings["mirrorAxisZ"] * math.pi # t = pm.datatypes.TransformationMatrix(t) # t.addRotation((rx, ry, rz), 'XYZ', 'object') else: scl = [1, 1, 1] t = transform.setMatrixScale(t, scl) self.ik_cns = primitive.addTransform( self.root, self.getName("ik_cns"), t) self.ctl = self.addCtl(self.ik_cns, "ctl", t, self.color_ik, self.settings["icon"], w=self.settings["ctlSize"] * self.size, h=self.settings["ctlSize"] * self.size, d=self.settings["ctlSize"] * self.size, tp=self.parentCtlTag) # we need to set the rotation order before lock any rotation axis if self.settings["k_ro"]: rotOderList = ["XYZ", "YZX", "ZXY", "XZY", "YXZ", "ZYX"] attribute.setRotOrder( self.ctl, rotOderList[self.settings["default_rotorder"]]) params = [s for s in ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx", "sy", "sz"] if self.settings["k_" + s]] ymt_util.setKeyableAttributesDontLockVisibility(self.ctl, params) if self.settings["joint"]: self.jnt_pos.append([self.ctl, 0, None, self.settings["uniScale"]])
def addObjects(self): """Add all the objects needed to create the component.""" t = self.guide.tra["root"] if self.settings["mirrorBehaviour"] and self.negate: scl = [1, 1, -1] else: scl = [1, 1, 1] t = transform.setMatrixScale(t, scl) # The border needs to fit the ctl range of motion size = self.settings["ctlSize"] minX = -1 if self.settings["tx_negative"] else 0 maxX = 1 if self.settings["tx_positive"] else 0 minY = -1 if self.settings["ty_negative"] else 0 maxY = 1 if self.settings["ty_positive"] else 0 margin = 0.1 * self.size border_offset = dt.Point(minX + maxX, minY + maxY) * 0.5 self.border = self.addCtl(self.root, "border", t, self.color_ik, "square", w=size + (maxX - minX) + margin, d=size + (maxY - minY) + margin, tp=self.parentCtlTag, po=border_offset, ro=dt.Vector(math.radians(90), 0, 0)) border_shape = self.border.getShape() border_shape.overrideDisplayType.set(2) # Set display to reference self.ctl = self.addCtl(self.border, "ctl", t, self.color_ik, self.settings["icon"], d=size, h=size, w=size, tp=self.parentCtlTag, ro=dt.Vector(math.radians(90), 0, 0)) self.border.scale.set([self.size, self.size, self.size]) params = [ s for s in ["tx", "ty"] if self.settings[s + "_negative"] or self.settings[s + "_positive"] ] attribute.setKeyableAttributes(self.ctl, params) attribute.setKeyableAttributes(self.border, []) tx_limit = [minX, maxX] ty_limit = [minY, maxY] pm.transformLimits(self.ctl, tx=tx_limit, etx=[1, 1]) pm.transformLimits(self.ctl, ty=ty_limit, ety=[1, 1])
def addObjects(self): """Add all the objects needed to create the component.""" # self.normal = self.guide.blades["blade"].z * -1 # self.binormal = self.guide.blades["blade"].x self.WIP = self.options["mode"] if self.negate and self.settings["overrideNegate"]: self.negate = False self.n_factor = 1 if self.settings["overrideNegate"]: self.mirror_conf = [0, 0, 1, 1, 1, 0, 0, 0, 0] else: self.mirror_conf = [0, 0, 0, 0, 0, 0, 0, 0, 0] # FK controllers ------------------------------------ self.fk_npo = [] self.fk_ctl = [] t = self.guide.tra["root"] parent = self.root tOld = False fk_ctl = None self.previusTag = self.parentCtlTag # transforms = [] # for i in range(len(self.guide.atra) - 1): # transforms.append(transform.getTransform(self.guide.atra[i])) for i, t in enumerate(self.guide.atra[:-1]): # dist = vector.getDistance(self.guide.apos[i], # self.guide.apos[i + 1]) t = transform.setMatrixScale(t) 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, "circle", w=self.size * .4, ro=datatypes.Vector([0, 0, 1.5708]), tp=self.previusTag, mirrorConf=self.mirror_conf) self.fk_npo.append(fk_npo) self.fk_ctl.append(fk_ctl) tOld = t self.previusTag = fk_ctl parent = fk_ctl if self.settings["addJoints"]: self.jnt_pos.append([fk_ctl, i, None, False])
def addObjects(self): """Add all the objects needed to create the component.""" if self.settings["neutralRotation"]: t = transform.getTransformFromPos(self.guide.pos["root"]) else: t = self.guide.tra["root"] if self.settings["mirrorBehaviour"] and self.negate: scl = [1, 1, -1] else: scl = [1, 1, 1] t = transform.setMatrixScale(t, scl) self.ik_cns = primitive.addTransform(self.root, self.getName("ik_cns"), t) self.SDKctl = self.addCtl( self.ik_cns, "SDK_ctl", t, self.color_ik, "cube", w=self.settings["ctlSize"] * self.size * 1.35, h=self.settings["ctlSize"] * self.size * 0.75, d=self.settings["ctlSize"] * self.size * 0.75, tp=self.parentCtlTag) self.ctl = self.addCtl(self.SDKctl, "ctl", t, self.color_fk, "sphere", w=self.settings["ctlSize"] * self.size, h=self.settings["ctlSize"] * self.size, d=self.settings["ctlSize"] * self.size, tp=self.parentCtlTag) # we need to set the rotation order before lock any rotation axis if self.settings["k_ro"]: rotOderList = ["XYZ", "YZX", "ZXY", "XZY", "YXZ", "ZYX"] attribute.setRotOrder( self.ctl, rotOderList[self.settings["default_rotorder"]]) attribute.setRotOrder( self.SDKctl, rotOderList[self.settings["default_rotorder"]]) params = [ s for s in ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx", "sy", "sz"] if self.settings["k_" + s] ] attribute.setKeyableAttributes(self.ctl, params) attribute.setKeyableAttributes(self.SDKctl, params) if self.settings["joint"]: self.jnt_pos.append([self.ctl, 0, None, self.settings["uniScale"]])
def addCurve(self): t = getTransform(self.root) scl = [1, 1, 1] if self.negate: scl = [-1, 1, 1] t = transform.setMatrixScale(t, scl) crv_root = addTransform(self.root, self.getName("crvs"), t) plane = self.addDummyPlane() self.addCurves(crv_root, plane) pm.delete(pm.PyNode(plane.name()))
def addObjects(self): """Add all the objects needed to create the component.""" if self.settings["neutralRotation"]: t = transform.getTransformFromPos(self.guide.pos["root"]) else: t = self.guide.tra["root"] if self.settings["mirrorBehaviour"] and self.negate: scl = [1, 1, -1] else: scl = [1, 1, 1] t = transform.setMatrixScale(t, scl) if self.settings["joint"] and self.settings["leafJoint"]: pm.displayInfo("Skipping ctl creation, just leaf joint") self.have_ctl = False else: self.have_ctl = True self.ik_cns = primitive.addTransform(self.root, self.getName("ik_cns"), t) self.ctl = self.addCtl(self.ik_cns, "ctl", t, self.color_ik, self.settings["icon"], w=self.settings["ctlSize"] * self.size, h=self.settings["ctlSize"] * self.size, d=self.settings["ctlSize"] * self.size, tp=self.parentCtlTag, guide_loc_ref="root") # we need to set the rotation order before lock any rotation axis if self.settings["k_ro"]: rotOderList = ["XYZ", "YZX", "ZXY", "XZY", "YXZ", "ZYX"] attribute.setRotOrder( self.ctl, rotOderList[self.settings["default_rotorder"]]) params = [ s for s in ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx", "sy", "sz"] if self.settings["k_" + s] ] attribute.setKeyableAttributes(self.ctl, params) if self.settings["joint"]: # TODO WIP: add new attr for seeting leaf joint + not build objcts if self.settings["leafJoint"]: self.jnt_pos.append([t, 0, None, self.settings["uniScale"]]) else: self.jnt_pos.append( [self.ctl, 0, None, self.settings["uniScale"]])
def _foreachControlOption(self, controlParentGrp, ctlOptions): oName = ctlOptions[0] oSide = ctlOptions[1] o_icon = ctlOptions[2] color = ctlOptions[3] wd = ctlOptions[4] oPar = ctlOptions[5] point = ctlOptions[6] position = transform.getTransformFromPos(point) scl = [1, 1, 1] if self.negate: scl = [-1, 1, 1] t = transform.setMatrixScale(position, scl) npo = addTransform(controlParentGrp, self.getName("%s_npo" % oName, oSide), t) npoBuffer = addTransform(npo, self.getName("%s_bufferNpo" % oName, oSide), t) # Create casual control if o_icon is not "npo": if o_icon == "sphere": rot_offset = None else: rot_offset = datatypes.Vector(1.57079633, 0, 0) ctl = self.addCtl( npoBuffer, "{}_ctl".format(oName), t, color, o_icon, w=wd, d=wd, ro=rot_offset, po=datatypes.Vector(0, 0, 0), ) # Create buffer node instead else: ctl = addTransform(npoBuffer, self.getName("%s_HookNpo" % oName, oSide), t) # Create up vectors for each control upv = addTransform(ctl, self.getName("%s_upv" % oName, oSide), t) upv.attr("tz").set(self.FRONT_OFFSET) return ctl, upv
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 addContainers(self): t = getTransform(self.root) scl = [1, 1, 1] if self.negate: scl = [-1, 1, 1] t = transform.setMatrixScale(t, scl) self.crv_root = addTransform(self.root, self.getName("crvs"), t) self.rope_root = addTransform(self.root, self.getName("ropes"), t) self.browsHooks_root = addTransform(self.root, self.getName("hooks"), t) self._visi_off_lock(self.crv_root) self._visi_off_lock(self.rope_root) self._visi_off_lock(self.browsHooks_root) if self.connect_surface_slider: bt = getTransform(self.root) self.slider_root = addTransform(self.root, self.getName("sliders"), bt) ymt_util.setKeyableAttributesDontLockVisibility( self.slider_root, []) # self.mainControlParentGrp = addTransform(self.root, self.getName("mainControls"), t) w = (self.outPos - self.inPos).length() d = (self.upPos - self.lowPos).length() self.mainControlParentGrp = addTransform(self.root, self.getName("mainControls"), t) self.mainControl = self.addCtl(self.mainControlParentGrp, "main_ctl", t, self.color_ik, "square", w=w, d=d, ro=datatypes.Vector(1.57079633, 0, 0), po=datatypes.Vector(0, 0, 1.0)) self.addToSubGroup(self.mainControl, self.primaryControllersGroupName) self.secondaryControlsParentGrp = addTransform( self.root, self.getName("secondaryControls"), t)
def addObjects(self): """Add all the objects needed to create the component.""" self.WIP = self.options["mode"] self.normal = self.getNormalFromPos(self.guide.apos) self.binormal = self.getBiNormalFromPos(self.guide.apos) self.length0 = vector.getDistance(self.guide.apos[0], self.guide.apos[1]) self.length1 = vector.getDistance(self.guide.apos[1], self.guide.apos[2]) self.length2 = vector.getDistance(self.guide.apos[2], self.guide.apos[3]) # 1 bone chain for upv ref self.armChainUpvRef = primitive.add2DChain( self.root, self.getName("armUpvRef%s_jnt"), [self.guide.apos[0], self.guide.apos[2]], self.normal, False, self.WIP) negateOri = self.armChainUpvRef[1].getAttr("jointOrientZ") * -1 self.armChainUpvRef[1].setAttr("jointOrientZ", negateOri) # FK Controlers ----------------------------------- t = transform.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, "xz", self.negate) self.fk0_npo = primitive.addTransform(self.root, self.getName("fk0_npo"), t) vec_po = datatypes.Vector(.5 * self.length0 * self.n_factor, 0, 0) self.fk0_ctl = self.addCtl(self.fk0_npo, "fk0_ctl", t, self.color_fk, "cube", w=self.length0, h=self.size * .1, d=self.size * .1, po=vec_po, tp=self.parentCtlTag) attribute.setKeyableAttributes( self.fk0_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) t = transform.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2], self.normal, "xz", self.negate) self.fk1_npo = primitive.addTransform(self.fk0_ctl, self.getName("fk1_npo"), t) vec_po = datatypes.Vector(.5 * self.length1 * self.n_factor, 0, 0) self.fk1_ctl = self.addCtl(self.fk1_npo, "fk1_ctl", t, self.color_fk, "cube", w=self.length1, h=self.size * .1, d=self.size * .1, po=vec_po, tp=self.fk0_ctl) attribute.setKeyableAttributes( self.fk1_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) t = transform.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3], self.normal, "xz", self.negate) # Define the wrist transform (wt) if self.settings["guideOrientWrist"]: wt = self.guide.tra["wrist"] if self.settings["mirrorIK"] and self.negate: scl = [1, 1, -1] else: scl = [1, 1, 1] wt = transform.setMatrixScale(wt, scl) t = wt self.fk2_npo = primitive.addTransform(self.fk1_ctl, self.getName("fk2_npo"), t) vec_po = datatypes.Vector(.5 * self.length2 * self.n_factor, 0, 0) self.fk2_ctl = self.addCtl(self.fk2_npo, "fk2_ctl", t, self.color_fk, "cube", w=self.length2, h=self.size * .1, d=self.size * .1, po=vec_po, tp=self.fk1_ctl) attribute.setKeyableAttributes(self.fk2_ctl) self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl] for x in self.fk_ctl: attribute.setInvertMirror(x, ["tx", "ty", "tz"]) # IK upv --------------------------------- # create tip point self.tip_ref = primitive.addTransform( self.armChainUpvRef[0], self.getName("tip_ref"), self.armChainUpvRef[0].getMatrix(worldSpace=True)) # create interpolate obj self.interpolate_lvl = primitive.addTransform( self.armChainUpvRef[0], self.getName("int_lvl"), self.armChainUpvRef[0].getMatrix(worldSpace=True)) # create roll npo and ctl self.roll_ctl_npo = primitive.addTransform( self.root, self.getName("roll_ctl_npo"), self.armChainUpvRef[0].getMatrix(worldSpace=True)) if self.negate: off_x = -1.5708 else: off_x = 1.5708 off_y = 1.5708 self.roll_ctl = self.addCtl(self.roll_ctl_npo, "roll_ctl", transform.getTransform(self.roll_ctl_npo), self.color_ik, "compas", w=self.size * .3, ro=datatypes.Vector([off_x, off_y, 0]), tp=self.parentCtlTag) attribute.setKeyableAttributes(self.roll_ctl, ["rx"]) # create upv control v = self.guide.apos[2] - self.guide.apos[0] v = self.normal ^ v v.normalize() v *= self.size * .8 v += self.guide.apos[1] self.upv_cns = primitive.addTransformFromPos(self.root, self.getName("upv_cns"), v) self.upv_ctl = self.addCtl(self.upv_cns, "upv_ctl", transform.getTransform(self.upv_cns), self.color_ik, "diamond", w=self.size * .12, tp=self.parentCtlTag) if self.settings["mirrorMid"]: if self.negate: self.upv_cns.rz.set(180) self.upv_cns.sy.set(-1) else: attribute.setInvertMirror(self.upv_ctl, ["tx"]) attribute.setKeyableAttributes(self.upv_ctl, self.t_params) # IK Controlers ----------------------------------- self.ik_cns = primitive.addTransformFromPos(self.root, self.getName("ik_cns"), self.guide.pos["wrist"]) t = transform.getTransformFromPos(self.guide.pos["wrist"]) if self.settings["guideOrientWrist"]: t = wt self.ik_cns.setMatrix(t) self.ik_cns.setTranslation(self.guide.pos["wrist"], space="world") self.ikcns_ctl = self.addCtl(self.ik_cns, "ikcns_ctl", t, self.color_ik, "null", w=self.size * .12, tp=self.parentCtlTag) attribute.setInvertMirror(self.ikcns_ctl, ["tx", "ty", "tz"]) if self.negate: m = transform.getTransformLookingAt(self.guide.pos["wrist"], self.guide.pos["eff"], self.normal, "x-y", True) else: m = transform.getTransformLookingAt(self.guide.pos["wrist"], self.guide.pos["eff"], self.normal, "xy", False) if self.settings["guideOrientWrist"]: m = wt self.ik_ctl = self.addCtl(self.ikcns_ctl, "ik_ctl", m, self.color_ik, "cube", w=self.size * .12, h=self.size * .12, d=self.size * .12, tp=self.roll_ctl) if self.settings["mirrorIK"]: if self.negate: self.ik_cns.sx.set(-1) self.ik_ctl.rz.set(self.ik_ctl.rz.get() * -1) else: attribute.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"]) attribute.setKeyableAttributes(self.ik_ctl) self.ik_ctl_ref = primitive.addTransform(self.ik_ctl, self.getName("ikCtl_ref"), m) # IK rotation controls if self.settings["ikTR"]: self.ikRot_npo = primitive.addTransform(self.root, self.getName("ikRot_npo"), m) self.ikRot_cns = primitive.addTransform(self.ikRot_npo, self.getName("ikRot_cns"), m) self.ikRot_ctl = self.addCtl(self.ikRot_cns, "ikRot_ctl", m, self.color_ik, "sphere", w=self.size * .12, tp=self.ik_ctl) attribute.setKeyableAttributes(self.ikRot_ctl, self.r_params) # References -------------------------------------- # Calculate again the transfor for the IK ref. This way align with FK trnIK_ref = transform.getTransformLookingAt(self.guide.pos["wrist"], self.guide.pos["eff"], self.normal, "xz", self.negate) if self.settings["guideOrientWrist"]: trnIK_ref = wt self.ik_ref = primitive.addTransform(self.ik_ctl_ref, self.getName("ik_ref"), trnIK_ref) self.fk_ref = primitive.addTransform(self.fk_ctl[2], self.getName("fk_ref"), trnIK_ref) # Chain -------------------------------------------- # The outputs of the ikfk2bone solver self.bone0 = primitive.addLocator( self.root, self.getName("0_bone"), transform.getTransform(self.fk_ctl[0])) self.bone0_shp = self.bone0.getShape() self.bone0_shp.setAttr("localPositionX", self.n_factor * .5) self.bone0_shp.setAttr("localScale", .5, 0, 0) self.bone0.setAttr("sx", self.length0) self.bone0.setAttr("visibility", False) self.bone1 = primitive.addLocator( self.root, self.getName("1_bone"), transform.getTransform(self.fk_ctl[1])) self.bone1_shp = self.bone1.getShape() self.bone1_shp.setAttr("localPositionX", self.n_factor * .5) self.bone1_shp.setAttr("localScale", .5, 0, 0) self.bone1.setAttr("sx", self.length1) self.bone1.setAttr("visibility", False) self.ctrn_loc = primitive.addTransformFromPos(self.root, self.getName("ctrn_loc"), self.guide.apos[1]) self.eff_loc = primitive.addTransformFromPos(self.root, self.getName("eff_loc"), self.guide.apos[2]) # Mid Controler ------------------------------------ t = transform.getTransform(self.ctrn_loc) self.mid_cns = primitive.addTransform(self.ctrn_loc, self.getName("mid_cns"), t) self.mid_ctl = self.addCtl(self.mid_cns, "mid_ctl", t, self.color_ik, "sphere", w=self.size * .2, tp=self.parentCtlTag) attribute.setKeyableAttributes( self.mid_ctl, params=["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) if self.settings["mirrorMid"]: if self.negate: self.mid_cns.rz.set(180) self.mid_cns.sz.set(-1) self.mid_ctl_twst_npo = primitive.addTransform( self.mid_ctl, self.getName("mid_twst_npo"), t) self.mid_ctl_twst_ref = primitive.addTransform( self.mid_ctl_twst_npo, self.getName("mid_twst_ref"), t) else: self.mid_ctl_twst_ref = self.mid_ctl attribute.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"]) # Roll join ref self.rollRef = primitive.add2DChain(self.root, self.getName("rollChain"), self.guide.apos[:2], self.normal, self.negate) for x in self.rollRef: x.setAttr("visibility", False) self.tws0_loc = primitive.addTransform( self.rollRef[0], self.getName("tws0_loc"), transform.getTransform(self.fk_ctl[0])) self.tws0_rot = primitive.addTransform( self.tws0_loc, self.getName("tws0_rot"), transform.getTransform(self.fk_ctl[0])) self.tws1_npo = primitive.addTransform( self.ctrn_loc, self.getName("tws1_npo"), transform.getTransform(self.ctrn_loc)) self.tws1_loc = primitive.addTransform( self.tws1_npo, self.getName("tws1_loc"), transform.getTransform(self.ctrn_loc)) self.tws1_rot = primitive.addTransform( self.tws1_loc, self.getName("tws1_rot"), transform.getTransform(self.ctrn_loc)) # thickness control self.thick_lvl = primitive.addTransform( self.mid_ctl, self.getName("thickness_lvl"), transform.getTransform(self.ctrn_loc)) self.thick_ctl = self.addCtl(self.thick_lvl, "thickness_ctl", transform.getTransform(self.mid_ctl), self.color_ik, "arrow", w=self.size * .1, ro=datatypes.Vector([0, 1.5708, 0]), tp=self.mid_ctl) if self.negate and not self.settings["mirrorMid"]: self.thick_ctl.rz.set(180) self.thick_ctl.sz.set(-1) attribute.setKeyableAttributes(self.thick_ctl, ["tx", "ty"]) self.tws1B_loc = primitive.addTransform( self.ctrn_loc, self.getName("tws1B_loc"), transform.getTransform(self.ctrn_loc)) self.tws1B_rot = primitive.addTransform( self.tws1B_loc, self.getName("tws1B_rot"), transform.getTransform(self.ctrn_loc)) self.tws2_npo = primitive.addTransform( self.root, self.getName("tws2_npo"), transform.getTransform(self.fk_ctl[2])) self.tws2_loc = primitive.addTransform( self.tws2_npo, self.getName("tws2_loc"), transform.getTransform(self.fk_ctl[2])) self.tws2_rot = primitive.addTransform( self.tws2_loc, self.getName("tws2_rot"), transform.getTransform(self.fk_ctl[2])) # angle reader ---------------------------------------- t = transform.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2], self.normal, "xy") self.readerA = primitive.addTransform(self.root, self.getName("readerA_loc"), t) self.readerB = primitive.addTransform(self.readerA, self.getName("readerB_loc"), t) self.readerB.rotateOrder.set(2) # Divisions ---------------------------------------- # We have at least one division at the start, the end and one for the # elbow. + 2 for elbow angle control if self.settings["supportJoints"]: ej = 2 else: ej = 0 self.divisions = self.settings["div0"] + self.settings["div1"] + 3 + ej self.div_cns = [] if self.settings["extraTweak"]: tagP = self.parentCtlTag self.tweak_ctl = [] for i in range(self.divisions): div_cns = primitive.addTransform(self.root, self.getName("div%s_loc" % i)) self.div_cns.append(div_cns) if self.settings["extraTweak"]: t = transform.getTransform(div_cns) tweak_ctl = self.addCtl(div_cns, "tweak%s_ctl" % i, t, self.color_fk, "square", w=self.size * .15, d=self.size * .15, ro=datatypes.Vector([0, 0, 1.5708]), tp=tagP) attribute.setKeyableAttributes(tweak_ctl) tagP = tweak_ctl self.tweak_ctl.append(tweak_ctl) self.jnt_pos.append([tweak_ctl, i, None, False]) else: self.jnt_pos.append([div_cns, i]) # End reference ------------------------------------ # To help the deformation on the wrist self.jnt_pos.append([self.eff_loc, 'end']) # match IK FK references self.match_fk0_off = self.add_match_ref(self.fk_ctl[1], self.root, "matchFk0_npo", False) self.match_fk0 = self.add_match_ref(self.fk_ctl[0], self.match_fk0_off, "fk0_mth") self.match_fk1_off = self.add_match_ref(self.fk_ctl[2], self.root, "matchFk1_npo", False) self.match_fk1 = self.add_match_ref(self.fk_ctl[1], self.match_fk1_off, "fk1_mth") if self.settings["ikTR"]: reference = self.ikRot_ctl self.match_ikRot = self.add_match_ref(self.ikRot_ctl, self.fk2_ctl, "ikRot_mth") else: reference = self.ik_ctl self.match_fk2 = self.add_match_ref(self.fk_ctl[2], reference, "fk2_mth") self.match_ik = self.add_match_ref(self.ik_ctl, self.fk2_ctl, "ik_mth") self.match_ikUpv = self.add_match_ref(self.upv_ctl, self.fk0_ctl, "upv_mth") # add visual reference self.line_ref = icon.connection_display_curve( self.getName("visalRef"), [self.upv_ctl, self.mid_ctl])
def _addControls(self, crv_ctl, option, sidecut): cvs = crv_ctl.getCVs(space="world") pm.progressWindow(title='controls', progress=0, max=len(cvs)) v0 = transform.getTransformFromPos(cvs[0]) v1 = transform.getTransformFromPos(cvs[-1]) distSize = vector.getDistance(v0, v1) * 3 npos = [] ctls = [] upvs = [] params = ["tx", "ty", "tz", "rx", "ry", "rz"] joints = self.upJoints + self.lowJoints iterator = enumerate(cvs) if sidecut: iterator = enumerate(cvs[1:-1]) for i, cv in iterator: pm.progressWindow(e=True, step=1, status='\nCreating control for%s' % cv) t = transform.getTransformFromPos(cv) # Get nearest joint for orientation of controls nearest_joint = None nearest_distance = None for joint in joints: distance = vector.getDistance(transform.getTranslation(joint), cv) if nearest_distance is None or distance < nearest_distance: nearest_distance = distance nearest_joint = joint if nearest_joint: t = transform.setMatrixPosition( transform.getTransform(nearest_joint), cv) temp = addTransform(self.root, self.getName("temp"), t) # temp.rx.set(0) t = transform.getTransform(temp) pm.delete(temp) # print(i, nearest_joint, temp) oName = option[i][0] oSide = option[i][1] o_icon = option[i][2] color = option[i][3] wd = option[i][4] oPar = option[i][5] if oSide == "R": scl = [1, 1, -1] else: scl = [1, 1, 1] t = transform.setMatrixScale(t, scl) npo = addTransform(self.root, self.getName("%s_npo" % oName, oSide), t) npos.append(npo) ctl = self.addCtl( npo, self.getName("{}_{}".format(oName, self.ctlName), oSide), t, color, o_icon, w=wd * distSize, d=wd * distSize, ro=datatypes.Vector(1.57079633, 0, 0), po=datatypes.Vector(0, 0, .07 * distSize), ) ctls.append(ctl) ymt_util.setKeyableAttributesDontLockVisibility(ctl, params + oPar) upv = addTransform(ctl, self.getName("%s_upv" % oName, oSide), t) upv.attr("tz").set(self.FRONT_OFFSET) upvs.append(upv) self.addToSubGroup(ctl, self.primaryControllersGroupName) pm.progressWindow(e=True, endProgress=True) return npos, ctls, upvs
def addObjects(self): """Add all the objects needed to create the component.""" ctlSize = vector.getDistance(self.guide.apos[0], self.guide.apos[1]) / 3.0 t_root = self.guide.tra["root"] t_root = transform.setMatrixScale(t_root) self.ik_cns = primitive.addTransform(self.root, self.getName("ik_cns"), t_root) t = transform.setMatrixPosition(t_root, self.guide.pos["top"]) self.top_npo = primitive.addTransform(self.ik_cns, self.getName("top_npo"), t) self.top_ctl = self.addCtl(self.top_npo, "top_ctl", t, self.color_ik, "arrow", w=ctlSize, ro=datatypes.Vector(1.5708, 1.5708, 0), tp=self.parentCtlTag) attribute.setKeyableAttributes(self.top_ctl, ["ty"]) t = transform.setMatrixPosition(t_root, self.guide.pos["bottom"]) self.bottom_npo = primitive.addTransform(self.top_npo, self.getName("bottom_npo"), t) self.bottom_npo.rz.set(180) self.bottom_ctl = self.addCtl(self.bottom_npo, "bottom_ctl", t, self.color_ik, "arrow", w=ctlSize, ro=datatypes.Vector(1.5708, 1.5708, 0), tp=self.parentCtlTag) self.bottom_ctl.rz.set(0) attribute.setKeyableAttributes(self.bottom_ctl, ["ty"]) self.bottom_pivot = primitive.addTransform( self.bottom_npo, self.getName("bottom_pivot"), transform.getTransform(self.top_ctl)) t = transform.setMatrixPosition(t_root, self.guide.pos["ext"]) self.ext_npo = primitive.addTransform(self.bottom_pivot, self.getName("ext_npo"), t) self.ext_npo.rz.set(-90) self.ext_ctl = self.addCtl(self.ext_npo, "ext_ctl", t, self.color_ik, "arrow", w=ctlSize, ro=datatypes.Vector(1.5708, 1.5708, 0), tp=self.parentCtlTag) self.ext_ctl.rz.set(0) attribute.setKeyableAttributes(self.ext_ctl, ["ty"]) t = transform.setMatrixPosition(t_root, self.guide.pos["int"]) self.int_npo = primitive.addTransform(self.ext_npo, self.getName("int_npo"), t) self.int_npo.rz.set(180) self.int_ctl = self.addCtl(self.int_npo, "int_ctl", t, self.color_ik, "arrow", w=ctlSize, ro=datatypes.Vector(1.5708, 1.5708, 0), tp=self.parentCtlTag) self.int_ctl.rz.set(0) attribute.setKeyableAttributes(self.int_ctl, ["ty"]) self.int_pivot = primitive.addTransform( self.int_npo, self.getName("int_pivot"), transform.getTransform(self.ext_ctl)) self.anchor = primitive.addTransform( self.int_pivot, self.getName("int_npo"), transform.getTransform(self.ik_cns)) if self.settings["joint"]: self.jnt_pos.append([self.anchor, 0, None, False])