def add_arm_connection_object(self, arm_comp): t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, axis="xy", negate=self.negate) self.arm_npo = pri.addTransform(self.ctl_npo, self.getName("dummy_npo"), t) pm.connectAttr("{}.rotate".format(self.ctl), "{}.rotate".format(self.arm_npo)) self.arm_npo.addChild(arm_comp.dummy_chain[0]) self.arm_npo.addChild(arm_comp.dummy_chain_npo) self.arm_npo.addChild(arm_comp.dummy_ikh) self.shoulder_npo = pri.addTransform(self.ctl_npo, self.getName("dummy_npo2"), t) self.shoulder_npo.addChild(self.ctl) fk_quat = self.decompose_rotate( arm_comp.fk_ctl[0], smooth_step=arm_comp.settings["smoothStep"]) ik_quat = self.decompose_rotate( arm_comp.dummy_chain_npo, smooth_step=arm_comp.settings["smoothStep"]) slerp = pm.createNode("quatSlerp") pm.connectAttr("{}.outputQuat".format(fk_quat), "{}.input1Quat".format(slerp)) pm.connectAttr("{}.outputQuat".format(ik_quat), "{}.input2Quat".format(slerp)) pm.connectAttr(arm_comp.blend_att, "{}.inputT".format(slerp)) quat2euler = pm.createNode("quatToEuler") pm.connectAttr(slerp + ".outputQuat", quat2euler + ".inputQuat") pm.connectAttr(quat2euler + ".outputRotate", self.shoulder_npo + ".rotate")
def addLookAtControlers(self, t_root, t_look): # Tracking # Eye aim control self.center_lookat = addTransform(self.over_ctl, self.getName("center_lookat"), t_root) radius = abs(self.getBboxRadius()[0] / 1.7) if True or not self.negate: ro = datatypes.Vector(0, 0, 0) po = datatypes.Vector(0, 0, radius) + self.offset else: ro = datatypes.Vector(math.pi, 0, 0) po = datatypes.Vector(0, 0, radius * -1.0) + self.offset self.arrow_npo = addTransform(self.root, self.getName("aim_npo"), t_look) self.arrow_ctl = self.addCtl( self.arrow_npo, "aim_%s" % self.ctlName, t_look, self.color_ik, "arrow", w=1, ro=ro, po=po, ) self.addToSubGroup(self.over_ctl, self.primaryControllersGroupName) ymt_util.setKeyableAttributesDontLockVisibility(self.arrow_ctl, params=["rx", "ry", "rz"])
def addObjects(self): po = dt.Vector(self.settings["ctlOffsetPosX"], self.settings["ctlOffsetPosY"], self.settings["ctlOffsetPosZ"]) so = dt.Vector(self.settings["ctlOffsetSclX"], self.settings["ctlOffsetSclY"], self.settings["ctlOffsetSclZ"]) ro = [ self.settings["ctlOffsetRotX"], self.settings["ctlOffsetRotY"], self.settings["ctlOffsetRotZ"] ] ro = set(map(lambda x: math.radians(x), ro)) ro = dt.Vector(*ro) self.normal = self.guide.blades["blade"].z * -1 self.binormal = self.guide.blades["blade"].x self.length0 = vec.getDistance(self.guide.apos[0], self.guide.apos[1]) t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, axis="xy", negate=self.negate) self.ctl_npo = pri.addTransform(self.root, self.getName("ctl_npo"), t) self.ctl = self.addCtl( self.ctl_npo, "ctl", t, self.color_fk, "cube", w=(self.length0 * so.x), h=(self.size * .1 * so.y), d=(self.size * .1 * so.z), po=(dt.Vector(.5 * self.length0 * self.n_factor, 0, 0) + po)) t = tra.getTransformFromPos(self.guide.apos[0]) self.orbit_ref1 = pri.addTransform(self.root, self.getName("orbit_ref1"), t) t = tra.getTransformFromPos(self.guide.apos[1]) self.orbit_ref2 = pri.addTransform(self.root, self.getName("orbit_ref2"), t) self.orbit_cns = pri.addTransform(self.ctl, self.getName("orbit_cns"), t) self.orbit_npo = pri.addTransform(self.orbit_cns, self.getName("orbit_npo"), t) self.orbit_ctl = self.addCtl(self.orbit_npo, "orbit_ctl", t, self.color_fk, "sphere", w=self.length0 / 4) self.jnt_pos.append([self.ctl, "shoulder"])
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 addLengthCtrl(self, crv): t = getTransform(self.guide.root) t = self._getTransformWithRollByBlade(t) cvs = crv.length() tm = datatypes.TransformationMatrix(t) tm.addTranslation([0.0, cvs * 0.01, cvs * 1.4], om.MSpace.kObject) local_t = datatypes.Matrix(tm) self.length_npo = addTransform(self.aim_npo, self.getName("length_npo"), local_t) self.length_in = addTransform(self.length_npo, self.getName("sacle_in"), local_t) size = self.size w = size h = size d = size self.length_ctl = self.addCtl( self.length_in, "length_ctl", local_t, self.color_ik, "arrow", w=w, h=h, d=d, ro=datatypes.Vector([-math.pi / 2., math.pi / 2., 0.]) ) self.fk_upvectors = [] chain = getChainTransform2(self.guide.apos, self.normal, self.negate) for i, t in enumerate(chain): upv_npo = addTransform(self.length_in, self.getName("%s_fkupv_npo" % i), t) self.fk_upvectors.append(upv_npo) # global input self.scale_npo = addTransform(self.root, self.getName("scale_npo"), local_t) self.scale_in = addTransform(self.scale_npo, self.getName("sacle_in"), local_t) self.scale_ctl = self.addCtl( self.scale_in, "scale_ctl", local_t, self.color_ik, "cube", w=w*.2, h=h*.2, d=d*.2, ro=datatypes.Vector([-math.pi / 2., 0., 0.]) ) ymt_util.setKeyableAttributesDontLockVisibility(self.scale_ctl, self.s_params) ymt_util.setKeyableAttributesDontLockVisibility(self.length_ctl, ["tx", "ty", "tz"])
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 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.length0 = vector.getDistance(self.guide.apos[0], self.guide.apos[1]) t = transform.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, axis="xy", negate=self.negate) self.ctl_npo = primitive.addTransform(self.root, self.getName("ctl_npo"), t) self.ctl = self.addCtl(self.ctl_npo, "ctl", t, self.color_fk, "cube", w=self.length0, h=self.size * .1, d=self.size * .1, po=datatypes.Vector( .5 * self.length0 * self.n_factor, 0, 0), tp=self.parentCtlTag) t = transform.getTransformFromPos(self.guide.apos[1]) self.orbit_ref1 = primitive.addTransform(self.ctl, self.getName("orbit_ref1"), t) self.orbit_ref2 = primitive.addTransform(self.root, self.getName("orbit_ref2"), t) self.orbit_cns = primitive.addTransform(self.ctl, self.getName("orbit_cns"), t) self.orbit_npo = primitive.addTransform(self.orbit_cns, self.getName("orbit_npo"), t) self.orbit_ctl = self.addCtl(self.orbit_npo, "orbit_ctl", t, self.color_fk, "sphere", w=self.length0 / 4, tp=self.ctl) self.jnt_pos.append([self.ctl, "shoulder"])
def addObjects(self): """Add all the objects needed to create the component.""" t = transform.getTransformFromPos(self.guide.pos["root"]) self.eyeOver_npo = primitive.addTransform(self.root, self.getName("eyeOver_npo"), t) self.eyeOver_ctl = self.addCtl(self.eyeOver_npo, "Over_ctl", t, self.color_fk, "sphere", w=1 * self.size, tp=self.parentCtlTag, guide_loc_ref="root") self.eye_npo = primitive.addTransform(self.eyeOver_ctl, self.getName("eye_npo"), t) self.eyeFK_ctl = self.addCtl(self.eye_npo, "fk_ctl", t, self.color_fk, "arrow", w=1 * self.size, tp=self.eyeOver_ctl) # look at t = transform.getTransformFromPos(self.guide.pos["look"]) self.ik_cns = primitive.addTransform(self.root, self.getName("ik_cns"), t) self.eyeIK_npo = primitive.addTransform(self.ik_cns, self.getName("ik_npo"), t) self.eyeIK_ctl = self.addCtl(self.eyeIK_npo, "ik_ctl", t, self.color_fk, "circle", w=.5 * self.size, tp=self.eyeFK_ctl, ro=datatypes.Vector([1.5708, 0, 0]), guide_loc_ref="look") attribute.setKeyableAttributes(self.eyeIK_ctl, self.t_params) self.jnt_pos.append([self.eyeFK_ctl, "eye", "parent_relative_jnt"]) self.jnt_pos.append( [self.eyeOver_ctl, "eyeOver", "parent_relative_jnt", False])
def initialHierarchy(self): """ Create the inital structure for the rig. """ # Root self.root = primitive.addTransformFromPos( self.model, self.getName("root"), self.guide.pos["root"]) self.addToGroup(self.root, names=["componentsRoots"]) # infos attribute.addAttribute(self.root, "componentType", "string", self.guide.compType) attribute.addAttribute(self.root, "componentName", "string", self.guide.compName) attribute.addAttribute(self.root, "componentVersion", "string", str(self.guide.version)[1:-1]) attribute.addAttribute(self.root, "componentAuthor", "string", self.guide.author) attribute.addAttribute(self.root, "componentURL", "string", self.guide.url) attribute.addAttribute(self.root, "componentEmail", "string", self.guide.email) # joint -------------------------------- if self.options["joint_rig"]: self.component_jnt_org = primitive.addTransform( self.rig.jnt_org, self.getName("jnt_org")) # The initial assigment of the active jnt and the parent relative # jnt is the same, later will be updated base in the user options self.active_jnt = self.component_jnt_org self.parent_relative_jnt = self.component_jnt_org return
def addObjects(self): """Add all the objects needed to create the component.""" self.normal = self.guide.blades["blade"].z * -1 self.binormal = self.guide.blades["blade"].x self.WIP = self.options["mode"] if self.negate and self.settings["overrideNegate"]: self.negate = False self.n_factor = 1 if self.settings["overrideNegate"]: self.mirror_conf = [0, 0, 1, 1, 1, 0, 0, 0, 0] else: self.mirror_conf = [0, 0, 0, 0, 0, 0, 0, 0, 0] # FK controllers ------------------------------------ self.fk_npo = [] self.fk_ctl = [] t = self.guide.tra["root"] parent = self.root tOld = False fk_ctl = None self.previusTag = self.parentCtlTag for i, t in enumerate( transform.getChainTransform(self.guide.apos, self.normal, self.negate)): dist = vector.getDistance(self.guide.apos[i], self.guide.apos[i + 1]) if self.settings["neutralpose"] or not tOld: tnpo = t else: tnpo = transform.setMatrixPosition( tOld, transform.getPositionFromMatrix(t)) fk_npo = primitive.addTransform(parent, self.getName("fk%s_npo" % i), tnpo) fk_ctl = self.addCtl(fk_npo, "fk%s_ctl" % i, t, self.color_fk, "cube", w=dist, h=self.size * .1, d=self.size * .1, po=datatypes.Vector(dist * .5 * self.n_factor, 0, 0), tp=self.previusTag, mirrorConf=self.mirror_conf) self.fk_npo.append(fk_npo) self.fk_ctl.append(fk_ctl) tOld = t self.previusTag = fk_ctl parent = fk_ctl if self.settings["addJoints"]: jnt_name = "_".join([self.name, str(i + 1).zfill(2)]) self.jnt_pos.append([fk_ctl, jnt_name, None, False])
def insert_dummy_arm(self, arm_comp): # IK dummy Chain ----------------------------------------- chain_pos = [ self.guide.apos[0], arm_comp.guide.apos[1], arm_comp.guide.apos[2] ] arm_comp.dummy_chain = pri.add2DChain(arm_comp.root, arm_comp.getName("dummy_chain"), chain_pos, arm_comp.normal, arm_comp.negate) arm_comp.dummy_chain[0].attr("visibility").set(arm_comp.WIP) arm_comp.dummy_ikh = pri.addIkHandle(arm_comp.root, arm_comp.getName("dummy_ikh"), arm_comp.dummy_chain) arm_comp.dummy_ikh.attr("visibility").set(False) pm.poleVectorConstraint(arm_comp.upv_ctl, arm_comp.dummy_ikh) pm.makeIdentity(arm_comp.dummy_chain[0], a=1, t=1, r=1, s=1) t = tra.getTransform(arm_comp.dummy_chain[0]) arm_comp.dummy_chain_npo = pri.addTransform( arm_comp.dummy_chain[0], self.getName("dummychain_npo"), t) arm_comp.dummy_chain_offset = pm.createNode("math_MatrixFromRotation") mult = pm.createNode("multMatrix") pm.connectAttr("{}.matrix".format(arm_comp.dummy_chain[0]), "{}.matrixIn[0]".format(mult)) pm.connectAttr("{}.output".format(arm_comp.dummy_chain_offset), "{}.matrixIn[1]".format(mult)) rot = pm.createNode("math_RotationFromMatrix") cmds.setAttr( "{}.rotationOrder".format(rot), cmds.getAttr("{}.rotateOrder".format(arm_comp.dummy_chain[0]))) pm.connectAttr("{}.matrixSum".format(mult), "{}.input".format(rot)) pm.connectAttr("{}.output".format(rot), "{}.rotate".format(arm_comp.dummy_chain_npo))
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 addAimControllers(self, t): # tracking custom trigger aimTrigger_root = addTransform(self.center_lookat, self.getName("aimTrigger_root"), t) # For some unknown reason the right side gets scewed rotation values resetTransform(aimTrigger_root) aimTrigger_lvl = addTransform(aimTrigger_root, self.getName("aimTrigger_lvl"), t) # For some unknown reason the right side gets scewed rotation values resetTransform(aimTrigger_lvl) aimTrigger_lvl.attr("tz").set(1.0) self.aimTrigger_ref = addTransform(aimTrigger_lvl, self.getName("self.aimTrigger_ref"), t) # For some unknown reason the right side gets scewed rotation values resetTransform(self.aimTrigger_ref) self.aimTrigger_ref.attr("tz").set(0.0) # connect trigger with arrow_ctl pm.parentConstraint(self.arrow_ctl, self.aimTrigger_ref, mo=True)
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 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.length0 = vector.getDistance(self.guide.apos[0], self.guide.apos[1]) t = transform.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, axis="xy", negate=self.negate) self.npo = primitive.addTransform(self.root, self.getName("npo"), t) self.ctl = self.addCtl( self.npo, "ctl", t, self.color_fk, "cube", w=self.length0, h=self.size * .1, d=self.size * .1, po=datatypes.Vector(.5 * self.length0 * self.n_factor, 0, 0), tp=self.parentCtlTag) self.mtx = primitive.addTransform(self.npo, self.getName("mtx"), t) t1 = transform.setMatrixPosition(t, self.guide.apos[1]) t2 = transform.getInterpolateTransformMatrix(t, t1, blend=0.98) self.loc = primitive.addTransform(self.mtx, self.getName("loc"), t2) self.end = primitive.addTransform(self.ctl, self.getName("end"), t1) self.jnt_pos.append([self.mtx, "root"]) self.jnt_pos.append([self.loc, 'end']) attribute.setKeyableAttributes(self.ctl) attribute.setInvertMirror(self.ctl, ["tx", "ty", "tz"])
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 addObjectsFkControl(self): parentdiv = self.root parentctl = self.root parent_twistRef = addTransform(self.root, self.getName("reference"), getTransform(self.root)) self.jointList = [] self.preiviousCtlTag = self.parentCtlTag chain = getChainTransform2(self.guide.apos, self.normal, self.negate) for i, t in enumerate(chain): parentdiv, parentctl = self._addObjectsFkControl( i, parentdiv, parentctl, t, parent_twistRef)
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.""" 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 spaceJump(ref=None, space=None, *args): """Space Jump gimmick This function create a local reference space from another space in the hierarchy Args: ref (None, optional): Transform reference space (None, optional): Space reference *args: Maya dummy Returns: pyNode: Transform """ if not ref and not space: if len(pm.selected()) == 2: ref = pm.selected()[0] space = pm.selected()[1] else: pm.displayWarning("Please select 2 objects. Reference Space " "and Jump Space") return refLocal = primitive.addTransform(ref, ref.name() + "_SPACE_" + space.name(), space.getMatrix(worldSpace=True)) spaceLocal = primitive.addTransform(space, ref.name() + "_JUMP_" + space.name(), space.getMatrix(worldSpace=True)) applyop.gear_mulmatrix_op(refLocal.attr("worldMatrix"), spaceLocal.attr("parentInverseMatrix[0]"), spaceLocal) pm.displayInfo("Jump Space for local space: " + space.name() + "created") return spaceLocal
def addCtl(self, parent, name, m, color, iconShape, **kwargs): """Create the control and apply the shape, if this is alrealdy stored in the guide controllers grp. Args: parent (dagNode): The control parent name (str): The control name. m (matrix): The transfromation matrix for the control. color (int or list of float): The color for the control in index or RGB. iconShape (str): The controls default shape. kwargs (variant): Other arguments for the iconShape type variations Returns: dagNode: The Control. """ if "degree" not in kwargs.keys(): kwargs["degree"] = 1 bufferName = name + "_controlBuffer" if bufferName in self.guide.controllers.keys(): ctl_ref = self.guide.controllers[bufferName] ctl = primitive.addTransform(parent, name, m) for shape in ctl_ref.getShapes(): ctl.addChild(shape, shape=True, add=True) pm.rename(shape, name + "Shape") else: ctl = icon.create(parent, name, m, color, iconShape, **kwargs) self.addToGroup(ctl, "controllers") # Set the control shapes isHistoricallyInteresting for oShape in ctl.getShapes(): oShape.isHistoricallyInteresting.set(False) # connecting the always draw shapes on top to global attribute if versions.current() >= 20220000: pm.connectAttr( self.ctlXRay_att, oShape.attr("alwaysDrawOnTop") ) # set controller tag if versions.current() >= 201650: pm.controller(ctl) self.add_controller_tag(ctl, None) attribute.addAttribute(ctl, "isCtl", "bool", keyable=False) return ctl
def addObjects(self): """Add all the objects needed to create the component.""" self.normal = self.guide.blades["blade"].z self.binormal = self.guide.blades["blade"].x # Chain of deformers ------------------------------- self.locList = [] self.npoList = [] parent = self.root self.jointList = [] for i, t in enumerate( transform.getChainTransform2(self.guide.apos, self.normal, self.negate)): lvl = primitive.addTransform(parent, self.getName("%s_lvl" % i), t) npo = primitive.addTransform(lvl, self.getName("%s_npo" % i), t) loc = primitive.addTransform(npo, self.getName("%s_loc" % i), t) self.jnt_pos.append([loc, i]) self.locList.append(loc) self.npoList.append(npo) if i == len(self.guide.apos) - 1: ctl_npo = primitive.addTransform(self.root, self.getName("ctl_npo"), t) self.meta_ctl = self.addCtl(ctl_npo, "ctl", t, self.color_fk, "cube", w=self.size * .5, h=self.size * .5, d=self.size * .5, tp=self.parentCtlTag)
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 t = transform.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, axis="yx", negate=self.negate) self.ctl_npo = primitive.addTransform( self.root, self.getName("ctl_npo"), t) self.ctl = self.addCtl(self.ctl_npo, "base_ctl", t, self.color_ik, "square", w=1.0, tp=self.parentCtlTag) attribute.setKeyableAttributes(self.ctl, self.tr_params) self.ref_base = primitive.addTransform( self.ctl, self.getName("ref_base"), t) t = transform.setMatrixPosition(t, self.guide.apos[1]) self.ik_cns = primitive.addTransform( self.root, self.getName("ik_cns"), t) self.tip_npo = primitive.addTransform( self.ik_cns, self.getName("tip_npo"), t) self.tip_ctl = self.addCtl(self.tip_npo, "tip_ctl", t, self.color_ik, "square", w=1.0, tp=self.ctl) attribute.setKeyableAttributes(self.tip_ctl, self.tr_params) self.ref_tip = primitive.addTransform( self.tip_ctl, self.getName("ref_tip"), t) self.div_cns = [] for i in range(self.settings["div"]): div_cns = primitive.addTransform(self.root, self.getName("div%s_loc" % i)) self.div_cns.append(div_cns) self.jnt_pos.append([div_cns, i])
def addOverControllers(self, t): self.over_npo = addTransform(self.root, self.getName("center_lookatRoot"), t) self.over_ctl = self.addCtl(self.over_npo, "over_%s" % self.ctlName, t, self.color_ik, "square", w=self.getBboxRadius()[0], d=self.getBboxRadius()[1], ro=datatypes.Vector(1.57079633, 0, 0), po=self.offset, ) self.addToSubGroup(self.over_ctl, self.primaryControllersGroupName) ymt_util.setKeyableAttributesDontLockVisibility( self.over_ctl, params=["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx", "sy", "sz"])
def addObjectsFkControl(self): parentdiv = self.root parentctl = self.root parent_twistRef = addTransform( self.root, self.getName("reference"), getTransform(self.root)) self.jointList = [] self.preiviousCtlTag = self.parentCtlTag chain = getChainTransform2(self.guide.apos, self.normal, self.negate) for i, t in enumerate(chain): parentdiv, parentctl = self._addObjectsFkControl(i, parentdiv, parentctl, t, parent_twistRef) # add visual reference icon.connection_display_curve(self.getName("visualFKRef"), self.fk_ctl)
def 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 t = transform.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, axis="yx", negate=self.negate) self.ctl_npo = primitive.addTransform(self.root, self.getName("ctl_npo"), t) self.ctl = self.addCtl(self.ctl_npo, "base_ctl", t, self.color_ik, "square", w=1.0, tp=self.parentCtlTag) self.ref_base = primitive.addTransform(self.ctl, self.getName("ref_base"), t) t = transform.setMatrixPosition(t, self.guide.apos[1]) self.ik_cns = primitive.addTransform(self.ctl, self.getName("ik_cns"), t) self.squash_npo = primitive.addTransform(self.ik_cns, self.getName("squash_npo"), t) self.squash_ctl = self.addCtl(self.squash_npo, "squash_ctl", t, self.color_ik, "crossarrow", w=1.0, ro=dt.Vector(1.5708, 0, 0), tp=self.ctl) attribute.setKeyableAttributes(self.squash_ctl, ["tx", "ty", "tz"]) self.ref_squash = primitive.addTransform(self.squash_ctl, self.getName("ref_squash"), t) self.div_cns = [] div_cns = primitive.addTransform(self.root, self.getName("div0_loc")) self.div_cns.append(div_cns) self.jnt_pos.append([div_cns, 0, None, False])
def createInterpolateTransform(objects=None, blend=.5, *args): """ Create space locator and apply gear_intmatrix_op, to interpolate the his pose between 2 selected objects. Args: objects (None or list of 2 dagNode, optional): The 2 dagNode to interpolate the transform. blend (float, optional): The interpolation blend factor. *args: Maya's dummy Returns: pyNode: The new transformation witht the interpolate matrix o_node applied. """ if objects or len(pm.selected()) >= 2: if objects: refA = objects[0] refB = objects[1] else: refA = pm.selected()[0] refB = pm.selected()[1] intMatrix = applyop.gear_intmatrix_op(refA.attr("worldMatrix"), refB.attr("worldMatrix"), blend) intTrans = primitive.addTransform( refA, refA.name() + "_INTER_" + refB.name(), datatypes.Matrix()) applyop.gear_mulmatrix_op(intMatrix.attr("output"), intTrans.attr("parentInverseMatrix[0]"), intTrans) pm.displayInfo("Interpolated Transform: " + intTrans.name() + " created") else: pm.displayWarning("Please select 2 objects. ") return return intTrans
def addObjects(self): """Add all the objects needed to create the component.""" t = self.guide.tra["root"] # The border needs to fit the ctl range of motion size = self.settings["ctlSize"] margin = self.settings["margin"] self.ctl = None if self.settings["addController"]: self.ctl = self.addCtl(self.root, "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.ctl.scale.set([self.size, self.size, self.size]) attribute.setKeyableAttributes( self.ctl, ["tx", "ty", "tz", "rx", "ry", "rz", "sx", "sy", "sz"]) else: self.ctl = primitive.addTransform(self.root, self.getName("cns"), t) self.ctl.scale.set([self.size, self.size, self.size]) attribute.setKeyableAttributes(self.ctl, []) self.border = self.addCtl(self.ctl, "border", t, self.color_ik, "square", w=size + margin, d=size + margin, tp=self.parentCtlTag, ro=dt.Vector(math.radians(90), 0, 0)) border_shape = self.border.getShape() border_shape.overrideDisplayType.set(2) # Set display to reference attribute.setKeyableAttributes(self.border, [])
def _add_loc_ctl(i, t, parent): loc = primitive.addTransform(parent, self.getName("bk%s_loc" % i), t) self.bk_loc.append(loc) if 0 < i: return loc ctl = self.addCtl(loc, "bk%s_ctl" % i, t, self.color_ik, "sphere", w=self.size * .15, tp=self.previousTag) ymt_util.setKeyableAttributesDontLockVisibility(ctl, self.r_params) self.previousTag = ctl self.bk_ctl.append(ctl) return ctl
def _add_fk(self, i, parent, t, tOld): dist = vec.getDistance(self.guide.apos[i], self.guide.apos[i + 1]) if self.settings["neutralpose"] or not tOld: tnpo = t else: tnpo = tra.setMatrixPosition(tOld, tra.getPositionFromMatrix(t)) fk_npo = pri.addTransform(parent, self.getName("fk%s_npo" % i), tnpo) fk_ctl = self.addCtl(fk_npo, "fk%s_ctl" % i, t, self.color_fk, "cube", w=dist, h=self.size * .1, d=self.size * .1, po=dt.Vector(dist * .5 * self.n_factor, 0, 0)) self.fk_npo.append(fk_npo) self.fk_ctl.append(fk_ctl) return fk_ctl